跟我动手搭框架二之AOP实现

代理这里主要用CGLIB代理,主要为实现前置通知,后置通知,环绕通知和异常通知

本篇主要承上启下,承上根据IOC容易实现简单AOP代理, 启下,对将要实现的WEB模块做一个规划

文章中多有代码,会在第三部分WEB容器实现,列出参考文档及GITHUB源码地址

目录

• 1.编写工具类
• 2.实现AOP
• 3.web实现规划

定义接口类并提供抽象空实现

抽象目的: 实现类只需要继承要,实现的方法,即可

/**
 * @Package: smile.proxy
 * @Description: 代理通知
 * @author: liuxin
 * @date: 2017/10/18 上午10:18
 */
public interface ProxyAspect {
    /**
     * 前置通知
     */
    void before();
    /**
     * 后置通知
     */
    void after();
    /**
     * 异常通知
     */
    void throwed();
    /**
     * 环绕通知
     */
    void around();
}
/**
 * @Package: smile.proxy
 * @Description:
 * @author: liuxin
 * @date: 2017/10/18 上午10:22
 */
public abstract class DefaultProxyAspect implements ProxyAspect {
    @Override
    public void before() {}
    @Override
    public void after() {}
    @Override
    public void throwed() {}
    @Override
    public void around() {}
}

定义CGLIBProxy工具

主要逻辑

• 实现提供方法级代理,也就是对象不用实例化
• 对实例进行代理

代码更有说服力,直接看注释

/**
 * @Package: com.example.proxy
 * @Description: JDK自带动态代理，只能代理，拥有接口的，而Cglib代理，是运行在动态生成字节码的工具中
 * 根据注解实现
 * @author: liuxin
 * @date: 17/3/31 上午10:24
 */
public class CGLibProxy implements MethodInterceptor {
    private ProxyAspect proxyAspect;
    private Class cls;
    private Object object;

    /**
     * 预处理
     * 当代理逻辑中依赖其他类,需要提前注入时候,仅扩展此类
     *
     * 扩展逻辑类 proxyAspect 从ioc容器中获取实例
     *
     * @return
     */
    public List<String> preProcessing() {
        SmileProxyAspect smileProxyAspect = (SmileProxyAspect) cls.getAnnotation(SmileProxyAspect.class);
        try {
            proxyAspect = smileProxyAspect.proxyAspect().newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return Arrays.asList(smileProxyAspect.methods());
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        Object result = null;
        //判断方法是否使用代理
        boolean contains = preProcessing().contains(method.getName());
        if (contains) {
            proxyAspect.around();
            proxyAspect.before();
            try {
                if (object == null) {
                    result = methodProxy.invokeSuper(obj, args);
                } else {
                    result = methodProxy.invoke(object, args);
                }
            } catch (Throwable throwable) {
                proxyAspect.throwed();
            }
            proxyAspect.after();
            proxyAspect.around();
        } else {
            result = methodProxy.invokeSuper(obj, args);
        }
        return result;
    }


    public static CGLibProxy instance() {
        return new CGLibProxy();
    }


    /**
     * 利用泛型
     * 获取代理类型
     *
     * @param cls
     * @param <T>
     * @return
     */
    public <T> T getProxy(Class<T> cls) {
        this.cls = cls;
        return (T) Enhancer.create(cls, this);
    }

    /**
     * 获取代理类
     * @param cls
     * @return
     */
    public Object toProxyObject(Class cls) {
        this.cls = cls;
        return  Enhancer.create(cls, this);
    }

    /**
     * 注入代理对象实例
     *
     * @param obj
     * @return
     */
    public CGLibProxy setProxyObject(Object obj) {
        this.object = obj;
        return this;
    }

    /**
     * 演示代码中,均使用@SmileProxyAspect注解实现
     * 注解中
     * proxyAspect 代理切面类,需要包括处理逻辑 要实现DefaultProxyAspect 需要实现的抽象方法
     * methods  需要代理的方法名称
     *
     * @param args
     */
    public static void main(String[] args) {
        /******************************************
         * 方法级代理
         */
        /**
         * 实现前置通知和后置通知
         */
        Jay2 proxy1 = CGLibProxy.instance().getProxy(Jay2.class);
        proxy1.dance("芭蕾舞");
        System.out.println(proxy1);
        /**
         * 使用默认通知,只打印日志
         */
        Jay2 proxy = CGLibProxy.instance().getProxy(Jay2.class);
        System.out.println(proxy);
        proxy.dance("芭蕾舞");
        /******************************************
         * 实例代理
         */
        /**
         * 拦截对象
         */
        Jay2 jay2 = CGLibProxy.instance().setProxyObject(new Jay2("周杰伦")).getProxy(Jay2.class);
        jay2.say();
        Jay2 jay3 = CGLibProxy.instance().setProxyObject(new Jay2("周杰伦")).getProxy(Jay2.class);
        jay3.say();
        System.out.println(Jay2.class.isAssignableFrom(jay3.getClass()));
        System.out.println(jay3);
        Object jay4= CGLibProxy.instance().setProxyObject(new Jay2("周杰伦")).toProxyObject(Jay2.class);

    }
}

AOP实现

• 实现方案

  当IOC容器扫描所有被@SmileComonpent标记的组件时候,会判断是否被@SmileProxyAspect 注解修饰,

  如果有@SmileProxyAspect,则对实例化对象生成代理,注入

/**
     * 扫描所有被标记的组件
     */
    public void scanComponent(Class<?> nextCls) {
        SmileComponent declaredAnnotation = nextCls.getDeclaredAnnotation(SmileComponent.class);
        Object beanInstance = null;
        beanInstance = nextCls.newInstance();
       //判断是否包括代理注解,如过包括就生成代理对象
        SmileProxyAspect smileProxyAspect = (SmileProxyAspect) nextCls.getAnnotation(SmileProxyAspect.class);
        if (smileProxyAspect != null) {        beanInstance=CGLibProxy.instance().setProxyObject(beanInstance).toProxyObject(nextCls);   
      ....
      ....
       registeredBeans.put(beanName, new BeanDefinition(nextCls, beanInstance));
               
    }

3. web规划

在对ioc容器及代理编写完成后,就到重点我们要实现,对HTTP请求的解析和处理. 在此实现,要对项目做一个规划,打一个草稿

项目基于Maven多模块实现

3.1 包名

groupId: org.smileframework.boot

artifactId:

• org.smileframework.web
• org.smileframework.tool
• org.smileframework.data
• org.smileframework.ioc

３.２TOOLS部分

工欲善其事必先利其器,所以先写我们将会遇到的工具类

• 生成代理部分 CGLIB代理 org.smileframework.tool.proxy
• 线程工厂及拒绝策略 org.smileframework.tool.threadpool
• json及xml转换 org.smileframework.tool.json | .xml
• 数据流工具类 org.smileframework.tool.io
• 类加载器器 org.smileframework.tool.clazz
• 文件读取工具 org.smileframework.tool.io.SmileClassPathResource

3.3 IOC部分

在处理器中扫描注解可以知道项目具有哪些功能
@SmileBootApplication 如果有改扫描器,就到子目录中的使用@SmileComponent注解的都加入到默认的beans容器中
然后开始实例化,如果发现Class中包括@InsertBean()将从bean容器中的对象,反射进去生成对象.发现方法中用@SmileBean修饰的同样从ioc容器中获取实例,并注入到该对象中,最终保存到IOC容器

3.4 合并WEB上下文

从bean容器中获取到ExtApplicationContext

3.5 绑定Url和处理类

@GetMapping 标记get请求方法
@PostMapping 标记post请求方法
@RequestBody 将请求体绑定到方法指定类型
@RequestHander 绑定请求头到被就是的map类型
@RequestParam 指定方法请求参数名

WebDefinition webDefinition = WebContextTools.getWebDefinitionByUrl(dispatchUrl, requestMethod);

校验使用反射,将该方法的参数名称和请求到的参数做一个简单校验
//测试将POST请求体中数据,反序列化为User
@PostMapping(value = "/smile/test/requestBody", consumes.., produces..)
public String testRequestBody(@RequestBoby UserDto user) {
    return user.getName() + "--" + user.getAge();
}

//Method: 获取到的执行方法 parameters:请求参数 headers:请求头
//将以上信息根据consumes定义的解析方法,转换成方法指定类型
Object[] args = ControllerUtils.getArgs(method, parameters,headers);
Object invokeResult = method.invoke(controller, args);
//根据produces定义的返回值类型,通过Netty channle返回给客户端

3.6 AOP 拦截

在扫描时候找到切面类,读取里面的class类型

proxyAspect: 代理逻辑,实现 1.前置 2. 后置 3.环绕 4.异常通知

@SmileProxyAspect(proxyAspect = ControllerProxyAspectDemo.class, methods = {"testRequestBody", "testRequestParam"})

获取到这个注解,并获取class类型,从bean容器中,获取这个对象(A),根据Smile的方法把这个A对象,进行代理.

3.7 web容器使用Netty

• 定义WebApplicationContext 类实现ExtApplicationContext上下文信息获取IOC容器,并扫描ioc获取url绑定handler绑定的信息
• 创建netty server端