【�{】理解AOP

Sat, 02 Mar 2013 14:28:00 GMT

Aspect Oriented Programming 面向切面�~�程。解耦是�E�序员编码开发过�E�中一直追求的。AOP也是��Z��解耦所诞生�?/p>

具体思想是：定义一个切面，在切面的�U�向定义处理�Ҏ��Q�处理完成之后，回到横向业务��?/p>

AOP 在Spring框架中被作�ؓ核心�l�成部分之一�Q�的��Spring��AOP发挥到很强大的功能。最常见的就是事务控制。工作之余，对于使用的工��P��不免需要了解其所以然。学习了一下，写了些程序帮助理解�?/p>

AOP 主要是利用代理模式的技术来实现的�?/p>

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

a、业务接�?/p>

/**
* 抽象主题角色�Q�声明了真实主题和代理主题的共同接口�?br /> *
* @author yanbin
*
*/
public interface ITalk {

public void talk(String msg);

}

b、业务实�?/div>

/**
* 真实主题角色�Q�定义真实的对象�?br /> *
* @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 + "�Q�我�q�龄�?/span>" + 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;
    }

}

c、代理对�?/div>

/**
* 代理主题角色�Q�内部包含对真实主题的引用，�q�且提供和真实主题角色相同的接口�?br /> *
* @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("唱歌�Q?/span>" + singname);
    }

}

d、测试类

/**
* 代理��试�c�，使用代理
*
* @author yanbin
*
*/
public class ProxyPattern {

    public static void main(String[] args) {
        // 不需要执行额外方法的�?/span>
        ITalk people = new PeopleTalk("AOP", "18");
        people.talk("No ProXY Test");
        System.out.println("-----------------------------");

        // 需要执行额外方法的�Q�切面）
        TalkProxy talker = new TalkProxy(people);
        talker.talk("ProXY Test", "代理");
    }

}

从这�D�代码可以看出来�Q�代理模式其实就是AOP的雏形�?上端代码中talk(String msg, String singname)是一个切面。在代理�c�M��的sing(singname)�Ҏ��是个后置处理�Ҏ��?/p>

�q�样��实��C��Q�其他的辅助�Ҏ��和业务方法的解耦。业务不需要专门去调用�Q�而是走到talk�Ҏ��Q�顺理成章的调用sing�Ҏ��

再从�q�段代码看：1、要实现代理方式�Q�必��要定义接口�?、每个业务类�Q�需要一个代理类�?/p>

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

业务接口�q�是必须得，业务接口�Q�业务类同上�?/p>

a、代理类�Q?/p>

/**
* 动态代理类
*
* @author yanbin
*
*/
public class DynamicProxy implements InvocationHandler {

    /** 需要代理的目标�c?nbsp;*/
    private Object target;

    /**
     * 写法固定�Q�aop专用:�l�定委托对象�q�返回一个代理类
     *
     * @param delegate
     * @return
     */
    public Object bind(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    /**
     * @param Object
     *            target�Q�指被代理的对象�?br />     * @param Method
     *            method�Q�要调用的方�?br />     * @param Object
     *            [] args�Q�方法调用时所需要的参数
     */
    @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;
    }

}

b、测试类

/**
* ��试�c?br /> *
* @author yanbin
*
*/
public class Test {

    public static void main(String[] args) {
        // �l�定代理�Q�这�U�方式会在所有的�Ҏ��都加上切面方�?/span>
        ITalk iTalk = (ITalk) new DynamicProxy().bind(new PeopleTalk());
        iTalk.talk("业务说明");
    }
}

输出�l�果会是�Q?/p>

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

说明只要在业务调用方法切面之前，是可以动态的加入需要处理的�Ҏ��?/p>

从代码来看，如果再徏立一个业务模块，也只需要一个代理类。ITalk iTalk = (ITalk) new DynamicProxy().bind(new PeopleTalk()); ��业务接口和业务�cȝ��定到动态代理类�?/p>

但是�q�种方式�Q�还是需要定义接口�?/p>

3、利用cglib

CGLIB是针对类来实��C��理的�Q�他的原理是�Ҏ��定的目标�cȝ��成一个子�c�，�q�覆盖其中方法实现增强。采用的是��承的方式。不�l�说�Q�看使用

a、业务类

/**
* 业务�c?br /> *
* @author yanbin
*
*/
public class PeopleTalk {

    public void talk(String msg) {
        System.out.println("people talk" + msg);
    }

}

b、cglib代理�c?/div>

/**
* 使用cglib动态代�?br /> *
* @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("事物开�?/span>");
        result = methodProxy.invokeSuper(proxy, args);
        System.out.println("事物�l�束");
        return result;
    }

}

c.��试�c?/div>

/**
* ��试�c?br /> *
* @author yanbin
*
*/
public class Test {

    public static void main(String[] args) {
        PeopleTalk peopleTalk = (PeopleTalk) new CglibProxy().getInstance(new PeopleTalk());
        peopleTalk.talk("业务�Ҏ��");
        peopleTalk.spreak("业务�Ҏ��");
    }

}

最后输出结果：

事物开�?br />people talk业务�Ҏ��
事物�l�束
事物开�?br />spreak chinese业务�Ҏ��
事物�l�束

�׃��幅有限�Q�这��主要对AOP的原理简单实现做了演�C�和阐述�Q�有助自��q��解。至于Spring的AOP实现上面无外乎其叻I��不过实现斚w��复杂的多�?/p>

原文��Q?div>http://www.cnblogs.com/yanbincn/archive/2012/06/01/2530377.html

��胡�?/a> 2013-03-02 22:28 发表评论

久久久精品久久久久久96,一区二区三区四区乱视频,日韩大片b站免费观看直播

【�{】理解AOP