Spring a set of all in 3 - AOP programming

Baizhi Education - Spring series courses - AOP programming

Chapter one: static agent design pattern

1. Why do you need agent design pattern
1.1 problems
  • In Java EE layered development, which layer is the most important for us

    DAO ---> Service --> Controller 
    
    JavaEE In layered development, the most important thing is Service layer
    
  • What code is included in the Service layer?

    Service In layer = Core functions(Dozens of lines and hundreds of codes) + Additional features(Additional functions)
    1. Core functions
       Business operation
       DAO call
    2. Additional features 
       1. Not a business
       2. not essential
       3. The amount of code is very small 
       
       Transactions, logs, performance...
       
    
  • How about writing additional functions in the Service layer?

    Service The angle of the caller of the layer( Controller):Need in Service Additional functions for layer writing.
                             Software designer: Service Layer does not require additional functionality
                             
    
  • Solutions in real life

2. Agent design mode
1.1 concept
Add additional functionality to the original class (target) through the proxy class
 Benefits: benefits to primitive classes(target)Maintenance of
1.2 interpretation of terms
1. Target class original class 
   It refers to business class (Core functions --> Business operation DAO call)
2. Target method
   Target class(Primitive class)The method in is the target method(Original method)
3. Additional features (Additional functions)
   Log, transaction, performance
1.3 core elements of agent development
proxy class = Target class(Primitive class) + Additional features + Primitive class(Target class)Implement the same interface

landlord or landlady ---> public interface UserService{
               m1
               m2
          }
          UserServiceImpl implements UserService{
               m1 ---> Business operation DAO call
               m2 
          }
          UserServiceProxy implements UserService
               m1
               m2
1.4 coding

Static proxy: manually write a proxy class (. Java. Class) for each original class

1.5 problems of static agent
1. There are too many static files, which is not conducive to project management
   UserServiceImpl  UserServiceProxy
   OrderServiceImpl OrderServiceProxy
2. Poor maintenance of additional functions
   The modification of additional functions in the proxy class is complex(trouble)

The second chapter is the dynamic agent development of Spring

1. The concept of spring dynamic proxy
Concept: the proxy class is the original class(Target class)Add additional features
 Benefits: benefits to primitive classes(Target class)Maintenance of
2. Build a development environment
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>5.1.14.RELEASE</version>
</dependency>

<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjrt</artifactId>
  <version>1.8.8</version>
</dependency>

<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.3</version>
</dependency>

3. Development steps of spring dynamic agent
  1. Create original object (target object)

    public class UserServiceImpl implements UserService {
        @Override
        public void register(User user) {
            System.out.println("UserServiceImpl.register Business operation + DAO ");
        }
    
        @Override
        public boolean login(String name, String password) {
            System.out.println("UserServiceImpl.login");
            return true;
        }
    }
    
    
    <bean id="userService" class="com.baizhiedu.proxy.UserServiceImpl"/>
    
  2. Additional features
    MethodBeforeAdvice interface

    Additional functions are written in the implementation of the interface and run before the original method is executed.
    
    public class Before implements MethodBeforeAdvice {
        /*
          Function: you need to write the additional functions that run before the execution of the original method in the before method
         */
        @Override
        public void before(Method method, Object[] args, Object target) throws Throwable {
            System.out.println("-----method before advice log------");
        }
    }
    
    <bean id="before" class="com.baizhiedu.dynamic.Before"/>
    
  3. Define pointcuts

    Entry point: where additional functions are added
    
    Purpose: the programmer decides to add additional functions to the original method according to his own needs
    register
    login
    
    Simple test: all methods are used as entry points and add additional functions.
    
    <aop:config>
       <aop:pointcut id="pc" expression="execution(* *(..))"/>
    </aop:config>
    
  4. Assembly (2 3 integration)

    Meaning of expression: all methods are added before Additional features of
    <aop:advisor advice-ref="before" pointcut-ref="pc"/>
    
  5. call

    Objective: to obtain Spring The dynamic proxy object created by the factory and called
    ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
    be careful:
       1. Spring The factory passes through the original object id Value gets the proxy object
       2. After obtaining the proxy object, you can store the object by declaring the interface type
       
    UserService userService=(UserService)ctx.getBean("userService");
    
    userService.login("")
    userService.register()
    
    
4. Dynamic agent detail analysis
  1. Where is the dynamic proxy class created by Spring?

    Spring At runtime, the framework uses dynamic bytecode technology to JVM Created, running in JVM Internally, after the procedure is completed, it will communicate with JVM Disappear together
    
    What is dynamic bytecode technology:Through the third dynamic bytecode framework, in JVM Create the bytecode of the corresponding class, and then create the object. When the virtual machine ends, the dynamic bytecode disappears.
    
    Conclusion: dynamic agents do not need to define class files, they are JVM It is created dynamically during operation, so it will not cause too many static agents and class files, which will affect project management.
    

    1. Dynamic agent programming simplifies agent development

      When creating proxy objects of other target classes (original classes) without changing the additional functions, you only need to specify the original class(target)Object.
      
    2. The maintainability of additional functions of dynamic agent is greatly enhanced

Chapter 3: detailed explanation of Spring dynamic proxy

1. Detailed explanation of additional functions
  • MethodBeforeAdvice analysis

    1. MethodBeforeAdvice Interface function: additional function operation is performed before the original method is executed.
    
    public class Before1 implements MethodBeforeAdvice {
        /*
          Function: you need to write the additional functions that run before the execution of the original method in the before method
    
          Method: The original method to which the extra functionality is added
                  login method
    
                  register method
    
                  showOrder method
    
          Object[]: The parameter of the original method added by the additional function. String name,String password
                                                   User
    
           Object: The original object UserServiceImpl added by the additional function
                                              OrderServiceImpl
         */
        @Override
        public void before(Method method, Object[] args, Object target) throws Throwable {
            System.out.println("-----new method before advice log------");
        }
    }
    
    2. before How to use the three parameters of the method in practice.
       before In practice, the parameters of the method will be used as needed. They may not be used or may not be used at all.
    
       Servlet{
           service(HttpRequest request,HttpResponse response){
                request.getParameter("name") -->
                
                response.getWriter() ---> 
           
           }
       
       }
    
    
  • Methodinterceptor (method interceptor)

    methodinterceptor Interface: additional functions can be run before, after and before the execution of the original method as required.
    
    public class Arround implements MethodInterceptor {
        /*
             invoke Function of the method: additional functions are written in invoke
                            Before the original method of additional functions
                                     After the original method
                                     Before and after the original method execution
             Determine: how does the original method work
    
             Parameter: method invocation (Method): the original method added by the additional function
                        login
                        register
                  invocation.proceed() ---> login function
                                            register function
    
              Return value: Object: the return value of the original method
    
             Date convert(String name)
         */
    
    
    
        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
              System.out.println("-----Additional features log----");
              Object ret = invocation.proceed();
    
              return ret;
        }
    }
    
    
    

    Additional functionality runs after the original method is executed

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
      Object ret = invocation.proceed();
      System.out.println("-----Additional functionality runs after the original method is executed----");
    
      return ret;
    }
    

    Additional functionality runs before and after the original method is executed

    What additional functions are added before and after the execution of the original method?
    affair
    
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
      System.out.println("-----Additional functionality runs before the original method is executed----");
      Object ret = invocation.proceed();
      System.out.println("-----Additional functionality runs after the original method is executed----");
    
      return ret;
    }
    

    Additional functionality runs when the original method throws an exception

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
    
      Object ret = null;
      try {
        ret = invocation.proceed();
      } catch (Throwable throwable) {
    
        System.out.println("-----The original method throws an exception to perform additional functions ---- ");
        throwable.printStackTrace();
      }
    
    
      return ret;
    }
    

    MethodInterceptor affects the return value of the original method

    The return value of the original method, directly as invoke Method, MethodInterceptor Does not affect the return value of the original method
    
    MethodInterceptor Affects the return value of the original method
    Invoke Method instead of directly returning the running result of the original method.
    
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
       System.out.println("------log-----");
       Object ret = invocation.proceed();
       return false;
    }
    
2. Detailed explanation of entry point
The entry point determines where additional functions are added(method)

<aop:pointcut id="pc" expression="execution(* *(..))"/>
exection(* *(..)) ---> All methods are matched    a  b  c 

1. execution()  Pointcut function
2. * *(..)      Pointcut expression 
2.1 pointcut expression
  1. Method pointcut expression
    ! [image-20200425105040237] (. / Baizhi Education - Spring series courses - AOP programming. assets/image-20200425105040237.png)

    *  *(..)  --> All methods
    
    * ---> Modifier return value
    * ---> Method name
    ()---> Parameter table
    ..---> No requirements for parameters (Whether there are parameters or not, any number of parameters and any type of parameters are OK)
    
    • Define the login method as the entry point

      * login(..)
      
      # Define register as the entry point
      * register(..)
      
    • The login method is defined, and the login method has two string type parameters as the entry point

      * login(String,String)
      
      #Note: for types not in java.lang package, the fully qualified name must be written
      * register(com.baizhiedu.proxy.User)
      
      # .. Can be used with specific parameter types
      * login(String,..)  --> login(String),login(String,String),login(String,com.baizhiedu.proxy.User)
      
    • Precise method entry point limitation

      Modifier return value         package.class.method(parameter)
      
          *               com.baizhiedu.proxy.UserServiceImpl.login(..)
          *               com.baizhiedu.proxy.UserServiceImpl.login(String,String)
      
  2. Class pointcut

    Specify a specific class as the pointcut(Where additional features are added)´╝îNaturally, all methods in this class will add corresponding additional functions
    
    • Grammar 1

      #All methods in the class add additional functionality 
      * com.baizhiedu.proxy.UserServiceImpl.*(..)  
      
    • Grammar 2

      #Ignore package
      1. Class has only one level package  com.UserServiceImpl
      * *.UserServiceImpl.*(..)
      
      2. Class has multi-level packages    com.baizhiedu.proxy.UserServiceImpl
      * *..UserServiceImpl.*(..)
      
  3. Package pointcut expression practice

    Specify where the package is added as additional functions. All classes and methods in the natural package will add additional functions
    
    • Grammar 1

      #All classes in the pointcut package must be in the proxy, not in the sub package of the proxy package
      * com.baizhiedu.proxy.*.*(..)
      
    • Grammar 2

      #The pointcut is in effect for both the current package and its sub packages 
      * com.baizhiedu.proxy..*.*(..) 
      
2.2 pointcut function
Pointcut function: used to execute pointcut expressions
  1. execution

    The most important pointcut function has the most complete functions.
    Execution method pointcut expression class pointcut expression package pointcut expression 
    
    Disadvantages: execution Execute the pointcut expression, which is troublesome to write
         execution(* com.baizhiedu.proxy..*.*(..))
         
    Note: other pointcut function simplifications are execution The writing complexity is completely consistent in function
    
  2. args

    Function: mainly used for functions(method) Parameter matching
    
    Pointcut: method parameters must be 2 string type parameters
    
    execution(* *(String,String))
    
    args(String,String)
    
  3. within

    Function: it is mainly used for matching class and package pointcut expressions
    
    Entry point: UserServiceImpl This class
    
    execution(* *..UserServiceImpl.*(..))
    
    within(*..UserServiceImpl)
    
    execution(* com.baizhiedu.proxy..*.*(..))
    
    within(com.baizhiedu.proxy..*)
    
    

4.@annotation

Function: add additional functions for methods with special annotations

<aop:pointcut id="" expression="@annotation(com.baizhiedu.Log)"/>
  1. Logical operation of pointcut function

    It refers to integrating multiple pointcut functions to work together to complete more complex requirements
    
    • and operation

      Case: login Two strings of parameters at the same time 
      
      1. execution(* login(String,String))
      
      2. execution(* login(..)) and args(String,String)
      
      Note: unlike operations, it is used for pointcut functions of the same type 
      
      Case: register Methods and login Method as a starting point 
      
      execution(* login(..)) or  execution(* register(..))
      
      
    • or operation

      Case: register Methods and login Method as a starting point 
      
      execution(* login(..)) or  execution(* register(..))
      

Chapter 4: AOP programming

1. AOP concept
AOP (Aspect Oriented Programing)   Aspect oriented programming = Spring Dynamic agent development
 The program development with aspect as the basic unit completes the construction of the program by coordinating and calling each other
 section = breakthrough point + Additional features

OOP (Object Oritened Programing)   object-oriented programming Java
 The program development with object as the basic unit completes the construction of the program through the cooperation and call between objects

POP (Producer Oriented Programing) Process oriented(Methods and functions)programming C 
The program development with process as the basic unit completes the construction of the program through the cooperation and call between processes
AOP Concept of:
     The essence is Spring Get dynamic agent development, and add additional functions to the original class through the agent class.
     Benefits: it is conducive to the maintenance of the original class

be careful: AOP Programming cannot replace OOP´╝îOOP Programming is intentionally supplemented.
2. Development steps of AOP programming
1. Original object
2. Additional features (MethodInterceptor)
3. breakthrough point
4. Assembly section (Additional features+breakthrough point)
3. Definition of terms
section = breakthrough point + Additional features 

geometry
   noodles = spot + Same nature

The fifth chapter is the underlying implementation principle of AOP

1. Core issues
1. AOP How to create a dynamic proxy class(Dynamic bytecode Technology)
2. Spring How does a factory create a proxy object
   Through the of the original object id Value to get the proxy object
2. Creation of dynamic proxy class
2.1 dynamic agent of JDK
  • Detailed explanation of Proxy.newProxyInstance method parameters

  • code

    public class TestJDKProxy {
    
        /*
            1. Borrow class loader TestJDKProxy
                           UserServiceImpl
            2. JDK8.x front
    
                final UserService userService = new UserServiceImpl();
         */
        public static void main(String[] args) {
            //1 create original object
            UserService userService = new UserServiceImpl();
    
            //2. Create dynamic agent with JDK
            /*
    
             */
    
            InvocationHandler handler = new InvocationHandler(){
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("------proxy  log --------");
                    //Original method run
                    Object ret = method.invoke(userService, args);
                    return ret;
                }
            };
    
            UserService userServiceProxy = (UserService)Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader(),userService.getClass().getInterfaces(),handler);
    
            userServiceProxy.login("suns", "123456");
            userServiceProxy.register(new User());
        }
    }
    
    
2.2 dynamic agent of cglib
CGlib The principle of creating a dynamic proxy: the parent-child inheritance relationship creates a proxy object, with the original class as the parent class and the proxy class as the child class. This can not only ensure the consistency of the two methods, but also provide a new implementation in the proxy class(Additional features+Original method)

  • CGlib encoding

    package com.baizhiedu.cglib;
    
    import com.baizhiedu.proxy.User;
    import org.springframework.cglib.proxy.Enhancer;
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.Method;
    
    public class TestCglib {
        public static void main(String[] args) {
            //1 create original object
            UserService userService = new UserService();
    
            /*
              2 Creating dynamic proxy objects by cglib
                Proxy.newProxyInstance(classloader,interface,invocationhandler)
    
                Enhancer.setClassLoader()
                Enhancer.setSuperClass()
                Enhancer.setCallback();  ---> MethodInterceptor(cglib)
                Enhancer.create() ---> agent
             */
    
            Enhancer enhancer = new Enhancer();
    
            enhancer.setClassLoader(TestCglib.class.getClassLoader());
            enhancer.setSuperclass(userService.getClass());
    
    
            MethodInterceptor interceptor = new MethodInterceptor() {
                //Equivalent to InvocationHandler --- invoke
                @Override
                public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                    System.out.println("---cglib log----");
                    Object ret = method.invoke(userService, args);
    
                    return ret;
                }
            };
    
            enhancer.setCallback(interceptor);
    
            UserService userServiceProxy = (UserService) enhancer.create();
    
            userServiceProxy.login("suns", "123345");
            userServiceProxy.register(new User());
        }
    }
    
    
  • summary

    1. JDK Dynamic agent   Proxy.newProxyInstance()  Create the implementation class of the proxy through the interface 
    2. Cglib Dynamic agent Enhancer                  Proxy class created by inheriting the parent class 
    
3. How does spring factory process original objects
  • Train of thought analysis

  • code

    public class ProxyBeanPostProcessor implements BeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            return bean;
        }
    
        @Override
        /*
             Proxy.newProxyInstance();
         */
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    
            InvocationHandler handler = new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("----- new Log-----");
                    Object ret = method.invoke(bean, args);
    
                    return ret;
                }
            };
          return Proxy.newProxyInstance(ProxyBeanPostProcessor.class.getClassLoader(),bean.getClass().getInterfaces(),handler);
        }
    }
    
    <bean id="userService" class="com.baizhiedu.factory.UserServiceImpl"/>
    
    
    <!--1. realization BeanPostProcessor Processing
            2. Pair in configuration file BeanPostProcessor Configure
        -->
    
    <bean id="proxyBeanPostProcessor" class="com.baizhiedu.factory.ProxyBeanPostProcessor"/>
    
    

Chapter 6: annotation based AOP programming

1. Development steps of annotation based AOP programming
  1. Original object

  2. Additional features

  3. breakthrough point

  4. Assembly section

    # Additional functions @ Around are defined through the facet class
               Pointcuts are defined   @Around("execution(* login(..))")
               @Aspect Section class 
               
    package com.baizhiedu.aspect;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    
    
    /*
           1. Additional features
                     public class MyArround implements MethodInterceptor{
    
                          public Object invoke(MethodInvocation invocation){
    
                                  Object ret = invocation.proceed();
    
                                  return ret;
    
                          }
    
                     }
    
           2. breakthrough point
                 <aop:config
                     <aop:pointcut id=""  expression="execution(* login(..))"/>
     */
    @Aspect
    public class MyAspect {
    
        @Around("execution(* login(..))")
        public Object arround(ProceedingJoinPoint joinPoint) throws Throwable {
    
            System.out.println("----aspect log ------");
    
            Object ret = joinPoint.proceed();
    
    
            return ret;
        }
    }
       
    
     <bean id="userService" class="com.baizhiedu.aspect.UserServiceImpl"/>
    
        <!--
           section
             1. Additional features
             2. breakthrough point
             3. Assembly section
    
    
        -->
    <bean id="arround" class="com.baizhiedu.aspect.MyAspect"/>
    
    <!--inform Spring Annotation based AOP programming-->
    <aop:aspectj-autoproxy />
    
2. Details
  1. Pointcut reuse

    Pointcut reuse: define a function in the facet class@Pointcut Annotation defines pointcut expressions in this way, which is more conducive to pointcut reuse in the future.
    
    @Aspect
    public class MyAspect {
        @Pointcut("execution(* login(..))")
        public void myPointcut(){}
    
        @Around(value="myPointcut()")
        public Object arround(ProceedingJoinPoint joinPoint) throws Throwable {
    
            System.out.println("----aspect log ------");
    
            Object ret = joinPoint.proceed();
    
    
            return ret;
        }
    
    
        @Around(value="myPointcut()")
        public Object arround1(ProceedingJoinPoint joinPoint) throws Throwable {
    
            System.out.println("----aspect tx ------");
    
            Object ret = joinPoint.proceed();
    
    
            return ret;
        }
    
    }
    
  2. How dynamic agents are created

AOP The bottom layer implements two proxy creation methods
1.  JDK  Create a proxy object by creating a new implementation class through the implementation interface
2.  Cglib Make new subclasses by inheriting the parent class      Create proxy object

Default AOP Programming underlying applications JDK Dynamic proxy creation method 
If switching Cglib
     1. Annotation based AOP development
        <aop:aspectj-autoproxy proxy-target-class="true" />
     2. conventional AOP development
        <aop:config proxy-target-class="true">
        </aop>

Chapter 7, a pit in AOP development

Pit: in the same business class, there are only the outermost methods for mutual calls between business methods,Is the addition of additional features(The internal methods are called in an ordinary way. They all call the original method). If you want the inner method to call the method of the proxy object, you must AppicationContextAware Get the factory, and then get the proxy object.
public class UserServiceImpl implements UserService, ApplicationContextAware {
    private ApplicationContext ctx;


    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
              this.ctx = applicationContext;
    }

    @Log
    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register Business operation + DAO ");
        //throw new RuntimeException("test exception");

        //The login method -- > core function of the original object is called
        /*
            Design purpose: login method of proxy object -- > additional functions + core functions
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext2.xml");
            UserService userService = (UserService) ctx.getBean("userService");
            userService.login();

            Spring Factory heavyweight resources should create only one factory in an application
         */

        UserService userService = (UserService) ctx.getBean("userService");
        userService.login("suns", "123456");
    }

    @Override
    public boolean login(String name, String password) {
        System.out.println("UserServiceImpl.login");
        return true;
    }
}

Chapter VIII summary of AOP stage knowledge

Tags: Java Spring SpringAop

Posted on Tue, 09 Nov 2021 02:10:34 -0500 by henrygao