Spring系列-AOP

Spring系列——AOP

第一章 静态代理设计模式

1、为什么需要代理设计模式？

• 在javaEE分层开发中，哪个层次对于我们来讲最重要

  DAO----> Service---->Controller
  
  在javaEE开发过程中，最重要的是Service层
  

• Service层中包含了哪些代码？

  Service层中 = 核心功能 + 额外功能
  1. 核心功能：业务运算、DAO调用
  2. 额外功能：不属于业务、可有可无、代码量小
  	事务、日志、性能...
  

• 额外功能写在Service层中好不好？

  Service层的调用这的角度（controller）：需要在Service层写额外功能
  					     软件设计者：不需要
  

2、代理设计模式

• 概念

  通过代理类，为原始类（目标）增加额外的功能
  好处：利于原始类（目标）的维护
  

• 代理开发的核心要素

  代理类 = 目标类（原始类） + 额外功能 + 原始类（目标类）实现新相同的接口
  

• 编码

  静态代理：为每一个原始类，手工编写一个代理类（.java .class）

  public class UserServiceProxy implements Uservice{
      private UserServiceImpl userService = new UserServiceImpl;
      
      @Override
      public void register(User user){
          System.out.println("-------log------");
          userService.register(user);
      }
      
      @Override
      public boolean login(String name, String password){
          system.out.println("------------log------------");
          return userService.login(name,password);
      }
  }
  

• 静态代理存在的问题

  1.静态类文件数量过多，不利于项目管理
  2.额外功能维护性差
  

第二章 Spring的动态代理

1、Spring动态代理的概念

概念：通过代理类为原始类（目标类）增加额外功能
好处：利于原始类（目标类）的维护

2、搭建开发环境

<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、Spring动态代理的开发步骤

1. 创建原始对象（目标对象）

   public class UserServiceImpl implements UserService{
       @Override
       public void register(User user){
           System.out.println("UserServiceImpl.register")
       }
       
       @Override
       public boolean login(String name, String password){
           System.out.println("UserServiceImpl.login");
           return true;
       }
   }
   

   <bean id="userService" class="com.xxx.UserServiceImpl">
   

2. 额外功能

   MethodBeforeAdvice接口

   额外的功能书写在接口的实现中，运行在原始方法执行之前运行额外功能
   

   public class Before implements MethodBeforeAdvice{
       /*
       作用：需要把运行在原始方法执行之前运行的额外功能，书写在Before方法中
       */
       @Override
       public void before(Method method. Object[] args, Object target) throws Exception{
           System.out.println("-----method before advice log-----");
       }
   }
   

   <bean id="before" class="com.xxxx.Before"/>
   

3. 定义切入点

   切入点：额外功能加入的位置
   

   <aop:config>
   	<aop:pointcut id="pc" expression="execution(* *(..))"/>
   </aop:config>
   

4. 组装（2 3整合）

   表达的含义：所有的方法   都加入before的额外功能
   <aop:advisor advice-ref="before" pointcut-ref="pc"/>
   

5. 调用

   目的：获得Spring工厂创建的动态代理对象，并进行调用
   ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
   注意：
   	1. Spring的工厂通过原始对象的id值获得的是代理对象
   	2. 获得代理对象后，可以通过声明接口类型，进行对象的存储
   	
   UserService userService = (UserService) ctx.getBean("userService");
   
   userService.login();
   userService.register();
   

4、动态代理细节分析

1. Spring创建的动态代理类在哪里？

   Spring框架在运行时，通过动态字节码技术，在JVM创建的，运行在JVM内部，等程序结束后，会和JVM一起结束
   
   什么叫动态字节码技术：通过第三个动态字节码框架，在JVM中创建对应类的字节码，进而创建对象，当虚拟机结束，动态字节码跟着消失
   
   结论：动态代理不需要定义类文件，都是JVM运行过程中动态创建的，所以不会造成静态代理，类文件数量过多，影响管理的进度
   

2. 动态代理编程简化代理的开发

   在额外功能不改变的前提下，创建其他目标类（原始类）的代理对象时，只需要指定原始（目标）对象即可
   

3. 动态代理额外功能的维护性大大增强

第三章 Spring动态代理详解

1、额外功能的详解

• MethodBeforeAdvice

  1. MethodBeforeAdvice接口作用：额外功能运行在原始方法执行之前，进行额外功能操作
  public class Before implements MethodBeforeAdvice{
  /*
  作用：需要把运行在原始方法执行之前运行的额外功能，书写在before方法中
  
  Method:额外功能所增加的那个原始方法
  		login方法
  		register方法
  		showOrder方法
  Object[]：额外功能所增加给的那个原始方法的参数。String name ,String password
  
  Object:额外功能所增加给的那个原始对象 UserServiceImpl
  								OrderServiceImpl
  */
      @Override
      public void before(Method method,Object[] args, Object target) throws Exception{
          System.out.println("");
      }
  }
  
  2. before方法的3个参数，在实战中，会根据需要进行使用，不一定都会用到，也有可能都不用
  

• MethodInyerceptor(方法拦截器)

  methodinterceptor接口：额外功能可以根据需要运行在原始方法执行 前、后、前后
  

  public class Arround implements MethodInterceptor {
      
      @Override
      public Object invoke(MethodInvocation invocation) throws Exception{
          System.out.println("-----额外功能  log----");
          Object ret = invocation.proceed();
          
          return ret;
      }
  }
  

  MethodInterceptor影响原始方法的返回值

  原始方法的返回值，直接作为invoke方法的返回值返回，MethodInterceptor不会影响原始方法的返回值
  MethodInterceptor影响原始方法的返回值
  Invoke方法的返回值，不要直接返回原始方法的原型结果即可
  
  @Override
  public Object invoke(MethodInvocation invocation) throws Throwable{
  	System.out.println("----log-----");
  	Object ret = invocation.proceed();
  	return false;
  }
  

2、切入点详解

切入点决定额外功能加入位置（方法）

<aop:pointcut id="pc" expression="execution(* *(..))"/>
execution(* *(..))  ---->  匹配所有方法

1. execution()  切入点函数
2. * *（..）     切入点表达式

2.1 切入点表达式

1. 方法切入点表达式

   public void   add(int i , int j)
   	*          * (..)
   	
   * *(..) ----> 所以方法
   
   *  ---->  修饰符  返回值
   *  ---->  方法名
   () ---->  参数表
   .. ---->  对于参数没有要求
   

   • 定义login方法作为切入点

     * login(..)
     
     #定义register作为切入点
     * register(..)
     

   • 定义login方法其login方法有两个字符串类型的参数作为切入点

     * login(String,String)
       
     #注意：非java.lang包中的类型，必须要写全限定名
        * register(com.xxxx.proxy.User)
     #  ..可以和具体的参数类型连用
        * login(String,..) --->login(String),login(String,String),login(String,com.xxx.User)
     

   • 精准方法切入点限定

     修饰符 返回值     包.类.方法(参数)
     
     	*			com.xxxx.UserServiceImpl.login(..)
     	*			com.xxxx.UserServiceImpl.login(String,String)
     

2. 类切入点

   指定特定类作为切入点（额外功能加入的位置），自然这个类中所有方法，都会加上对应的额外功能
   

   • 语法1

     #类中的所有方法加入了额外功能
     * com.xxxx.UserServiceImpl.*(..)
     

   • 语法2

     #忽略包
     1. 类只存在一级包   com.UserServiceImpl
     	* *。UserServiceImpl.*(..)
     	
     2. 类存在多级包   com.xxxx.main.java.UserServiceImpl
     	* *..UserServiceImpl.*(..)
     

3. 包切入点表达式

   指定包作为额外功能加入的位置，自然包中的所有类及其方法都会加入额外的功能
   

   • 语法1

     #切入点包中的所有类，必须在proxy中，不能在proxy包的子包中
     * com.bai.proxy.*.*(..)
     

   • 语法2

     #切入点当前包及其子包都生效
     * com.bai.proxy..*.*(..)
     

2.2 切入点函数

切入点函数：用于执行切入点表达式

1. execution

   最为重要的切入点行数，功能最全
   执行 方法切入点表达式 类切入点表达式 包切入点表达式
   
   弊端：execution执行切入点表达式，书写麻烦
   	 execution(* com.bai.proxy..*.*(..))
   
   注意：其他的切入点函数 简化是excution书写复杂度，功能上完全一致
   

2. args

   作用：主要用于函数（方法）参数的匹配
   
   切入点：方法承诺书必须得是2个字符串类型的参数
   
   execution(* *(String,String))
   
   args(String,String)
   

3. within

   作用：主要用于进行类、包切入点表达式的匹配
   切入点：UserServiceImpl这个类
   
   execution(* *..UserServiceImpl.*(..))
   
   within(*..UserServiceImpl)
   
   execution(* com.bai.proxy..*.*(..))
   
   within(com.bai.proxy..*)
   

4. @annotation

   作用：为具有特殊注解的方法加入额外功能
   
   <aop:pointcut id="" expression="@annotation(com.bai.Log)"/>
   

5. 切入点函数的逻辑运算

   指的是  整合多个切入点行数一起配合工作，进而完成更为复杂的需求
   

   • and 与操作

     案例：login 参数 2个字符串
     
     1. execution(* login(String,String))
     
     2. execution(* login(..)) and args(String,String)
     
     注意：与操作不能用于同种类型的切入点函数
     

   • or 或操作

     案例：register方法 和 login方法作为切入点
     execution(* login(..)) or execution(* register(..))
     

第四章 AOP编程

1、AOP概念

AOP(Aspect Oriented Programing) 面向切面编程  = Spring动态代理开发
以切面为基本单位的程序开发，通过切面间的彼此协同，相互调用，完成程序的构建

OOP（Object Oriented Programing） 面向对象编程  JAVA
以对象为基本单位的程序开发，通过对象间的彼此协同，相互调用，完成程序的构建

POP(Producer Oriented Programing) 面向过程（方法、函数）编程  C
以过程为基本单位的程序开发，通过过程间的彼此协同，相互调用，完成程序的构建

AOP的概念：
	本质就是Spring的动态代理开发，通过代理类为原始类增加额外功能。
	好处：利于原始类的维护
	
注意：AOP编程不可取代OOP，是OOP编程的有意补充

2、AOP编程的开发步骤

1. 原始对象
2. 额外功能（MethodInterceptor）
3. 切入点
4. 组装切面（额外功能+切入点）

3、切面的名词解释

切面 = 切入点 + 额外功能

第五章 AOP的底层实现原理

1、核心问题

1. AOP如何创建动态代理类（动态字节码技术）
2. Spring工厂如何加工创建代理对象
	通过原始对象的id值，获得的是代理对象

2、动态代理类的创建

• JDK的动态代理

  • Proxy.newProxyInstance方法参数详解

    Proxy.newProxyInstance(classloader,interfaces,invovationhandler)
    

  • 编码

    public class TestJDKProxy{
        /*
        	1. 借用类加载器   TestJDKProxy
        					UserServiceImpl
        	2. JDK8.x前
        		final UserService userService = new UserServiceImpl();
        */
        public static void main(String[] args){
            // 1.创建原始对象
            UserService userService = new UserServiceImpl();
            
            // 2.JDK创建动态代理
            InvocationHandler handler = new InvocationHandler(){
                @Override
                public Object invoke(Object proxy, Method method,Object[] args) throws Throwable{
                    System.out.println("-----proxy log----");
                    // 原始方法运行
                    Object ret = method.invoke(userServiceImpl,args);
                    return ret;
                }
        	};
        UserService userServiceProxy = (UserService) Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader,UserService.getClass().getInterfaces(),handler);
        userServiceProxy.login("suns","123456");
        userServiceProxy.register(new User());
    	}
    }
    

• CGlib的动态代理

  CGlib创建动态代理的原理：父子继承关系创建代理对象，原始类作为父类，代理类作为子类，这样既可以保证2者方法一致，同时在代理类中提供新的实现（额外功能+原始方法）
  

  • 编码

    public class TestCglib{
        public static void main(String[] args) {
          
        // 1. 创建原始对象
        UserService userService = new UserService();
        
        // 2. 通过cglib方式创建动态代理对象
        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(TestCglib.class.getClassLoader());
        enhancer.setSuperclass(userService.getClass());
        
        MethodInterceptor interceptor = new MethodInterceptor(){
            // 等同于 Invocationhandler  -- invoke
            @Override
            public Object intercept(Object o, Mehtod method, Object[]Proxy 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","123456");
          userServiceProxy.register(new User());
    	}    
    }
    

• 总结

  1. JDK动态代理 Proxy.newProxyInstance()  通过接口创建代理的实现类
  2. Cglib动态代理 Enhancer 				 通过继承父类创建的代理类
  

3、Spring工厂如何加工原始对象

public class ProxyBeanPostProcessor implements BeanPostProcessor{
    @Override
    public Object postProcessBeforeInitialization(Object bean,String beanName) throws Throwable{
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean,String beanName)
throws Throwable{
        InvocationHandler handler = new InvocationHandler(){
            @Override
            public Object invoke(Objectproxy, Method method, Object[] args){
                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.xxxx.UserServiceImpl"/>

<bean id ="proxyBeanPostProcessor" class="com.xxxx.ProxyBeanPostProcessor"/>

第六章 基于注解的AOP编程

1、基于注解的AOP编程的开发步骤

1. 原始对象

2. 额外功能

3. 切入点

4. 组装切面

   # 通过切面类 定义了 额外功能 @Around
       	   定义了 切入点   @Around("execution(* login(..))")
       	   @Aspect 切面类
       
       
   @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.xxxx.UserServiceImpl"/>
   <!--
   	切面
   		1.额外功能
   		2.切入点
   		3.组装切面
   -->
   <bean id="arround" class="com.xxxx.MyAspect"/>
   
   <!--告知Spring基于注解进行AOP编程-->
   <aop:aspect-autoproxy />
   

2、细节

1、切入点复用

# 切入点复用：在切面类中定义一个函数，上面@Pointcut注解，通过这种方式，定义切入点表达式，后续更有利于切入点复用

@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、动态代理的创建方式

AOP底层实现  2中代理创建方式
1. JDK  通过实现接口  做新的实现类方式  创建代理对象
2. Cglib通过继承父类  做新的子类       创建代理对象

默认情况 AOP编程  底层应用JDK动态代理创建方式
如果切换Cglib
	1. 基于注解AOP开发
	<aop:aspectj-autopeoxy proxy-target-class="true" />
	2. 传统的AOP开发
	<aop:config proxy-target-class="true"></aop>	

第七章 AOP开发中的坑

在同一个业务类中，进行业务方法间的相互调用，只有最外层的方法，才是加入了额外功能（内部的方法，通过普通的方式调用，都调用的是原始方法）。如果想让内层的方法也调用代理对象的方法，就要ApplicationContextAware获得工厂，进而获得代理对象
    
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");
        
        UserService userService = (UserService) ctx.getBeans("userService");
        userService.login("suns","123455");
    }
    
    @Override
    public boolean login(String name, String password) {
        System.out.println("UserServiceimpl.login");
        return true;
    }
}

第八章 AOP阶段知识总结

AOP编程开发（Spring动态代理开发）

• 传统方式
• 注解方式