Spring AOP的使用（基于传统动态代理）

最新推荐文章于 2023-06-24 03:35:06 发布

原创最新推荐文章于 2023-06-24 03:35:06 发布 · 453 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

Web

spring

本文介绍了Spring AOP的概念和如何通过传统动态代理实现这一思想。AOP核心是将不重要的部分切出，作为切面在需要时加入。详细讲述了如何创建代理类、使用代理类，并解释了如何体现AOP思想。接着，文章展示了Spring AOP的实现步骤，包括导入依赖、创建切面、配置XML，并说明了如何避免@Autowired导致的问题，提供了示例代码以帮助理解。

什么是AOP？

专业术语：

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

想要详细了解建议去看这位大牛的文章----【SpringBoot-3】

简单来说AOP的核心思想就是把一个类中那些不重要的部分切出去或者说拆出去，做成一个切面，然后在需要使用的时候再把切面加上去。

动态代理是JAVA的JDK给我们提供的一种机制，为什么会有这种机制呢？是因为JAVA本身运行就是基于代理的，JAVA有虚拟机，JAVA所有的类都是交给虚拟机运行的，这个过程就是一种代理。代码在运行时，每一个类和每一个方法的运行都是被虚拟机代理的。

动态代理的实现

在这里插入图片描述

1、实现一个代理类

下方的代码是实现代理类的简单流程：

代理类的创建，首先需要实现InvocationHandler接口
类中定义一个Object属性，在后续使用代理类的时候，可以用来转换为各种类，因为Object类是所有类的父类。
invoke方法里就包括被代理的类中的方法，方法中的method参数就是被invoke方法代理的类中的方法，为了方便能够获取代理类，最后再把这个类return出去。

//代理类的写法
//需要这个类能够代理别人，需要实现这个接口，调用InvocationHandler句柄
public class ProxyDemo implements InvocationHandler {

    private Object object;

    //传入需要被代理的类（object）
    public ProxyDemo(Object object){
        this.object = object;
    }

    //invoke方法里就包括被代理的类中的方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //这里就是实现AOP的核心思想，面向切面编程，我们可以把切面代码写到这个地方
        //因为在这里添加切面后，后续只要使用这个代理类的方法，都会远行切面，就比如说日志功能

        beforeAdvice();//实现AOP思想，beforeAdvice作为一个切面切入

        //method参数就是被invoke方法代理的类中的方法
        //运行代理对象的方法
        Object proxyObject = method.invoke(object,args);
        return proxyObject;
    }
    //前置通知
    public void beforeAdvice(){
        //模拟一下日志功能
        System.out.println("前置建议：日志记录");
    }
}

2、使用代理类

假如我现在想要获取AccountDAO的代理类并调用insert方法，获取代理类的方式如下：

package org.csu.spring.demo.aop.test;

import org.csu.spring.demo.aop.persistence.AccountDAO;
import org.csu.spring.demo.aop.persistence.AccountDAOImpl;
import org.csu.spring.demo.aop.proxy.ProxyDemo;
import org.junit.Test;

import java.lang.reflect.Proxy;

public class Demo {

    @Test
    public void test(){
        AccountDAO accountDAO = new AccountDAOImpl();

        //获得类的原型 class1 获得了accountDAO类的原型，因为类最终是以.class文件形式存在的
        Class class1 = accountDAO.getClass();
        //虚拟机提供的反射Proxy，new一个代理出来。三个参数分别是一个加载器，还需要一个类的接口，最后需要一个代理的对象
        Object object = Proxy.newProxyInstance(class1.getClassLoader(),class1.getInterfaces(),new ProxyDemo(accountDAO));
        //把代理的对象，强制转换成被代理对象，后面使用这个对象的就是通过代理执行的
        accountDAO = (AccountDAO)object;
        //这个时候使用的对象，就是被代理之后的对象
        accountDAO.insert();

    }
}

获取代理类的核心就是这四条代码
在这里插入图片描述

但是这样使用代理类，怎么反映了AOP的思想？

AOP的思想就是把一个类中那些不重要的部分切出去或者说拆出去，做成一个切面，然后在需要使用的时候再把切面加上去。

再看看我们的代理类的实现代码，哪里可以体现AOP的思想？

当我们想调用被代理的对象的方法，我们实际上执行的是这串代码
Object proxyObject = method.invoke(object,args);

在这里插入图片描述
但是在invoke方法中，我们还有上下个地方（分为前置通知和后置通知）可以自由的添加方法，而我们正可以把那些经常用到，但是不是很重要的方法放在这两个地方。就比如说日志记录，我们很多地方都需要使用它，但是在每次调用时都需要新建一个日志记录的对象，会较为麻烦。所以我们采取动态代理的方式来简化代码。在这里插入图片描述

运行一个类例子

对比一下直接accountDAO对象的insert方法和使用代理对象accountDAO的insert方法，我们看看输入结果。
在这里插入图片描述

不难看出同样是account.insert()方法。通过动态代理的方式，可以在代理运行insert方法时（不止是insert方法，只要是类中存在的方法都会在之前运行我们添加的方法），在之前还能加入其他的方法，这就可以体现出AOP的思想。

我们使用Spring AOP可以帮我们简化动态代理的过程

Spring AOP的实现(传统动态代理)

1、导入spring-aop依赖

在pom.xml文件中加入spring-aop的依赖

	 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
<!--      spring依赖的版本都需要相同-->
      <version>5.2.4.RELEASE</version>
    </dependency>

2、创建切面

通过实现spring给我们提供的切面，spring给我们提供了很多种类的接口，比如：BeforeAdvice接口，意思是后置建议，在所代理的类中的方法实现后再实现我们添加的方法。而这里我们使用的是AfterReturningAdvice（在一个方法返回后的一个建议，或者说一个切面）

package org.csu.spring.demo.aop.proxy;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class SpringAOPProxyDemo implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("后置建议：日志记录.....");
    }
}

3、配置xml文件

在这里插入图片描述
创建一个Spring Config的文件，文件名是自己取的。在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: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/context
       https://www.springframework.org/schema/context/spring-context.xsd">
        
    <bean id="accountDAO" class="org.csu.spring.demo.aop.persistence.AccountDAOImpl"/>
    
    <bean id="demoProxy" class="org.csu.spring.demo.aop.proxy.SpringAOPProxyDemo"/>
    
    <!--    使用spring提供给我们的方式将两个类绑订在一起就行了-->
    <!--    这个id可以随便取，class必须写ProxyFactoryBean，就是由工厂帮我们创建代理对象-->
    <bean id="demoAfterProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--    ref就是需要增强的类，也就是需要代理的类-->
        <property name="target" ref="accountDAO"/>
        <!--    value使用的是前面定义的bean id="demoProxy"中的id-->
        <property name="interceptorNames" value="demoProxy"/>
        <!--     value需要写完成的类名-->
        <property name="proxyInterfaces" value="org.csu.spring.demo.aop.persistence.AccountDAO"/>
    
    </bean>
    
</beans>

使用方式

使用这个内部类的方式就很简单了，利用我们前面提到的Junit和Spring联动的测试依赖和@RunWith和@ContextConfiguration两个标签，初始化Spring容器让它容器帮我们创建好对象后，使用@Resource标签指定名字，把前面配置后id为demoAfterProxy代理类对象注入进去，这样我们就可以使用这个切面啦。
（注意：这里不能用@Autowired自动注入标签，因为该标签是按类型注入，只要有accountDAO类，它就会直接注入进去，而这里的代理类和被代理类都这个类型的，所以会出现把被代理类注入的情况，从而使用不了切面）

package org.csu.spring.demo.aop.test;

import org.csu.spring.demo.aop.persistence.AccountDAO;
import org.csu.spring.demo.aop.persistence.AccountDAOImpl;
import org.csu.spring.demo.aop.proxy.ProxyDemo;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
import java.lang.reflect.Proxy;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-aop.xml")
public class Demo {
    
    @Resource(name = "demoAfterProxy")
    private AccountDAO accountDAO;

    @Test
    public void test(){
        
        accountDAO.insert();    
        
}

测试一下
在这里插入图片描述

示例代码

代码结构图
在这里插入图片描述

完整代码

在这里插入图片描述

package org.csu.spring.demo.aop.persistence;

public interface AccountDAO {
    void insert();
    void delete();
    void update();
    void find();
}

在这里插入图片描述

package org.csu.spring.demo.aop.persistence;

public class AccountDAOImpl implements AccountDAO {

    @Override
    public void insert() {
        System.out.println("插入");
    }

    @Override
    public void delete() {
        System.out.println("删除");
    }

    @Override
    public void update() {
        System.out.println("更新");
    }

    @Override
    public void find() {
        System.out.println("查找");
    }
}

在这里插入图片描述

package org.csu.spring.demo.aop.proxy;

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

//代理类的写法
//需要这个类能够代理别人，需要实现这个接口，调用InvocationHandler句柄
public class ProxyDemo implements InvocationHandler {

    private Object object;

    //传入需要被代理的类（object）
    public ProxyDemo(Object object){
        this.object = object;
    }

    //invoke方法里就包括被代理的类中的方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //这里就是实现AOP的核心思想，面向切面编程，我们可以把切面代码写到这个地方
        //因为在这里添加切面后，后续只要使用这个代理类的方法，都会远行切面，就比如说日志功能

        beforeAdvice();//实现AOP思想，beforeAdvice作为一个切面切入

        //method参数就是被invoke方法代理的类中的方法
        //运行代理对象的方法
        Object proxyObject = method.invoke(object,args);


        return proxyObject;
    }
    //前置通知
    public void beforeAdvice(){
        //模拟一下日志功能
        System.out.println("前置建议：日志记录");
    }
}

在这里插入图片描述

package org.csu.spring.demo.aop.proxy;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class SpringAOPProxyDemo implements AfterReturningAdvice {

    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("后缀建议：日志记录.....");
    }
}

在这里插入图片描述

package org.csu.spring.demo.aop.test;

import org.csu.spring.demo.aop.persistence.AccountDAO;
import org.csu.spring.demo.aop.persistence.AccountDAOImpl;
import org.csu.spring.demo.aop.proxy.ProxyDemo;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
import java.lang.reflect.Proxy;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-aop.xml")
public class Demo {

    @Resource(name = "demoAfterProxy")
    private AccountDAO accountDAO;

    @Test
    public void test(){

        accountDAO.insert();


//        AccountDAO accountDAO = new AccountDAOImpl();
//
//        //获得类的原型 class1 获得了accountDAO类的原型，因为类最终是以.class文件形式存在的
//        Class class1 = accountDAO.getClass();
//        //虚拟机提供的反射Proxy，new一个代理出来。三个参数分别是一个加载器，还需要一个类的接口，最后需要一个代理的对象
//        Object object = Proxy.newProxyInstance(class1.getClassLoader(),class1.getInterfaces(),new ProxyDemo(accountDAO));
//        //把代理的对象，强制转换成被代理对象，后面使用这个对象的就是通过代理执行的
//        accountDAO = (AccountDAO)object;
//        //这个时候使用的对象，就是被代理之后的对象
//        accountDAO.insert();
    }
}

在这里插入图片描述

<?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: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/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="accountDAO" class="org.csu.spring.demo.aop.persistence.AccountDAOImpl"/>

    <bean id="demoProxy" class="org.csu.spring.demo.aop.proxy.SpringAOPProxyDemo"/>

    <!--    使用spring提供给我们的方式将两个类绑订在一起就行了-->
    <!--    id可以随便取，class必须写ProxyFactoryBean，就是由工厂帮我们创建代理对象-->
    <bean id="demoAfterProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--    ref就是需要增强的类，也就是需要代理的类-->
        <property name="target" ref="accountDAO"/>
        <!--    value使用的是前面定义的bean id="demoProxy"中的id-->
        <property name="interceptorNames" value="demoProxy"/>
        <!--     value需要写完成的类名-->
        <property name="proxyInterfaces" value="org.csu.spring.demo.aop.persistence.AccountDAO"/>

    </bean>
    
</beans>

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.csu</groupId>
  <artifactId>springdemo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>springdemo Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

<!--  需要配置的文件从这开始-->
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
<!--    spring-core spring-beans spring-context spring-expression -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
<!--      这些依赖的版本需要相同-->
      <version>5.2.4.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>javax.annotation</groupId>
      <artifactId>javax.annotation-api</artifactId>
      <version>1.3.2</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>

  </dependencies>
<!--  这里结束-->


  <build>
    <finalName>springdemo</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>