手写spring

体系结构

Spring 有可能成为所有企业应用程序的一站式服务点，然而，Spring 是模块化的，允许你挑选和选择适用于你的模块，不必要把剩余部分也引入。下面的部分对在 Spring 框架中所有可用的模块给出了详细的介绍。

Spring 框架提供约 20 个模块，可以根据应用程序的要求来使用。

核心容器

核心容器由spring-core，spring-beans，spring-context，spring-context-support和spring-expression（SpEL，Spring表达式语言，Spring Expression Language）等模块组成，它们的细节如下：

• spring-core模块提供了框架的基本组成部分，包括 IoC 和依赖注入功能。

• spring-beans 模块提供 BeanFactory，工厂模式的微妙实现，它移除了编码式单例的需要，并且可以把配置和依赖从实际编码逻辑中解耦。

• context模块建立在由core和 beans 模块的基础上建立起来的，它以一种类似于JNDI注册的方式访问对象。Context模块继承自Bean模块，并且添加了国际化（比如，使用资源束）、事件传播、资源加载和透明地创建上下文（比如，通过Servelet容器）等功能。Context模块也支持Java EE的功能，比如EJB、JMX和远程调用等。ApplicationContext接口是Context模块的焦点。spring-context-support提供了对第三方库集成到Spring上下文的支持，比如缓存（EhCache, Guava, JCache）、邮件（JavaMail）、调度（CommonJ, Quartz）、模板引擎（FreeMarker, JasperReports, Velocity）等。

• spring-expression模块提供了强大的表达式语言，用于在运行时查询和操作对象图。它是JSP2.1规范中定义的统一表达式语言的扩展，支持set和get属性值、属性赋值、方法调用、访问数组集合及索引的内容、逻辑算术运算、命名变量、通过名字从Spring IoC容器检索对象，还支持列表的投影、选择以及聚合等。

数据访问/集成

数据访问/集成层包括 JDBC，ORM，OXM，JMS 和事务处理模块，它们的细节如下：

（注：JDBC=Java Data Base Connectivity，ORM=Object Relational Mapping，OXM=Object XML Mapping，JMS=Java Message Service）

• JDBC 模块提供了JDBC抽象层，它消除了冗长的JDBC编码和对数据库供应商特定错误代码的解析。

• ORM 模块提供了对流行的对象关系映射API的集成，包括JPA、JDO和Hibernate等。通过此模块可以让这些ORM框架和spring的其它功能整合，比如前面提及的事务管理。

• OXM 模块提供了对OXM实现的支持，比如JAXB、Castor、XML Beans、JiBX、XStream等。

• JMS 模块包含生产（produce）和消费（consume）消息的功能。从Spring 4.1开始，集成了spring-messaging模块。。

• 事务模块为实现特殊接口类及所有的 POJO 支持编程式和声明式事务管理。（注：编程式事务需要自己写beginTransaction()、commit()、rollback()等事务管理方法，声明式事务是通过注解或配置由spring自动处理，编程式事务粒度更细）

Web

Web 层由 Web，Web-MVC，Web-Socket 和 Web-Portlet 组成，它们的细节如下：

• Web 模块提供面向web的基本功能和面向web的应用上下文，比如多部分（multipart）文件上传功能、使用Servlet监听器初始化IoC容器等。它还包括HTTP客户端以及Spring远程调用中与web相关的部分。。

• Web-MVC 模块为web应用提供了模型视图控制（MVC）和REST Web服务的实现。Spring的MVC框架可以使领域模型代码和web表单完全地分离，且可以与Spring框架的其它所有功能进行集成。

• Web-Socket 模块为 WebSocket-based 提供了支持，而且在 web 应用程序中提供了客户端和服务器端之间通信的两种方式。

• Web-Portlet 模块提供了用于Portlet环境的MVC实现，并反映了spring-webmvc模块的功能。

其他

还有其他一些重要的模块，像 AOP，Aspects，Instrumentation，Web 和测试模块，它们的细节如下：

• AOP 模块提供了面向方面的编程实现，允许你定义方法拦截器和切入点对代码进行干净地解耦，从而使实现功能的代码彻底的解耦出来。使用源码级的元数据，可以用类似于.Net属性的方式合并行为信息到代码中。

• Aspects 模块提供了与 AspectJ 的集成，这是一个功能强大且成熟的面向切面编程（AOP）框架。

• Instrumentation 模块在一定的应用服务器中提供了类 instrumentation 的支持和类加载器的实现。

• Messaging 模块为 STOMP 提供了支持作为在应用程序中 WebSocket 子协议的使用。它也支持一个注解编程模型，它是为了选路和处理来自 WebSocket 客户端的 STOMP 信息。

• 测试模块支持对具有 JUnit 或 TestNG 框架的 Spring 组件的测试。

手写Spring

为了深入了解Spring框架的核心容器，用自己的理解将spring框架的IOC写一遍。

这里只粘贴了部分代码，具体代码可以看下：https://github.com/xiaojiesir/handwritingspring

项目结构

1.利用dom4j读取ApplicationContext.xml信息

ApplicationContext.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
    <component-scan base-package="com.xiaojiesir.demo"></component-scan>
</beans>

读取xml文件内容

package com.springframework.handler.resolver;

import java.io.IOException;
import java.io.InputStream;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class XMLConfiguration {
    private static final String CONFIG_PATH = "ApplicationContext.xml";

    public String getScanBasePackage(){
        String basePackageString = null;

        InputStream is = this.getClass().getClassLoader().getResourceAsStream(CONFIG_PATH);
        SAXReader saxReader = new SAXReader();

        try {
            Document document = saxReader.read(is);

            if(null != document){
                Element rootElement = document.getRootElement();
                Element element = rootElement.element("component-scan");
                //判断是否配置扫描
                if(null != element){
                    basePackageString = element.attributeValue("base-package");
                }
            }else{
                System.out.println("获取配置文件失败！");
            }

        } catch (DocumentException e) {
            e.printStackTrace();
        }finally {
            try {
                is.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        return basePackageString;
    }
}

2.扫描对应包下的被标记的类，并将被标记的类放在basePackageMappingToClass集合中

定义一个用来存放类对象的线程安全的集合  basePackageMappingToClass

public static List<Class<?>> basePackageMappingToClass = Collections.synchronizedList(new ArrayList<>());

因为我采用的是扫描整个包，所以需要遍历读取class文件，然后利用类的路径获取类的对象

代码如下：

private void scanBasePackage(String scanBasePackage) {
        // 接收一个表示路径的参数，返回一个URL对象，该URL对象表示name对应的资源（文件）。
        //该方法只能接收一个相对路径，不能接收绝对路径如/xxx/xxx。并且，接收的相对路径是相对于项目的包的根目录来说的。
　　　　　// scanBasePackage：com.xiaojiesir.demo
        URL url = this.getClass().getClassLoader().getResource(scanBasePackage.replaceAll("\\.", "/"));
        //   url ---> file:/D:/workspace/myspring/target/classes/com/xiaojiesir/demo
        //获取当前目录下所有文件

        try {
            File file = new File(url.toURI());//将url转为文件路径格式
            file.listFiles(new FileFilter() { //File类的文件过滤器

                //accept()方法接收到了参数pathname后参数是listFiles()传来的 在accept()的方法中进行判断.
                @Override
                public boolean accept(File pathname) {
                    //判断是否为目录
                    if(pathname.isDirectory()){
                        scanBasePackage(scanBasePackage + "."+ pathname.getName());
                    }else{
                        //获取当前类的类路径
                        String classPath = scanBasePackage + "." + pathname.getName().replaceAll("\\.class", "");
                        //通过类的路径获取类的对象
                        try {
                            System.out.println(classPath);
　　　　　　　　　　　　　　　　　//com.xiaojiesir.demo.controller.UserController
　　　　　　　　　　　　　　　　　//com.xiaojiesir.demo.dao.impl.UserDaoImpl
　　　　　　　　　　　　　　　　　//com.xiaojiesir.demo.dao.UserDao
　　　　　　　　　　　　　　　　　//com.xiaojiesir.demo.pojo.User
　　　　　　　　　　　　　　　　　//com.xiaojiesir.demo.service.impl.UserServiceImpl
　　　　　　　　　　　　　　　　　//com.xiaojiesir.demo.service.UserService

　　　　　　　　　　　　　　　　　Class<?> clazz = this.getClass().getClassLoader().loadClass(classPath);
                            //判断类上面是否有@MyController,@MyRepository,@MyService注解
                            if(clazz.isAnnotationPresent(MyController.class)
                                    || clazz.isAnnotationPresent(MyRepository.class)
                                    || clazz.isAnnotationPresent(MyService.class)){
                                //把MySpring管理的类放在集合中
                                basePackageMappingToClass.add(clazz);
                            }
                        } catch (ClassNotFoundException e) {
                            e.printStackTrace();
                        }

                    }
                    return false;
                }
            });
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
    }

3.完成别名与对象实例映射对应关系

定义一个线程安全的集合，存储别名和类的实例映射

public static Map<String, Object> aliasMappingInstance = Collections.synchronizedMap(new HashMap<>());

private void initAliasMappingToInstance() {
        if(basePackageMappingToClass.size() == 0){
            return;
        }
        for(int i = 0;i < basePackageMappingToClass.size();i++){
            Class<?> clazz = basePackageMappingToClass.get(i);
            String alias = getBeanAlias(clazz);//定义类的别名，如果类注解有值，按照注解值，反之类名小写

            try {
                aliasMappingInstance.put(alias,clazz.newInstance());
            } catch (InstantiationException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

4.遍历List集合，利用反射完成依赖注入

private void initInstanceInjectionObject() {
        if(basePackageMappingToClass.size() == 0){
            return;
        }
        for(int i = 0;i < basePackageMappingToClass.size();i++){
            Class<?> clazz =basePackageMappingToClass.get(i);
            String instanceAlias = getBeanAlias(clazz);
            //获取需要依赖注入的对象
            Object needInjectionObj = aliasMappingInstance.get(instanceAlias);

            //获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的申明字段。
            Field[] fields = clazz.getDeclaredFields();

            if(null != fields && fields.length > 0){
                for(int j = 0;j < fields.length;j++){
                    //定义存储需要装配的依赖对象
                    Object injectObj = null;
                    Field field = fields[j];
                    //判断是否有@MyAutowired注解
                    if(field.isAnnotationPresent(MyAutowired.class)){
                        MyAutowired myAutowired = field.getAnnotation(MyAutowired.class);
                        //判断value是否为空字符串
                        if(!"".equals(myAutowired.value())){
                            //装配别名名称
                            String alias = myAutowired.value();
                            //获取到装配的依赖对象
                            injectObj = aliasMappingInstance.get(alias);
                        }else{
                            //按照默认方式装配依赖对象
                            Class<?> fieldType = field.getType();
                            //获取容器中所有实例的类型
                            Collection<Object> values = aliasMappingInstance.values();
                            Iterator<Object> iterator = values.iterator();
                            while(iterator.hasNext()){
                                Object object = iterator.next();
                                //判断是否为同一个类型
                                if(fieldType.isAssignableFrom(object.getClass())){
                                    //找到需要装配依赖对象的实例
                                    injectObj = object;
                                    break;
                                }
                            }
                        }
                    }
                    //设置字段访问权限
                    field.setAccessible(true);
                    try {
                        //把依赖对象装配到响应的实例中
                        field.set(needInjectionObj, injectObj);
                    } catch (IllegalArgumentException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
    }

5.根据对象实例别名获取实例

public Object getBean(String name){
        return aliasMappingInstance.get(name);
    }