spring:AOP

最新推荐文章于 2024-06-14 15:02:13 发布

m0_46337171

最新推荐文章于 2024-06-14 15:02:13 发布

阅读量65

点赞数

分类专栏：第六阶段文章标签： java

本文链接：https://blog.csdn.net/m0_46337171/article/details/113531792

版权

第六阶段专栏收录该内容

13 篇文章 0 订阅

订阅专栏

前言

文章内容输出来源：拉勾教育JAVA就业训练营

一 Proxy

我们可以将业务代码和事务代码进行拆分，通过动态代理的方式，对业务方法进行事务的增强。这样就不会对业务层产生影响，解决了耦合性的问题啦！
常用的动态代理技术
- JDK 代理 : 基于接口的动态代理技术·：利用拦截器（必须实现invocationHandler）加上反射机制生成一个代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理，从而实现方法增强
- CGLIB代理：基于父类的动态代理技术：动态生成一个要代理的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截技术拦截所有的父类方法的调用，顺势织入横切逻辑，对方法进行增强

1.1 JDK动态代理方式

@Component
public class JdkProxyFactory {
  @Autowired
  private AccountService accountService;
  @Autowired
  private TransactionManager transactionManager;
  public AccountService createAccountServiceJdkProxy() {
    AccountService accountServiceProxy = null;
    accountServiceProxy = (AccountService)
Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
        accountService.getClass().getInterfaces(), new
InvocationHandler() {
      @Override
      public Object invoke(Object proxy, Method method, Object[] args)
      throws Throwable {
        Object result = null;
        try {
          // 1.开启事务
          transactionManager.beginTransaction();
          // 2.业务操作
          result = method.invoke(accountService, args);
          // 3.提交事务
          transactionManager.commit();
       } catch (Exception e) {
          e.printStackTrace();
          // 4.回滚事务
          transactionManager.rollback();
          } finally {
          // 5.释放资源
          transactionManager.release();
       }
        return result;
     }
   });
    return accountServiceProxy;
 }

1.2 CGLIB动态代理方式

@Component
public class CglibProxyFactory {
  @Autowired
  private AccountService accountService;
  @Autowired
  private TransactionManager transactionManager;
  public AccountService createAccountServiceCglibProxy() {
    AccountService accountServiceProxy = null;
    /*
    *  参数一：目标对象的字节码对象
    *  参数二：动作类，实现增强功能
    * */
    accountServiceProxy = (AccountService)
Enhancer.create(accountService.getClass(), new MethodInterceptor() {
      @Override
      public Object intercept(Object o, Method method, Object[] objects,
MethodProxy methodProxy) throws Throwable {
        Object result = null;
        try {
          // 1.开启事务
          transactionManager.beginTransaction();
          // 2.业务操作
          result = method.invoke(accountService, objects);
          // 3.提交事务
          transactionManager.commit();
       } catch (Exception e) {
          e.printStackTrace();
          // 4.回滚事务
          transactionManager.rollback();
       } finally {
          // 5.释放资源
          transactionManager.release();
       }
        return result;
     }
   });
    return accountServiceProxy;
 }
}

二初识AOP

2.1 什么是AOP

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程
AOP 是 OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内
容，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
这样做的好处是：
1. 在程序运行期间，在不修改源码的情况下对方法进行功能增强
2. 逻辑清晰，开发核心业务的时候，不必关注增强业务的代码
3. 减少重复代码，提高开发效率，便于后期维护

2.2 AOP底层实现

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

2.3 AOP相关术语

* Target（目标对象）：代理的目标对象
* Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类
* Joinpoint（连接点）：所谓连接点是指那些可以被拦截到的点。在spring中,这些点指的是方法，因为
spring只支持方法类型的连接点
* Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
* Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知
分类：前置通知、后置通知、异常通知、最终通知、环绕通知
* Aspect（切面）：是切入点和通知（引介）的结合
* Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织
入，而AspectJ采用编译期织入和类装载期织入

2.4 AOP开发明确事项

2.4.1 开发阶段（我们做的）

编写核心业务代码（目标类的目标方法）切入点
把公用代码抽取出来，制作成通知（增强功能方法）通知
在配置文件中，声明切入点与通知间的关系，即切面

2.4.2 运行阶段（Spring框架完成的）

Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

2.4.3 底层代理实现

在 Spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

当bean实现接口时，会用JDK代理模式
当bean没有实现接口，用cglib实现（可以强制使用cglib（在spring配置中加入<aop:aspectj-autoproxy proxyt-target-class=”true”/>）

2.5 知识小结

* aop：面向切面编程
* aop底层实现：基于JDK的动态代理 和 基于Cglib的动态代理
* aop的重点概念：
Pointcut（切入点）：真正被增强的方法
Advice（通知/ 增强）：封装增强业务逻辑的方法
Aspect（切面）：切点+通知
Weaving（织入）：将切点与通知结合，产生代理对象的过程

三基于XML的AOP开发

3.1 快速入门

3.1.1 创建java项目，导入AOP相关坐标

<!--导入spring的context坐标，context依赖aop-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.5.RELEASE</version>
  </dependency>
  <!-- aspectj的织入（切点表达式需要用到该jar包） -->
  <dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.13</version>
  </dependency>

3.1.2 创建目标接口和目标实现类

3.1.3 创建通知类

3.1.4 将目标类和通知类对象创建权交给spring

<!--目标类交给IOC容器-->
<bean id="accountService" class="com.lagou.service.impl.AccountServiceImpl">
</bean>
<!--通知类交给IOC容器-->
<bean id="myAdvice" class="com.lagou.advice.MyAdvice"></bean>

3.1.5 在核心配置文件中配置织入关系，及切面

导入aop命名空间

<?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
http://www.springframework.org/schema/aop/spring-aop.xsd">
  <!--目标类交给IOC容器-->
  <bean id="accountService" class="com.lagou.service.impl.AccountServiceImpl">
</bean>
  <!--通知类交给IOC容器-->
  <bean id="myAdvice" class="com.lagou.advice.MyAdvice"></bean>
  <aop:config>
    <!--引入通知类-->
    <aop:aspect ref="myAdvice">
      <!--配置目标类的transfer方法执行时，使用通知类的before方法进行前置增强-->
      <aop:before method="before"
            pointcut="execution(public void
com.lagou.service.impl.AccountServiceImpl.transfer())"></aop:before>
    </aop:aspect>
  </aop:config>
</beans>

3.2 XML配置AOP详解

3.2.1 切点表达式

表达式语法：

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

切点表达式抽取
当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替pointcut 属性来引用抽取后的切点表达式。

<aop:config>
  <!--抽取的切点表达式-->
<aop:pointcut id="myPointcut" expression="execution(* com.lagou.service..*.*
(..))"> </aop:pointcut>
  <aop:aspect ref="myAdvice">
    <aop:before method="before" pointcut-ref="myPointcut"></aop:before>
  </aop:aspect>
</aop:config>

3.2.2 通知类型

通知的配置语法：

<aop:通知类型 method=“通知类中方法名” pointcut=“切点表达式"></aop:通知类型>

名称	标签	说明
前置通知	aop:before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	aop:afterReturning	用于配置后置通知。指定增强的方法在切入点方法之后执行
异常通知	aop:afterThrowing	用于配置异常通知。指定增强的方法出现异常后执行
最终通知	aop:after	用于配置最终通知。无论切入点方法执行时是否有异常，都会执行
环绕通知	aop:around	用于配置环绕通知。开发者可以手动控制增强代码在什么时候执行

注意：

通常情况下，环绕通知都是独立使用的

3.3 知识小结

* aop织入的配置
<aop:config>
    <aop:aspect ref=“通知类”>
      <aop:before method=“通知方法名称” pointcut=“切点表达式"></aop:before>
    </aop:aspect>
  </aop:config>
                           
* 通知的类型
前置通知、后置通知、异常通知、最终通知
环绕通知
* 切点表达式
execution([修饰符] 返回值类型 包名.类名.方法名(参数))

四基于注解的AOP开发

4.1 快速入门

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

4.2 注解配置AOP详解

4.2.1 切点表达式

切点表达式的抽取

@Component
@Aspect
public class MyAdvice {
  @Pointcut("execution(* com.lagou..*.*(..))")
  public void myPoint(){}
  @Before("MyAdvice.myPoint()")
  public void before() {
    System.out.println("前置通知...");
 }

4.2.2 通知类型

通知的配置语法：@通知注解(“切点表达式")

名称	标签	说明
前置通知	@Before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	@AfterReturning	用于配置后置通知。指定增强的方法在切入点方法之后执行
异常通知	@AfterThrowing	用于配置异常通知。指定增强的方法出现异常后执行
最终通知	@After	用于配置最终通知。无论切入点方法执行时是否有异常，都会执行
环绕通知	@Around	用于配置环绕通知。开发者可以手动控制增强代码在什么时候执行

注意：

当前四个通知组合在一起时，执行顺序如下：
@Before -> @After -> @AfterReturning（如果有异常：@AfterThrowing）

4.2.3 纯注解配置

@Configuration
@ComponentScan("com.lagou")
@EnableAspectJAutoProxy //替代 <aop:aspectj-autoproxy />
public class SpringConfig {
}

4.3 知识小结

* 使用@Aspect注解，标注切面类
* 使用@Before等注解，标注通知方法
* 使用@Pointcut注解，抽取切点表达式
* 配置aop自动代理 <aop:aspectj-autoproxy/> 或 @EnableAspectJAutoProxy

m0_46337171

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring:AOP

目录前言一 Proxy1.1 JDK动态代理方式1.2 CGLIB动态代理方式三初识AOP3.1 什么是AOP3.2 AOP底层实现3.3 AOP相关术语3.4 AOP开发明确事项3.4.1 开发阶段（我们做的）3.4.2 运行阶段（Spring框架完成的）3.4.3 底层代理实现3.5 知识小结四基于XML的AOP开发4.1 快速入门4.1.1 创建java项目，导入AOP相关坐标4.1.2 创建目标接口和目标实现类4.1.3 创建通知类4.1.4 将目标类和通知类对象创建权交给spring4.1.5
复制链接

扫一扫