xml-based AOP in Spring

Keywords: Java Spring xml Maven Programming

1. The whole process of Aop is Aspect Oriented Programming, which is a technology for facet-oriented programming, to achieve the same maintenance of program functions through pre-compilation and run-time dynamic agents.Aop is the continuation of oop, a hot spot in software development, and an important content in Spring framework.It is a derived example of functional programming, which can be used to split parts of business logic with Aop, thus reducing the coupling between parts of business logic, improving the reusability of programs, and improving development efficiency.Simply put, it is to extract duplicate code from our program and enhance it by using dynamic proxy technology and existing methods without modifying the source code when it needs to be executed.

Related Terms

JoinPoint: Link points Those that are intercepted refer to methods in spring because spring only supports connection points of method type

Pointcut: The entry point is the definition of which JoinPont s we want to intercept

Advice: Notification/Enhancement Notification is what you do after intercepting a Joinpoint

Notification Type: Pre Notification, Post Notification, Exception Notification, Final Notification, Surround Notification

Introduction: Introduction is a special notification that Introductions can dynamically add methods or field s to a class at run time without modifying its class code

Target: Target object, target object of proxy

Weaving weaving is the process of applying enhancements to target objects to create new proxy objects. spring uses dynamic proxy weaving, AspectJ uses compile-time weaving and class-loading weaving

Proxy: Proxy, a result proxy class produced when a class is enhanced by Aop weaving

Aspect: Aspect is the combination of entry point and notification (introductory)

In spring, the framework decides which dynamic proxy method to use based on whether the target class implements an interface or not.

XMl-based AOP steps

1. Create a Maven project to introduce spring coordinates

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

2. Create business-tier interfaces:

package com.mingqi.services;
public interface IAccountService {
     * Simulate login account
    void saveAccount();

     * Simulate account updates
     * @param id
    void updateAccount(int id);

     * Simulate account deletion
     * @return
    int deleteAccount();


3. Create Business Tier Implementation Class

package com.mingqi.services.impl;
import com.mingqi.services.IAccountService;
public class AccountServicesImpl implements IAccountService {
    public void saveAccount() {
        System.out.println("Save performed");

    public void updateAccount(int id) {
        System.out.println("Update performed"+id);

    public int deleteAccount() {
        System.out.println("Delete performed");
        return 0;

4. Create Tool Class

package com.mingqi.utils;
import org.aspectj.lang.ProceedingJoinPoint;
 * Tool class for user logging, which provides common code
public class Logger {
     * For printing logs: plan for them to execute before the entry point method is executed (the entry point method is the business layer method)
    public  void beforePrintLog(){
        System.out.println("Logger In class pringLog Method started logging.");
    public  void afterReturningPrintLog()
        System.out.println("after returning advise Logger In class beforePrintLog Method started logging.");
     * Exception Notification
    public void afterThrowingPrintLog()
        System.out.println("Exception Notification Logger In class afterThrowingPrintLog Method started logging.");

     * Final Notification
    public void afterPrintLog()
        System.out.println("Final Notification Logger In class afterPrintLog Method started logging.");

     * Around Advice
     * Problem When we configured the surround notification, the entry point method did not execute and the notification method executed
     * Analysis: By comparing the surround notification codes in the dynamic proxy, we found that surround notifications in the dynamic proxy have explicit entry point method calls, but not in our code.
     * Solution: The Spring framework provides us with an interface: ProceedingJoinPoint.The interface has a method proceed(), which is equivalent to explicitly calling the method of the entry point
     *        This interface can be used as a parameter method to surround notifications, and the spring framework provides us with implementation classes for this interface to use when the program executes
     * spring Surround notifications in
     *      He's one of the ways the spring framework gives us manual control over when enhancements will execute in code
     * @param pjp
     * @return
    public Object aroundPringLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
            Object[] args = pjp.getArgs();//Get the parameters required for method execution

            System.out.println("Logger In class aroundPringLog Method started logging.Front");

            rtValue = pjp.proceed(args);//Explicitly invoke business tier methods (entry point methods)

            System.out.println("Logger In class aroundPringLog Method started logging.Rear");

            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger In class aroundPringLog Method started logging.abnormal");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger In class aroundPringLog Method started logging.Final");

4. Create a bean configuration file

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       <!--Configure spring's IOC and service objects in it-->
       <bean id="accountSevice" class="com.mingqi.services.impl.AccountServicesImpl"></bean>
       <!-- xml-based OP configuration steps in spring
         1. Give the notification beans to spring to manage
         2. Use aop:config tag table name to start AOP configuration
         3. UseAop:aspectLabel indicates configuration facet
             id property: is to provide a unique identification for the facet
             ref attribute: is the id of the specified notification class
         4. InAop:aspectInside the label, use the corresponding label to configure the type of notification
             Our example now is to have the printlog method execute before the entry point method executes, so it is a pre-notification
             aop:before: Identify pre-notifications
                Method property: Used to specify which method in the Logger class is a pre-notification
                pointcut property: Used to specify an entry point expression that means which enhancements are made to methods in the business tier
                Writing of the entry point expression:
                   Keyword: execution
                   Expression: Access modifier return value package name. Package name. Package name.... Class name. Method name (parameter list)
                   Standard writing: public voidCom.mingqi.service.Impl.AccountServiceImpl.saveAccount()
                   Access modifiers can be omitted:voidCom.mingqi.service.Impl.AccountServiceImpl.saveAccount()
                   Return values can use wildcards to identify any return value: *com.mingqi.service.impl.AccountServiceImpl.saveAccount()
                   Package names can use wildcards to represent any package, but several levels of packages require writing * *. *. *.AccountServiceImpl.saveAccount()
                   Package names can be used..To represent the current package and its subpackages: * *.AccountServiceImpl.saveAccount()
                   Both class and method names can use * to achieve uniformity *. *. *();
                   Parameter list: You can write data types directly:
                                 The base type writes the name directly: int
                                 Write package names by reference type. How class names are written:java.lang.String
                                Wildcards can be used to identify any type, only parameters are required
                                You can use..To identify whether parameters are available or not, and parameters can be of any type

                      Full wildcard writing:
                    * *..*.*(..)
                   A common way to write entry point expressions in real-world development:
                          Cut to all methods of the business tier implementation class,*com.mingqi.service.impl. *. *(.));
       <!--Configure Logger class-->
       <bean id="logger" class="com.mingqi.utils.Logger"></bean>
       <!--Use aop:config tag table name to start AOP configuration-->
              <aop:pointcut id="pt1" expression="execution(* com.mingqi.services.impl.*.*(..))"></aop:pointcut>
              <!--UseAop:aspectLabel indicates configuration facet-->
              <aop:aspect id="LogAdvice" ref="logger">
                     <!--Configure Pre-Notification: Execute before the entry point method executes
                     <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>-->

                     <!--Configuration Post Notification: Value after the entry point method has been properly executed.It and exception notifications can always execute only one
                          <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>-->
                     <!--Configure exception notifications: execute after the entry point method execution has generated an exception.It and post-notification can never execute more than one
                         <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>-->
                     <!--Configure final notification: the entry point method will execute after it whether it executes properly or not
                        <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>-->
                     <!--Configure surround notifications for detailed comments see the Logger class-->
                        <aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around>

6. Create test classes

package com.mingqi.test;
import com.mingqi.services.IAccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringIoc {
    public void TestAccount()
        ApplicationContext ac= new ClassPathXmlApplicationContext("beam.xml");
        IAccountService accountService=(IAccountService) ac.getBean("accountSevice");


Posted by Bikkebakke on Fri, 19 Jun 2020 17:58:24 -0700