Java：使用动态代理做一个简单的AOP

最新推荐文章于 2024-09-25 10:59:43 发布

new_Aiden

最新推荐文章于 2024-09-25 10:59:43 发布

阅读量158

点赞数

文章标签： java 动态代理实现AOP 动态代理设计模式 AOP实现

本文链接：https://blog.csdn.net/new_Aiden/article/details/72058125

版权

这里直接贴出了代码，运行之后就知道动态代理是用来干什么的了。这里使用动态代理做了一个简单的AOP例子。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MainClass {

    public static void main(String[] args) {
        OnClickListenerImpl onClickListenerImpl = new OnClickListenerImpl();
        AopHandler handler = new AopHandler(onClickListenerImpl);
        handler.setBeforeListener((target, method, _args) -> System.out.println("前置增强"));
        handler.setAfterListener((target, method, _args) -> System.out.println("后置增强"));
        handler.setExceptionListener((target, method, _args) -> System.out.println("异常增强"));

        OnClickListener listener = (OnClickListener) Proxy.newProxyInstance(
                MainClass.class.getClassLoader(),
                new Class[]{OnClickListener.class},
                handler
        );
        listener.onClick();
    }

    private interface OnClickListener {
        void onClick();
    }

    private static class OnClickListenerImpl implements OnClickListener {

        @Override
        public void onClick() {
            System.out.println("点击了");
        }
    }

    private interface BeforeListener {
        void before(Object target, Method method, Object[] args);
    }

    private interface AfterListener {
        void after(Object target, Method method, Object[] args);
    }

    private interface ExceptionListener {
        void exception(Object target, Method method, Object[] args);
    }

    private static class AopHandler implements InvocationHandler {

        private BeforeListener beforeListener;
        private AfterListener afterListener;
        private ExceptionListener exceptionListener;
        private Object target;

        AopHandler(Object target) {
            this.target = target;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            try {
                if (null != beforeListener) {
                    beforeListener.before(target, method, args);
                }
                Object object = method.invoke(target, args);
                if (null != afterListener) {
                    afterListener.after(target, method, args);
                }
                return object;
            } catch (Exception e) {
                if (null != exceptionListener) {
                    exceptionListener.exception(target, method, args);
                }
                return null;
            }
        }

        void setBeforeListener(BeforeListener beforeListener) {
            this.beforeListener = beforeListener;
        }

        void setAfterListener(AfterListener afterListener) {
            this.afterListener = afterListener;
        }

        void setExceptionListener(ExceptionListener exceptionListener) {
            this.exceptionListener = exceptionListener;
        }
    }
}