【从零写javaweb框架】(九)开发AOP框架

最新推荐文章于 2024-02-09 20:23:03 发布

原创最新推荐文章于 2024-02-09 20:23:03 发布 · 472 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#框架 #java #javaweb #架构 #spring

从零写javaweb框架专栏收录该内容

12 篇文章

订阅专栏

本文详细介绍如何在Java MVC框架中实现AOP功能，包括定义切面注解、设计代理接口及其实现，并利用CGLib动态创建代理对象。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

上一篇我们完成搭建了一个简单的MVC框架，使其可以通过DispatchServlet来处理所有的请求【从零写javaweb框架】(八)请求转发器，这一篇会实现AOP功能。

一.什么是AOP

AOP(Aspect-Oriented Programming)是对面向对象编程(OOP)的一种补充，可以译为面向切面编程。其中切面是AOP的一个术语，表示从业务逻辑中分离出来的横切逻辑，比如性能监控，日志记录、权限控制等，这些逻辑都可从核心的业务逻辑代码中抽离出去。也就是说，通过AOP可以解决代码耦合问题，是职责更加单一。

我个人的理解:AOP的作用通俗一点说就是可以在方法的前后附加上其他代码，每次调用此方法之前或之后(又或者前后都有)，都会先后执行附加的代码。

二.设计模式之代理模式

如果想继续深入了解AOP的实现，我们需要先了解静态代理模式和动态代理模式，这里附上我以前写的两篇博文(如果之前已经了解过代理模式了，那么可以直接跳过看下一步):

静态代理模式:设计模式_4:代理模式

动态代理模式:设计模式_25:动态代理模式

三.开发AOP框架

紧接着我之前写的框架，现在要开始实现AOP了，首先定义一个切面注解:

package org.smart4j.framework.annotation;

import java.lang.annotation.*;

/**
 * desc : 切面注解
 * Created by Lon on 2018/2/3.
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Aspect {

    /**
     * 注解
     */
    Class<? extends Annotation> value();

}

这个注解的value是一个class，表示我们要对哪个标有此注解类里的方法进行切入(其实就是要代理哪个类)，我们可以注解在一个类上面，表示此类是一个切面类。用法:@Aspect(Controller.class)，它表示我们要对标有Controller(这个注解是我们之前编写的，如果忘记了可以回头看一看)注解的类进行切入。

然后继续在框架中添加一个名为Proxy的接口:

package org.smart4j.framework.proxy;

/**
 * desc : 代理接口
 * Created by Lon on 2018/2/3.
 */
public interface Proxy {

    /**
     * 执行链式代理
     */
    Object doProxy(ProxyChain proxyChain) throws Throwable;

}

这个Proxy接口中有一个doProxy方法，参数是一条代理链proxyChain，这条代理链的作用是把多个代理串起来，并一个个依次执行，执行顺序取决于添加到链上的先后顺序，ProxyChain代码：

package org.smart4j.framework.proxy;

import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

/**
 * desc : 代理链
 * Created by Lon on 2018/2/3.
 */
public class ProxyChain {
    
    // 要代理的目标类
    private final Class<?> targetClass;
    // 要代理的目标对象
    private final Object targetObject;
    // 要代理的目标方法
    private final Method targetMethod;
    // 目标方法的代理(这个是CGLib为我们提供的)
    private final MethodProxy methodProxy;
    // 要代理的目标方法的方法参数
    private final Object[] methodParams;

    // 代理列表
    private List<Proxy> proxyList = new ArrayList<Proxy>();
    // 代理索引
    private int proxyIndex = 0;

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

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

    public Method getTargetMethod() {
        return targetMethod;
    }

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

    /**
     * 如果尚未达到proxyList上限，则从proxyList上拿取相应的对象，执行它的doProxy方法，
     * 在Proxy接口的实现中会提供相应的横切逻辑，并调用doProxyChain方法，随后将再次调用
     * 当前ProxyChain对象的doProxyChain方法，知道proxyIndex达到proxyList上限为止，
     * 到最后再调用methodProxy的invokeSuper方法，执行目标对象的业务逻辑。
     */
    public Object doProxyChain() throws Throwable{
        Object methodResult;
        if (proxyIndex < proxyList.size()) {
            methodResult = proxyList.get(proxyIndex++).doProxy(this);
        } else {
            methodResult = methodProxy.invokeSuper(targetObject, methodParams);
        }
        return methodResult;
    }

}

我们下面一步还用到了动态代理，所以要往maven加入CGLib:

    <!-- CGLib -->
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>2.2.2</version>
    </dependency>

现在写一个类，用它来动态创建代理对象，命名为ProxyManager:

package org.smart4j.framework.proxy;

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

import java.lang.reflect.Method;
import java.util.List;

/**
 * desc : 代理管理器
 * Created by Lon on 2018/2/5.
 */
public class ProxyManager {

    @SuppressWarnings("unchecked")
    public static <T> T createProxy(final Class<?> targetClass, final List<Proxy> proxyList){
        return (T) Enhancer.create(targetClass, new MethodInterceptor() {
            public Object intercept(Object targetObject, Method targetMethod,
                                    Object[] methodParams, MethodProxy methodProxy) throws Throwable {
                return new ProxyChain(targetClass,targetObject, targetMethod,methodProxy,methodParams,proxyList).doProxyChain();
            }
        });
    }

}

接下来需要通过切面类来调用ProxyManager，写一个抽象类，让它提供一个模板方法，并在该抽象类的具体实现中扩展相应的抽象方法:

package org.smart4j.framework.proxy;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Method;

/**
 * desc : 切面代理类
 * Created by Lon on 2018/2/6.
 */
public abstract class AspectProxy implements Proxy{

    private static final Logger LOGGER = LoggerFactory.getLogger(AspectProxy.class);

    public Object doProxy(ProxyChain proxyChain) throws Throwable{
        Object result = null;

        Class<?> cls = proxyChain.getTargetClass();
        Method method = proxyChain.getTargetMethod();
        Object[] params = proxyChain.getMethodParams();

        begin();
        try {
            if (this.intercept(cls, method, params)){
                this.before(cls, method, params);
                result = proxyChain.doProxyChain();
                this.after(cls, method, params, result);
            } else {
                result = proxyChain.doProxyChain();
            }
        } catch (Throwable e){
            LOGGER.error("proxy failure", e);
            error(cls, method, params, e);
            throw e;
        } finally {
            end();
        }
        return result;
    }

    public void begin(){
    }

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


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

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

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

    public void end(){

    }

}

在doProxy方法中，我们从proxyChain参数中获取了目标类、目标方法与方法参数、之后用try/catch/finally代码块来实现调用框架，从框架中抽象出一系列的钩子方法，这些抽象方法可在AspectProxy的子类中有选择性地进行实现。

下一篇会写加载AOP框架