AOP代理模式

转自 ：http://www.cnblogs.com/xujiming/p/5737531.html

http://blog.csdn.net/mrzhoug/article/details/51336833   

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

按照代理的创建时期，代理类可以分为两种。 

静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。 
动态代理：在程序运行时，运用反射机制动态创建而成。

 

静态代理的每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。 

 

动态代理 
与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 

 

Spring AOP使用动态代理技术在运行期间织入增强的代码，主要有两种代理机制：基于JDK的动态代理；基于CGLib的动态代理。JDK本身只提供接口的代理，而不支持类的代理。

1、静态代理：就是设计模式中的proxy模式

a、业务接口

/** * 抽象主题角色：声明了真实主题和代理主题的共同接口。 *  * @author yanbin *  */public interface ITalk {    public void talk(String msg);}
1
2
3
4
5
6
7
8
9
10
11

b、业务实现

/** * 真实主题角色：定义真实的对象。 *  * @author yanbin *  */public class PeopleTalk implements ITalk {    public String username;    public String age;    public PeopleTalk(String username, String age) {        this.username = username;        this.age = age;    }    public void talk(String msg) {        System.out.println(msg + "!你好,我是" + username + "，我年龄是" + age);    }    public String getName() {        return username;    }    public void setName(String name) {        this.username = name;    }    public String getAge() {        return age;    }    public void setAge(String age) {        this.age = age;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

c、代理对象

/** * 代理主题角色：内部包含对真实主题的引用，并且提供和真实主题角色相同的接口。 *  * @author yanbin *  */public class TalkProxy implements ITalk {    private ITalk talker;    public TalkProxy(ITalk talker) {        // super();        this.talker = talker;    }    public void talk(String msg) {        talker.talk(msg);    }    public void talk(String msg, String singname) {        talker.talk(msg);        sing(singname);    }    private void sing(String singname) {        System.out.println("唱歌：" + singname);    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

d、测试类

/** * 代理测试类，使用代理 * * @author yanbin *  */public class ProxyPattern {    public static void main(String[] args) {        // 不需要执行额外方法的。        ITalk people = new PeopleTalk("AOP", "18");        people.talk("No ProXY Test");        System.out.println("-----------------------------");        // 需要执行额外方法的（切面）        TalkProxy talker = new TalkProxy(people);        talker.talk("ProXY Test", "代理");    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

从这段代码可以看出来，代理模式其实就是AOP的雏形。 上端代码中talk(String msg, String singname)是一个切面。在代理类中的sing(singname)方法是个后置处理方法。

这样就实现了，其他的辅助方法和业务方法的解耦。业务不需要专门去调用，而是走到talk方法，顺理成章的调用sing方法

再从这段代码看：1、要实现代理方式，必须要定义接口。2、每个业务类，需要一个代理类。

2、动态代理：jdk1.5中提供，利用反射。实现InvocationHandler接口。

业务接口还是必须得，业务接口，业务类同上。

a、代理类：

/** * 动态代理类 *  * @author yanbin *  */public class DynamicProxy implements InvocationHandler {    /** 需要代理的目标类 */    private Object target;    /**     * 写法固定，aop专用:绑定委托对象并返回一个代理类     *      * @param delegate     * @return     */    public Object bind(Object target) {        this.target = target;        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);    }    /**     * @param Object     *            target：指被代理的对象。     * @param Method     *            method：要调用的方法     * @param Object     *            [] args：方法调用时所需要的参数     */    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        Object result = null;        // 切面之前执行        System.out.println("切面之前执行");        // 执行业务        result = method.invoke(target, args);        // 切面之后执行        System.out.println("切面之后执行");        return result;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

b、测试类

/** * 测试类 *  * @author yanbin *  */public class Test {    public static void main(String[] args) {        // 绑定代理，这种方式会在所有的方法都加上切面方法        ITalk iTalk = (ITalk) new DynamicProxy().bind(new PeopleTalk());        iTalk.talk("业务说明");    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出结果会是：

切面之前执行 
people talk业务说法 
切面之后执行

说明只要在业务调用方法切面之前，是可以动态的加入需要处理的方法。

从代码来看，如果再建立一个业务模块，也只需要一个代理类。ITalk iTalk = (ITalk) new DynamicProxy().bind(new PeopleTalk()); 将业务接口和业务类绑定到动态代理类。

但是这种方式：还是需要定义接口。

3、利用cglib

CGLIB是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强。采用的是继承的方式。不细说，看使用

a、业务类

/** * 业务类 *  * @author yanbin *  */public class PeopleTalk {    public void talk(String msg) {        System.out.println("people talk" + msg);    }}
1
2
3
4
5
6
7
8
9
10
11
12
13

b、cglib代理类

/** * 使用cglib动态代理 *  * @author yanbin *  */public class CglibProxy implements MethodInterceptor {    private Object target;    /**     * 创建代理对象     *      * @param target     * @return     */    public Object getInstance(Object target) {        this.target = target;        Enhancer enhancer = new Enhancer();        enhancer.setSuperclass(this.target.getClass());        // 回调方法        enhancer.setCallback(this);        // 创建代理对象        return enhancer.create();    }    @Override    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {        Object result = null;        System.out.println("事物开始");        result = methodProxy.invokeSuper(proxy, args);        System.out.println("事物结束");        return result;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

c.测试类

/** * 测试类 *  * @author yanbin *  */public class Test {    public static void main(String[] args) {        PeopleTalk peopleTalk = (PeopleTalk) new CglibProxy().getInstance(new PeopleTalk());        peopleTalk.talk("业务方法");        peopleTalk.spreak("业务方法");    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

最后输出结果：

事物开始 
people talk业务方法 
事物结束 
事物开始 
spreak chinese业务方法 
事物结束

//写多很好！