Spring笔记(2) - AOP编程

最新推荐文章于 2022-11-09 09:11:14 发布

Quantum_Wu

最新推荐文章于 2022-11-09 09:11:14 发布

阅读量250

点赞数 3

分类专栏： java笔记 Spring笔记文章标签： java spring aop 设计模式

本文链接：https://blog.csdn.net/qq_45538657/article/details/109540611

版权

java笔记同时被 2 个专栏收录

20 篇文章 1 订阅

订阅专栏

Spring笔记

10 篇文章 0 订阅

订阅专栏

Spring笔记(2) - AOP编程

作者: Wyt

系列文章目录

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

前言

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

孙哥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. 目标类 原始类 
   指的是 业务类 (核心功能 --> 业务运算 DAO调用)
2. 目标方法，原始方法
   目标类(原始类)中的方法 就是目标方法(原始方法)
3. 额外功能 (附加功能)
   日志，事务，性能

2.1.3 优势

1. 中介隔离作用：在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。

2. 开闭原则，增加功能：代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。

	如果有中介(Proxy)帮忙负责额外功能: 1. 打广告 2. 与租客商谈
	那房东(Service)只需负责核心业务: 1. 签合同 2. 收钱
	
可以有两大好处: 
	1. 中介隔离作用:
		相当于房东把房子交给中介托管, 那么租客接触不到房东
	2. 开闭原则，增加功能：
		保证房东核心业务不受影响, 可以根据各方面因素要求中介对额外功能增删改, 例如增加广告或者其他业务

2.2 静态代理

2.2.1 开发步骤

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

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

StaticProxy

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的基础配置

<?xml version="1.0" encoding="UTF-8"?>
<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.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.9.4</version>
        </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对象-->
<bean id="before" class="com.baizhiedu.dynamic.Before"/>

相关概念：
	切入点：额外功能加入的位置
	目的：由程序员根据自己的需要，决定额外功能加入给那个原始方法

简单的测试：所有方法都做为切入点，都加入额外的功能。

<aop:config>
   <!--execution(* *(..))含义：所有的方法都加入 before的额外功能-->
   <aop:pointcut id="pc" expression="execution(* *(..))"/>
   <!--组装-->
   <aop:advisor advice-ref="before" pointcut-ref="pc"/>
</aop:config>

在测试类中进行测试

Before

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的补充

额外功能运行在原始方法抛出异常的时候

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

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 切入点函数

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

execution

	最为重要的切入点函数，功能最全。
可以执行 (1)方法切入点表达式 (2)类切入点表达式 (3)包切入点表达式 

弊端：execution执行切入点表达式, 书写麻烦
     execution(* com.baizhiedu.proxy..*.*(..))
     
注意：其他的切入点函数 简化是execution书写复杂度，功能上完全一致

args

作用：主要用于函数(方法) 参数的匹配

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

	execution(* *(String,String))
	args(String,String)

whthin

作用：主要用于进行类、包切入点表达式的匹配

	举例:
	切入点：UserServiceImpl这个类

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

	execution(* com.baizhiedu.proxy..*.*(..))
	within(com.baizhiedu.proxy..*)

@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方法参数详解

JDK1

三个参数:

loader: 用哪个类加载器去加载代理对象
interfaces: 动态代理类需要实现的接口
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());
    }
}

CGlib

总结

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中
	<bean id="User" class="com.wyt.proxy.UserServiceImpl"/>
	
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"/>


<!--1. 实现BeanPostProcessor 进行加工
        2. 配置文件中对BeanPostProcessor进行配置
    -->

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

4. 基于注解的AOP编程

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

原始对象
额外功能
切入点
组装切面

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. 切入点
 *      <aop:config>
 *         <aop:pointcut id="" expression="execution(* login(..))"/>
 *      </aop:config>
 */
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

<?xml version="1.0" encoding="UTF-8"?>
<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"/>

    <!--
        切面:
            1. 额外切面
            2. 切入点
            3. 组装切面
    -->
    <bean id="around" class="com.wyt.aspect.MyAspect"/>

    <!--告知Spring基于注解进行AOP编程-->
    <aop:aspectj-autoproxy />

</beans>

运行TextAspectProxy的主函数，控制台输出结果如下:

Aspect

4.2. 细节

切入点复用

//切入点复用：在切面类中定义一个函数
//@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;
       }
   
   }

动态代理的创建方式

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

  默认情况 AOP编程 底层应用JDK动态代理创建方式
  
  如果切换Cglib:
     1. 基于注解AOP开发
        <aop:aspectj-autoproxy proxy-target-class="true" />
     2. 传统的AOP开发
        <aop:config proxy-target-class="true">
        </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阶段知识总结

Summary

Quantum_Wu

关注

3
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
4
评论
Spring笔记(2) - AOP编程

Spring笔记(2) - AOP编程作者: Wyt系列文章目录Spring笔记(1) - 工厂文章目录Spring笔记(2) - AOP编程系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结前言正文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
复制链接

扫一扫