一篇文章掌握Sping APO

Spring APO简介
AOP(Aspect Oriented Programming)，即面向切面编程，可以说是OOP(Object Oriented Programming，面向对象编程)的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为为部分对象引入公共部分的时候，OOP就会引入大量重复的代码。例如：日志功能。
AOP技术利用一宗成为"横切"的技术，解剖封装的对象内部，并将那些影响了多个类的公共行为风爪功能到一个可重用模块，这样就能减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处。而各处都基本相似。比如权限认证、日志、事务处理。
Spring Aop其代码实质，即代理模式的应用。
代理模式代码的主要特点是：不改变原有类的前提下，在原有类的默写方法执行前后，插入任意代码。所以代理模式需要写新的类对原有的类进行包装。Aop的最大意义是：在不改变原来代码的前提下，也不对源代码做任何协议接口要求。而实现了类似插件的方式，来修改源代码，给源代码插入新的执行代码。实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。
AOP应用场景
AOP适合于那些具有横切逻辑的应用：性能检测，访问控制，事务管理、缓存、对象池管理以及日志记录AOP将这些分散在各个业务逻辑中的代码通过横向切割的方式抽取到一个独立的模块中。AOP 实现的关键就在于 AOP 框架自动创建的 AOP 代理，AOP 代理则可分为静态代理和动态代理两大类，其中静态代理是指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强；而动态代理则在运行时借助于 JDK 动态代理、CGLIB 等在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。
AOP使用场景：AOP用来封装横切关注点，具体可以在下面的场景中使用，Authentication 权限，Caching 缓存，Context passing 内容传递，Error handling 错误处理，Lazy loading 懒加载，Debugging 调试，logging, tracing, profiling and monitoring 记录跟踪 优化 校准，Performance optimization 性能优化，Persistence 持久化，Resource pooling 资源池，Synchronization 同步，Transactions 事务。
AOP相关名词概念：
方面（Aspect）：一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管理是J2EE应用中一个很好的横切关注点例子。方面用Spring的 Advisor或拦截器实现。
连接点（Joinpoint）: 程序执行过程中明确的点，如方法的调用或特定的异常被抛出
通知（Advice）: 在特定的连接点，AOP框架执行的动作。各种类型的通知包括“around”、“before”和“throws”通知。通知类型将在下面讨论。许多AOP框架包括Spring都是以拦截器做通知模型，维护一个“围绕”连接点的拦截器链。Spring中定义了四个advice: BeforeAdvice, AfterAdvice, ThrowAdvice和DynamicIntroductionAdvice
切入点(Pointcut):指定一个通知将被引发的一系列连接点的集合。AOP框架必须允许开发者指定切入点：例如，使用正确的表达式。spring定义了Pointcut接口，用来组合MethodMatcher和ClassFilter，可以通过名字很清楚的理解， MethodMatcher是用来检查目标类的方法是否可以被应用此通知，而ClassFilter是用来检查Pointcut是否应该应用到目标类上。
引入（Introduction）: 添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现 IsModified接口，来简化缓存。Spring中要使用Introduction, 可有通过DelegatingIntroductionInterceptor来实现通知，通过DefaultIntroductionAdvisor来配置Advice和代理类要实现的接口。
目标对象（Target Object）: 包含连接点的对象。也被称作被通知或被代理对象。POJO
AOP代理（AOP Proxy）: AOP框架创建的对象，包含通知。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。
织入（Weaving）: 组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

AOP原理剖析
代理模式分为动态代理和静态代理。现在我们就以代理模式为基础先实现我们自己的AOP框架，再来研究Spring的AOP的实现原理。
先以静态代理实现，静态代理关键是在代理对象和目标对象实现共同的接口，并且代理对象持有目标对象的引用。

package com.aop.test;
 
/*
 *Created by William on 2018/8/12 0012
 */
public interface IHello {
    void sayHello(String str);
接口实现类：

package com.aop.test;

/*
*Created by William on 2018/8/12 0012
*/
public class Hello implements IHello {
@Override
public void sayHello(String str) {
System.out.println("hello " + str);
}
}

静态代理Proxy类：
package com.aop.test;
 
import com.aop.test.log.Logger;
 
/*
 *静态代理
 *Created by William on 2018/8/12 0012
 */
public class ProxyHello implements IHello {
    private IHello iHello;
    public ProxyHello(IHello iHello){
//        super();
        this.iHello = iHello;
    }
    @Override
    public void sayHello(String str) {
        Logger.start();
        iHello.sayHello(str);
        Logger.end();
    }
}
静态代理测试类：
package com.aop.test;
 
/*
 *静态代理测试
 * Created by William on 2018/8/12 0012
 */
public class StaticProxyTest {
    public static void main(String[] args) {
        IHello hello = new ProxyHello(new Hello());
        hello.sayHello("静态代理");
    }
}

这样我们就实现了一个最简单的AOP，但是这样会存在一个问题：如果我们像Hello这样的类很多，那么，我们是不是要去写很多个HelloProxy这样的类呢。其实也是一种很麻烦的事。在jdk1.3以后，jdk跟我们提供了一个API java.lang.reflect.InvocationHandler的类， 这个类可以让我们在JVM调用某个类的方法时动态的为些方法做些什么事。下面我们就来实现动态代理的实现。
　　动态代理实现主要是实现InvocationHandler，并且将目标对象注入到代理对象中，利用反射机制来执行目标对象的方法。
　　接口实现与静态代理相同，代理类代码：
　　```
　　package com.aop.test.dynamicProxy;
 
import com.aop.test.log.Logger;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
/*
 *Created by William on 2018/8/12 0012
 */
public class DynaProxyHello implements InvocationHandler {
    private Object target;//目标对象
    /**
     * 通过反射来实例化目标对象
     * @param object
     * @return
     */
    public Object bind(Object object){
        this.target = object;
        return Proxy.newProxyInstance(this.target.getClass().getClassLoader(),
                this.target.getClass().getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        Logger.start();
        result = method.invoke(this.target, args);
        Logger.end();
        return result;
    }
}

动态代理测试类：

package com.aop.test.dynamicProxy;
 
        import com.aop.test.Hello;
        import com.aop.test.IHello;
 
/*
 *Created by William on 2018/8/12 0012
 */
public class DynamicProxyTest {
    public static void main(String[] args) {
        IHello hello = (IHello) new DynaProxyHello().bind(new Hello());
        hello.sayHello("动态代理测试");
    }
}
看完上面的代码可能和Spring AOP相比有一个问题，日志类只能在方法前后打印，但是AOP应该是可以在满足条件就可以执行，所有是否可以将DynaPoxyHello对象和日志操作对象(Logger)解耦呢？

    看下面代码实现，将将DynamicPoxyHello对象和日志操作对象(Logger)解耦：

    我们要在被代理对象的方法前面或者后面去加上日志操作代码(或者是其它操作的代码)，那么，我们可以抽象出一个接口，这个接口里就只有两个方法：一个是在被代理对象要执行方法之前执行的方法,我们取名为start，第二个方法就是在被代理对象执行方法之后执行的方法,我们取名为end。
     Logger的接口：

package com.aop.test.dynamicProxy;

import java.lang.reflect.Method;

/*
*Created by William on 2018/8/12 0012
*/
public interface ILogger {
void start(Method method);
void end(Method method);
}
Logger的接口实现：

package com.aop.test.dynamicProxy;
 
import java.lang.reflect.Method;
import java.util.Date;
 
/*
 *Created by William on 2018/8/12 0012
 */
public class DLogger implements ILogger {
    @Override
    public void start(Method method) {
        System.out.println(new Date()+ method.getName() + " say hello start...");
    }
 
    @Override
    public void end(Method method) {
        System.out.println(new Date()+ method.getName() + " say hello end");
    }
}
动态代理类：

package com.aop.test.dynamicProxy;

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

/*
*Created by William on 2018/8/12 0012
*/
public class DynaProxyHello implements InvocationHandler {
//调用对象
private Object proxy;
//目标对象
private Object target;

public Object bind(Object target, Object proxy) {
    this.target = target;
    this.proxy = proxy;
    return Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(), this);
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    Object result = null;
    //反射得到操作者的实例
    Class clazz = this.proxy.getClass();
    //反射得到操作者的Start方法
    Method start = clazz.getDeclaredMethod("start", new Class[]{Method.class});
    //反射执行start方法
    start.invoke(this.proxy, new Object[]{method});
    //执行要处理对象的原本方法
    method.invoke(this.target, args);
    //反射得到操作者的end方法
    Method end = clazz.getDeclaredMethod("end", new Class[]{Method.class});
    //反射执行end方法
    end.invoke(this.proxy, new Object[]{method});
    return result;
}

}
测试代码：

package com.aop.test.dynamicProxy;
 
import com.aop.test.Hello;
import com.aop.test.IHello;
 
/*
 *Created by William on 2018/8/12 0012
 */
public class DynamicProxyTest {
    public static void main(String[] args) {
        IHello hello = (IHello) new DynaProxyHello().bind(new Hello(), new DLogger());//如果我们需要日志功能，则使用代理类
        //IHello hello = new Hello();//如果我们不需要日志功能则使用目标类
        hello.sayHello("明天");
    }
}
![在这里插入图片描述](https://img-blog.csdnimg.cn/20190227161049526.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NhbXVyYWk3Nw==,size_16,color_FFFFFF,t_70)
    通过上面例子，可以发现通过动态代理和发射技术，已经基本实现了AOP的功能，如果我们只需要在方法执行前打印日志，则可以不实现end()方法，这样就可以控制打印的时机了。如果我们想让指定的方法打印日志，我们只需要在invoke（）方法中加一个对method名字的判断，method的名字可以写在xml文件中，这样我们就可以实现以配置文件进行解耦了，这样我们就实现了一个简单的spring aop框架。