Spring AOP

Spring  AOP(面向切面编程)

一、谈谈代理模式

　　　　代理模式在java 开发中是一种比较常见的设计模式。设计目的旨在为服务类与客户类之间插入其他功能，插入的功能对于调用者是透明的，起到伪装控制的作用。如租房的例子  房客、中介、房东。对应于代理模式中即：客户类 代理类  委托类（被代理类）。

　　　　代理模式的两个设计原则:

　　　　　　　　　　　　　　　　1.   代理类与委托类具有相似的行为（共同接口）

　　　　　　　　　　　　　　　　2.   代理类增强委托类的行为（代理类拥有委托类的引用，同时又有自己的功能实现）

　　　　实现代理模式的三要素：

　　　　　　　　　　　　　　　　1.　接口

　　　　　　　　　　　　　　　　2.　代理角色　　代理类拥有真实角色的引用，与真实角色实现共同接口

　　　　　　　　　　　　　　　　3.　真实角色　　委托类

　　　　Uml简图如下:

　　　　　　　　　　　　

　　　　　代理模式分为两类:静态代理和动态代理及批量化代理（aop）

　　　　　　　　　　　

 　　　　　1、静态代理

　　　　　　为某个对象提供一个代理，代理角色固定，以控制对这个对象的访问。 代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。

 

　　　　　　代码演示：　

真实角色和代理角色共同实现这一接口　

package com.wisezone.test;

/**
 * 真实角色和代理角色共同实现这一接口
 * @author 王东海
 * @2017年4月29日
 */
public interface Marry {
    
    public void toMarry();
}

真实角色（自己）

package com.wisezone.test;

/**
 * 真实角色（自己）
 * @author 王东海
 * @2017年4月29日
 */
public class You implements Marry {

    @Override
    public void toMarry() {
        System.out.println("等了这么久，终于等到你了。。。。");
    }

}

代理角色：婚庆公司

package com.wisezone.test;

/**
 * 代理角色：婚庆公司
 * @author 王东海
 * @2017年4月29日
 */
public class MarryCompany implements Marry {

    //引入真实角色的引用
    private You you;
    
    
    public MarryCompany(You you) {
        this.you = you;
    }

    public void before(){
        System.out.println("婚礼正在紧张筹备中，请耐心等待。。。");
    }
    
    
    public void after(){
        System.out.println("恭喜你现在正式成为已婚人士。。。");
    }


    @Override
    public void toMarry() {
        
        before();
        you.toMarry();
        after();
    }

}

 测试类

package com.wisezone.test;

/**
 * 测试类
 * @author 王东海
 * @2017年4月29日
 */
public class Test {
    public static void main(String[] args) {
        MarryCompany marryCompany = new MarryCompany(new You());
        marryCompany.toMarry();
    }
}

结果:

---------------------------------------------------------------------------------------------------------------------------------------------------

　　　　因为静态代理对于代理的角色是固定的，如dao层 20个dao类，如果要对方法的访问权限进行代理，此时需要创建20个静态代理角色，引起类爆炸，无法满足生产上的需要，于是就催生了动态代理的思想。

 　　　　　2、动态代理

　　　　　　　　　相比于静态代理，动态代理在创建代理对象上更加的灵活，它会根据需要通过反射机制在程序运行期动态的为目标对象创建代理对象，代理的行为可以代理多个方法，即满足生产需要的同时又达到代码通用的目的。

　　　　动态代理的两种实现方式：

　　　　　　　　I.jdk实现动态代理。

　　　　　　　　对于jdk动态代理实现方式比较复杂，回调方式实现 底层原理参考:

 　　　　　　　　http://rejoy.iteye.com/blog/1627405

代码演示：

package com.wisezone.test;

/**
 * 真实角色和代理角色共同实现这一接口
 * @author 王东海
 * @2017年4月29日
 */
public interface Marry {
    
    public void toMarry();
}

package com.wisezone.test;

/**
 * 真实角色（自己）
 * @author 王东海
 * @2017年4月29日
 */
public class You implements Marry {

    @Override
    public void toMarry() {
        System.out.println("等了这么久，终于等到你了。。。。");
    }

}

package com.wisezone.test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * jdk实现动态代理
 * @author 王东海
 * @2017年4月29日
 */
public class JDKHandler implements InvocationHandler {

    private Object target;
    
    
    public JDKHandler(Object target) {
        super();
        this.target = target;
    }

    /**
     * 参数1：类加载器
     * 参数2：目标类实现的所有接口    返回的是一个数组
     * 参数3：实现InvocationHandler接口对象
     * @return
     * Object
     */
    public Object getProxy(){
        
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }
    
    public void before(){
        System.out.println("婚礼正在紧张筹备中，请耐心等待。。。");
    }
    
    
    public void after(){
        System.out.println("恭喜你现在正式成为已婚人士。。。");
    }
    

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        before();
        Object result = method.invoke(target, args);//执行目标类方法
        after();
        return result;
    }

}

package com.wisezone.test;

/**
 * 测试类
 * @author 王东海
 * @2017年4月29日
 */
public class Test {
    public static void main(String[] args) {
        JDKHandler jdkHandler = new JDKHandler(new You());
        Marry marry = (Marry) jdkHandler.getProxy();
        marry.toMarry();
    }
}

结果：

　　　　　　　　II.cglib 动态代理实现（了解）

　　　　　　　　code generator library ，操作字节码。 与jdk提供的代理区别，Proxy：委托类必须有接口，制作过程比较快，执行慢；cglib：委托类可以没有接口，继承的思维来实现相似性，制作代理过程比较慢，执行快。主要:解决没有接口类的代理实现。

代码演示：

1、引入jar包

package com.wisezone.test;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**
 * cglib实现动态地理
 * @author 王东海
 * @2017年4月29日
 */
public class CglibInterceptor implements MethodInterceptor {

    private Object target;
    
    
    public CglibInterceptor(Object target) {
        super();
        this.target = target;
    }

    public Object getProxy(){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();//创建代理对象并返回
    }
    
    
    public void before()
    {
        System.out.println("婚礼正在紧张筹备中，请耐心等待。。。");
        
    }
    
    
    public void after()
    {
        
        System.out.println("恭喜你进入人生第二阶段。。。。");
    }
    

    @Override
    public Object intercept(Object arg0, Method arg1, Object[] arg2,
            MethodProxy arg3) throws Throwable {
        before();
        Object result = arg3.invokeSuper(arg0, arg2);
        after();
        return result;
    }

}

package com.wisezone.test;

/**
 * 测试类
 * @author 王东海
 * @2017年4月29日
 */
public class TestCglibProxy {
    public static void main(String[] args) {
        CglibInterceptor cglibInterceptor = new CglibInterceptor(new You());
        You you = (You) cglibInterceptor.getProxy();
        you.toMarry();
    }
}

结果：