文档章节

链式-AOP

业余编程人士
 业余编程人士
发布于 2017/06/01 11:00
字数 624
阅读 9
收藏 0

链式-AOP 属于 责任链模式,eg: 我们可以将每个 Proxy 用一根链子串起来,形成一个 Proxy Chain。然后调用这个 Proxy Chain,让它去依次调用 Chain 中的每个 Proxy。

public interface Proxy { // 具体要串在链子上的东东

    void doProxy(ProxyChain proxyChain);
}
public class ProxyChain { // 链子,用来串Proxy用的

    private List<Proxy> proxyList;
    private int currentProxyIndex = 0;

    private Class<?> targetClass; // 具体哪个类
    private Object targetObject;  // 的哪个对象
    private Method targetMethod;  // 的哪个方法
    private Object[] methodParams; // 有哪几个参数的方法
    private MethodProxy methodProxy;  // 方法代理对象
    private Object methodResult;  // 方法返回结果

    public ProxyChain(Class<?> targetClass, Object targetObject, Method targetMethod, Object[] methodParams, MethodProxy methodProxy, List<Proxy> proxyList) {
        this.targetClass = targetClass;
        this.targetObject = targetObject;
        this.targetMethod = targetMethod;
        this.methodParams = methodParams;
        this.methodProxy = methodProxy;
        this.proxyList = proxyList;
    }

    public Class<?> getTargetClass() {
        return targetClass;
    }

    public Object getTargetObject() {
        return targetObject;
    }

    public Method getTargetMethod() {
        return targetMethod;
    }

    public Object[] getMethodParams() {
        return methodParams;
    }

    public MethodProxy getMethodProxy() {
        return methodProxy;
    }

    public Object getMethodResult() {
        return methodResult;
    }

    public void doProxyChain() {
        if (currentProxyIndex < proxyList.size()) {
            proxyList.get(currentProxyIndex++).doProxy(this); // 调用链条上的某个Proxy的某个方法
        } else {
            try {
                methodResult = methodProxy.invokeSuper(targetObject, methodParams);
            } catch (Throwable throwable) {
                throw new RuntimeException(throwable);
            }
        }
    }
}
public class ProxyManager { // 一个Proxy工厂,用来创建Proxy用的

    private Class<?> targetClass; // 具体要创建哪一个类的Proxy
    private List<Proxy> proxyList;

    public ProxyManager(Class<?> targetClass, List<Proxy> proxyList) {
        this.targetClass = targetClass;
        this.proxyList = proxyList;
    }

    @SuppressWarnings("unchecked")
    public <T> T createProxy() {
        return (T) Enhancer.create(targetClass, new MethodInterceptor() {
            @Override
            public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                ProxyChain proxyChain = new ProxyChain(targetClass, target, method, args, proxy, proxyList);
                proxyChain.doProxyChain();
                return proxyChain.getMethodResult();
            }
        });
    }
}

上面的三个类 只是创建了一种链式模式,下面要利用这种链式模式 实现AOP:

// “模版方法模式”,就是定义一个抽象类 里面一些空方法 当模版
public abstract class AbstractProxy implements Proxy { // 实现 Proxy 借口

    @Override
    public final void doProxy(ProxyChain proxyChain) {
        Class<?> cls = proxyChain.getTargetClass(); // 具体哪个类要增强
        Method method = proxyChain.getTargetMethod(); // 的具体哪个方法
        Object[] params = proxyChain.getMethodParams(); // 的方法参数

        begin(); // 所有方法执行前要干什么
        try {
            if (filter(cls, method, params)) {
                before(cls, method, params); // 具体方法执行前要干什么
                proxyChain.doProxyChain(); 
                after(cls, method, params); // 具体方法执行后要干什么
            } else {
                proxyChain.doProxyChain();
            }
        } catch (Throwable e) {
            error(cls, method, params, e);
        } finally {
            end(); // 所有方法执行完后要干什么
        }
    }

    public void begin() {
    }

    public boolean filter(Class<?> cls, Method method, Object[] params) {
        return true;
    }

    public void before(Class<?> cls, Method method, Object[] params) {
    }

    public void after(Class<?> cls, Method method, Object[] params) {
    }

    public void error(Class<?> cls, Method method, Object[] params, Throwable e) {
    }

    public void end() {
    }
}

具体实现:

public class BeforeProxy extends AbstractProxy {

    @Override
    public void before(Class<?> cls, Method method, Object[] params) {
        System.out.println("Before");
    }
}
public class AfterProxy extends AbstractProxy {

    @Override
    public void after(Class<?> cls, Method method, Object[] params) {
        System.out.println("After");
    }
}

编写客户端代码:

public class Client {

    public static void main(String[] args) {
        List<Proxy> proxyList = new ArrayList<Proxy>();
        proxyList.add(new BeforeProxy());
        proxyList.add(new AfterProxy());

        ProxyManager proxyManager = new ProxyManager(GreetingImpl.class, proxyList);
        GreetingImpl greetingProxy = proxyManager.createProxy();

        greetingProxy.sayHello("Jack");
    }
}

 

© 著作权归作者所有

上一篇: JVM 调优手段
业余编程人士
粉丝 5
博文 19
码字总数 9137
作品 0
其他
程序员
私信 提问
Smart Framework V1.4 发布

Smart Framework V1.4 发布 1. 【特性】可使用 @Order 注解定义 AOP 拦截顺序 2. 【特性】在 AOP 的后置增强中提供方法返回值 3. 【改进】使用单例模式重构了所有 Helper 类 4. 【改进】使用...

黄勇
2013/11/02
1K
8
Spring AOP与拦截器的区别

作用层面 拦截器只对action负责,作用层面一般位于Controller层 Spring AOP主要是拦截对Spring管理的Bean的访问,一般作用与Service层 2、联系与区别 联系: Spring AOP和拦截器一样,都是A...

niithub
2018/05/06
1K
0
Cache Plugin 实现过程

本文是《轻量级 Java Web 框架架构设计》的系列博文。 前几天写过一篇文章,关于如何实现 Cache Plugin,错过的朋友可以看这篇:《能否让 Cache 变得更加优雅?》。 今天,我想和大家分享一下...

黄勇
2013/11/07
2.3K
4
Smart framework 缓存插件的实现

Smart是一个轻量级的java web框架,里面已经实现了IOC,AOP以及事务管理,同时也实现了MVC模块。本插件是基于Smart的AOP来进行实现的。目标是:在不需要改变当前业务代码的情况下将缓存功能嵌...

Bieber
2013/11/02
1K
2
frost373/OneJava

##OneJava是什么? 一个基于Java的一站式WEB开发框架,框架的设计原则是简洁、灵活和降低学习成本。 OneJava除了一些基本的依赖(日志,Cglib等),不需要集成其他框架,而是实现了自己的MVC...

frost373
2016/11/15
0
0

没有更多内容

加载失败,请刷新页面

加载更多

3_数组

3_数组

行者终成事
今天
7
0
经典系统设计面试题解析:如何设计TinyURL(二)

原文链接:https://www.educative.io/courses/grokking-the-system-design-interview/m2ygV4E81AR 编者注:本文以一道经典的系统设计面试题:《如何设计TinyURL》的参考答案和解析为例,帮助...

APEMESH
今天
7
0
使用logstash同步MySQL数据到ES

概述   在生成业务常有将MySQL数据同步到ES的需求,如果需要很高的定制化,往往需要开发同步程序用于处理数据。但没有特殊业务需求,官方提供的logstash就很有优势了。   在使用logstas...

zxiaofan666
今天
10
0
X-MSG-IM-分布式信令跟踪能力

经过一周多的鏖战, X-MSG-IM的分布式信令跟踪能力已基本具备, 特点是: 实时. 只有要RX/TX就会实时产生信令跟踪事件, 先入kafka, 再入influxdb待查. 同时提供实时sub/pub接口. 完备. 可以完整...

dev5
今天
7
0
OpenJDK之CyclicBarrier

OpenJDK8,本人看的是openJDK。以前就看过,只是经常忘记,所以记录下 图1 CyclicBarrier是Doug Lea在JDK1.5中引入的,作用就不详细描述了,主要有如下俩个方法使用: await()方法,如果当前线...

克虏伯
今天
8
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部