Spring AOP的理解

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

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

使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

AOP核心概念

1、横切关注点

对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点

2、切面（aspect）

类是对物体特征的抽象，切面就是对横切关注点的抽象

3、连接点（joinpoint）

被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器

4、切入点（pointcut）

对连接点进行拦截的定义

5、通知（advice）

所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类

6、目标对象

代理的目标对象

7、织入（weave）

将切面应用到目标对象并导致代理对象创建的过程

8、引入（introduction）

在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段

在这之前先来看一个例子：

一个IPerson接口

public interface IPerson
{
    public void Do();
}

一个实现类Person.java

public class Person implements IPerson
{
    @Override
    public void Do() {
        System.out.println("Hello");
    }
}

一个main方法测试：

public class test
{
    public static void main(String[] args) {
        IPerson person = new Person();
        person.Do();
    }
}

输出的就是：Hello

这时候如果想要在上面的person.Do();之前或之后做一些其他的事情可以借助一个类——java中代理

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

public class PersonHandler implements InvocationHandler
{

    private Object obj;

    public PersonHandler(Object obj) {
        this.obj = obj;
    }

    public static <T> T GetInstance(Object obj) {
        PersonHandler handler = new PersonHandler(obj);
        @SuppressWarnings("unchecked")
        T proxy = (T) Proxy.newProxyInstance(obj.getClass().getClassLoader(), 
                obj.getClass().getInterfaces(), handler);
        return proxy;
    }

    /**
     * proxy: 指代我们所代理的那个真实对象
     * method: 指代的是我们所要调用真实对象的某个方法的Method对象 
     * args:指代的是调用真实对象某个方法时接受的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = method.invoke(obj, args);
        System.out.println("after");
        return result;
    }
}

先看一下上面的invoke方法，它有三个参数，意思分别在代码的注释里指出。

这里面通过反射调用方法，当我们把person传进来的时候，就会调用Do()方法，在调用的之前和之后分别加了个输出语句。

这时候改一个main方法看一下效果：

public class test
{
    public static void main(String[] args) {    
        IPerson person = PersonHandler.GetInstance(new Person());
        person.Do();
    }
}

运行输出的结果如下：

before
Hello
after

说明已经拦截到person里的方法并可以做一些其他的事情。

现在为了方便，想把IPerson person = PersonHandler.GetInstance(new Person());里的new Person()换成Person.class，这样就不用每次都new一个对象，在上面的PersonHandler类里面加一个构造方法：

public static <T> T GetInstance(Class<?> cls) {
        try {
            Object obj = cls.newInstance();

             return GetInstance(obj);
        }
        catch (InstantiationException | IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }

这样就可以使用IPerson person = PersonHandler.GetInstance(Person.class);来创建实例了。

现在，想简化一下：能不能IPerson person = PersonHandler.GetInstance( );直接使用空参的形式来创建实例呢？

当然也会是可以的，可以使用xml来配置（这是不是就是xml里bean的来源呢？）

通过xml里配置的接口和对应的实现类可以实现这种想法。每次将xml里所有的信息解析出来放到集合里，可以在PersonHandler类的构造里面进行遍历判断当前的是哪一个实例。

这种想法有一定的缺陷：如果类越来越多，上百甚至上千个，再一个一个去xml里配置就显得特别的繁琐。

所以，另一种想法：能不能在上面价加个注解就可以实现实例化呢，如：

public class test
{

    public static void main(String[] args) {
        @XXXX
        IPerson person ;
        person.Do();
    }
}

通过上面的注解，就可以实例化对象直接调用Do()方法。通过扫描查找所有带有@XXXX注解的类在某个方法里全部实例化。用到的时候就可以直接使用。
将上面的注解换成@Autowired不就是Spring里的自动装载吗？

绕了这么一大圈，现在回过头来看看AOP就会非常容易了。

现在在Spring里面使用AOP就相当于在PersonHandler类里面的invoke方法，只不过现在不在那个类里面写了。

Spring提供了几种实现AOP的方式：

一、基于XML配置的Spring AOP

二、使用注解配置AOP

三、AspectJ切点函数

四、AspectJ通知注解

五、零配置实现Spring IoC与AOP

这里暂时先介绍一种xml配置的方式：

先定义一个类：

public class TimeHandler
{
    public void printTime()
    {
        System.out.println("CurrentTime = " + System.currentTimeMillis());
    }
}

xml配置（aop.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:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

	<bean id="person" class="com.test.impl.Person" />

	<aop:config>
		<aop:aspect id="time" ref="timeHandler" order="1">
			<aop:pointcut id="addAllMethod"
				expression="execution(* com.test.api.Do.*(..))" />
			<aop:before method="printTime" pointcut-ref="addAllMethod" />
			<aop:after method="printTime" pointcut-ref="addAllMethod" />
		</aop:aspect>
	</aop:config>

</beans>

运行的结果就会在调用Do()之前和之后分别打印出时间。

进阶阶段推荐看一下这篇博客：Spring Aop