Spring笔记(2) - AOP编程

Spring笔记(2) - AOP编程

  • 作者: Wyt

系列文章目录

Spring笔记(1) - 工厂
Spring笔记(2) - AOP编程
Spring笔记(3) - 持久层整合
Spring笔记(4) - MVC框架整合
Spring笔记(5) - 注解编程入门
Spring笔记(6) - 注解编程基础

文章目录

  • Spring笔记(2) - AOP编程
  • 系列文章目录
  • 前言
  • 正文
    • 1. 背景
      • 1.1 为什么需要代理模式
        • 传统开发中存在的问题
    • 2. 设计模式之代理模式
      • 2.1 介绍
        • 2.1.1 概念
        • 2.1.2 在JavaEE中
        • 2.1.3 优势
      • 2.2 静态代理
        • 2.2.1 开发步骤
        • 2.2.2 静态代理存在的问题
      • 2.3 Spring动态代理 - AOP入门
        • 2.3.1 AOP的概念
        • 2.3.2 名词解释 - 切面
        • 2.3.3 开发步骤
          • 2.3.3.1 搭建开发环境
            • (1) applicationContext.xml的基础配置
            • (2) 搭建开发环境(pom.xml)
            • (3) 代码操作(添加额外功能)
            • (4) 定义切入点
        • 2.3.4 动态代理细节分析
          • 2.3.4.1 Spring创建的动态代理类在哪里
          • 2.3.4.2 动态代理的优势
      • 2.4 Spring动态代理 - AOP详解
        • 2.4.1 MethodBeforeAdvice
        • 2.4.2 MethodInterceptor(方法拦截器)
        • 2.4.3 关于MethodInterceptor的补充
        • 2.4.4 切入点详解
          • 2.4.4.1 切入点(表达式)决定额外功能的加入位置
          • 2.4.4.2 定义某一相同名称方法作为切入点
          • 2.4.4.3 对方法的参数有要求
          • 2.4.4.4 某一类下的相同名称的方法
          • 2.4.4.5 精准方法切入点限定
        • 2.4.5 类切入点
        • 2.4.6 包切入点
        • 2.4.7 切入点函数
        • 2.4.8 切入点函数的逻辑运算
    • 3. AOP的底层实现原理
      • 3.1 两大核心问题
      • 3.2 动态代理类的创建
        • 3.2.1 JDK的动态代理
        • 3.2.2 CGlib的动态代理
      • 3.3 Spring工厂如何加工原始对象
    • 4. 基于注解的AOP编程
      • 4.1 基于注解的AOP编程的开发步骤
      • 4.2. 细节
    • 5. AOP开发中的一个坑
    • 6. AOP阶段知识总结


前言

此笔记由孙哥的视频整理而来

孙哥B站视频链接如下:
孙哥说Spring5 全部更新完毕 完整笔记、代码看置顶评论链接~学不会Spring? 因为你没找对人

正文

1. 背景

1.1 为什么需要代理模式

  • 传统开发中存在的问题
  • 在JavaEE分层开发中,哪个层次对于我们来讲最重要

1. DAO (Data Access Object): 数据访问层, 负责数据库的访问与操作
2. Service: 服务层(业务层), 封装Dao层的操作,使一个方法对外表现为实现一种功能,			 例如:网购生成订单时,不仅要插入订单信息记录,还要查询商品库存是否充			    足,购买是否超过限制等等。
3. Controller: 控制器层, 负责请求转发,接受页面过来的参数,传给Service处理,接				   到返回值,再传给页面。
	Controller层像是一个服务员,他把客人(前端)点的菜(数据、请求的类型等)进行汇总什么口味、咸淡、量的多少,交给厨师长(Service层),厨师长则告诉沾板厨师(Dao 1)、汤料房(Dao 2)、配菜厨师(Dao 3)等(统称Dao层)我需要什么样的半成品,副厨们(Dao层)就负责完成厨师长(Service)交代的任务
												——CSDN用户 狗生有点疲惫
DAO ---> Service --> Controller 

JavaEE分层开发中,最为重要的是Service层
  • Service层的功能
Service层: 核心功能(几十行 上百代码) + 额外功能(附加功能)
1. 核心功能
    业务运算
    DAO调用
2. 额外功能 
   1. 不属于业务
   2. 可有可无
   3. 代码量很小 
   
   	如:事务、日志、性能...
  • 遇到的问题
	鉴于额外功能的特性, 无论是否将额外功能写入Service层, 都无法满足需求
1. 不写入:
	缺少相应的功能
2. 写入
	有可能造成资源的浪费, 且不容易对额外功能进行增删改操作
	假如把房东看做是Service层,
	核心业务有 1. 签合同 2. 收钱
	额外业务有 1. 打广告 2. 与租客商谈

2. 设计模式之代理模式

2.1 介绍

2.1.1 概念
* 在代理模式(Proxy Pattern)中,一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。
* 类比
	假如我想自己去买一辆二手车, 那么我需要车源, 在购买的过程中还需要商定价格、质量检测等一系列繁琐的步骤
	但是如果我们通过中介公司来买车, 他们可以负责找车源、办理车辆过户等流程, 而我们则负责付钱就行
	在这里, 我们可以吧中介公司看做是代理类
2.1.2 在JavaEE中
  1. 概念
	通过代理类,为原始类(目标)增加额外的功能
	好处:利于原始类(目标)的维护
  1. 名词解释
1. 目标类 原始类 
   指的是 业务类 (核心功能 --> 业务运算 DAO调用)
2. 目标方法,原始方法
   目标类(原始类)中的方法 就是目标方法(原始方法)
3. 额外功能 (附加功能)
   日志,事务,性能
2.1.3 优势
1. 中介隔离作用:在某些情况下,一个客户类不想或者不能直接引用一个委托对象,而代理类对象可以在客户类和委托对象之间起到中介的作用,其特征是代理类和委托类实现相同的接口。

2. 开闭原则,增加功能:代理类除了是客户类和委托类的中介之外,我们还可以通过给代理类增加额外的功能来扩展委托类的功能,这样做我们只需要修改代理类而不需要再修改委托类,符合代码设计的开闭原则。
	如果有中介(Proxy)帮忙负责额外功能: 1. 打广告 2. 与租客商谈
	那房东(Service)只需负责核心业务: 1. 签合同 2. 收钱
	
可以有两大好处: 
	1. 中介隔离作用:
		相当于房东把房子交给中介托管, 那么租客接触不到房东
	2. 开闭原则,增加功能:
		保证房东核心业务不受影响, 可以根据各方面因素要求中介对额外功能增删改, 例如增加广告或者其他业务

2.2 静态代理

2.2.1 开发步骤
代理类 = 目标类(原始类) + 额外功能 + 原始类(目标类)实现相同的接口

	新建一个代理类, 在代理类的重载方法中运行原始类中的方法, 并且可以在重载方法中添加其他代码, 以实现额外功能

Spring笔记(2) - AOP编程_第1张图片

2.2.2 静态代理存在的问题
1. 要为每一个原始类创建代理类, 容易导致静态类文件数量过多,不利于项目管理
   	UserServiceImpl  UserServiceProxy
   	OrderServiceImpl OrderServiceProxy
2. 额外功能维护性差
   	代理类中 额外功能修改复杂(麻烦)

2.3 Spring动态代理 - AOP入门

2.3.1 AOP的概念
AOP (Aspect Oriented Programing)   面向切面编程 = Spring动态代理开发
以切面为基本单位的程序开发,通过切面间的彼此协同,相互调用,完成程序的构建
切面 = 切入点 + 额外功能

OOP (Object Oritened Programing)   面向对象编程 Java
以对象为基本单位的程序开发,通过对象间的彼此协同,相互调用,完成程序的构建

POP (Producer Oriented Programing) 面向过程(方法、函数)编程 C 
以过程为基本单位的程序开发,通过过程间的彼此协同,相互调用,完成程序的构建
AOP的概念:
     本质就是Spring得动态代理开发,通过代理类为原始类增加额外功能。
     好处:利于原始类的维护

注意:AOP编程不可能取代OOP
2.3.2 名词解释 - 切面
	切面 = 切入点 + 额外功能 

	几何学: 面 = 点 + 相同的性质
2.3.3 开发步骤
1. 原始对象
2. 额外功能 (MethodInterceptor)
3. 切入点
4. 组装切面 (额外功能+切入点)
2.3.3.1 搭建开发环境
(1) applicationContext.xml的基础配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd
        ">
特别注意:
	xmlns:aop="http://www.springframework.org/schema/aop"

	http://www.springframework.org/schema/aop 			https://www.springframework.org/schema/aop/spring-aop.xsd
(2) 搭建开发环境(pom.xml)
		<dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-aopartifactId>
            <version>5.1.14.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.aspectjgroupId>
            <artifactId>aspectjrtartifactId>
            <version>1.8.8version>
        dependency>
        <dependency>
            <groupId>org.aspectjgroupId>
            <artifactId>aspectjweaverartifactId>
            <version>1.9.4version>
        dependency>
(3) 代码操作(添加额外功能)
  • 以MethodBeforeAdvice接口为例
	MethodBeforeAdvice: 额外的功能书写在接口的实现中,运行在原始方法执行之前运行额外功能
  • Before.java
public class Before implements MethodBeforeAdvice {
    /*
      作用:需要把运行在原始方法执行之前运行的额外功能,书写在before方法中
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("-----method before advice log------");
    }
}
(4) 定义切入点

<bean id="before" class="com.baizhiedu.dynamic.Before"/>
相关概念:
	切入点:额外功能加入的位置
	目的:由程序员根据自己的需要,决定额外功能加入给那个原始方法
  • 简单的测试:所有方法都做为切入点,都加入额外的功能。
<aop:config>
   
   <aop:pointcut id="pc" expression="execution(* *(..))"/>
   
   <aop:advisor advice-ref="before" pointcut-ref="pc"/>
aop:config>
  • 在测试类中进行测试
    Spring笔记(2) - AOP编程_第2张图片

Spring笔记(2) - AOP编程_第3张图片

2.3.4 动态代理细节分析
2.3.4.1 Spring创建的动态代理类在哪里
	Spring框架在运行时,通过动态字节码技术,在JVM创建的,运行在JVM内部,等程序结束后,会和JVM一起消失

	动态字节码技术: 通过第三个动态字节码框架,在JVM中创建对应类的字节码,进而创建对象,当虚拟机结束,动态字节码跟着消失。

	结论:动态代理不需要定义类文件,都是JVM运行过程中动态创建的,所以不会造成静态代理,类文件数量过多,影响项目管理的问题。
2.3.4.2 动态代理的优势
1. 动态代理编程简化代理的开发
	在额外功能不改变的前提下,创建其他目标类(原始类)的代理对象时,只需要指定原始(目标)对象即可。
2. 动态代理额外功能的维护性大大增强

2.4 Spring动态代理 - AOP详解

  • 两大接口: MethodBeforeAdvice 、 MethodInterceptor(方法拦截器)
2.4.1 MethodBeforeAdvice
作用:额外功能运行在原始方法执行之前,进行额外功能操作。
public class Before implements MethodBeforeAdvice {
    /*
    作用:需要把运行在原始方法执行之前运行的额外功能,书写在before方法中

	参数:
      Method method: 额外功能所增加给的那个原始方法
      Object[] args: 额外功能所增加给的那个原始方法的参数。
      Object target: 额外功能所增加给的那个原始对象 
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("-----new method before advice log------");
    }
}

   //before方法的参数,在实战中,会根据需要进行使用,不一定都会用到,也有可能都不用。
2.4.2 MethodInterceptor(方法拦截器)
作用: 额外功能可以根据需要运行在原始方法运行的各个时候执行
public class Arround implements MethodInterceptor {
    /*
         invoke方法的作用:额外功能书写在invoke
                        额外功能  原始方法之前
                                 原始方法之后
                                 原始方法执行之前 之后
         参数:MethodInvocation (Method):额外功能所增加给的那个原始方法
              invocation.proceed() ---> 原始方法运行的位置

          返回值:Object: 原始方法的返回值
     */

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
          System.out.println("-----额外功能在原始方法之前运行 log----");
          Object ret = invocation.proceed();
		  System.out.println("-----额外功能在原始方法之后运行 log----");
        
          return ret;
    }
}

思考:
	什么额外功能需要在原始方法运行前后都要运行?
	答: 事务
2.4.3 关于MethodInterceptor的补充
  1. 额外功能运行在原始方法抛出异常的时候
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {

  Object ret = null;
  try {
    ret = invocation.proceed();
  } catch (Throwable throwable) {

    System.out.println("-----原始方法抛出异常 执行的额外功能 ---- ");
    throwable.printStackTrace();
  }
  return ret;
}
  1. MethodInterceptor影响原始方法的返回值
	原始方法的返回值,直接作为invoke方法的返回值返回,MethodInterceptor不会影响原始方法的返回值

MethodInterceptor如何影响原始方法的返回值: 
	Invoke方法的返回值,不要直接返回原始方法的运行结果即可。
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
   System.out.println("------log-----");
   Object ret = invocation.proceed();
   return false;
}
2.4.4 切入点详解
2.4.4.1 切入点(表达式)决定额外功能的加入位置
<aop:pointcut id="pc" expression="execution(* *(..))"/>
exection(* *(..)) ---> 匹配了所有方法
	
1. execution()  切入点函数
2. * *(..)      切入点表达式 
	public void add(int i, int j)
	          *   *(..)
解释:
	* ---> 修饰符 返回值
	* ---> 方法名
	()---> 参数表
	..---> 对于参数没有要求 (参数有没有,参数有几个都行,参数是什么类型的都行)
2.4.4.2 定义某一相同名称方法作为切入点
	即给某一方法添加额外功能: 方法名 + (..)
# 如:定义register作为切入点
* register(..)
2.4.4.3 对方法的参数有要求
* 例: login(String,String)

# ..可以和具体的参数类型连用
* login(String,..)  --> login(String),login(String,String),login(String,com.baizhiedu.proxy.User)
2.4.4.4 某一类下的相同名称的方法
# 注意:非java.lang包中的类型,必须要写全限定名
* register(com.baizhiedu.proxy.User)
2.4.4.5 精准方法切入点限定
	修饰符 返回值         包.类.方法(参数)
	*               com.proxy.UserServiceImpl.login(..)
    *               com.proxy.UserServiceImpl.login(String,String)
2.4.5 类切入点
	概念: 指定特定类作为切入点(额外功能加入的位置),自然这个类中的所有方法,都会加上对应的额外功能
  • 语法一
# 类中的所有方法加入了额外功能 
* com.baizhiedu.proxy.UserServiceImpl.*(..)  
  • 语法二
#忽略包
1. 类只存在一级包  com.UserServiceImpl
* *.UserServiceImpl.*(..)

2. 类存在多级包    com.baizhiedu.proxy.UserServiceImpl
* *..UserServiceImpl.*(..)
2.4.6 包切入点
	概念: 指定包作为额外功能加入的位置,自然包中的所有类及其方法都会加入额外的功能
  • 语法一
# 切入点包中的所有类,必须在proxy中,不能在proxy包的子包中
* com.baizhiedu.proxy.*.*(..)
  • 语法二
# 切入点当前包及其子包都生效  表达式区别: proxy后两个.
* com.baizhiedu.proxy..*.*(..) 
2.4.7 切入点函数
	概念: 切入点函数:用于执行切入点表达式
  1. execution
	最为重要的切入点函数,功能最全。
可以执行 (1)方法切入点表达式 (2)类切入点表达式 (3)包切入点表达式 

弊端:execution执行切入点表达式, 书写麻烦
     execution(* com.baizhiedu.proxy..*.*(..))
     
注意:其他的切入点函数 简化是execution书写复杂度,功能上完全一致
  1. args
作用:主要用于函数(方法) 参数的匹配

	举例: 
	切入点:方法参数必须得是2个字符串类型的参数

	execution(* *(String,String))
	args(String,String)
  1. whthin
作用:主要用于进行类、包切入点表达式的匹配

	举例:
	切入点:UserServiceImpl这个类

	execution(* *..UserServiceImpl.*(..))
	within(*..UserServiceImpl)

	execution(* com.baizhiedu.proxy..*.*(..))
	within(com.baizhiedu.proxy..*)
  1. @annotation注解
  • 作用:为具有特殊注解的方法加入额外功能

  • 开发步骤:

    (1) 定义注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 以Log为例
 * 其中@Teget, @Retention是修饰注解的注解, 称为元注解
 */

@Target(ElementType.METHOD)  //应用在方法上, where
@Retention(RetentionPolicy.RUNTIME)  //when
public @interface Log {

}

(2) 在applicationcontext.xml中增加切入点

<aop:pointcut id="log" expression="@annotation(com.wyt.Log)"/>

(3) 在需要加入额外功能的方法添加注解

//例如
@Log
@Override
public void register(User user) {
    System.out.println("UserServiceImpl.register 业务运算 + DAO");
}
2.4.8 切入点函数的逻辑运算
	整合多个切入点函数一起配合工作,进而完成更为复杂的需求
  • and(与)操作

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

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

3. AOP的底层实现原理

3.1 两大核心问题

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

3.2 动态代理类的创建

3.2.1 JDK的动态代理
  • 运行过程:

    JVM -> 动态代理类 -> 代理对象

  • Proxy.newProxyInstance方法参数详解

Spring笔记(2) - AOP编程_第4张图片

  • 三个参数:
  1. loader: 用哪个类加载器去加载代理对象
  2. interfaces: 动态代理类需要实现的接口
  3. h: 动态代理方法在执行时,会调用h里面的invoke方法去执行
1. ClassLoader loader
	(1)类加载器的作用:
    	1. 通过类加载器把对应类的字节码文件加载JVM
    	2. 通过类加载器创建类的Class对象, 进而创建这个类的对象
    	
   	(2)类加载器的运行过程:
   		.java -> .class(字节码文件) -> (通过类加载器)加载到JVM -> (通过类加载器创建).class对象 -> new 类的对象	
   
   	(3)如何获得类加载器
   		JVM会为每一个类的.class文件自动分配与之对应的类加载器
   		
   	(4)备注:
    	Class对象记录了这个类最完整的信息
2. @NotNull Class[] interfaces

	通过 原始类对象.getClass().getInterfaces() 获得接口
3. @NotNull InvocationHandler h
	
	简介: InvocationHandler接口是proxy代理实例的调用处理程序实现的一个接口,每一个proxy代理实例都有一个关联的调用处理程序;在代理实例调用方法时,方法调用被编码分派到调用处理程序的invoke方法。
	
	当我们通过动态代理对象调用一个方法时候,这个方法的调用就会被转发到实InvocationHandler接口类的invoke方法来调用
	
	/**
	* Object: 返回原始方法的返回值
    * proxy: 代理对象
    * method: 我们所要调用某个对象真实的方法的Method对象, 即核心功能
    * args: 原始方法的参数
    */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
  • 代码演示
package com.wyt.jdk;

import com.wyt.proxy.User;
import com.wyt.proxy.UserService;
import com.wyt.proxy.UserServiceImpl;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


/**
 * @author Wyt
 * @date 2020/10/28 20:07
 */

public class TextJDKProxy {
    public static void main(String[] args) {
        //1.创建原始对象
        UserService userService = new UserServiceImpl();

        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("---proxy log before---");
                //原始方法运行
                Object ret = method.invoke(userService, args);

                System.out.println("---proxy log after---\n");

                return ret;
            }
        };

        //获得代理对象
        UserService userServiceProxy = (UserService) Proxy.newProxyInstance(TextJDKProxy.class.getClassLoader(), userService.getClass().getInterfaces(), handler);

        userServiceProxy.login("wyt", "123456");
        userServiceProxy.register(new User());
    }
}
  • 其他详细代码: https://blog.csdn.net/qq_45538657/article/details/109362844
3.2.2 CGlib的动态代理
  • JDK动态代理的不足
	JDK动态代理需要:
	1. 接口
	2. 原始类
	3. 代理类 (与原始类同接口)
	
	当遇到没有原始类没有实现任何接口的的情况, 则无法实现JDK动态代理
  • CGlib是什么
	CGLIB(Code Generator Library)是一个强大的、高性能的代码生成库。其被广泛应用于AOP框架(Spring、dynaop)中,用以提供方法拦截操作。Hibernate作为一个比较受欢迎的ORM框架,同样使用CGLIB来代理单端(多对一和一对一)关联(延迟提取集合使用的另一种机制)。

​ CGLIB作为一个开源项目,其代码托管在github,地址为:https://github.com/cglib/cglib

  • CGib代理的原理
	CDLIB 原理: 父子继承关系创建代理对象,原始类作为父类,代理类作为子类,这样既可以保证两者方法一致,同时在代理类中提供新的实现 (额外功能+原始方法)
	public class UserServiceProxy extends UserServiceImpl{...}
	
	CGLIB 底层: 使用字节码处理框架ASM,来转换字节码并生成新的类。不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

	CGLIB 缺点: 对于final方法,无法进行代理。
  • 代码实现
package com.wyt.cglib;

import com.wyt.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;

/**
 * @author Wyt
 * @date 2020/10/29 19:29
 */
public class TestCglib {
    public static void main(String[] args) {
        //1. 创建原始对象
        UserService userService = new UserService();

        /*
            jdk方式:
                Proxy.newProxyInstance(classloader, interface, invocation)

            2. 通过cglib方式创建动态代理对象

            Enhancer.serClassLoader() - 类加载器
            Enhancer.setSuperClass()  - 父类
            Enhancer.serCallback()    - 额外功能  --> MethodInterceptor(cglib)

            Enhancer.create() --> 代理
         */
        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, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("---cglib log---");
                Object ret = method.invoke(userService, objects);

                return ret;
            }
        };

        enhancer.setCallback(interceptor);

        UserService userServiceProxy = (UserService) enhancer.create();

        userServiceProxy.login("wyt", "123456");
        userServiceProxy.register(new User());
    }
}

Spring笔记(2) - AOP编程_第5张图片

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

3.3 Spring工厂如何加工原始对象

  • 过程: 动态代理结合BeanPostProcessor

  • 思路分析

1. 创建原始对象
	client中
	ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
	UserService userService = (UesrService) ctx.getBean("userService");
	
	ApplicationContext.xml中
	
	
2. 加工过程:
	(1)postProcessBeforeInitialization
	(2)IntializingBean
	(上面两步一般不管)
	
	(3)postProcessAfterInitialization(Object bean, String beanName) {
	userServiceProxy = Proxy.newProxyInstance(classloader, interface, invocationHandler)
	
	return userServiceProxy;
	}
  • 代码示例
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.wyt.factory.UserServiceImpl"/>




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

4. 基于注解的AOP编程

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

  1. 原始对象
  2. 额外功能
  3. 切入点
  4. 组装切面
  • UserService
package com.wyt.aspect;

import com.wyt.proxy.User;

public interface UserService {
    public void register(User user);

    public boolean login(String name, String password);
}
  • UserServiceImpl
package com.wyt.aspect;

import com.wyt.Log;
import com.wyt.proxy.User;

public class UserServiceImpl implements UserService {
    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register 业务运算 + DAO");
    }

    @Override
    public boolean login(String name, String password) {
        System.out.println("UserServiceImpl.login");
        return true;
    }
}
  • MyAspect
/* 通过切面类 (@Aspect)
	1. 定义了 额外功能 @Around
    2. 定义了 切入点   @Around("execution(* login(..))")
*/

package com.wyt.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

@Aspect
/**
 * 1. 额外功能
 *      public class MyAround implements MethodInterceptor {
 *          public Object invoke (MethodInvocation invocation) {
 *              Object ret = invocation.proceed();
 *              return ret;
 *          }
 *      }
 *
 * 2. 切入点
 *      
 *         
 *      
 */
public class MyAspect {

    @Around("execution(* login(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("---aspect before log---");
        Object ret = joinPoint.proceed();
        System.out.println("---aspect after log---");

        return ret;
    }
}
  • TextAspectProxy
package com.wyt.aspect;

import com.wyt.proxy.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TextAspectProxy {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext2.xml");
        UserService userService = (UserService) ctx.getBean("userService");

        userService.login("wyt", "123456");

        userService.register(new User());
    }
}

  • applicationContext2.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="com.wyt.aspect.UserServiceImpl"/>

    
    <bean id="around" class="com.wyt.aspect.MyAspect"/>

    
    <aop:aspectj-autoproxy />

beans>
  • 运行TextAspectProxy的主函数,控制台输出结果如下:

Spring笔记(2) - AOP编程_第6张图片

4.2. 细节

  1. 切入点复用
//切入点复用:在切面类中定义一个函数
//@Pointcut注解: 通过这种方式,定义切入点表达式,后续更加有利于切入点复用。
   
   @Aspect
   public class MyAspect {
       @Pointcut("execution(* login(..))")
       public void myPointcut(){}
   
       @Around(value="myPointcut()")
       public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
   
           System.out.println("----aspect log---");
   
           Object ret = joinPoint.proceed();
   
           return ret;
       }
   
   
       @Around(value="myPointcut()")
       public Object around1(ProceedingJoinPoint joinPoint) throws Throwable {
   
           System.out.println("---aspect tx---");
   
           Object ret = joinPoint.proceed();
   
           return ret;
       }
   
   }
  1. 动态代理的创建方式
* AOP底层实现: 2种代理创建方式
1.  JDK  通过实现接口 做新的实现类方式 创建代理对象
2.  Cglib通过继承父类 做新的子类      创建代理对象

  默认情况 AOP编程 底层应用JDK动态代理创建方式
  
  如果切换Cglib:
     1. 基于注解AOP开发
        
     2. 传统的AOP开发
        
        

5. AOP开发中的一个坑

//坑:在同一个业务类中, 进行业务方法间的相互调用, 只有最外层的方法, 才是加入了额外功能 (内部的方法, 通过普通的方式调用, 都调用的是原始方法)。如果想让内层的方法也调用代理对象的方法, 就要AppicationContextAware获得工厂, 进而获得代理对象。

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 业务运算 + DAO ");

        //调用的是原始对象的login方法 ---> 核心功能
        /*
            设计目的:代理对象的login方法 --->  额外功能+核心功能
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext2.xml");
            UserService userService = (UserService) ctx.getBean("userService");
            userService.login();

            Spring工厂重量级资源 一个应用中 应该只创建一个工厂
         */

        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;
    }
}

6. AOP阶段知识总结

Spring笔记(2) - AOP编程_第7张图片

你可能感兴趣的:(java笔记,Spring笔记,java,spring,aop,设计模式)