spring aop

1、AOP基本概念

要理解切面编程，就需要先理解什么是切面，web层级设计中。
web层->网关层->服务层->数据层，每一层之间也是一个切面。编程中，对象与对象之间，方法与方法之间，模块与模块之间都是一个个切面。

专业术语
Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。
Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
Target（目标对象）：织入 Advice 的目标对象.。
Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程。

1、通知（Advice）:织入到目标类连接点上的一段程序代码。通知分为五种类型：

 - Before：在方法被调用之前调用  
 - After：在方法完成后调用通知，无论方法是否执行成功 
 - After-returning：在方法成功执行之后调用通知  
 - After-throwing：在方法抛出异常后调用通知 
 - Around:通知了好、包含了被通知的方法，在被通知的方法调用之前后调用之后执行自定义的行为

2、切点（Pointcut）：AOP通过“切点”定位特定的连接点
3、连接点（Joinpoint）:程序执行的某个特定位置：如类开始初始化前、类初始化后、类某个方法调用前、调用后、方法抛出异常后。这些代码中的特定点，称为“连接点”。
4、 织入（Weaving）：织入是将增强添加到目标类具体连接点上的过程。AOP有三种织入方式：

 - 编译期织入，这要求使用特殊的Java编译器；
 - 类装载期织入，这要求使用特殊的类装载器；
 - 动态代理织入，在运行期为目标类添加增强生成子类的方式。

Spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。
5、切面（Aspect）切面由切点和通知组成，它既包括了横切逻辑的定义，也包括了连接点的定义

2、代理模式

静态代理

// 接口
public interface IUserDao {
    void save();
 
    void find();
}
 
// 目标对象
public class UserDao implements IUserDao {
    @Override
    public void save() {
        System.out.println("模拟：保存用户！");
    }
 
    @Override
    public void find() {
        System.out.println("模拟：查询用户");
    }
}
 
/**
 * 静态代理 特点：
 *  1. 目标对象必须要实现接口 
 * 2. 代理对象，要实现与目标对象一样的接口
 */
public class UserDaoProxy implements IUserDao {
 
    // 代理对象，需要维护一个目标对象
    private IUserDao target = new UserDao();
 
    @Override
    public void save() {
        System.out.println("代理操作： 开启事务...");
        target.save(); // 执行目标对象的方法
        System.out.println("代理操作：提交事务...");
    }
 
    @Override
    public void find() {
        target.find();
    }
}
 
public class StaticProxyTest {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
 
        IUserDao proxy = new UserDaoProxy();
        proxy.save();
    }
 
}

优点：
代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合）。
缺点：
1）代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
2）代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。

动态代理

// 接口
public interface IUserDao {
    void save();
 
    void find();
}
 
// 目标对象
public class UserDao implements IUserDao {
 
    @Override
    public void save() {
        System.out.println("模拟： 保存用户！");
    }
 
    @Override
    public void find() {
        System.out.println("查询");
    }
}
 
 
 
 
/*
 *动态代理类只能代理接口（不支持抽象类），代理类都需要实现InvocationHandler类，
 *实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的，
 *该invoke方法返回的值是被代理接口的一个实现类
 */
public class LogHandler implements InvocationHandler {

    // 目标对象
    private Object targetObject;
    //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。
    public Object newProxyInstance(Object targetObject){
        this.targetObject=targetObject;
        //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
        //第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
        //第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口
        //第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法
        //根据传入的目标返回一个代理对象
        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
                targetObject.getClass().getInterfaces(),this);
    }
    @Override
    //关联的这个实现类的方法被调用时将被执行
    /*InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数*/
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object ret=null;
        try{
            /*原对象方法调用前处理日志信息*/
            System.out.println("satrt-->>");
            //调用目标方法
            ret=method.invoke(targetObject, args);
            /*原对象方法调用后处理日志信息*/
            System.out.println("success-->>");
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("error-->>");
            throw e;
        }
        return ret;
    }

}
 

被代理对象targetObject通过参数传递进来。
我们通过targetObject.getClass().getClassLoader()获取ClassLoader对象。
然后通过targetObject.getClass().getInterfaces()获取它实现的所有接口。
然后将targetObject包装到实现了InvocationHandler接口的LogHandler对象中。
通过newProxyInstance函数我们就获得了一个动态代理对象。

//客户端代码
   public class JDKDynamicProxyTest { 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // 目标对象
        IUserDao target = new UserDao();
        // 创建代理类
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        System.out.println("代理对象: "+proxy.getClass());
        proxy.save();
     }
}

可以看到，我们可以通过LogHandler代理不同类型的对象，如果我们把对外的接口都通过动态代理来实现，那么所有的函数调用最终都会经过invoke函数的转发。
因此我们就可以在这里做一些自己想做的操作，比如日志系统、事务、拦截器、权限控制等。
这也就是AOP(面向切面编程)的基本原理。

优点：
动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。
这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。
而且动态代理的应用使我们的类职责更加单一，复用性更强