一篇文章带你详解Spring的AOP

目录
  • 1、AOP 什么?
  • 2、需求
  • 3、解决办法1:使用静态代理
    • 第一步:创建 UserService 接口
    • 第二步:创建 UserService的实现类
    • 第三步:创建事务类 MyTransaction
    • 第四步:创建代理类 ProxyUser.java
  • 4、解决办法2:使用JDK动态代理
  • 5、AOP 关键术语 
  • 6、AOP 的通知类型  
  • 7、使用 Spring AOP 解决上面的需求
    • 上面的配置我们在注释中写的很清楚了。这里我们重点讲解一下:
      • ①、切入点表达式,一个完整的方法表示如下:
      • ②、springAOP的具体加载步骤:
  • 总结

1、AOP 什么?

AOP(Aspect Oriented Programming),通常称为面向切面编程。它利用一种称为"横切"的技术,剖解开封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,并将其命名为"Aspect",即切面。所谓"切面",简单说就是那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块之间的耦合度,并有利于未来的可操作性和可维护性。

什么是切面,什么是公共模块,那么我们概念少说,直接通过一个实例来看看 AOP 到底是什么。

2、需求

现在有一张表 User,然后我们要在程序中实现对 User表的增加和删除操作。

要求:增加和删除操作都必须要开启事务,操作完成之后要提交事务。

User.java

package com.ys.aop.one;
public class User {
    private int uid;
    private String uname;
    public int getUid() {
        return uid;
    }
    public void setUid(int uid) {
        this.uid = uid;
    }
    public String getUname() {
        return uname;
    }
    public void setUname(String uname) {
        this.uname = uname;
    }
}

3、解决办法1:使用静态代理

第一步:创建 UserService 接口

package com.ys.aop.one;
public interface UserService {
    //添加 user
    public void addUser(User user);
    //删除 user
    public void deleteUser(int uid);
}

第二步:创建 UserService的实现类

package com.ys.aop.one;
public class UserServiceImpl implements UserService{
    @Override
    public void addUser(User user) {
        System.out.println("增加 User");
    }
    @Override
    public void deleteUser(int uid) {
        System.out.println("删除 User");
    }
}

第三步:创建事务类 MyTransaction

package com.ys.aop.one;
public class MyTransaction {
    //开启事务
    public void before(){
        System.out.println("开启事务");
    }
    //提交事务
    public void after(){
        System.out.println("提交事务");
    }
}

第四步:创建代理类 ProxyUser.java

package com.ys.aop.one;
public class ProxyUser implements UserService{
    //真实类
    private UserService userService;
    //事务类
    private MyTransaction transaction;
    //使用构造函数实例化
    public ProxyUser(UserService userService,MyTransaction transaction){
        this.userService = userService;
        this.transaction = transaction;
    }
    @Override
    public void addUser(User user) {
        transaction.before();
        userService.addUser(user);
        transaction.after();
    }
    @Override
    public void deleteUser(int uid) {
        transaction.before();
        userService.deleteUser(uid);
        transaction.after();
    }
}

测试:

@Test
    public void testOne(){
        MyTransaction transaction = new MyTransaction();
        UserService userService = new UserServiceImpl();
        //产生静态代理对象
        ProxyUser proxy = new ProxyUser(userService, transaction);
        proxy.addUser(null);
        proxy.deleteUser(0);
    }

结果:

这是一个很基础的静态代理,业务类UserServiceImpl 只需要关注业务逻辑本身,保证了业务的重用性,这也是代理类的优点,没什么好说的。我们主要说说这样写的缺点:

①、代理对象的一个接口只服务于一种类型的对象,如果要代理的方法很多,势必要为每一种方法都进行代理,静态代理在程序规模稍大时就无法胜任了。

②、如果接口增加一个方法,比如 UserService 增加修改 updateUser()方法,则除了所有实现类需要实现这个方法外,所有代理类也需要实现此方法。增加了代码维护的复杂度。

4、解决办法2:使用JDK动态代理

动态代理就不要自己手动生成代理类了,我们去掉 ProxyUser.java 类,增加一个ObjectInterceptor.java

package com.ys.aop.two;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import com.ys.aop.one.MyTransaction;
public class ObjectInterceptor implements InvocationHandler{
    //目标类
    private Object target;
    //切面类(这里指事务类)
    private MyTransaction transaction;
    //通过构造器赋值
    public ObjectInterceptor(Object target,MyTransaction transaction){
        this.target = target;
        this.transaction = transaction;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //开启事务
        this.transaction.before();
        //调用目标类方法
        method.invoke(this.target, args);
        //提交事务
        this.transaction.after();
        return null;
    }
}

测试:

@Test
    public void testOne(){
        //目标类
        Object target = new UserServiceImpl();
        //事务类
        MyTransaction transaction = new MyTransaction();
        ObjectInterceptor proxyObject = new ObjectInterceptor(target, transaction);
        /**
         * 三个参数的含义:
         * 1、目标类的类加载器
         * 2、目标类所有实现的接口
         * 3、拦截器
         */
        UserService userService = (UserService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), proxyObject);
        userService.addUser(null);
    }

结果:

那么使用动态代理来完成这个需求就很好了,后期在 UserService 中增加业务方法,都不用更改代码就能自动给我们生成代理对象。而且将 UserService 换成别的类也是可以的。

也就是做到了代理对象能够代理多个目标类,多个目标方法。

注意:我们这里使用的是 JDK 动态代理,要求是必须要实现接口。与之对应的另外一种动态代理实现模式 Cglib,则不需要,我们这里就不讲解 cglib 的实现方式了。

不管是哪种方式实现动态代理。本章的主角:AOP 实现原理也是动态代理

5、AOP 关键术语 

1.target:目标类,需要被代理的类。例如:UserService

2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如:所有的方法

3.PointCut 切入点:已经被增强的连接点。例如:addUser()

4.advice 通知/增强,增强代码。例如:after、before

5. Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.

6.proxy 代理类:通知+切入点

7. Aspect(切面): 是切入点pointcut和通知advice的结合

具体可以根据下面这张图来理解:

6、AOP 的通知类型  

Spring按照通知Advice在目标类方法的连接点位置,可以分为5类

  • 前置通知 org.springframework.aop.MethodBeforeAdvice

    • 在目标方法执行前实施增强,比如上面例子的 before()方法
  • 后置通知 org.springframework.aop.AfterReturningAdvice
    • 在目标方法执行后实施增强,比如上面例子的 after()方法
  • 环绕通知org.aopalliance.intercept.MethodInterceptor
    • 在目标方法执行前后实施增强
  • 异常抛出通知 org.springframework.aop.ThrowsAdvice
    • 在方法抛出异常后实施增强
  • 引介通知 org.springframework.aop.IntroductionInterceptor
    • 在目标类中添加一些新的方法和属性

7、使用 Spring AOP 解决上面的需求

我们只需要在Spring 的配置文件 applicationContext.xml 进行如下配置:

<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">
    <!--1、 创建目标类 -->
    <bean id="userService" class="com.ys.aop.UserServiceImpl"></bean>
    <!--2、创建切面类(通知)  -->
    <bean id="transaction" class="com.ys.aop.one.MyTransaction"></bean>
    <!--3、aop编程
        3.1 导入命名空间
        3.2 使用 <aop:config>进行配置
                proxy-target-class="true" 声明时使用cglib代理
                如果不声明,Spring 会自动选择cglib代理还是JDK动态代理
            <aop:pointcut> 切入点 ,从目标对象获得具体方法
            <aop:advisor> 特殊的切面,只有一个通知 和 一个切入点
                advice-ref 通知引用
                pointcut-ref 切入点引用
        3.3 切入点表达式
            execution(* com.ys.aop.*.*(..))
            选择方法         返回值任意   包             类名任意   方法名任意   参数任意
    -->
    <aop:config>
        <!-- 切入点表达式 -->
        <aop:pointcut expression="execution(* com.ys.aop.*.*(..))" id="myPointCut"/>
        <aop:aspect ref="transaction">
            <!-- 配置前置通知,注意 method 的值要和 对应切面的类方法名称相同 -->
            <aop:before method="before" pointcut-ref="myPointCut"></aop:before>
            <aop:after-returning method="after" pointcut-ref="myPointCut"/>
        </aop:aspect>
    </aop:config>
</beans>

测试:

@Test
    public void testAop(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService useService = (UserService) context.getBean("userService");
        useService.addUser(null);
    }

结果:

上面的配置我们在注释中写的很清楚了。这里我们重点讲解一下:

①、切入点表达式,一个完整的方法表示如下:

execution(modifiers-pattern? ref-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)
             类修饰符           返回值           方法所在的包                  方法名                     方法抛出的异常

那么根据上面的对比,我们就很好理解:

execution(* com.ys.aop.*.*(..))
选择方法         返回值任意   包             类名任意   方法名任意   参数任意

②、springAOP的具体加载步骤:

1、当spring容器启动的时候,加载了spring的配置文件

2、为配置文件中的所有bean创建对象

3、spring容器会解析aop:config的配置

1、解析切入点表达式,用切入点表达式和纳入spring容器中的bean做匹配,如果匹配成功,则会为该bean创建代理对象,代理对象的方法=目标方法+通知,如果匹配不成功,不会创建代理对象

4、在客户端利用context.getBean()获取对象时,如果该对象有代理对象,则返回代理对象;如果没有,则返回目标对象

说明:如果目标类没有实现接口,则spring容器会采用cglib的方式产生代理对象,如果实现了接口,则会采用jdk的方式

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • Java Spring AOP详解

    目录 1.什么是AOP? 2.AOP在Spring中的作用 3.使用Spring实现AOP 方式一:使用Spring的接口 方法二:使用自定义类来实现 方法三:使用注解实现 总结 1.什么是AOP? AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型.利用AOP可以对业务逻辑的各个部

  • 聊聊Spring——AOP详解(AOP概览)

    目录 一.对AOP的初印象 首先先给出一段比较专业的术语: 然后我们举一个比较容易理解的例子: 二.AOP中的相关概念 这里还是先给出一个比较专业的概念定义: 然后举一个容易理解的例子: 三.其他的一些内容 Advice 的类型 一.对AOP的初印象 首先先给出一段比较专业的术语: 在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术. AOP是OOP的延续,是软件开发中的一个热点,也是

  • 详解Java SpringAOP切面类

    目录 切面类是什么 为什么需要切面类? 下面用日志功能来讲解切面类怎么创建 日志的作用 AOP的五大通知 Spring AOP类的实现技术 一.准备工作 切面类中有什么? 这些通知有什么用? 为什么命名为切面类? 下面来看代码 总结 切面类是什么 简单的来说,就是动态的在方法的指定位置添加指定的代码. 为什么需要切面类? 在软件开发的过程中,有很多业务,特别是在编写核心业务的时候,往往需要很多其他的辅助业务,比如说身份验证(银行转账需要身份验证).数据缓存.日志输出.这些往往在某个核心业务中处于

  • 详解Java Spring AOP

    目录 前言 一.AOP底层原理 1.AOP底层使用动态代理 二.AOP术语 1.连接点 2.切入点 3.通知(增强) 4.切面 三.AOP 操作(准备工作) Spring 框架一般都是基于 AspectJ 实现 AOP 操作 方式一:使用Spring的接口实现增添功能 方式二:自定义类 方式三:全注解配置实现 总结 前言 面向切面编程,利用 AOP 可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率.即不改变源代码而添加新功能,可插

  • 详解Spring AOP

    目录 什么是AOP? AOP术语 通知(Advice) 连接点(Join point) 切点(Pointcut) 连接点和切点的区别 切面(Aspect) 引入(Introduction) 织入(Weaving) SpringAOP SpringAOP的特点 SpringBoot集成SpringAOP - 依赖引入 - 创建注解 - 定义切面 - 设置切点 - 业务接口编写 - 测试 通知时机 - 正常情况 - 异常情况 总结 什么是AOP? ​AOP,即我们平时经常提到的面向切面编程.首先我们

  • 一篇文章带你详解Spring的AOP

    目录 1.AOP 什么? 2.需求 3.解决办法1:使用静态代理 第一步:创建 UserService 接口 第二步:创建 UserService的实现类 第三步:创建事务类 MyTransaction 第四步:创建代理类 ProxyUser.java 4.解决办法2:使用JDK动态代理 5.AOP 关键术语 6.AOP 的通知类型 7.使用 Spring AOP 解决上面的需求 上面的配置我们在注释中写的很清楚了.这里我们重点讲解一下: ①.切入点表达式,一个完整的方法表示如下: ②.spri

  • 一篇文章带你详解Spring的概述

    目录 1.什么是 Spring ? 2.Spring 起源 3.Spring 特点 ①.方便解耦,简化开发 ②.AOP编程的支持 ③.声明式事务的支持 ④.方便程序的测试 ⑤.方便集成各种优秀框架 ⑥.降低Java EE API的使用难度 ⑦.Java 源码是经典学习范例 4.Spring 框架结构 5.Spring 框架特征 6.Spring 优点 总结: 1.什么是 Spring ? Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Jo

  • 一篇文章带你了解Java Spring基础与IOC

    目录 About Spring About IOC Hello Spring Hello.java Beans.xml Test.java IOC创建对象的几种方式 Spring import settings Dependency Injection 1.构造器注入 2.set注入 3.拓展注入 P-namespcae&C-namespace Bean scopes singleton prototype Bean的自动装配 byName autowire byType autowire 小结

  • 详解spring中aop不生效的几种解决办法

    先看下这个问题的背景:假设有一个spring应用,开发人员希望自定义一个注解@Log,可以加到指定的方法上,实现自动记录日志(入参.出参.响应耗时这些) package com.cnblogs.yjmyzz.springbootdemo.aspect; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy

  • 一篇文章带你玩转Spring bean的终极利器

    前言 前面的篇幅里有提到通过InitializingBean和Disposable等接口可以对bean的初始化和销毁做一些自定义操作,那么有一点要注意,那仅仅是在bean被容器实例化之后的操作,在spring的世界里,要想对实例化这个过程做点什么,作为一个普通业务的开发人员,显然不需要去继承ApplicationContext或者BeanFactory,因为spring container为我们提供了一些接口,让我们以插件的形式去扩展BeanFactory对bean的初始化操作,其中就有我们今天

  • 一篇文章带你了解初始Spring

    目录 为什么要使用Spring Spring概述 Spring容器使用流程 1.启动容器 2.完成bean的初始化 3.注册bean到容器中 4.装配bean的属性 bean的注册 bean属性注入 总结 为什么要使用Spring Why Spring? Spring makes programming Java quicker, easier, and safer for everybody. Spring's focus on speed, simplicity, and productiv

  • 一篇文章带你理解Java Spring三级缓存和循环依赖

    目录 一.什么是循环依赖?什么是三级缓存 二.三级缓存如何解决循环依赖? 三.使用二级缓存能不能解决循环依赖? 总结 一.什么是循环依赖?什么是三级缓存 [什么是循环依赖]什么是循环依赖很好理解,当我们代码中出现,形如BeanA类中依赖注入BeanB类,BeanB类依赖注入A类时,在IOC过程中creaBean实例化A之后,发现并不能直接initbeanA对象,需要注入B对象,发现对象池里还没有B对象.通过构建函数创建B对象的实例化.又因B对象需要注入A对象,发现对象池里还没有A对象,就会套娃.

  • 一篇文章从无到有详解Spring中的AOP

    前言 AOP (Aspect Orient Programming),直译过来就是 面向切面编程.AOP 是一种编程思想,是面向对象编程(OOP)的一种补充.面向对象编程将程序抽象成各个层次的对象,而面向切面编程是将程序抽象成各个切面. 从<Spring实战(第4版)>图书中扒了一张图: 从该图可以很形象地看出,所谓切面,相当于应用对象间的横切点,我们可以将其单独抽象为单独的模块. <?xml version="1.0" encoding="UTF-8&qu

  • 详解Spring Bean的配置方式与实例化

    目录 一. Spring Bean 配置方式 配置文件开发 注解开发 二.Spring Bean实例化 环境准备 构造方法实例化Bean 静态工厂实例化Bean 实例工厂实例化Bean FactoryBean 一. Spring Bean 配置方式 由 Spring IoC 容器管理的对象称为 Bean,Bean 配置方式有两种:配置文件开发和注解开发 配置文件开发 Spring 配置文件支持两种格式:xml和properties,此教程以xml配置文件讲解. XML 配置文件的根元素是 <be

  • 一篇文章带你了解清楚Mysql 锁

    一丶为什么数据库需要锁 数据库锁设计的初衷是处理并发问题.作为多用户共享 的资源,当出现并发访问的时候,数据库需要合理地控制资源的访问规则.而锁就是用来实 现这些访问规则的重要数据结构. 根据加锁的范围,MySQL 里面的锁大致可以分成全局锁.表级锁和行锁三类 二丶全局锁&全库逻辑备份 全局锁就是对整个数据库实例加锁.全局锁的典型使用场景是,做全库逻辑备份,全库逻辑备份有以下几种方式: 1.Flush tables with read lock (FTWRL) Flush tables with

随机推荐