仿写一个简陋的 IOC/AOP 框架 mini-spring

  • Z时代
  • 2024-01-10
  • 分类：综合

本文内容纲要：

- 环境搭建&快速使用
- 简介
- 模块组成
- 项目构建
- framework 实现流程
- 启动 tomcat 服务
- 扫描类
- 初始化Bean工厂
- 初始化Handler
- 框架使用
- 总结与参考
- 参考

讲道理，感觉自己有点菜。Spring 源码看不懂，不想强行解释，等多积累些项目经验之后再看吧，但是 Spring 中的控制反转（IOC）和面向切面编程（AOP）思想很重要，为了更好的使用 Spring 框架，有必要理解这两个点，为此，我使用 JDK API 实现了一个玩具级的简陋 IOC/AOP 框架 mini-spring，话不多说，直接开干。

环境搭建&快速使用

全部代码已上传 GitHub：https://github.com/czwbig/mini-spring

  1. 将代码弄到本地并使用 IDE 打开，这里我们用 IDEA；

  2. 使用 Gradle 构建项目，可以使用 IDEA 提供的 GUI 操作，也可以直接使用 gradle build 命令；

Image

  1. 如下图，右击 mini-spring\framework_use_test\build\libs\framework_use_test-1.0-SNAPSHOT.jar ，点击 Run，当然也可以直接使用 java -jar jarPath.jar 命令来运行此 jar 包；

Image

  1. 浏览器打开 localhost:8080/rap 即可观察到显示 CXK 字母，同时 IDE 控制台会输出：

    first,singing .

    and the chicken monster is dancing now.

    CXK rapping...

    oh! Don't forget my favorite basketball.

下面开始框架的讲解。

简介

本项目使用 Java API 以及内嵌 Tomcat 服务器写了一个玩具级 IOC/AOP web 框架。实现了 @Controller、@AutoWired、@Component 、@Pointcut、@Aspect、@Before、@After 等 Spring 常用注解。可实现简单的访问 uri 映射，控制反转以及不侵入原代码的面向切面编程。

讲解代码实现之前，假设读者已经掌握了基础的项目构建、反射、注解，以及 JDK 动态代理知识，项目精简，注释详细，并且总代码 + 注释不足 1000 行，适合用来学习。其中构建工具 Gradle 没用过也不要紧，我也是第一次使用，当成没有 xml 的 Maven 来看就行，下面我会详细解读其构建配置文件。

模块组成

项目由两个模块组成，一个是框架本身的模块，实现了框架的 IOC/AOP 等功能，如下图：

Image

类比较多，但是大部分都是代码很少的，特别是注解定义接口，不要怕。

  • aop 包中是 After 等注解的定义接口，以及动态代理辅助类；

  • bean 包中是两个注解定义，以及 BeanFactory 这个 Bean 工厂，其中包含了类扫描和 Bean 的初始化的代码；

  • core 包是一个 ClassScanner 类扫描工具类；

  • starter 包是一个框架的启动与初始化类；

  • web/handler 包中是 uri 请求的处理器的收集与管理，如查找 @Controller 注解修饰的类中的 @RequestMapping 注解修饰的方法，用来响应对应 uri 请求。

  • web/mvc 包定义了与 webMVC 有关的三个注解；

  • web/server 包中是一个嵌入式 Tomcat 服务器的初始化类；

  • web/servlet 包中是一个请求分发器，重写的 service() 方法定义使用哪个请求处理器来响应浏览器请求；

另一个模块是用来测试（使用）框架的模块，如下图：

Image

就像我们使用 Spring 框架一样，定义 Controller 等来响应请求，代码很简单，就不解释了。

项目构建

根目录下有 setting.gradle、build.gradle 项目构建文件，其中 setting.gradle 指定了项目名以及模块名。

rootProject.name = 'mini-spring'
include 'framework'
include 'framework_use_test'

build.gradle 是项目构建设置，主要代码如下：

plugins {
    id 'java'
}
group 'com.caozhihu.spring'
version '1.0-SNAPSHOT'
sourceCompatibility = 1.8
repositories {
    repositories { maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' } }
//    mavenCentral()
}
dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

引入了 gradle 的 java 插件，因为 gradle 不仅仅可以用于 java 项目，也可以用于其他项目，引入了 java 插件定义了项目的文件目录结构等。

然后就是项目的版本以及 java 源代码适配级别，这里是 JDK 1.8，在后面是指定了依赖仓库，gradle 可以直接使用 maven 仓库。

最后就是引入项目具体依赖，这里和 maven 一样。

每个模块也有单独的 build.gradle 文件来指定模块的构建设置，这里以 framework_use_test 模块的 build.gradle 文件来说明：

dependencies {
    // 只在单元测试时候引入此依赖
    testCompile group: 'junit', name: 'junit', version: '4.12'
    // 项目依赖
    compile(project(':framework'))
}
jar {
    manifest {
        attributes "Main-Class": "com.caozhihu.spring.Application"
    }
    // 固定打包句式
    from {
        configurations.runtime.asFileTree.files.collect { zipTree(it) }
    }
}

除去和项目根目录下构建文件相同部分，其他的构建代码如上，这里的 dependencies 除了添加 Junit 单元测试依赖之外，还指定了 framework 模块。

下面指定了 jar 包的打包设置，首先使用 manifest 设置主类，否则生成的 jar 包找不到主类清单，会无法运行。还使用了 from 语句来设置打包范围，这是固定句式，用来收集所有的 java 类文件。

framework 实现流程

如下图：

Image

启动 tomcat 服务

public void startServer() throws LifecycleException {
        tomcat = new Tomcat();
        tomcat.setPort(8080);
        tomcat.start();
        // new 一个标准的 context 容器并设置访问路径；
        // 同时为 context 设置生命周期监听器。
        Context context = new StandardContext();
        context.setPath("");
        context.addLifecycleListener(new Tomcat.FixContextListener());
        // 新建一个 DispatcherServlet 对象，这个是我们自己写的 Servlet 接口的实现类，
        // 然后使用 `Tomcat.addServlet()` 方法为 context 设置指定名字的 Servlet 对象，
        // 并设置为支持异步。
        DispatcherServlet servlet = new DispatcherServlet();
        Tomcat.addServlet(context, "dispatcherServlet", servlet)
                .setAsyncSupported(true);
        // Tomcat 所有的线程都是守护线程，
        // 如果某一时刻所有的线程都是守护线程，那 JVM 会退出，
        // 因此，需要为 tomcat 新建一个非守护线程来保持存活，
        // 避免服务到这就 shutdown 了
        context.addServletMappingDecoded("/", "dispatcherServlet");
        tomcat.getHost().addChild(context);
        Thread tomcatAwaitThread = new Thread("tomcat_await_thread") {
            @Override
            public void run() {
                TomcatServer.this.tomcat.getServer().await();
            }
        };
        tomcatAwaitThread.setDaemon(false);
        tomcatAwaitThread.start();
    }

这里看代码注释，结合下面这张 tomcat 架构图就可以理解了。

Image

图片来自 http://click.aliyun.com/m/1000014411/

如果暂时不理解也没关系，不影响框架学习，我只是为了玩一玩内嵌 tomcat，完全可以自己实现一个乞丐版的网络服务器的。

这里使用的是我们自定义的 Servlet 子类 DispatcherServlet 对象，该类重写了 service() 方法，代码如下：

@Override
    public void service(ServletRequest req, ServletResponse res) throws IOException {
        for (MappingHandler mappingHandler : HandlerManager.mappingHandlerList) {
            // 从所有的 MappingHandler 中逐一尝试处理请求，
            // 如果某个 handler 可以处理(返回true)，则返回即可
            try {
                if (mappingHandler.handle(req, res)) {
                    return;
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
        res.getWriter().println("failed!");
    }

HandlerManager 和 MappingHandler 处理器后面会讲，这里先不展开。至此，tomcat 服务器启动完成；

扫描类

扫描类是通过这句代码完成的：

// 扫描类
List<Class<?>> classList = ClassScanner.scannerCLasses(cls.getPackage().getName());

ClassScanner.scannerCLasses 方法实现如下：

public static List<Class<?>> scannerCLasses(String packageName)
            throws IOException, ClassNotFoundException {
        List<Class<?>> classList = new ArrayList<>();
        String path = packageName.replace(".", "/");
        // 线程上下文类加载器默认是应用类加载器，即 ClassLoader.getSystemClassLoader();
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        // 使用类加载器对象的 getResources(ResourceName) 方法获取资源集
        // Enumeration 是古老的迭代器版本，可当成 Iterator 使用
        Enumeration<URL> resources = classLoader.getResources(path);
        while (resources.hasMoreElements()) {
            URL url = resources.nextElement();
            // 获取协议类型，判断是否为 jar 包
            if (url.getProtocol().contains("jar")) {
                // 将打开的 url 返回的 URLConnection 转换成其子类 JarURLConnection 包连接
                JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection();
                String jarFilePath = jarURLConnection.getJarFile().getName();
                // getClassesFromJar 工具类获取指定 Jar 包中指定资源名的类；
                classList.addAll(getClassesFromJar(jarFilePath, path));
            } else {
                // 简单起见，我们暂时仅实现扫描 jar 包中的类
                // todo
            }
        }
        return classList;
    }
    private static List<Class<?>> getClassesFromJar(String jarFilePath, String path) throws IOException, ClassNotFoundException {
         // 为减少篇幅，这里完整代码就不放出来了
    }

注释很详细，就不多废话了。

初始化Bean工厂

这部分是最重要的，IOC 和 AOP 都在这里实现。

代码请到在 BeanFactory 类中查看，GitHub 在线查看 BeanFactory

注释已经写的非常详细。这里简单说下处理逻辑。

首先通过遍历上一步类扫描获得类的 Class 对象集合，将被 @Aspect 注解的类保存起来，然后初始化其他被 @Component 和 @Controller 注解的类，并处理类中被 @AutoWired 注解的属性，将目标引用对象注入（设置属性的值）到类中，然后将初始化好的对象保存到 Bean 工厂。到这里，控制反转就实现好了。

接下来是处理被 @Aspect 注解的类，并解析他们中被 @Pointcut、@Before 和 @After 注解的方法，使用 JDK 动态代理生成代理对象，并更新 Bean 工厂。

注意，在处理被 @Aspect 注解的类之前，Bean 工厂中的对象依赖已经设置过了就旧的 Bean，更新了 Bean 工厂中的对象后，需要通知依赖了被更新对象的对象重新初始化。

例如对象 A 依赖对象 B，即 A 的类中有一句

@AutoWired
B b;

同时，一个切面类中的切点 @Pointcut 的值指向了 B 类对象，然后他像 Bean 工厂更新了 B 对象，但这时 A 中引用的 B 对象，还是之前的旧 B 对象。

这里我的解决方式是，将带有 @AutoWired 属性的类保存起来，处理好 AOP 关系之后，再次初始化这些类，这样他们就能从 Bean 工厂获得新的已经被代理过的对象了。

至于如何使用 JDK 动态代理处理 AOP 关系的，请参考 GitHub ProxyDyna 类

中代码，总的来说是，定义一个 ProxyDyna 类实现 InvocationHandler 接口，然后实现 invoke() 方法即可，在 invoke() 方法中处理代理增强逻辑。

然后获取对象的时候，使用 Proxy.newProxyInstance() 方法而不是直接 new，如下：

Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);

初始化Handler

HandlerManager 类中调用 parseHandlerFromController() 方法来遍历处理所有的已扫描到的类，来初始化 MappingHandler 对象，方法代码如下：

private static void parseHandlerFromController(Class<?> aClass) {
        Method[] methods = aClass.getDeclaredMethods();
        // 只处理包含了 @RequestMapping 注解的方法
        for (Method method : methods) {
            if (method.isAnnotationPresent(RequestMapping.class)) {
                // 获取赋值 @RequestMapping 注解的值，也就是客户端请求的路径，注意，不包括协议名和主机名
                String uri = method.getDeclaredAnnotation(RequestMapping.class).value();
                List<String> params = new ArrayList<>();
                for (Parameter parameter : method.getParameters()) {
                    if (parameter.isAnnotationPresent(RequestParam.class)) {
                        params.add(parameter.getAnnotation(RequestParam.class).value());
                    }
                }
                // List.toArray() 方法传入与 List.size() 恰好一样大的数组，可以提高效率
                String[] paramsStr = params.toArray(new String[params.size()]);
                MappingHandler mappingHandler = new MappingHandler(uri, aClass, method, paramsStr);
                HandlerManager.mappingHandlerList.add(mappingHandler);
            }
        }
    }

MappingHandler 对象表示如何处理一次请求，包括请求 uri，应该调用的类，应该调用的方法以及方法参数。

如此，在 MappingHandler 的 handle() 方法中处理请求，直接从 Bean 工厂获取指定类对象，从 response 对象中获取请求参数值，使用反射调用对应方法，并接收方法返回值输出给浏览器即可。

再回顾我们启动 tomcat 服务器时指定运行的 servlet：

@Override
    public void service(ServletRequest req, ServletResponse res) throws IOException {
        for (MappingHandler mappingHandler : HandlerManager.mappingHandlerList) {
            // 从所有的 MappingHandler 中逐一尝试处理请求，
            // 如果某个 handler 可以处理(返回true)，则返回即可
            try {
                if (mappingHandler.handle(req, res)) {
                    return;
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
        res.getWriter().println("failed!");
    }

一目了然，其 service() 方法只是遍历所有的 MappingHandler 对象来处理请求而已。

框架使用

测试使用 IOC 和 AOP 功能。这里以定义一个 /rap 路径举例，

1. 定义Controller

@Controller
public class RapController {
    @AutoWired
    private Rap rapper;
    @RequestMapping("/rap")
    public String rap() {
        rapper.rap();
        return "CXK";
    }
}

RapController 从 Bean 工厂获取一个 Rap 对象，访问 /rap 路径是，会先执行该对象的 rap() 方法，然后返回 "CXK" 给浏览器。

2. 定义 Rap 接口及其实现类

public interface Rap {
    void rap();
}
// ----another file----
@Component
public class Rapper implements Rap {
    public void rap() {
        System.out.println("CXK rapping...");
    }
}

接口一定要定义，否则无法使用 AOP，因为我们使用的是 JDK 动态代理，只能代理实现了接口的类（原理是生成一个该接口的增强带向）。Spring 使用的是 JDK 动态代理和 CGLIB 两种方式，CGLIB 可以直接使用 ASM 等字节码生成框架，来生成一个被代理对象的增强子类。

使用浏览器访问 http://localhost:8080/rap ，即可看到 IDE 控制台输出 CXK rapping...，可以看到，@AutoWired 注解成功注入了对象。

但如果我们想在 rap 前面先 唱、跳，并且在 rap 后面打篮球，那么就需要定义织面类来面向切面编程。

定义一个 RapAspect 类如下：

@Aspect
@Component
public class RapAspect {
    // 定义切点，spring的实现中，
    // 此注解可以使用表达式 execution() 通配符匹配切点，
    // 简单起见，我们先实现明确到方法的切点
    @Pointcut("com.caozhihu.spring.service.serviceImpl.Rapper.rap()")
    public void rapPoint() {
    }
    @Before("rapPoint()")
    public void singAndDance() {
        // 在 rap 之前要先唱、跳
        System.out.println("first,singing <chicken is too beautiful>.");
        System.out.println("and the chicken monster is dancing now.");
    }
    @After("rapPoint()")
    public void basketball() {
        // 在 rap 之后别忘记了篮球
        System.out.println("oh! Don't forget my favorite basketball.");
    }
}

织面类 RapAspect 定义了切入点以及前置后置通知等，这样 RapController 中使用 @AutoWired 注解引入的 Rap 对象，会被替换为增强的 Rap 代理对象，如此，我们无需改动 RapController 中任何一处代码，就实现了在 rap() 方法前后执行额外的代码（通知）。

增加 RapAspect 后，再次访问会在 IDE 控制台输出：

first,singing <chicken is too beautiful>.
and the chicken monster is dancing now.
CXK rapping...
oh! Don't forget my favorite basketball.

总结与参考

没啥好说的，该说的，都说了，你懂得，就够了，怎么有某一种悲哀.... 哈哈哈哈

Image

参考

tomcat 使用与框架图：手写一个简化版Tomcat

gradle 配置与 DI 部分实现：慕课网

Spring 常用注解 how2j SPRING系列教材

本文内容总结：环境搭建&快速使用，简介，模块组成，项目构建，framework 实现流程，启动 tomcat 服务，扫描类，初始化Bean工厂，初始化Handler，框架使用，总结与参考，参考，

原文链接：https://www.cnblogs.com/czwbig/p/11159946.html

以上是 仿写一个简陋的 IOC/AOP 框架 mini-spring 的全部内容， 来源链接： utcz.com/z/296650.html

回到顶部