程序员经验分享-hwhale

Spring-03 Aop简介，实现原理，基于ProxyFactoryBean实现Aop，基于AspectJ开发的实现

2023-11-06

Spring-03

1. SpringAop简介

AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。

aop 解决的问题就是将共同重复的代码就行抽离（日志，事务，鉴权）

什么是切面？切面就是一个类，类里面包含类某一类具体业务（日志，事务，鉴权），用这个类 去拦截/增强 你需要监控的方法或者业务

1.1类与切面的关系

在这里插入图片描述
AOP的使用，使开发人员在编写业务逻辑时可以专心于核心业务，而不用过多的关注于其他业务逻辑的实现，这不但提高了开发效率，而且增强了代码的可维护性。

2.AOP术语

在这里插入图片描述
Proxy（代理）：将通知应用到目标对象之后，被动态创建的对象。

Weaving（织入）：将切面代码插入到目标对象上，从而生成代理对象的过程。

Advice（通知/增强处理）：AOP框架在特定的切入点执行的增强处理，即在定义好的切入点处所要执行的程序代码。可以将其理解为切面类中的方法。

Target Object（目标对象）：指所有被通知的对象，也被称为被增强对象。如果AOP框架采用的是动态的AOP实现，那么该对象就是一个被代理对象。

Aspect（切面）：封装的用于横向插入系统功能（如事务、日志等）的类

Joinpoint（连接点）：在程序执行过程中的某个阶段点

Pointcut（切入点）：切面与程序流程的交叉点，即那些需要处理的连接点

2. Aop的实现原理

实现两种

  • 基于自身的ProxyFactoryBean 实现aop功能
  • 借助于aspectj第三方aop框架实现

aspectj 也是一个优秀的aop框架内

JDK动态代理

JDK动态代理是通过java.lang.reflect.Proxy 类来实现的，我们可以调用Proxy类的newProxyInstance()方法来创建代理对象。对于使用业务接口的类，Spring默认会使用JDK动态代理来实现AOP。

CGLIB代理

JDK的动态代理用起来非常简单，但它是有局限性的，使用动态代理的对象必须实现一个或多个接口。

为了实现类的代理可以使用CGLIB代理

​ CGLIB（Code Generation Library）是一个高性能开源的代码生成包，它采用非常底层的字节码技术，对指定的目标类生成一个子类，并对子类进行增强。

3.基于ProxyFactoryBean实现Aop

ProxyFactoryBean是FactoryBean接口的实现类，FactoryBean负责实例化一个Bean，而ProxyFactoryBean负责为其他Bean创建代理实例。在Spring中，使用ProxyFactoryBean是创建AOP代理的基本方式。

可以配置的属性
在这里插入图片描述

ProxyTargetClass (是否强制使用CGLIB来实现代理)

​ (true : 强制使用CGLIB来实现代理)

​ (false : 不强制使用CGLIB来实现代理，首选JDK来实现代理)（默认值）

isOptimize (是否对生成代理策略进行优化)

​ (true : 进行优化，如果有接口就代理接口(使用JDK动态代理)，没有接口代理类（CGLIB代理）)

​ (false : 不进行优化) （默认值）

实现：

3.1引入依赖

	<properties>
        <!--在当前pom 或者父类pom 中声明属性  -->
        <spirng.version>5.0.16.RELEASE</spirng.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spirng.version}</version>
        </dependency>
        <!-- 导入spring aop -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spirng.version}</version>
        </dependency>
    </dependencies>

3.2创建切面MyAspect

package com.yth.myaspect;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import java.util.Date;
/**
 * @author yth
 * @date 2020/10/21 - 15:11
 */
public class MyAspect implements MethodInterceptor {
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("代理对象开始执行--"+methodInvocation.getMethod().getName()+new Date());

        Object result = methodInvocation.proceed();
        System.out.println("代理对象结束执行--"+methodInvocation.getMethod().getName());
        return result;
    }
}

3.3在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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean class="com.yth.dao.impl.StudentDaoImpl" id="studentDao"></bean>
    <bean class="com.yth.myaspect.MyAspect" id="aspect"></bean>
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="factoryBean">
        <!--
        当实现接口时，指定对应得接口  可以选择不写，
        如果代理只有类，不能写否者报错
        <property name="proxyInterfaces" value="com.wgz.spring.dao.StudentDaoIm"></property>-->
            <!--
                true   cglib 代理
                false  jdk 动态代理
            -->
        <property name="proxyTargetClass" value="false"></property>
            <!--
                指定目标对象
            -->
        <property name="target" ref="studentDao"></property>
             <!--
                指定切面
             -->
        <property name="interceptorNames" value="aspect"></property>
        
    </bean>
</beans>

3.4测试

public static void main(String[] args) {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("aspectj\\Aspectj.xml");
    StudentDao studentDao=  applicationContext.getBean(StudentDao.class);
    studentDao.fingStudentById(100);
}

3.5总结

为什么会有jdk和CGLIB两种选择？

1.jdk 只能代理类实现的接口的类，而没有实现接口类必须使用CGLIB
2.从性能来说：
CGLIB：创建慢，执行块（CGLIB 要生成对应的代理的代码，在创建代理对象）
JDK：创建快，执行慢（反射本身执行就比正常代码的慢）

4. 基于AspectJ开发的实现

AspectJ是一个基于Java语言的AOP框架，它提供了强大的AOP功能。Spring 2.0以后，Spring AOP引入了对AspectJ的支持，并允许直接使用AspectJ进行编程，而Spring自身的AOP API也尽量与AspectJ保持一致。新版本的Spring框架，也建议使用AspectJ来开发AOP。

使用AspectJ实现AOP有两种方式：

  • 基于XML的声明式AspectJ
  • 基于注解的声明式AspectJ

4.1 spring通知的类型

Spring按照通知在目标类方法的连接点位置，可以分为5种类型，具体如下：

  • org.springframework.aop.MethodBeforeAdvice（前置通知）
    在目标方法执行前实施增强，可以应用于权限管理等功能。
  • org.springframework.aop.AfterReturningAdvice（后置通知）
    在目标方法执行后实施增强，可以应用于关闭流、上传文件、删除
    临时文件等功能。
  • org.aopalliance.intercept.MethodInterceptor（环绕通知）
    在目标方法执行前后实施增强，可以应用于日志、事务管理等功能。
  • org.springframework.aop.ThrowsAdvice（异常抛出通知）
    在方法抛出异常后实施增强，可以应用于处理异常记录日志等功能。
  • org.springframework.aop.IntroductionInterceptor（引介通知）
    在目标类中添加一些新的方法和属性，可以应用于修改老版本程序。

4.2基于XML的声明式AspectJ

1.引入依赖

<!--引入 aspectj依赖-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.6.12</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.12</version>
        </dependency>

2.创建切面

package com.yth.aspectj;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
/**
 * 切面类
 * @author yth
 * @date 2020/10/21 - 17:26
 */
public class MyAspectj {
    /**
     * 前置通知，在目标对象调用之前调用
     */
    public void myBefore(JoinPoint joinPoint){
        // joinPoint  连接点 在这里我们得到的是 切入点    他们都是方法
        //joinPoint.getSignature().getName() 获取目标对象执行的方法名
        System.out.println("myBefore--------"+joinPoint.getSignature().getName());
    }
    /**
     * 后置通知，在目标对象之后调用
     * 目标对象, 能在执行完毕之后执行,并获得结果
     */
    public void myAfterReturning(JoinPoint joinPoint,Object result){
        //joinPoint.getTarget()  获取目标对象
        //System.out.println(joinPoint.getTarget());
        System.out.println("myAfterReturning--------"+joinPoint.getSignature().getName());
        System.out.println("方法执行的结果------"+result);
    }
    /**
     * 环绕通知
     */
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("myAround--------"+proceedingJoinPoint.getSignature().getName());
        // 让 目标对象执行 相应的方法 如果不执行代表  被拦截
        // 返回值 目标对象执行 的结果
        Object result = proceedingJoinPoint.proceed();
        System.out.println(result);
        // 必须将 目标对象执行结果 返回给代理
        return result;
    }
    /**
     * 异常通知
     */
    public void  myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("myAfterThrowing-被调用的方法名："+joinPoint.getSignature().getName());
        //得到异常信息
        System.out.println("myAfterThrowing-异常信息："+e.getMessage());
    }
    /**
     * 最终通知, 相当于finally无论是否异常都会执行的代码
     */
    public void myAfter(JoinPoint joinPoint){
        System.out.println("myAfter--------"+joinPoint.getSignature().getName());
    }
}

2.创建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 class="com.yth.aspectj.MyAspectj" id="myAspectj"></bean>
    <!--目标对象-->
    <bean class="com.yth.dao.impl.StudentDaoImpl" id="studentDao"></bean>
    <!--    基于aspectj xml 实现 所有织入实现功能都必须写在 aop:config   -->
    <aop:config>
        <!--    配置 切点  全局切点 可以被多个切面所应用    切点 就是要拦截的方法
                expression="execution()  切点表达式 就是找到那些需要被拦截的方法   -->
        <aop:pointcut id="myPoint" expression="execution(* com.yth.dao.*.*.*(..))"/>
        <!-- 配置切面   切面就是一个类 里面的方法主要用于拦截/增强 目标对象
             ref="myAspect" 引用切面实例 进行织入 过程 -->
        <aop:aspect id="aopAspectj" ref="myAspectj">
            <!--    前置通知 和 切点绑定  -->
            <aop:before method="myBefore" pointcut-ref="myPoint"></aop:before>
            <!--    后置通知 和 切点绑定     returning="result"  指定后置通知用那个参数 接收目标对象返回的结果 -->
            <aop:after-returning method="myAfterReturning" pointcut-ref="myPoint" returning="result"></aop:after-returning>
            <!--    环绕通知 和 切点绑定  -->
            <aop:around method="myAround" pointcut-ref="myPoint"></aop:around>
            <!--    异常通知 和 切点绑定   throwing="e" 指定异常通知用那个参数 接收异常信息  -->
            <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPoint" throwing="e"></aop:after-throwing>
            <!--    最终通知 和 切点绑定  -->
            <aop:after method="myAfter" pointcut-ref="myPoint"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

3.测试

public static void main(String[] args) {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("aspectj\\Aspectj.xml");
    StudentDao studentDao = (StudentDao) applicationContext.getBean("studentDao");
    studentDao.fingStudentById(100);
}

4.3基于注解的AspectJ

AspectJ框架为AOP的实现提供了一套注解，用以取代Spring配置文件中为实现AOP功能所配置的臃肿代码。AspectJ的注解及其描述如下所示：

在这里插入图片描述
1.创建切面

package com.yth.aspectj_annotation;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author yth
 * @date 2020/10/21 - 20:20
 */
@Component
@Aspect
public class AspectJAnnotation {
    @Pointcut("execution(* com.yth.dao.*.*.*(..))")
    public void pointCut(){}
    /**
     * 前置通知，在目标对象调用之前调用
     */
    @Before("pointCut()")
    public void myBefore(JoinPoint joinPoint){
        // joinPoint  连接点 在这里我们得到的是 切入点    他们都是方法
        //joinPoint.getSignature().getName() 获取目标对象执行的方法名
        System.out.println("myBefore--------"+joinPoint.getSignature().getName());
    }
    /**
     * 后置通知，在目标对象之后调用
     * 目标对象, 能在执行完毕之后执行,并获得结果
     */
    @AfterReturning(value = "pointCut()",returning = "result")
    public void myAfterReturning(JoinPoint joinPoint,Object result){
        //joinPoint.getTarget()  获取目标对象
        //System.out.println(joinPoint.getTarget());
        System.out.println("myAfterReturning--------"+joinPoint.getSignature().getName());
        System.out.println("方法执行的结果------"+result);
    }
    /**
     * 环绕通知
     */
    @Around("pointCut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("myAround--------"+proceedingJoinPoint.getSignature().getName());
        // 让 目标对象执行 相应的方法 如果不执行代表  被拦截
        // 返回值 目标对象执行 的结果
        Object result = proceedingJoinPoint.proceed();
        System.out.println(result);
        // 必须将 目标对象执行结果 返回给代理

        return result;
    }
    /**
     * 异常通知
     */
    @AfterThrowing(value = "pointCut()",throwing = "e")
    public void  myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("myAfterThrowing-被调用的方法名："+joinPoint.getSignature().getName());

        // 得到异常信息
        System.out.println("myAfterThrowing-异常信息："+e.getMessage());
    }
    /**
     * 最终通知, 相当于finally无论是否异常都会执行的代码
     */
    @After("pointCut()")
    public void myAfter(JoinPoint joinPoint){
        System.out.println("myAfter--------"+joinPoint.getSignature().getName());
    }
}

2.创建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"
       xmlns:context="http://www.springframework.org/schema/context"
       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 http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    <context:component-scan base-package="com.yth"></context:component-scan>
</beans>

3.测试

public static void main(String[] args) {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("aspectj_annotation\\Aspectj_Annotation.xml");
    StudentDao studentDao = applicationContext.getBean(StudentDao.class);
    studentDao.fingStudentById(100);
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

AOP

Spring

Java

Spring-03 Aop简介，实现原理，基于ProxyFactoryBean实现Aop，基于AspectJ开发的实现 的相关文章

随机推荐

  • 2020蓝桥杯模拟——长草

    1 题目描述 小明有一块空地 他将这块空地划分为 n 行 m 列的小块 每行和每列的长度都为 1 小明选了其中的一些小块空地 种上了草 其他小块仍然保持是空地 这些草长得很快 每个月 草都会向外长出一些 如果一个小块种了草 则它将向自己的上

  • win10远程连接win7连接不上去的处理办法 发布时间：2020-04-15

    win10远程连接win7连接不上去的处理办法 发布时间 2020 04 15 12 39发布者 系统城 lufang浏览数 1227 很多用户在使用win10远程桌面的时候 想要去连接win7系统的电脑 却发现自己电脑出现了连接不上的问题

  • Android Studio中的SDK Manager使用

    前言 网上的开源项目中使用的Build Tools的版本可能和自己本地的版本不一致 如果本地没有对应的版本 可能会出现编译报错的问题 关于项目的BuildTools的版本设置在build gradle中 便已报错如下图 解决BuildToo

  • php接入企业微信

    企业微信 现在来讲应该是一个很常见了的功能了 下面 我就以tp6来给大讲下接入企业微信的小demo吧 首先 在common php的公共方法里面写入下面两段代码 function sendRequest url 用curl请求获取acces

  • java图片验证码在服务器上返回乱码问题

    本机上没有问题 部署在阿里云服务器上都几个月了都没有问题 上传过一次代码后突然验证码就显示为看不懂的符号了 然而代码对此并没有影响的 打印生成的验证码 String word vcu produceNumAndChar length LOG

  • ES集群节点宕机导致shard unassigned解决方案

    ES集群概况 1台master节点 4台data节点 9个shards 问题 一台data节点宕机 导致5个分片处于unassigned状态 集群状态变为red 无法自动rerouting 解决步骤 1 查看所有节点的日志信息 通过日志 我

  • 开源数据目录管理工具_Java开发中用到的数据库迁移工具（flyway）

    什么是数据库版本管理 任何web软件和应用程序都需要强大的数据库管理工具 因此开发者选择一款合适的数据库管理工具尤为重要 本文列出了几款好用的数据库管理工具 有些并非开源或免费 以供开发者们参考选择 做过开发的小伙伴们都知道 实现一个需求时

  • ***没有规则可以创建“XXX”需要的目标“XXX”问题的解决方案

    在第4季 上学期 专题2 U Boot新手入门中 1 在Linux中解压uboot tq2440 tar gz 2 tar xvzf uboot tq2440 tar gz 3 进入 uboot tq2440 4 make TQ2440 c

  • 软件加密系统Themida常见问题集锦—Themida是否支持命令行保护？

    Themida是先进的Windows软件保护系统 它被用于满足软件开发人员对于所开发应用程序安全保护的需求 使其远离被先进的逆向工程和软件破解的危险 通过下载Themida 我们集中在软件保护器所具有的主要弱点 从而提供了解决这些问题的完整

  • jdbc oracle多数据源,JdbcTemplate 配置多数据源

    有时候需要对接第三方厂商的数据库或者视图 我们不想让多数据源入侵我们现有的项目 那么可以试下JdbcTemplate 这里以Oracle视图为例 先确定下对方Oracle版本 然后引入对应版本的pom org springframework

  • SNKr：创造新的潮圈文化 将区块链与时尚潮流结合

    直播内容整理 关于SNKr SNKr以 Real Recognize Real 为核心愿景 是一个由区块链赋能的潮流文化生态社区项目 由SWELL公司发起 SNKr致力于连接潮流文化中的 真 玩家与 真 产品 通过loT和区块链技术帮助品牌

  • AcWing110. 防晒

    输入样例 3 2 3 10 2 5 1 5 6 2 4 1 输出样例 2 解析 按照右区间排序 优先满足小的 include

  • python读取图片的几种方式

    opencv的像素值在 0 1 0 1 show的时候转换到 0 255 import cv2 img cv2 imread imgfile cv2 imshow img win name img cv2 waitKey 0 无限期等待输入

  • 不要自称为程序员

    如果有我可以添加到每个工程教育的一门课程 它不涉及编译器或门或时间复杂度 这将是您工业101的现实 因为我们不教他们和许多不必要的痛苦和折磨这个结果 这后立志要为你作为一个年轻的工程师的职业生涯中的自我介绍 填写在您的教育差距 就如何在 现

  • TMPGEnc 4.0 XPress(小日本4)优化安装教程

    小日本4 TMPGEnc 4 0 XPress 是小日本2 54的升级版本 与小日本2 54之间本来还有一个3 0 版本 不过3 0 没有产生太大影响即升级到4 0 版本 尽管是小日本2 54的升级版本 但3 0 以后此软件便属于全新开发

  • VirtualBox安装OpenWRT虚拟机，及Kernel panic - not syncing: Attempted to kill init故障排除

    编译或下载镜像文件 openwrt x86 generic Generic combined ext4 img gz 解压 gunzip d openwrt x86 generic Generic combined ext4 img gz

  • c++构建正态分布的随机数

    最近编程的时候遇到一个问题 需要用c 来产生一个满足正态分布的的随机数 用c 产生一个均匀分布的随机数很容易 但是满足正态分布还是有点懵逼的 然后就在网上搜一些资料 发现有三种方法可以产生正态分布的随机数 但是看别人从理论上的推导 感觉还是

  • node——使用Nginx + Node.js部署你的网站

    Nginx是一个高性能的HTTP和反向代理服务器 反向代理就是通常所说的web服务器加速 它是一种通过在繁忙的web服务器和internet之间增加一个高速的web缓冲服务器来降低实际的web服务器的负载 Nginx由俄罗斯程序员利用C语言

  • python的动态加载的一个注意地方

    先描述一下我的问题背景 然后给出错误发现 最终给出解决办法 1 我有很多python文件 并且这些文件内容会按照一定周期被更新但是文件名字不变 并且每个文件内都有一个一样的class的名字 需要我去动态调用 我的调用方法是使用的python

  • Spring-03 Aop简介，实现原理，基于ProxyFactoryBean实现Aop，基于AspectJ开发的实现

    Spring 03 1 SpringAop简介 AOP的全称是Aspect Oriented Programming 即面向切面编程 也称面向方面编程 它是面向对象编程 OOP 的一种补充 目前已成为一种比较成熟的编程方式 aop 解决的问

热门标签