spring aop 及实现方式

最新推荐文章于 2023-08-13 16:36:19 发布

yiyiLy

最新推荐文章于 2023-08-13 16:36:19 发布

阅读量352

点赞数

原文链接：https://www.jianshu.com/p/5b9a0d77f95f

版权

最近看到aop，就做一点小小的总结。

image

一、AOP的基本概念：

1、什么是aop：

AOP（Aspect Oriented Programming）称为面向切面编程，在程序开发中主要用来解决一些系统层面上的问题，比如日志，事务，权限等待，Struts2的拦截器设计就是基于AOP的思想，是个比较经典的例子。
在不改变原有的逻辑的基础上，增加一些额外的功能。代理也是这个功能，读写分离也能用aop来做。

AOP可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

AOP技术恰恰相反，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。
使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

2、AOP的相关概念：

(1)横切关注点：对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点
(2)Aspect(切面):通常是一个类，里面可以定义切入点和通知
(3)JointPoint(连接点):程序执行过程中明确的点，一般是方法的调用。被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器
(4)Advice(通知):AOP在特定的切入点上执行的增强处理，有before(前置),after(后置),afterReturning(最终),afterThrowing(异常),around(环绕)
(5)Pointcut(切入点):就是带有通知的连接点，在程序中主要体现为书写切入点表达式
(6)weave(织入)：将切面应用到目标对象并导致代理对象创建的过程
(7)introduction(引入)：在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段
(8)AOP代理(AOP Proxy)：AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，也可以是CGLIB代理，前者基于接口，后者基于子类
(9)目标对象（Target Object）: 包含连接点的对象。也被称作被通知或被代理对象。POJO

3、Advice通知类型介绍：

(1)Before:在目标方法被调用之前做增强处理,@Before只需要指定切入点表达式即可

(2)AfterReturning:在目标方法正常完成后做增强,@AfterReturning除了指定切入点表达式后，还可以指定一个返回值形参名returning,代表目标方法的返回值

(3)AfterThrowing:主要用来处理程序中未处理的异常,@AfterThrowing除了指定切入点表达式后，还可以指定一个throwing的返回值形参名,可以通过该形参名

来访问目标方法中所抛出的异常对象

(4)After:在目标方法完成之后做增强，无论目标方法时候成功完成。@After可以指定一个切入点表达式

(5)Around:环绕通知,在目标方法完成前后做增强处理,环绕通知是最重要的通知类型,像事务,日志等都是环绕通知,注意编程中核心是一个ProceedingJoinPoint

4、AOP使用场景：

Authentication 权限
Caching 缓存
Context passing 内容传递
Error handling 错误处理
Lazy loading　懒加载
Debugging　　调试
logging, tracing, profiling and monitoring　记录跟踪　优化　校准
Performance optimization　性能优化
Persistence　　持久化
Resource pooling　资源池
Synchronization　同步
Transactions 事务

好，概念方面讲清楚了之后，下面说说实现方案：

二、关于jar包依赖:

首先，使用aop依赖包除了Spring提供给开发者的jar包外，还需额外上网下载两个jar包：
1、aopalliance.jar
2、aspectjweaver.jar
我用的是maven管理jar，具体如下：
pom.xml：

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.8.RELEASE</version>
        </dependency>

        <!--spring aop + aspectj-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.0.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.9</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.9</version>
        </dependency>

三、使用AOP的几种方式:

1.经典的基于代理的AOP
2.@AspectJ注解驱动的切面
3.纯POJO切面（纯粹通过<aop:fonfig>标签配置）
4.注入式AspectJ切面

四、具体使用方式:

先把项目结构贴一下，用Java Project+Maven与用Web Project 会有小区别，一会说到。包结构：

1、经典的基于代理的AOP实现，用的是一个helloworld为例：

(1)先定义一个接口，任何可以说“helloworld”的类都可以实现它。

public interface HelloWorld {

    void printHelloWorld();

    void doPrint();
}

(2)定义两个接口实现类。

public class HelloWorldImpl1 implements HelloWorld {

    public void printHelloWorld() {
        System.out.println("------11111------按下HelloWorld1.printHelloWorld()-----11111111-------");
    }

    public void doPrint() {
        System.out.println("------1111111------打印HelloWorldImpl1-----1111111------");
        return ;
    }
}

public class HelloWorldImpl1 implements HelloWorld {

    public void printHelloWorld() {
        System.out.println("------11111------按下HelloWorld1.printHelloWorld()-----11111111-------");
    }

    public void doPrint() {
        System.out.println("------1111111------打印HelloWorldImpl1-----1111111------");
        return ;
    }
}

(3)HelloWorld的两个实现类关注的是业务逻辑，但在此之外还需要其他的功能逻辑等，如打印时间、打印日志等等。这里开始就需要AOP替“HelloWorldImpl”完成！解耦！首先需要一个TimeHandler类。因为一个是切入点前执行、一个是切入点之后执行，所以实现对应接口。
横切关注点，这里是打印时间：

public class TimeHandler implements MethodBeforeAdvice, AfterReturningAdvice {


    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("代理----前----CurrentTime = " + System.currentTimeMillis());

    }

    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("代理----后----CurrentTime = " + System.currentTimeMillis());
    }
}

(3)最关键的来了，Spring核心配置文件application.xml配置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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
">

    <!-- 定义被代理者 -->
    <bean id="h1" class="com.lym.aopTest.HelloWorldImpl1"></bean>
    <bean id="h2" class="com.lym.aopTest.HelloWorldImpl2"></bean>

    <!-- 定义通知内容，也就是切入点执行前后需要做的事情 -->
    <bean id="timeHandler" class="com.lym.aopTest.TimeHandler"></bean>

    <!-- 定义切入点位置，这里定义到了doPrint方法上 -->
    <bean id="timePointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
        <property name="pattern" value=".*doPrint"></property>
    </bean>

    <!-- 使切入点与通知相关联，完成切面配置 -->
    <bean id="timeHandlerAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
        <property name="advice" ref="timeHandler"></property>
        <property name="pointcut" ref="timePointcut"></property>
    </bean>

    <!-- 设置代理 -->
    <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 代理的对象，有打印时间能力 -->
        <property name="target" ref="h1"></property>
        <!-- 使用切面 -->
        <property name="interceptorNames" value="timeHandlerAdvisor"></property>
        <!-- 代理接口，hw接口 -->
        <property name="proxyInterfaces" value="com.lym.aopTest.HelloWorld"></property>
    </bean>
    <!-- 设置代理 -->
    <bean id="proxy2" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 代理的对象，有打印时间能力 -->
        <property name="target" ref="h2"></property>
        <!-- 使用切面 -->
        <property name="interceptorNames" value="timeHandlerAdvisor"></property>
        <!-- 代理接口，hw接口 -->
        <property name="proxyInterfaces" value="com.lym.aopTest.HelloWorld"></property>
    </bean>

   <!--<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>-->

</beans>

(5)测试类，Test，其中，通过AOP代理的方式执行h1、h2，其中doPrint()方法会把执行前、执行后的操作执行，实现了AOP的效果！

public class Test {

    public static void main(String[] args){
        //@SuppressWarnings("resource")
        //如果是web项目，则使用以下代码加载配置文件，如果是一般的Java项目，则使用注释的方式
        ApplicationContext appCtx = new ClassPathXmlApplicationContext("conf/application.xml");
        //ApplicationContext appCtx = new FileSystemXmlApplicationContext("conf/application.xml");
        HelloWorld hw1 = (HelloWorld) appCtx.getBean("proxy");
        HelloWorld hw2 = (HelloWorld) appCtx.getBean("proxy2");
        hw1.printHelloWorld();
        System.out.println();
        hw1.doPrint();
        System.out.println();

        hw2.printHelloWorld();
        System.out.println();
        hw2.doPrint();
    }
}

打印结果如下，可以看到，配置在h1、h2的doPrint()前后打印时间的方法都执行了：

yiyiLy

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
spring aop 及实现方式

最近看到aop，就做一点小小的总结。image一、AOP的基本概念：1、什么是aop：AOP（Aspect Oriented Programming）称为面向切面编程，在程序开发中主要用来解决一些系统层面上的问题，比如日志，事务，权限等待，Struts2的拦截器设计就是基于AOP的思想，是个比较经典的例子。在不改变原有的逻辑的基础上，增加一些额外的功能。代理也是这个功能，...
复制链接

扫一扫