手撸简易Spring框架（一）

前言

本篇文章旨在搭建项目，不写太多实际的代码，以后的文章我们一步步再填充进来。

新建Maven工程

创建一个空maven工程，pom中暂时不需要引入其他jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wh</groupId>
    <artifactId>mySpring</artifactId>
    <version>1.0-SNAPSHOT</version>
</project>

新建好相关的目录，接下来我们会一步步填充需要的类。

BeanFactory

BeanFactory是IOC容器的顶层父接口，大名鼎鼎的 ApplicationContext就是继承它，它定义了我们最常用的获取Bean的方法。

package com.wh.springframework.core.factory;

public interface BeanFactory {

    Object getBean(String name) throws Exception;

    <T> T getBean(Class<T> requiredType) throws Exception;
}

ApplicationContext

ApplicationContext 我们非常熟悉，继承了BeanFactory、MessageSource、ApplicationEventPublisher等等接口，功能非常强大，但这也导致它的继承体系很庞大（如下图），对我们写一个简单的Spring框架很不利。

为了方便我们理解，也为了尽可能的简单，我们这里只建一个ApplicationContext接口且只继承BeanFactory，其实现类为DefaultApplicationContext。

package com.wh.springframework.context;

import com.wh.springframework.core.factory.BeanFactory;

/**
 * 空接口，大家明白就好
 * 原接口需要继承ListableBeanFactory, HierarchicalBeanFactory等等，这里就简单继承BeanFactory 
 **/
public interface ApplicationContext extends BeanFactory {

}

相信大家都知道，ApplicationContext 实现类中最重要的就是 refresh() 方法，它的流程就包括了IOC容器初始化、依赖注入和AOP，方法中的注释已经写的很明白了。

package com.wh.springframework.context.support;

import com.wh.springframework.context.ApplicationContext;

public class DefaultApplicationContext implements ApplicationContext {

    //配置文件路径
    private String configLocation;

    public DefaultApplicationContext(String configLocation) {
        this.configLocation = configLocation;
        try {
            refresh();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void refresh() throws Exception {
        //1、定位，定位配置文件

        //2、加载配置文件，扫描相关的类，把它们封装成BeanDefinition

        //3、注册，把配置信息放到容器里面(伪IOC容器)
        //到这里为止，容器初始化完毕

        //4、把不是延时加载的类，提前初始化
    }

	@Override
    public Object getBean(String beanName) throws Exception {
        return null;
    }

	@Override
    public <T> T getBean(Class<T> requiredType) throws Exception {
        return (T) getBean(requiredType.getName());
    }
}

成员变量configLocation保存了我们的配置文件路径，所以这里就先把这个配置文件先新建出来。在resource目录下需要新建一个配置文件application.properties，并且指定扫描的包路径。

scanPackage=com.wh

BeanDefinition

我们原来使用xml作为配置文件时，定义的Bean其实在IOC容器中被封装成了BeanDefinition，也就是Bean的配置信息，包括className、是否为单例、是否需要懒加载等等。它是一个interface，这里我们直接定义成class。

package com.wh.springframework.beans.config;

public class BeanDefinition {

    private String beanClassName;

    private boolean lazyInit = false;

    private String factoryBeanName;

    public String getBeanClassName() {
        return beanClassName;
    }

    public void setBeanClassName(String beanClassName) {
        this.beanClassName = beanClassName;
    }

    public BeanDefinition(){}


    public boolean isLazyInit() {
        return lazyInit;
    }

    public void setLazyInit(boolean lazyInit) {
        this.lazyInit = lazyInit;
    }

    public String getFactoryBeanName() {
        return factoryBeanName;
    }

    public void setFactoryBeanName(String factoryBeanName) {
        this.factoryBeanName = factoryBeanName;
    }
}

BeanDefinitionReader

我们需要读取配置文件，扫描相关的类才能解析成BeanDefinition，这个读取 + 扫描的类就是BeanDefinitionReader。

package com.wh.springframework.beans.support;

import java.util.Properties;

public class BeanDefinitionReader {

    //配置文件
    private Properties config = new Properties();

    //配置文件中指定需要扫描的包名
    private final String SCAN_PACKAGE = "scanPackage";

    public BeanDefinitionReader(String... locations) {

    }
    
	public Properties getConfig() {
        return config;
    }
}

BeanWrapper

当BeanDefinition的Bean配置信息被读取并实例化成一个实例后，这个实例封装在BeanWrapper中。

package com.wh.springframework.beans;

public class BeanWrapper {

    /**Bean的实例化对象*/
    private Object wrappedObject;

    public BeanWrapper(Object wrappedObject) {
        this.wrappedObject = wrappedObject;
    }

    public Object getWrappedInstance() {
        return this.wrappedObject;
    }

    public Class<?> getWrappedClass() {
        return getWrappedInstance().getClass();
    }
}

annotation

当Bean需要被Spring进行管理时，我们有@Component、@Controller、@Service、@Repository等注解。需要注入时则通过@Autowired或@Resource。这里我们先把常用的都先定义出来，统一放在com.xxx.springframework.annotation下。

package com.wh.springframework.annotation;

import java.lang.annotation.*;

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    String value() default "";
}

package com.wh.springframework.annotation;

import java.lang.annotation.*;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Component {
    String value() default "";
}

package com.wh.springframework.annotation;

import java.lang.annotation.*;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
    String value() default "";
}

package com.wh.springframework.annotation;

import java.lang.annotation.*;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Component
@Documented
public @interface Service {
    String value() default "";
}

package com.wh.springframework.annotation;

import java.lang.annotation.*;

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestMapping {
    String value() default "";
}

package com.wh.springframework.annotation;

import java.lang.annotation.*;

@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestParam {
    String value() default "";
}

最后

OK，到这里我们就基本搭建好了整个架构，IOC和DI都是基于目前这个框架，等后面写到AOP和MVC再添加一些新的类。下一篇文章我们正式开始手写IOC！