AOP相关

一、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 HelloWorldImpl2 implements HelloWorld {

    public void printHelloWorld() {
        System.out.println("------222222------按下HelloWorld2.printHelloWorld()------2222222------");
    }

    public void doPrint() {
        System.out.println("-------22222-----打印HelloWorldImpl2------22222-----");
        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()前后打印时间的方法都执行了：

五、使用aop记录数据库操作的执行时间

在项目中，我们往往需要记录数据库操作的时间，根据操作时间的不同，分别记录不同等级的日志。

首先我们可以写一个类实现MethodInterceptor接口：

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
 
/**
 * 自定义 AOP 处理时间类
 */
public class TimeHandler implements MethodInterceptor {
    /**
     * log
     */
    private final static Log log = LogFactory.getLog(TimeHandler.class);
    /**
     * 对于执行时间超过指定毫秒，日志级别为error
     * 单位：毫秒
     * 默认值：200
     */
    private int error = 200;
    /**
     * 对于执行时间超过指定毫秒，日志级别为warn
     * 单位：毫秒
     * 默认值：100
     */
    private int warn = 100;
    /**
     * 对于执行时间超过指定毫秒，日志级别为info
     * 单位：毫秒
     * 默认值：50
     */
    private int info = 50;
 
    /**
     * Method invoke ...
     *
     * @param methodInvocation of type MethodInvocation
     * @return Object
     * @throws Throwable when
     */
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        long procTime = System.currentTimeMillis();
        try {
            return methodInvocation.proceed();
        }
        finally {
            procTime = System.currentTimeMillis() - procTime;
            String msg = "Process method " + methodInvocation.getMethod().getName() + " successful! Total time: " + procTime + " milliseconds!";
            if (procTime > error) {
                if (log.isErrorEnabled()) log.error(msg);
            } else if (procTime > warn) {
                if (log.isWarnEnabled()) log.warn(msg);
            } else if (procTime > info) {
                if (log.isInfoEnabled()) log.info(msg);
            } else {
                if (log.isDebugEnabled()) log.debug(msg);
            }
        }
    }
 
    /**
     * Method setError sets the error of this TimeHandler object.
     *
     * @param error the error of this TimeHandler object.
     */
    public void setError(int error) {
        this.error = error;
    }
 
    /**
     * Method setWarn sets the warn of this TimeHandler object.
     *
     * @param warn the warn of this TimeHandler object.
     */
    public void setWarn(int warn) {
        this.warn = warn;
    }
 
    /**
     * Method setInfo sets the info of this TimeHandler object.
     *
     * @param info the info of this TimeHandler object.
     */
    public void setInfo(int info) {
        this.info = info;
    }
}

然后我们可以在Spring中配置

<!-- Dao方法处理时间 -->
    <bean id="daoTimeHandler" class="TimeHandler"/>
 
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <property name="beanNames">
            <value>*Dao</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>daoTimeHandler</value>
            </list>
        </property>
    </bean>

以上在运行时就可以在每个*Dao执行后记录该操作的使用时间。