✨博客主页：👉不会压弯的小飞侠
✨欢迎关注：👉点赞👍收藏⭐留言✒
✨系列专栏：👉spring专栏
✨如果觉得博主的文章还不错的话，请三连支持一下博主。
✨欢迎大佬指正，一起学习！一起加油！

✨什么是AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

✨AOP概念

Spring的AOP实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

• 常用的术语如下:
• Target(目标对象)︰代理的目标对象
• Proxy(代理):一个类被AOP织入增强后，就产生一个结果代理类
• Joinpoint(连接点)︰所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点
• Pointcut(切入点)∶所谓切入点是指我们要对哪些Joinpoint进行拦截的定义
• Advice (通知/增强)∶所谓通知是指拦截到Joinpoint之后所要做的事情就是通知
• Aspect(切面):是切入点和通知(引介)的结合
• Weaving (织入)∶是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而Aspect - 采用编译期织入和类装载期织入

✨动态代理

Spring中的AOP是基于动态代理实现的，即 JDK动态代理和Cglib动态代理。

• 常用的动态代理技术
  • JDK代理:基于接口的动态代理技术
  • cglib代理:基于父类的动态代理技术

✨JDK动态代理

JDK代理：基于接口的动态代理技术。
案例：

✨TargetInterface

package com.study.proxy.jdk;

public interface TargetInterface {
    void save();
}


  

 

  
1
  
2
  
3
  
4
  
5
  
6
 

✨Target

package com.study.proxy.jdk.impl;

import com.study.proxy.jdk.TargetInterface;

public class Target implements TargetInterface {
    public void save() {
        System.out.println("TargetImpl....");
    }
}


  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
 

✨Advice

package com.study.proxy.jdk;

public class Advice {
    public void before(){
        System.out.println("前置增强....");
    }
    public void after(){
        System.out.println("后置增强....");
    }
}


  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
 

✨ProxyTest

package com.study.proxy.jdk;

import com.study.proxy.jdk.impl.Target;

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

public class ProxyTest  {
    public static void main(String[] args) {
        //目标对象
       final Target target=new Target();
       //增强对象
        final Advice advice=new Advice();
        TargetInterface proxy= (TargetInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(), //目标对象加载器
                target.getClass().getInterfaces(),  //目标对象相同的接口字节码对象数组
                new InvocationHandler() {
                    //调用代理对象的任何方法，实质执行的都是invoke方法
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //前置增强
                        advice.before();
                        Object invoke = method.invoke(target, args);
                        //后置增强
                        advice.after();
                        return invoke;
                    }
                }
        );
        //调用代理对象的方法
        proxy.save();

    }
}
/*
前置增强....
TargetImpl....
后置增强....
 */

  

 

  
 
 

  
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
 

✨Cglib动态代理

Cglib代理：基于父类的动态代理技术。
案例：

✨Target

package com.study.proxy.cglib;

public class Target {
    public void save() {
        System.out.println("TargetImpl....");
    }
}


  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
 

✨Advice

package com.study.proxy.cglib;

public class Advice {
    public void before(){
        System.out.println("前置增强....");
    }
    public void after(){
        System.out.println("后置增强....");
    }
}


  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
 

✨Proxy

package com.study.proxy.cglib;

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

import java.lang.reflect.Method;

public class ProxyTest  {
    public static void main(final String[] args) {
        //目标对象
       final Target target=new Target();
       //增强对象
        final Advice advice=new Advice();

        //调用代理对象的方法,基于cglib
        //创建增强器
        Enhancer enhancer = new Enhancer();
        //设置父类目标
        enhancer.setSuperclass(Target.class);
        //设置回调
        enhancer.setCallback(new MethodInterceptor() {
            public Object intercept(Object proxy, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                //执行前置
                advice.before();
                //执行目标
                Object invoke = method.invoke(target, args);
                //执行后置
                advice.after();
                return invoke;
            }
        });
        //创建代理对象
        Target proxy = (Target) enhancer.create();
        proxy.save();


    }
}
/*
前置增强....
TargetImpl....
后置增强....
 */

  

 

  
 
 

  
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
 

文章来源: blog.csdn.net，作者：不会压弯的小飞侠，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/qq_43514330/article/details/125461203