Spring基础篇：面向切面编程

public class UserServciceProxy implements UserService {
    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
3
4
5
6
7
8
9
10
11
12
13
14
15

public class OrderServiceProxy implements OrderServcie{
    private OrderServiceImpl orderService = new OrderServiceImpl();
    @Override
    public void showOrder() {
        System.out.println("-------logs---------");
        orderService.showOrder();
    }
}
1
2
3
4
5
6
7
8

        
        <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.8.3version>
        dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/**
 * @Auther: DaShu
 * @Date: 2021/6/15 18:57
 * @Description:
 */
public interface UserService {
    public void register(User user);
    public boolean login(String name, String Password);
}

1
2
3
4
5
6
7
8
9
10

    <bean id="userService" class = "com.pactera.spring.proxy.UserServiceImpl"/>
1

    <bean id="userService" class = "com.pactera.spring.proxy.UserServiceImpl"/>
    <bean id="before" class="com.pactera.spring.dynamic.Before"/>
1
2

/**
 * @Auther: DaShu
 * @Date: 2021/6/15 19:39
 * @Description:
 */
public class Before implements MethodBeforeAdvice {
    //作用：需要把运行在原始方法执行之前的额外功能，书写在before当中
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("---------------method before advice log-----------------");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

    <aop:config>
        
        
        <aop:pointcut id="pc" expression="execution(* *(..))"/>
    aop:config>
1
2
3
4
5

    <aop:config>
        
        
        <aop:pointcut id="pc" expression="execution(* *(..))"/>
        
        <aop:advisor advice-ref="before" pointcut-ref="pc"/>
    aop:config>
1
2
3
4
5
6
7

/**
 * @Auther: DaShu
 * @Date: 2021/6/21 20:12
 * @Description:
 */
public class Around implements MethodInterceptor {
    @Override
    //这个接口的方法是有返回值的这也就解释了spring的注解开发的aop是Around方法里边的返回值是Object类型的
    //这个接口里边有一个invoke方法，我们也就把额外功能写入invoke当中，这个额外功能就能运行在原始方法之前，也能运行在原始方法之后。也可以运行在原始方法之前，之后。
    //原始方法怎么运行呢？这就需要知道这个方法的参数的含义：
    //这个方法的参数：这个就代表的事原始方法，底层相当于是对目标方法对象Method的一个更高级别的封装，可以认为他们两个设计相等的。methodInvocation.proceed()方法就代表目标方法执行了。
    //这个MthodInvocation就代表的事目标方法，而这里的methodinvocation.invoke就代表目标方法的运行。
    //到这：讲清楚了原始方法的运行是怎么回事的，
    //这个方法的返回值：这个返回值的原因在于实现接口的时候，接口按照接口返回值的类型，invoke方法有返回值 ，这里的Object
    //代表的就是原始方法执行之后的返回值，所以这个方法必须有一个Object,如果原始方法的返回值是void，那么我们返回一个null就行了。
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        return null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       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/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class = "com.pactera.spring.proxy.UserServiceImpl"/>
    <bean id="orderService" class = "com.pactera.spring.proxy.OrderServiceImpl"/>

    <bean id = "around" class = "com.pactera.spring.dynamic.Around"/>
    <aop:config>
        
        
        <aop:pointcut id="pc" expression="execution(* *(..))"/>
        
        <aop:advisor advice-ref="around" pointcut-ref="pc"/>
    aop:config>
beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

    /*
     * @Target: 用于测试Arround方法
     * @Author: DaShu
     * @Date: 2021/6/21 20:53
     * @Result:
     */
    @Test
    public void test3(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext3.xml");
        com.pactera.spring.proxy.OrderServcie orderService = (com.pactera.spring.proxy.OrderServcie)ctx.getBean("orderService");
        orderService.showOrder();
        //...........................这里是额外功能...............................
        //OrderServiceImpl.showOrder
        //-------------------------------这里还是额外功能----------------------------------------
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package com.pactera.spring.dynamic;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
 * @Auther: DaShu
 * @Date: 2021/6/21 20:12
 * @Description:
 */
public class Around implements MethodInterceptor {
    @Override
    //这个接口的方法是有返回值的这也就解释了spring的注解开发的aop是Around方法里边的返回值是Object类型的
    //这个接口里边有一个invoke方法，我们也就把额外功能写入invoke当中，这个额外功能就能运行在原始方法之前，也能运行在原始方法之后。也可以运行在原始方法之前，之后。
    //原始方法怎么运行呢？这就需要知道这个方法的参数的含义：
    //这个方法的参数：这个就代表的事原始方法，底层相当于是对目标方法对象Method的一个更高级别的封装，可以认为他们两个设计相等的。methodInvocation.proceed()方法就代表目标方法执行了。
    //这个MthodInvocation就代表的事目标方法，而这里的methodinvocation.invoke就代表目标方法的运行。
    //到这：讲清楚了原始方法的运行是怎么回事的，
    //这个方法的返回值：这个返回值的原因在于实现接口的时候，接口按照接口返回值的类型，invoke方法有返回值 ，这里的Object
    //代表的就是原始方法执行之后的返回值，所以这个方法必须有一个Object,如果原始方法的返回值是void，那么我们返回一个null就行了。
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("...........................这里是额外功能...............................");
        Object proceed = null;
        try {
            proceed = methodInvocation.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("-------------------------------这里还是核心功能------------------------");
        }
        System.out.println("-------------------------------这里还是额外功能----------------------------------------");
        return proceed;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

* *(..) -->这样匹配的是所有的表达式
定义一份方法的时候有五要素，修饰符、返回值、方法名、参数表、方法体
认为划分的话就是实际上就是三个部分，修饰符+返回值    方法名   参数表
分别对应的事*  * （..）,这里是由严格的对应关系的，*的含义是通配符，*表示的对什么没有要求，*表示的事对所有的事的匹配。
* --->修饰符  返回值没有要求
* --->方法名没有要求
() --->参数表
.. --->对于参数没有要求（参数有没有都行，参数有几个都行，参数是什么类型都行）
1
2
3
4
5
6
7
8

定义login方法作为切入点
* login(..)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

    /*
     * @Target: 用于测试* login(String,String)这个切入点表达式
     * @Author: DaShu
     * @Date: 2021/6/21 20:53
     * @Result: 这个切入点定义到了login方法，并且具有两个参数，并且两个参数都是String类型；
     */
    @Test
    public void test5(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext3.xml");
        UserService userService = (UserService)ctx.getBean("userService");
        userService.login("zhangjie","zhangjie");
        //...........................这里是额外功能...............................
        //UserServiceImpl.login
        //-------------------------------这里还是额外功能----------------------------------------

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

如果并没有定义的方法切入点的话，那么aop是不会抛出异常的仅仅不执行aop功能而已。如果参数中的参数不是java.lang包下的，需要写全限定类名来定义切入点方法的的参数类型，例如：

* login(com.tk.medule.Bean,com.tk.module.bean1);
* 不是java.lang包下的类写要写全限定类名。 
*  login（String,..） //我们longin方法第一个参数是String，后边的参数有没有，有几个都无所谓。login(String)login(String,String)login(String,com.shit.ShitClass);
..可以和具体的参数类型连用。
运行结果和上面一致。
1
2
3
4
5

我们目前所讲解的方法的切入点表达式相对比较简单，而且不精准

• 不精准的原因在这：

• login(…)这样写专注于login方法，但是在不同的包下往往有着相同的文件名的类，他们中间有着相同的实现方法，
  
  这样会有多个满足要求的方法会经过匹配。这样写不精准，此时我们想选择的是某个一个类当中的方法的话，需要加上类的信息，这样也是不行的，还需要加上包的信息，这样包+类+方法，甚至：包+类+方法+参数 就精准了。这样应该这样写，这样写就相对来讲比较完整了。

• 精准的方法切入点的返回值的限定。
  
  

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       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/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class = "com.pactera.spring.proxy.UserServiceImpl"/>
    <bean id="orderService" class = "com.pactera.spring.proxy.OrderServiceImpl"/>

    <bean id = "around" class = "com.pactera.spring.dynamic.Around"/>


    <aop:config>
        
        
        <aop:pointcut id="pc" expression="execution(* com.pactera.spring.proxy.UserServiceImpl.login(String,..))"/>
        
        <aop:advisor advice-ref="around" pointcut-ref="pc"/>
    aop:config>
beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

类切入点

假设我需要把一个类当中的所有的方法定义为切入点，这样我我们可以使用这个类切入点：
类切入点：指定类切入点，只不过是这样的一个称呼，所有的额外功能还是加在了这个类的全部的方法上，这样的形式是包+类：

详细的切入点配置如下，测试结果不贴出来了，和其他的一样没啥区别。

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       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/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class = "com.pactera.spring.proxy.UserServiceImpl"/>
    <bean id="orderService" class = "com.pactera.spring.proxy.OrderServiceImpl"/>

    <bean id = "around" class = "com.pactera.spring.dynamic.Around"/>


    <aop:config>
        
        
        <aop:pointcut id="pc" expression="execution(* com.pactera.spring.proxy.UserServiceImpl.*(String,..))"/>
        
        <aop:advisor advice-ref="around" pointcut-ref="pc"/>
    aop:config>
beans>

* com.com.com.impl.*(..)   --->类中的所有方法加入了额外功能。这是第一种语法形式。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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

不同包下的同名的类作为类切入点，
* *.UserServiceImpl.*(..) -->这样写是不可以的，一个*只能匹配一级包，一般我们的类不会写在com包下的，这样写是有问题的，如果是多级包应该是*..表达的就是一级包乃至多级包。
* *..UserServiceImpl.*(..)-->这样写就能匹配多级目录下的这个类了。
任何包下的这个类都作为切入点。
1
2
3
4

包切入点表达式

我想为所有的某个包下的所有的方法添加切入点：

* com.baizhuedu.a.*.*(..) -->匹配这个包下的所有类的所有的方法。
注意上边这样写只能在a的包下，不能在a的子包下，子包下是不能被匹配到的。
* com.baizhuedu..a.*.*(..) -->匹配a包，包括a子包下的所有的类。
1
2
3

将来我们的这个切入店，包的切入点的使用价值更高。

切入点函数

切入点函数的作用就是用执行切入点表达式的函数，
excution:最为重要的一个切入点函数，也是功能最全的
执行方法切入点表达式，也可以执行类切入点表达式，也可以执行包切入点表达式
弊端：excution执行切入点表达式的时候，书写麻烦，比如：execution（* com.baizhiedu.proxy….(…)；这样写起来很麻烦，spring为我们提供了其他的切入点函数，其他的切入点函数只是起到了简化execution切入点函数的作用，功能还是一样的的，本质上是没有任何区别的，简化的事execution书写的复杂度，但是功能上是完全一致的。

args

作用：主要用于函数（方法的）参数的匹配，
需求1：方法的切入点其他我不关系，参数必须是两个String的方法作为切入点
execution(* *(String,String)) -->使用excution这样写
args(String,String) -->使用args这样写。

1
2
3
4
5

代码和测试结果如下：

    <aop:config>
        
        

        <aop:pointcut id="pc" expression="args(String,String))"/>
        
        <aop:advisor advice-ref="around" pointcut-ref="pc"/>
    aop:config>
1
2
3
4
5
6
7
8

    /*
     * @Target: 用于测试* login(String,String)这个切入点表达式_测试多个切入点表达形式
     * @Author: DaShu
     * @Date: 2021/6/21 20:53
     * @Result: 这个切入点定义到了login方法，并且具有两个参数，并且两个参数都是String类型；
     */
    @Test
    public void test6(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext3.xml");
        UserService userService = (UserService)ctx.getBean("userService");
        userService.login("zhangjie","zhangjie");
        //...........................这里是额外功能...............................
        //UserServiceImpl.login
        //-------------------------------这里还是额外功能----------------------------------------
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

whthin这个函数

主要用于类、包切入点的表达式的匹配。
需求：切入点想选择UserServiceImpl这一个类，不关心包
execution(* *..UserService.*(..)) -->使用execution方式这样写。
within(*..UserServiceImpl) -->这个不关系包只关心类的书写方法。
execution(* com.baizhiedu.proxy..*.*(..)) --使用execution这样写。
within(com.baizhiedu.proxy..*)
1
2
3
4
5
6

其实这种简化的写法就是在execution函数选择了一些东西，省略了一些东西。

@Annotation

作用：为具有特定注解的方法加入额外功能，这个是最核心的功能
分析一下：

    <aop:config>
        <!--这个标签就是用来定义切入点的，expression这个是切入点表达式,代表所有的方法都要加上这个额外功能-->
        <!--所有的方法，都作为切入点作为额外功能。-->
<!--        <aop:pointcut id="pc" expression="execution(* com.pactera.spring.proxy.UserServiceImpl.*(String,..))"/>    -->
        <aop:pointcut id="pc" expression="@annotation(com.pactera.spring.annotation.Log)"/>
        <!--组装，组长的目的就是为了把切入点与额外的功能进行整合-->
        <aop:advisor advice-ref="around" pointcut-ref="pc"/>
    </aop:config>
1
2
3
4
5
6
7
8

/**
 * @Auther: DaShu
 * @Date: 2021/6/15 18:58
 * @Description:
 */
public class UserServiceImpl implements UserService{
    @Override
    @Log
    public void register(User user) {
        //这代表的事业务运算+dao的调用，额外功能不写在这里边。
        System.out.println("UserServiceImpl.register");
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

切入点函数的逻辑运算

切入点函数的逻辑运算值得是整合多个切入点函数一起配合工作，进而完成更为复杂的需求
逻辑运算指的就是整合多个切入点函数的，让他们一起起作用，进而满足可能会遇到的更为复杂的需求，基本操作
and 与操作

案例1：login得叫login,参数是两个String类型即可。
execution(* login(String,String))  -->使用原生execution的书写方式
execution(* login(..))  and  args(String,String)  --使用切入点函数的逻辑运算。
两个表达式必须同时满足，两者取的是交集

注意：与操作不能用于同种类型的切入点函数，
1
2
3
4
5
6

or 或操作

两个切入点满足之一即可进行。
1

！非操作

    <aop:config>

        <aop:pointcut id="pc" expression="@annotation(com.spring.annotation.Log) and !execution(* com.spring.proxy.UserServiceImpl.re*(..))"/>
        <aop:pointcut id="pc01" expression="@annotation(com.spring.annotation.Log) and !execution(* com.spring.proxy.UserServiceImpl.register(..))"/>
        <aop:advisor advice-ref="around" pointcut-ref="pc"/>
    aop:config>
1
2
3
4
5
6

    @Test
    public void test1() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
        UserService userService = (UserService) ctx.getBean("userService");
        userService.register(new User());
        userService.register01(new User());
        //UserServiceImpl.register
        //UserServiceImpl.register01

    }
    @Test
    public void test2() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
        UserService userService = (UserService) ctx.getBean("userService");
        userService.login("sun", "123456");
        //...........................这里是额外功能1...............................
        //UserServiceImpl.login
        //-------------------------------这里还是外功能2----------------------------------------
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这个非操作使用的是!这个符号。

Spring动态代理开发总结

• 为什么使用spring动态代理开发？
  动态代理开发就是代理开发，作用就是通过代理类对目标类或者叫做原始类增加额外的功能，好处就利于原始类的维护，这里代理类的好处，具体到spring的动态代理的来讲呢，一共是四步，spring创建目标对象，spring创建额外功能对象，定义切入点，整合切入点和额外功能。

第四章：AOP编程

Aop编程 Aspect Oriented Programming面向切面编程，什么叫做面向切
面编程，oop面向对象编程，pop面向过程编程

• 面向对象编程含义

以对象为基本单位的程序开发，通过对象间的彼此协同，相互调用来达到开发目的。

• 面向过程编程

以过程为基本单位的层程序开发，以过程之间的相互协同，相互调用来达到开发的目的，这里的古城值得就是方法或者说函数

• 面向切面编程
  以切面为基本单位的层程序开发，以切面之间的相互协同，相互调用来达到开发的目的。如果我们能找到切面，并且以切面进行开发，就是以切面进行开发

切面：切入点+额外功能。他们两个被组装后形成切面。这是spring动态代理的开发当中是面向切面编程的基础。spring的动态代理开发其实就是面向切面编程，这两个是完全等价的，Aop编程的背后的技术就是动态代理技术。

• 什么是Aop编程
  Aop编程的本质就是Spring动态代理的开发，通过代理为原始类增加额外的功能，好处就是利于原始类的维护，有了Aop编程之后就可以取代oop这个说法是不正确的，她是从oop上发展来的，不存在 取代的关系，他仅仅是oop编程的一种有益的补充。

Aop的开发步骤

准备原始对象
准备原始功能
切入点
组装成切面（额外功能+切入点）
这里的开发步骤和spring的动态代理技术是没有任何区别的。

• 名词解释-切面
  切面：切入点+额外功能
• 为什么spring的切入点+额外功能叫做切面呢？
  不用管，没啥用。
  
  形成了一个切面，所以叫切面。

第五章：AOP底层实现原理

也就是动态代理的底层实现原理

• 核心问题：

1、 Aop如何帮我们创建这个动态代理类，这个动态代理类是依赖于一门动态字节码技术，动态字节码技术到底是如何通过我们的编码将jvm中的动态代理类创建出来的呢？
2、Spring在做动态代理或者aop编程的时候，有一个非常有意思的事，他是怎么把原始对象的id值，拿到的事动态代理对象的id值的呢？
以上的问题就等效与：spring是如何创建和加工动态代理对象的。

如何创建动态代理类

spring创建动态代理类有两种方式，第一种方式是jdk动态代理，第二种是Cglib动态代理。

• JDK动态代理
  这里研究的事动态代理对象的创建，而并不是动态代理类的创建，真正的动态代理类的创建是Proxy.newInstatnce(…)这个方法执行的时候，在jvm内存中创建的动态代理类，上边这个方法获取的是动态代理对象，

spring的动态代理或者说spring的aop的代理对象的创建和使用，他的本质也是使用的事jdk动态代理或者cglib动态代理，他的写法已经在是spring当中固定好了，所以，原始对象必须得是交由spring进行创建，另外本质的spring向外暴露的动态代理的实现方式还是对jdk底层动态代理实现或者cglib动态代理实现的封装。

创建动态代理的三要素：原始对象、额外功能、动态代理和原始类实现相同的接口。

这个动态代理在这一组参数当中，invocationHandler这是一个接口，这个接口对应了我们的额外功能，在这个接口当中有一个invoke方法，实现了这个接口之后呢，这个接口当中有三个方法，方法中有三个参数，如下，执行任何一个方法（原始方法）都需要三个要素，对象、方法、参数列表，不论是普通调用，或者使用反射，都是这么个情况，所以第二个参数是方法对象，第三个参数是方法的参数数组，还需要第一步创建的原始对象，这样就可以执行原始方法了，这个invoke方法的返回值代表的是原始方法的返回值，这里的这个接口当中的invoke方法是原生jdk提供的动态代理的实现方式，spring对我们暴露的实现方式呢有那个MethodInceptor这个接口，这个接口当中的invoke方法中有一个参数对象，可以执行proceed（）方法其实这个就是对原生jdk的一个封装，原生的肯定复杂一点，封装之后的肯定更好用。

代理对象要和原始对象实现相同的接口，为什么我们动态代理对象要和原始对象实现相同的接口呢，因为都耦合与一个接口才能迷惑调用者呀，

我们创建的是jdk的动态代理，也需要实现和目标类相同的接口，这个条件不是我们来实现，而是proxy.newProxyInstance这个方法类帮我们实现，这里的传入的第二个参数就是干这个用的。提供这个参数是使用，是采用UserService.class对象，就可以使用userService.getClass().getInterfaces()；这个形式获取就可以了。

        //创建原始对象
        UserService userService = new UserServiceImpl();
        //创建动态代理基于jdk，创建动态代理基于jdk的方式，需要调用jdk为我们提供的一个工具proxy
        //这个方法的返回值就是这个类的动态代理对象。
        //这个方法需要三个参数，第一个参数
1
2
3
4
5

到这里我们实现动态代理的的三个要素就准备好了，原始对象，我们自己new的，

额外功能呢由于我们采用的事jdk形式的动态代理，所以我们使用的接口是,将额外功能书写在这接口实现类中的invoke方法当中，进行响应的处理，实现同样的接口，就是获取原始对象实现的接口传递给这个方法，然而在这个Proxy.newProxyInstatnce()这个方法当中还有一个来加载器对象这样的一个参数，这样的一个参数究竟作用是什么呢，这就是
类加载器的作用：（单纯谈类加载器的作用）
1.通过类加载器把对应类的字节码文件加载到虚拟机当中，
2.通过类加载器创建类的class对象，进而创建这个类的实例。
Class对象记录着这个类最完整的信息。
我们书写的java文件是java的源码文件，java文件经过编译之后的文件称为字节码文件，也就是.class文件，程序的运行是class文件加载到jvm内存当中之后被执行的结果，那么将class字节码文件加载到虚拟机当中是谁干的呢？ 是类加载器，字节码进入到虚拟机当中之后，类加载器帮我们加载class文件到jvm内存之后，还会帮助我们创建这个类的Class对象，这里边有这个类最全的信息，进而可以创建这个类的实例。这个类加载器在我们的创建对象的过程当中是尤为重要的，类加载器这么重要，如何获取类加载器呢？
虚拟机会为每一个class分配对应的类加载器，有了这个类加载器之后呢，我们就可以创建这个类的字节码对象了，在动态代理的创建中为什么需要类加载器呢？动态代理也是在虚拟机当中获得动态代理类，进而帮我们创建动态代理对象，这个动态代理类没有源文件，也买有字节码文件，动态代理类他是怎么获取这个类的字节码来创建对象的呢？动态代理是通过动态字节码技术来创建字节码，直接就将字节码写到了虚拟机当中，没有一个加载字节码的过程，这个动态字节码技术在我们的虚拟机当中是怎么实现的？我们是怎么对他进行编程的呢？他暴露给我们程序员的就是Proxy.newProxyInstance（）这个方法，这个方法中就会使用这个动态字节技术，作为这个动态字节码技术，而且我们在这个方法中已经传入了所有的创建动态代理类所需要的原材料，那么使用这个动态字节码技术呢，直接将字节码写到了虚拟机当中，所以呢类加载的第一个作用就没有用武之地了，这里的类加载器起的作用个呢是床架你这个动态代理类的Class对象，也就是发挥他的第二个技术，省略了一个加载的过程，有了这个字节码对象我们就能创建这个类的实例了（所有的创建对象都是如此），到了这里呢，就不太好搞了，之前的普通类加载的时候呢是虚拟机根据字节码文件（.class文件）进行分配，现在呢，动态代理类是动态字节码，并没有这个Class文件，没有这个class文件，虚拟机就不会为他分配类加载器，也就没有办法生成Class对象，此时在动态代理创建的过程当中，需要类加载器创建代理类的Class对象，可是动态代理类没哟对应的Class问文件，虚拟机也就不会为他分配类加载器，但是我们又需要，怎么办？借一个，借用的是源文件的类加载对象，来过来为动态代理类创建Class对象的，进而创建这个类的实例，这也是这里为什么需要一个类加载器参数的原因。借用谁的？比方说UserService,或者UserServiceImpl

package com.spring;

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

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

/**
 * @Auther: DaShu
 * @Date: 2021/6/23 19:23
 * @Description:
 */
public class JdkProxyTest {
    public static void main(String[] args) {
        //创建原始对象
        UserService userService = new UserServiceImpl();
        //创建动态代理基于jdk，创建动态代理基于jdk的方式，需要调用jdk为我们提供的一个工具proxy
        //这个方法的返回值就是这个类的动态代理对象。
        //这个方法需要三个参数，第一个参数
        //为了简单采用内部类的方式来实现invocationhANDLER

        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("-----------这里是代理对象中的额外功能-------------");
                //目标方法执行
                Object invoke = method.invoke(userService, args);
                System.out.println("-----------这里是代理对象中的额外功能-------------");
                return invoke;
            }
        };
        UserService proxyUserService = (UserService) Proxy.newProxyInstance(
                JdkProxyTest.class.getClassLoader(),
                userService.getClass().getInterfaces(),
                invocationHandler);
        proxyUserService.login("崔磊磊", "12345");
        proxyUserService.register(new User());
        //-----------这里是代理对象中的额外功能-------------
        //UserServiceImpl.login
        //-----------这里是代理对象中的额外功能-------------
        //-----------这里是代理对象中的额外功能-------------
        //UserServiceImpl.register
        //-----------这里是代理对象中的额外功能-------------

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

我们说这个了类的类加载器是借的，我们借的谁的都行。

注意：jdk8.0之前呢 内部类访问外部类类的变量需要外部类的成员边量是final修饰的，jdk8.0之后呢会自动加上这个final，

• CGLIB动态代理创建方式
  cglib动态代理也是spring底层默认支持的一种动态代理创建方式，他跟jdk动态代理的区别在哪里呢？
  jdk动态代理中：原始对象需要实现一个接口，比方说UserServiceImpl 实现 UserService接口，代理对象需要和原始兑现实现相同的接口，为什么会有一个这样的要求呢？第一保证代理类和原始类方法一致，第二点保证代理类当中提供对应方法的新的实现，就可以加入额外功能了，也可以调用原始方法，所以说我们的代理类，这样代理的诉求就实现了。这就是jdk的动态代理。
  作为cglib来讲创建动态代理类有什么特点呢？原始类没有实现任何接口，没有实现任何接口的这样的代理类创建代理对象的时候，反正我们的初衷就是我们的代理类和原始类中必须有相同的方法，新的实现里边包括这个额外功能和原始功能的调用，新的代理类可以使用什么来开发呢？cglib要求他所创建的这个代理类要去继承这个原始类，这样来保证你有的这个方法我也有，变相也保证了代理类和原始类有这个共同方法的要求，然后就有机会添加新的实现，调用原始方法super.就可以了，这样的实现的方式不同，但是最终的结果是一致的。cglib采用的事这个父子继承的关系，不管原始类有没有实现接口。

cgilib实现动态代理的的步骤，1，准备原始对象UserService原始对象的userService不需要实现任何的接口，里边准备两个原始方法，第二部，创建代理对象，创建代理对象需要cgilib对应的jar包，这个jar包spring已经默认帮我们引入进来了，这样我们就可以直接使用，cgilib的jar包中最为关键的类是一个Enhancer的接口，作为这个类来讲，我们调用create方法进行创建代理对象，这里边需要几个参数，他所需要的参数和jdk的参数是一模一样的，只不过这里边的接口类型指定的值父类的class对象，还有一个父类的原始功能，Enhancer.setClassLoader()Enhance.setSupperClass,Enhance.setCallBack（MethodInterceptor）这个接口是cgilib中的接口跟当时的spring不是一个接口，
创建这个cglib的Methodinterceptor的接口的时候，采用一个内部类的形式，创建他的子类的实例对象，子类对象需要重写他的intereceptor方法，

package com.spring.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @Auther: DaShu
 * @Date: 2021/6/24 19:41
 * @Description:
 */
public class TestCglib {
    public static void main(String[] args) {
        UserService userService = new UserService();

        //通过cgilib方式进行创建，
        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(TestCglib.class.getClassLoader());
        enhancer.setSuperclass(userService.getClass());
        MethodInterceptor interceptor = new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("----------cgilib日志额外功能。----------");
                //等同于invocationHandler中的invoke方法，
                Object invoke = method.invoke(userService, args);
                return invoke;
            }
        };
        enhancer.setCallback(interceptor);
        UserService proxyUserService = (UserService)enhancer.create();
        proxyUserService.login();
        proxyUserService.register();
        //----------cgilib日志额外功能。----------
        //UserService.login
        //----------cgilib日志额外功能。----------
        //UserService.register
    }
}

///**
// * @Auther: DaShu
// * @Date: 2021/6/24 19:39
// * @Description: 这个代表原始类。
// */
//public class UserService {
//    public void login(){
//        System.out.println("UserService.login");
//    }
//    public void register(){
//        System.out.println("UserService.register");
//    }
//}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

• 总结
  jdk动态代理，Proxy.newProxyInstance();,通过接口原始对象的代理类，cgilib动态代理依赖于Eahancer这个类，通过继承原始类创建原始类的代理类，在spring的后续过程中，如果在面试过程中可以把这些方法中的对应的参数说清楚，这是一个大大的加分项。

BeanPostProcessor分析

后置处理Bean，这个东西的全称叫做BeanPostProcessor，最主要的作用是对spring创建的对象进行再加工，这个是spring工厂中的一个非常有用的高级特性，在spring底层很多高级的封装的时候都有这个技术的影子，讲了aop底层的实现的时候，会发现这个技术的价值是非常高的，spring的aop底层实现很大的一部分是这个在进行技术进行技术支撑，

BeanPostProcessor是对spring的bean工厂进行在加工，spring工厂创建对象的过程是：spring获取spring的核心配置文件之后对spring的核心配置文件进行解析，获取到响应的bean标签会后，通过反射技术调用该类的构造方法，创建该类的实例，第二件事是spring对这个类中的成员变量按照配置进行注入，注入完成之后，调用这个类的初始化方法，对这个类进行一个初始化，这个初始化方法是我们自己定义的，经过这样的一个过程，这个对象就创建并初始化好了，现在就可以通过getBean通过id进行获取这个对象，而这个后置处理bean，是在工厂创建完成这个对象之后，对这个对象进行再次加工，这就是这门技术的意义，那么她是怎么实现对这个工厂创建出来的对象进行再次加工的呢？BeanPostProcessor是一个接口，我们需要把这个对象加工的内容写到接口实现类对应的方法中即可。
在这个接口当中呢有两两个方法，第一个方法是postProcessBeforeInitialization，另外的方法叫after,这样的接口，当Bean实现了这个接口之后，spring在创建这个对象的过程中，在spring完成调用构造方法创建实例，并依据配置进行注入之后，spring就会调用这个类的postProcessBeforeIntitialzation方法进行一个初始化操作，是通过这个方法中的第一个Object类型bean参数进行传递的，另外一个参数，是这个对象在spring中的id值。在这个方法中通过这两个参数就获取到了这个参数，就可以在方法中对这个实例进行加工了。还要把这个加工好的对象交还给spring，通过参数把这个对象进行处理，交还给spring之后，执行我们配置好的初始化方法，然后将这个对象交给after这个方法，通过这个方法进行一次在加工，加工完毕之后，将这个参数传递个返回给spring。最后在客户处可以通过getBean方法进行获取。

这就是bean引入了Beanpostprocessor这个技术之后的全部的过程分析。后置处理bean的运行原理分析。
对于使用者，我们的作用就是让我们的bean实现这样的接口和接口中的方法，返回的值是Object

创建实例—注入—before方法—初始化方法—After方法，
有了这两个方法之后呢，实际的过程中，我们我们极少做初始化操作，所以，我们区分这个之前之后，这两个操作就合二为一的，

实际上spring的初始操作使用的很少，所以，这个所谓的前后，也就没有什么前后之分了，两个挨着呢，实现其中的一个方法即可，也就是将代码写入到一个方法中就可以了。选谁，选After就可以了。但是啥也不干你也得有一个return bean得到操作。需要注意的事before这个操作，我们必须return bean对象，这张图使我们必须要理解的内容。

开发步骤

定义一个类实现这个接口

package com.spring;

import com.spring.postBeanProcessor.Catagory;
import org.junit.jupiter.api.Test;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Auther: DaShu
 * @Date: 2021/6/24 21:17
 * @Description:
 */
public class TestPostBeanProcessor {
    @Test
    public void test1(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext1.xml");
        //-----------------------before-----------------------
        //PostBeanProcessorTest{id=10, name='xioajianren'}
        //-----------------------before-----------------------
        //------------------------init-----------------------
        //PostBeanProcessorTest{id=11, name='xiaojianren1'}
        //--------------------------init---------------------
        //---------------------------after-------------------------------
        //PostBeanProcessorTest{id=12, name='xiaojianren2'}
        //---------------------------after-------------------------------
    }
}


package com.spring.postBeanProcessor;

/**
 * @Auther: DaShu
 * @Date: 2021/6/24 21:38
 * @Description:
 */
public class Catagory {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "PostBeanProcessorTest{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public void init(){
        System.out.println("------------------------init-----------------------");
        System.out.println(this.toString());
        System.out.println("--------------------------init---------------------");
    }

}



package com.spring.postBeanProcessor;

        import org.springframework.beans.BeansException;
        import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * @Auther: DaShu
 * @Date: 2021/6/24 21:04
 * @Description:
 */
public class PostBeanProcessorTest implements BeanPostProcessor {


    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if(bean instanceof com.spring.postBeanProcessor.Catagory){
            System.out.println("-----------------------before-----------------------");
            System.out.println(bean.toString());
            ((com.spring.postBeanProcessor.Catagory)bean).setId(11);
            ((com.spring.postBeanProcessor.Catagory)bean).setName("xiaojianren1");
            System.out.println("-----------------------before-----------------------");
        }
        return bean;
    }



    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("---------------------------after-------------------------------");
        ((com.spring.postBeanProcessor.Catagory)bean).setId(12);
        ((com.spring.postBeanProcessor.Catagory)bean).setName("xiaojianren2");
        System.out.println(bean.toString());
        System.out.println("---------------------------after-------------------------------");
        return bean;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       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/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id = "catagory" class = "com.spring.postBeanProcessor.Catagory" init-method="init">
        <property name="id" value="10"/>
        <property name="name" value="xioajianren"/>
    bean>
    <bean id = "postBeanProcessorTest" class = "com.spring.postBeanProcessor.PostBeanProcessorTest" />

beans>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

再看这个postbeanprocessor在Aop中的使用，

• Spring工厂如何加工创建代理对象
  为什么通过原始对象id获取的是代理对象的id值呢？这是aop的核心原理的第二个问题，spring的工厂是如何加工和创建这个对象呢？
  在spring创建一个对象的时候，spring的工厂可以通过BeanPostProcessor这个工厂来进一步加工这个对象，我们的当时写的案例非常的简单，创建好对象之后，spring工厂调用，在后置BeanPostProcessor当中对这个bean进行赋值，然后将处理后的bean进行返回，当动态代理结合上beanpostprocessor之后，就可以实现这个通过原始的id返回对应的代理对象，其原理呢就是将这个加工代理对象的方法写入到这个后置处理bean中BeanPostProcessor当中的PostProcessorAfterInization这个方法中，然后将代理对象的地址进行返回即可。
  我们知道我们很少做这个初始化操作，所以，这个前置处理和后置处理的位置是挨着的，他们的作用是完全一样的，这样的before我们就不用了，直接将bean对象进行返回，交还给spring即可，然后呢，这个所有加工的代理都写在了后置处理的这个方法中，调用的事Proxy.newProxyInstance（）这个方法，这里的实现前边都讲过了，然后将创建好的代理对象交还给spring工厂，这样spring工厂就可以通过id获取的事代理对象，这就是通过原始对象的id值获取的事代理对象的加工。

Spring工厂对于代理的加工

是通过通过spring工厂创建并获取代理对象的，这就解释了spring如何是将通过id的值获取的事代理的对象。

package com.spring.factory;

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

/**
 * @Auther: DaShu
 * @Date: 2021/6/28 21:34
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext2.xml");
        UserService userService = (UserService)ctx.getBean("userService");

        userService.login("suns","liming");
        userService.register(new User());
        //------------new Log()----------------
        //UserServiceImpl.login
        //------------new Log()----------------
        //UserServiceImpl.register
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

package com.spring.factory;

import com.spring.annotation.Log;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

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

/**
 * @Auther: DaShu
 * @Date: 2021/6/28 21:24
 * @Description:
 */
public class ProxyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    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 invoke = method.invoke(bean, args);
                return invoke;
            }
        };
        //这样返回的已经不再是原始对象而是，加工之后产生的代理对象。
        return Proxy.newProxyInstance(ProxyBeanPostProcessor.class.getClassLoader(),bean.getClass().getInterfaces(),handler);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       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/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class = "com.spring.factory.UserServiceImpl"/>
    <bean id = "proxyBeanPostProcessor" class = "com.spring.factory.ProxyBeanPostProcessor"/>
beans>


1
2
3
4
5
6
7
8
9
10
11
12

基于注解的AOP编程

从jdk5.0之后就java就引入了注解的开发，作为spring框架来讲，支持基于注解进行aop开发，但其核心仍然是aop的开发，所以，仍然包括那四步；

原始对象

原始对象这一块，仍然需要在配置文件中配置这个对象。
下边的三个步骤其实就是为了创建组装切面。切面是由切入点和额外功能组装而成，要想构建切面现有额外功能，再有切入点，在进行组装就好了，所以，后三个过程就是为了创建切面。在基于注解的开发过程中它所定义的切面就是一个切面类。我们创建一个MyAspect这样的切面类。想要表达这个类是一个切面类的话我们需要一个这样的注解，@Aspect这样的注解，一旦我们的类加上这个注解之后，这个类就成了切面类，切面类中包含额外功能和切入点。

额外功能

需要在切面类上增加一个@Aspect注解，通过这个注解，就可以定义这是一个切面类，但凡是一个切面，都必须要有额外功能和切入点，这样才能组成切面，如何才查看？
在切面类当中如何定义一个切面方法，这个额外功能的方法可以随意命名，但是上边必须要有一个@Around注解，这里的注解就替换了之前实现接口的问题，

切入点

组装切面

通过切面定义了额外功能，@Around通过切面类也定义了切入点@Around(excution( login(…)))，@Aspect定义了切面类。这样所有的内容就和xml开发模式匹配了。我们需要将切面类交由Spring进行创建对象还需要告诉Spring我们现在是基于注解开发Spring的AOP*

• 注解开发的基本示例

package com.spring.aspect;

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

/**
 * @Auther: DaShu
 * @Date: 2021/6/28 21:54
 * @Description:
 */
@Aspect
public class MyAspect {
    /**
     * ProceedingJoinPoint这个等效于MethodInvocation
     * 这里写的是额外功能的部分,现在的额外功能不需要实现接口了，只需要加入注解。
     * */
    @Around("execution(* login(..))")
    public Object arround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("--------------aspect log-----------");
        Object proceed = joinPoint.proceed();
        return proceed;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

    
    <bean id="userService" class = "com.spring.aspect.UserServiceImpl"/>
    
    <bean id ="around" class = "com.spring.aspect.MyAspect"/>
    
    <aop:aspectj-autoproxy/>```
1
2
3
4
5
6

• 如何做多个额外功能 & 切入点复用

在以上基础写法的基础上进行修改，修改MyAspect这个类，其他保持一致。所谓的切入点复用，就是在切面类中定义一个函数，这个函数上边加上@Point注解，后续更加附加功能有利于切入点的复用。

package com.spring.aspect;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

/**
 * @Auther: DaShu
 * @Date: 2021/6/28 21:54
 * @Description:
 */
@Aspect
public class MyAspect {
    //定义一个公共切入点表达式
    @Pointcut("execution(* login(..))")
    public void myPointcut(){}
    /**
     * ProceedingJoinPoint这个等效于MethodInvocation
     * 这里写的是额外功能的部分,现在的额外功能不需要实现接口了，只需要加入注解。
     * */
    @Around(value="myPointcut()")//在这里调用切入点表达式，就完成了整合。
    public Object arround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("--------------aspect log-----------");
        Object proceed = joinPoint.proceed();
        return proceed;
    }

    @Around(value="myPointcut()")
    public Object arround1(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("--------------aspect tx-----------");
        Object proceed = joinPoint.proceed();
        return proceed;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

Spring对于JDK和Cglib动态代理的切换

Aop底层是实现过程中一共有两种实现方式，一种是jdk的，通过实现接口做新的实现类的方式 创建代理对象，Cglib他是通过继承父类的方式来做新的子类来创建最终的代理对象，这种基于注解的AOP代理方式，他最底层是应用那种方式呢？它里边的代理类使用debugger来查看的话是proxy这个代理jdk来做的，默认情况下Aopbiancheng 底层用用的事JDK的动态代理方式，如果切换CGLIB应该怎么办？引入proxy-target-class="true"这个属性就好了，就可以实现切换了，当然这种增加属性的这种方式只适用于针对注解的开发方式

  
  
    <aop:aspectj-autoproxy proxy-target-class="true"/>
1
2
3

如果按照传统的AOP开发应该怎么修改呢？
我們要知道无论是基于注解的还是传统的Aop开发都是默认是JDK动态代理，传统的方式想要切换也是在配置文件中进行配置，配置方式是：

第六章：AOP开发中的坑

编程人员在常规过程中不常遇到的问题，但是一旦遇到这个问题，就一定会出错

一：代码实例

public class TestASpectProxy {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext3.xml");
        UserService userService = (UserService) ctx.getBean("userService");
        userService.register(new User());
        //--------------aspect log-----------
        //--------------aspect tx-----------
        //UserServiceImpl.register
        //UserServiceImpl.login
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

@Aspect
public class MyAspect {
    //这是一个类切入点，给所有的都加上额外功能
    @Pointcut("execution(* *..UserServiceImpl.*(..))")
    public void myPointcut(){}
    /**
     * ProceedingJoinPoint这个等效于MethodInvocation
     * 这里写的是额外功能的部分,现在的额外功能不需要实现接口了，只需要加入注解。
     * */
    @Around(value="myPointcut()")//在这里调用切入点表达式，就完成了整合。
    public Object arround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("--------------aspect log-----------");
        Object proceed = joinPoint.proceed();
        return proceed;
    }

    @Around(value="myPointcut()")
    public Object arround1(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("--------------aspect tx-----------");
        Object proceed = joinPoint.proceed();
        return proceed;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class UserServiceImpl implements UserService {
    @Override
    public void login(String username, String password) {
        System.out.println("UserServiceImpl.login");
    }

    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register");
        this.login("suns","123456");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

测试结果并不符合预期，login方法调用的时候额外功能并没有展示，这个就是那个坑，为什么login方法没有执行额外功能呢？当我们的调用者调用register方法的时候，我们调用的是Proxy代理对象的Register方法，加入了日志加入了事务，最终执行了这两个额外功能，没有问题，但是调用login方法的时候，是在原有功能当中调用的login方法，调用的并不是代理对象中的login方法而是调用的login原生的login方法所以没有额外功能的加入。

这个告诉我们的道理就是：方法中调用类中原始对象的方法的的时候，那么久不会有额外功能的引入，要想使调用方法的额外功能也展示需要调用代理对象的对应的方法，而不是原始对象的对应的方法。也就是说我们需要在我们的register方法中获取到Spring的工厂对象，进而拿到我们的代理对象，进而调用我们的代理对象的login方法，然而初步的想法是在register方法中创建Spring的工厂对象，然而这是不可取的，这是重量级资源，占用大量内存，可以采取的途径是让我们的UserServiceImpl 实现ApplicationContextAware接口，Aware的含义是知道的意思，这个接口中有一个方法是setApplicationContext，通过这个方法入参是工厂对象，Spring容器启动时会回调这个方法，将引用赋值给这个这个方法，所以我们实现方法之后，存一份就好了。**

public class UserServiceImpl implements UserService, ApplicationContextAware {
    private ApplicationContext ctx;

    @Override
    public void login(String username, String password) {
        System.out.println("UserServiceImpl.login");
    }

    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register");
        UserService userService = (UserService) ctx.getBean("userService");//userService是代理对象
        userService.login("suns","123456");
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

二：测试结果

public class TestASpectProxy {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext3.xml");
        UserService userService = (UserService) ctx.getBean("userService");
        userService.register(new User());
        //--------------aspect log-----------
        //--------------aspect tx-----------
        //UserServiceImpl.register
        //    --------------aspect log-----------
        //--------------aspect tx-----------
        //UserServiceImpl.login

    }
}
//实现了被调用的时候也有这个额外功能的实现。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

总结

在同一个业务类中，进行业务方法间的相互调用的时候，只有最外层的方法，加入了额外功能了。

内部的方法通过普通的方式进行调用，并没有额外功能，都是原始方法，那么如果想让内层的方法也调用代理对象的方法，就需要通过ApplicationContextAware获得工厂，进而获得代理对象