随笔- 131 文章- 0 评论- 2 阅读- 54098

Spring-AOP(jdk代理、cglib代理、xml中的AOP、注解中的AOP)

1. 概念

- 　AOP(Aspect Oriented Programming) ：面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。也就是横向开发。
- 　AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。

　　　　　利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2. 作用&优势

- 　作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强。

　　　　　　　　开闭原则：对拓展开放，对修改关闭。

- 　优势：减少重复代码，提高开发效率，并且便于维护。

3. AOP 的底层实现

　　　　AOP 的底层是通过 Spring 提供的的动态代理技术实现的。

　　　　在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

4. 常用的动态代理技术

JDK 代理 : 基于接口的动态代理技术。先创建代理对象。（常用）
cglib 代理：基于父类的动态代理技术。后创建代理对象。

5. 面向切面注意

- 　插入代码不能影响源代码执行。
- 　添加非必要功能与程序业务无关。

　　　　以游戏内98K为例：98K的创造只为射击，这就是源代码；在不改动98K的基础上安装八倍镜或消音器为更方便使用，就用到了代理。

6. JDK代理

　　1）新建Maven项目：

　　　　设置： file conf --> settings 与 repository仓库更改为安装Maven目录下。

　　导入依赖：

    <dependencies>
        <!--导入spring的context坐标，context依赖aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
    </dependencies>

　　　　新建 target 包 --> ITarget接口/Impl包 --> TargetImpl 目标类

//接口类
public interface ITarget {
    void say();
}

// 目标类
public class TargetImpl implements ITarget {

    @Override
    public void say() {
        System.out.println("目标类执行！");
    }
}

<!--    JDK代理    -->
    <bean id="TargetImpl" class="com.bei.target.impl.TargetImpl"></bean>

public class Main {
    public static void main(String[] args) {
//        JDK代理
//        生成目标对象，修饰成final
        final TargetImpl target = new TargetImpl();
//        创建代理对象
        ITarget proxy = (ITarget)Proxy.newProxyInstance(  // 方法内套方法：匿名内部类  --强转接口

// 被代理类的类加载器  target.getClass().getClassLoader(), // 被代理类的实现接口  target.getClass().getInterfaces(), // 需要增强的方法 new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("JDK代理：前增强--目标类执行！"); // 属于反射，方法的执行 Object invoke = method.invoke(target, args); System.out.println("JDK代理：后增强--目标类执行！"); return invoke; } } ); proxy.say(); } }

　　结果：

　　解析：

- 　Proxy.newProxyInstance() 方法是生成代理对象的，有三个参数，类加载器，目标类的所有接口字节码对象，InvocationHandler；
- 　InvocationHandler：可以理解为一个回调函数，里面的invoke()是关键，代理对象执行方法就是在执行invoke()方法；
- 　method.invoke(target, args)：属于反射，方法的执行。

　　　　　　　　方法内套方法：匿名内部类。
　　　　　　接口名 小名 = (接口名) 方法()；--强转接口

7. cglib 代理

　　1）cglib导入依赖

    <dependencies>
        <!--导入spring的context坐标，context依赖aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <!-- aspectj的织入 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>

<!--        cglib 导入-->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.1_3</version>
        </dependency>

    </dependencies>

　　依然是上面 JDK代理的 target 包、ITarget接口、TargetImpl 目标类及 Bean。

public class Main {
    public static void main(String[] args) {
        
//        cglib代理
//        生成目标对象，修饰成final
        final TargetImpl target = new TargetImpl();
//        创建增强器
        Enhancer enhancer = new Enhancer();
//        设置父类
        enhancer.setSuperclass(TargetImpl.class);
//        设置回调
        enhancer.setCallback(  // 方法内套方法：匿名内部类
                new MethodInterceptor() {
                    @Override
                    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                        System.out.println("cglib-前置代码增强！");
                        Object invoke = method.invoke(target, objects);
                        System.out.println("cglib-后置代码增强！");
                        return invoke;
                    }
                }
        );
// 后创建代理对象。
        ITarget iTarget = (ITarget) enhancer.create();
        iTarget.say();
    }
}

结果：

8. AOP相关概念：（以上面98k为例，安装八倍镜或消音器）

- Target（目标对象）：代理的目标对象；(源代码) 例：98K或消音器
- Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类； 例：安装了八倍镜或消音器的98K
- Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点；例：能在98K上装八倍镜或消音器的位置(地方)
- Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义；例：装了八倍镜或消音器的位置(地方)

　　　　　　　连接点有多个，切点仅一个。

- Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知； 例：八倍镜或消音器
- Aspect（切面）：是切入点和通知的结合；
- Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而Aspect采用编译期织入和类装载期织入。 例：配件安装的过程

9. xml中的AOP：

　　1）导入 AOP 相关坐标：如上 cglib 依赖导入；

    <dependencies>
        <!--导入spring的context坐标，context依赖aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <!-- aspectj的织入 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>

<!--        cglib 导入-->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.1_3</version>
        </dependency>

    </dependencies>

　　2）创建目标接口和目标类（内部有切点）

//目标接口
public interface ITarget {
    void say();
}

@Repository("TargetImpl")
// 目标类
public class TargetImpl implements ITarget {

    @Override
    public void say() {
        try {
            Thread.sleep(2000); // 线程休眠 2s
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("目标类执行！");
    }
}

　　3）创建切面类（内部有增强方法）

//xml 的 AOP
@Repository("MyAspect")

public class MyAspect {
//    前置增强方法
    public void before(){
        System.out.println("xml内前置增强了！");
    }
//    后置增强方法
    public void after() {
        System.out.println("xml内后置增强了！");
    }

//    环绕增强
    public Object around(ProceedingJoinPoint joinPoint){
//        开始时间
        long start = System.currentTimeMillis();
//        获取当前要执行的类的类名
        String declaringTypeName = joinPoint.getSignature().getDeclaringTypeName();
//        获取当前要执行的方法的方法名
        String name = joinPoint.getSignature().getName();
        Object proceed = null;
        try {
//            AOP代理链接执行
            proceed = joinPoint.proceed();
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
//        结束时间
        long end = System.currentTimeMillis();
        System.out.println("类名：" + declaringTypeName);
        System.out.println("方法名是：" + name);
        System.out.println("执行时间为：" + (end - start) + "ms");
        return proceed;
    }
}

　　4）将目标类和切面类的对象创建权交给 spring

<!--    配置目标类  -->
<bean id="TargetImpl" class="com.bei.target.impl.TargetImpl"></bean>


<!--    将目标类和切面类的对象创建权交给spring   -->
<!--    配置切面类  -->
    <bean id="MyAspect" class="com.bei.aspect.MyAspect"></bean>

　　5）在 applicationContext.xml 中配置织入关系

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
">

<!--    JDK代理    -->
<!--    配置目标类   -->
    <bean id="TargetImpl" class="com.bei.target.impl.TargetImpl"></bean>

<!--    将目标类和切面类的对象创建权交给spring   -->
<!--    配置切面类  -->
    <bean id="MyAspect" class="com.bei.aspect.MyAspect"></bean>

    <aop:config>
        <aop:aspect ref="MyAspect">
            <aop:before method="before" pointcut="execution(* com.bei.target.impl.*.*(..))"/>
            <aop:after method="after" pointcut="execution(* com.bei.target.impl.*.*(..))"/>
            <aop:around method="around" pointcut="execution(* com.bei.target.impl.*.*(..))"/>
        </aop:aspect>
    </aop:config>

</beans>

　　6）测试

　　　　回到main 方法里：

public class Main {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        ITarget targetImpl = (ITarget)context.getBean("TargetImpl");  // 强转接口
        targetImpl.say();
        
    }
}

　　输出结果：

9. 切点表达式

　 execution([修饰符] 返回值类型 包名.类名.方法名(参数))
     常用的书写格式：
    execution(* 包名.*.*(..)) 如10:注解中的AOP

- 访问修饰符可以省略；
- 返回值类型、包名、类名、方法名可以使用星号* 代表任意；
- 包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类；
- 参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表；

10. 注解中的AOP （使用注解）

　　1）创建目标接口和目标类（内部有切点）

@Repository("TargetImpl")
// 目标类
public class TargetImpl implements ITarget {
    @Override
    public void say() {
        try {
            Thread.sleep(2000); // 线程休眠 2s
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("目标类执行！");
    }
}

　　2）创建切面类（内部有增强方法）

@Repository("MyAspect")
@Aspect
//切面类
public class MyAspect {
//    前置增强方法
    @Before("execution(* com.bei.target.impl.*.*(..))")  // 注解的AOP
    public void before(){
        System.out.println("AOP 前置 增强了！");
    }
//    后置增强方法
    @After("execution(* com.bei.target.impl.*.*(..))")
    public void after() {
        System.out.println("AOP 后置 增强了！");
    }

//    环绕增强
    @Around("execution(* com.bei.target.impl.*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint){
//        开始时间
        long start = System.currentTimeMillis();
//        获取当前要执行的类的类名
        String declaringTypeName = joinPoint.getSignature().getDeclaringTypeName();
//        获取当前要执行的方法的方法名
        String name = joinPoint.getSignature().getName();
        Object proceed = null;
        try {
//        AOP代理链接执行
            proceed = joinPoint.proceed();
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
//        结束时间
        long end = System.currentTimeMillis();
        System.out.println("类名：" + declaringTypeName);
        System.out.println("方法名是：" + name);
        System.out.println("执行时间为：" + (end - start) + "ms");
        return proceed;
    }
}

　　3）将目标类和切面类的对象创建权交给 spring

<!--    目标类    -->
    <bean id="TargetImpl" class="com.bei.target.impl.TargetImpl"></bean>

<!--    将目标类和切面类的对象创建权交给spring   -->
<!--    配置切面类  -->
    <bean id="MyAspect" class="com.bei.aspect.MyAspect"></bean>

　　4）在切面类中使用注解配置织入关系

　　　　如 2) 注解：

 1 @Aspect
 2 
 3 //    前置增强方法
 4     @Before("execution(* com.bei.target.impl.*.*(..))")
 5 
 6 //    后置增强方法
 7     @After("execution(* com.bei.target.impl.*.*(..))")
 8 
 9 //    环绕增强
10     @Around("execution(* com.bei.target.impl.*.*(..))")

　　5）在配置文件中开启组件扫描和 AOP 的自动代理

    <!--组件扫描-->
    <context:component-scan base-package="com.bei"/>
    <!--aop的自动代理-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

　　6）测试

　　　　回到main：

public class Main {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        ITarget targetImpl = (ITarget)context.getBean("TargetImpl");
        targetImpl.say();
    }
}

　　　　结果：

拓展重点：

　　面试题：反射
　　　　类加载有InstanseClass，在InstanseClass，有一个Java_mirror：Java镜像。
　　　　（反序列化接口）通过Java镜像获取，可以获取所有信息。

posted @ 2023-12-22 22:37 学Java的`Bei 阅读(247) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Spring-IOC

· Stream流

· Spring - AOP（面向切面编程）

· Spring12第十二 --spring aop切面编程

· SpringAOP

公告

昵称：学Java的`Bei
园龄： 1年3个月
粉丝： 11
关注： 5

+加关注

2025年3月

日

一

二

三

四

五

六

warmNest-llb

Spring-AOP(jdk代理、cglib代理、xml中的AOP、注解中的AOP)

1. 概念

2. 作用&优势

3. AOP 的底层实现

4. 常用的动态代理技术

5. 面向切面注意

6. JDK代理

7. cglib 代理

8. AOP相关概念：（以上面98k为例，安装八倍镜或消音器）

9. xml中的AOP：

9. 切点表达式

10. 注解中的AOP （使用注解）

拓展重点：

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论