springIOC原理——自己实现一下不就懂了嘛

最新推荐文章于 2022-01-03 15:28:21 发布

小王子jvm

最新推荐文章于 2022-01-03 15:28:21 发布

阅读量382

点赞数

本文链接：https://blog.csdn.net/weixin_55086330/article/details/118228967

版权

设计模式专栏收录该内容

2 篇文章 0 订阅

订阅专栏

使用Spring

只需要引入对应的依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
</dependencies>

maven自动依赖几个核心包：

测试

//DAO 层
public interface UserDao {
    void add();
}
public class UserDaoImpl implements UserDao {
    public void add() {
        System.out.println("UserDao...");
    }
}

//service 层
public interface UserService {
    void add();
}
public class UserServiceImpl implements UserService {

    private UserDao userDao;
    private String username;
    private String password;


    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        userDao.add();
        System.out.println("UserService实现类"+username+"=="+password);
    }
}

使用xml配置文件方式，配置如下：

<beans >
    <!--创建userService，依赖注入dao-->
    <bean id="userService" class="com.sheep.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
        <property name="username" value="sheep"/>
        <property name="password" value="123456"/>
    </bean>

    <!--dao相关的bean-->
    <bean id="userDao" class="com.sheep.dao.impl.UserDaoImpl"/>
</beans>

然后就是controller，用一个main模拟：

public class MainController {
    public static void main(String[] args) throws Exception {
        //创建IOC容器，加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-ioc.xml");
        //获取相应的bean
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

经过测试是可以正常输出内容的。

自定义SpringIOC

整个工程的结构如下：
在这里插入图片描述

定义bean相关的pojo类

PropertyValue类

用于封装bean的属性，体现到上面的配置文件就是封装bean标签的子标签property标签数据。

/**
 * 每一bean可能会引用其他bean，这个用来封装被引用的bean解析后的属性
 * @Description: 封装被引用的bean解析后的属性
 *  name : 引用的名字，也就是放在容器中的key
 *  ref : 引用类型
 *  value : 基本类型的引用
 */
public class PropertyValue {
    private String name;
    private String ref;
    private String value;

    public PropertyValue() {
    }

    public PropertyValue(String name, String ref, String value) {
        this.name = name;
        this.ref = ref;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getRef() {
        return ref;
    }

    public void setRef(String ref) {
        this.ref = ref;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}

MutablePropertyValues类

一个bean标签可以有多个property子标签，所以再定义一个MutablePropertyValues类，用来存储并管理多个PropertyValue对象。

/**
 * 一个bean标签可以有多个property子标签，所以再定义一个MutablePropertyValues类，用来存
 * 储并管理多个PropertyValue对象。
 */
public class MutablePropertyValues implements Iterable<PropertyValue> {

    //用一个list集合保存
    private final List<PropertyValue> propertyValueList;

    public MutablePropertyValues() {
        propertyValueList = new ArrayList<PropertyValue>();
    }

    public MutablePropertyValues(List<PropertyValue> propertyValueList) {
        this.propertyValueList = (propertyValueList != null ?
                propertyValueList : new ArrayList<PropertyValue>());
    }

    //获取所有的PropertyValue，并以数组的形式返回
    public PropertyValue[] getPropertyValues(){
        return (PropertyValue[]) propertyValueList.toArray();
    }

    //通过propertyName获取对应的PropertyValue
    public PropertyValue getPropertyValue(String propertyName){
        for (PropertyValue propertyValue : propertyValueList) {
            if (propertyName.equals(propertyValue.getName())){
                return propertyValue;
            }
        }
        return null;
    }

    //迭代器模式，用于遍历
    public Iterator<PropertyValue> iterator() {
        return propertyValueList.iterator();
    }

    //判断是否为空
    public boolean isEmpty(){
        return this.propertyValueList.isEmpty();
    }

    //是否已有这个封装的对象
    public boolean contains(String propertyName) {
        return getPropertyValue(propertyName) != null;
    }

    //添加一个propertyValue到容器中,存在的化进行覆盖
    public MutablePropertyValues addPropertyValue(PropertyValue propertyValue){
        for (int i = 0; i < propertyValueList.size(); i++) {
            PropertyValue tmp = this.propertyValueList.get(i);
            if (tmp.getName().equals(propertyValue.getName())){
                //存在就覆盖
                propertyValueList.set(i,new PropertyValue(propertyValue.getName(),
                        propertyValue.getRef(),propertyValue.getValue()));
            }
        }
        this.propertyValueList.add(propertyValue);
        return this;
    }
}

BeanDefinition类

BeanDefinition类用来封装bean信息的，主要包含id（即bean对象的名称）、class（需要交由 spring管理的类的全类名）及子标签property数据。

/**
 * 解析出来的Bean的配置属性
 */
public class BeanDefinition {
    private String id;
    private String className;

    private MutablePropertyValues propertyValues;

    public BeanDefinition() {
        propertyValues = new MutablePropertyValues();
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public MutablePropertyValues getPropertyValues() {
        return propertyValues;
    }

    public void setPropertyValues(MutablePropertyValues propertyValues) {
        this.propertyValues = propertyValues;
    }
}

定义注册表相关类

BeanDefinitionRegistry接口

BeanDefinitionRegistry接口定义了注册表的相关操作，定义如下功能：

注册BeanDefinition对象到注册表中
从注册表中删除指定名称的BeanDefinition对象
根据名称从注册表中获取BeanDefinition对象
判断注册表中是否包含指定名称的BeanDefinition对象
获取注册表中BeanDefinition对象的个数
获取注册表中所有的BeanDefinition的名称

/**
 * 用于注册保存BeanDefinition
 */
public interface BeanDefinitionRegistry {

    void registryBeanDefinition(String beanName, BeanDefinition beanDefinition);

    void removeBeanDefinition(String beanName) throws Exception;

    BeanDefinition getBeanDefinition(String beanName) throws Exception;

    boolean containsBeanDefinition(String beanName);

    int getBeanDefinitionCount();

    String[] getBeanDefinitionsName();
}

SimpleBeanDefinitionRegistry类

该类实现了BeanDefinitionRegistry接口，定义了Map集合作为注册表容器。

public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry {

    //既然是需要保存，就需要用到map
    private final Map<String,BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();

    //注册这个BeanDefinition到表中
    public void registryBeanDefinition(String beanName, BeanDefinition beanDefinition) {
        beanDefinitionMap.put(beanName,beanDefinition);
    }

    //删除
    public void removeBeanDefinition(String beanName) throws Exception {
        beanDefinitionMap.remove(beanName);
    }

    //获取这个beanDefinition
    public BeanDefinition getBeanDefinition(String beanName) throws Exception {
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
        return beanDefinition;
    }

    public boolean containsBeanDefinition(String beanName) {
        return beanDefinitionMap.containsKey(beanName);
    }

    public int getBeanDefinitionCount() {
        return beanDefinitionMap.size();
    }

    public String[] getBeanDefinitionsName() {
        return  beanDefinitionMap.keySet().toArray(new String[0]);
    }
}

定义解析器相关类

BeanDefinitionReader接口

BeanDefinitionReader是用来解析配置文件并在注册表中注册bean的信息。定义了两个规范：

获取注册表的功能，让外界可以通过该对象获取注册表对象。
加载配置文件，并注册bean数据。

/**
 * 解析xml并在封装成BeanDefinition的规范接口
 */
public interface BeanDefinitionReader {
    BeanDefinitionRegistry getBeanDefinitionRegistry();
    void loadBeanDefinitions(String classPath) throws Exception;
}

XmlBeanDefinitionReader类

既然要解析xml文件，解析的包是必不可少的：

<dependency>
    <groupId>dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>1.6.1</version>
</dependency>

XmlBeanDefinitionReader类是专门用来解析xml配置文件的。该类实现 BeanDefinitionReader接口并实现接口中的两个功能。

public class XmlBeanDefinitionReader implements BeanDefinitionReader {

    private BeanDefinitionRegistry registry;

    public XmlBeanDefinitionReader() {
        this.registry = new SimpleBeanDefinitionRegistry();
    }

    public BeanDefinitionRegistry getBeanDefinitionRegistry() {
        return registry;
    }

    /**
     * 加载配置文件，并解析成对应的BeanDefinition
     * @param classPath
     * @throws Exception
     */
    public void loadBeanDefinitions(String classPath) throws Exception {
        //从类路径下加载
        InputStream is = this.getClass().getClassLoader().getResourceAsStream(classPath);
        //利用dom4j解析配置文件
        SAXReader saxReader = new SAXReader();
        Document document = saxReader.read(is);
        Element rootElement = document.getRootElement();    //也就是Beans标签
        parseBean(rootElement); //解析这个根节点并封装
    }

    /**
     * 利用dom4j进行解析
     * @param rootElement
     */
    private void parseBean(Element rootElement) {
        //获取所有的标签，这里只有bean标签
        List<Element> elements = rootElement.elements();
        for (Element element : elements) {
            //遍历这些标签，逐个解析
            String id = element.attributeValue("id");
            String className = element.attributeValue("class");

            //封装这些参数
            BeanDefinition beanDefinition = new BeanDefinition();
            beanDefinition.setId(id);
            beanDefinition.setClassName(className);

            //然后继续解析可能会有的引用依赖，也就是property
            List<Element> list = element.elements("property");
            MutablePropertyValues propertyValues = new MutablePropertyValues();

            //逐个解析
            for (Element element1 : list) {
                String name = element1.attributeValue("name");
                String ref = element1.attributeValue("ref");
                String value = element1.attributeValue("value");

                PropertyValue propertyValue = new PropertyValue(name, ref, value);
                propertyValues.addPropertyValue(propertyValue);
            }
            //将所有的依赖全部注入相应的bean
            beanDefinition.setPropertyValues(propertyValues);
            registry.registryBeanDefinition(id,beanDefinition);
        }
    }
}

IOC容器相关类

BeanFactory接口

在该接口中定义IOC容器的统一规范即获取bean对象。

/**
 * IOC容器的顶级接口，规范怎么获取生产获取Bean，这就是一个典型的工厂模式
 */
public interface BeanFactory {

    Object getBean(String name) throws Exception;
    <T> T getBean(String name,Class<? extends T> clazz) throws Exception;
}

ApplicationContext接口

该接口的所以的子实现类对bean对象的创建都是非延时的，所以在该接口中定义 refresh() 方法，该方法主要完成以下两个功能：

加载配置文件。
根据注册表中的BeanDefinition对象封装的数据进行bean对象的创建。

public interface ApplicationContext extends BeanFactory {

    void refresh() throws Exception;
}

AbstractApplicationContext类

作为ApplicationContext接口的子类，所以该类也是非延时加载，所以需要在该类中定义一个 Map集合，作为bean对象存储的容器。
声明BeanDefinitionReader类型的变量，用来进行xml配置文件的解析，符合单一职责原则。 BeanDefinitionReader类型的对象创建交由子类实现，因为只有子类明确到底创建 BeanDefinitionReader哪个儿子实现类对象。

public abstract class AbstractApplicationContext implements ApplicationContext {

    //聚合BeanDefinitionReader，用来解析XML，一个类一个功能
    protected BeanDefinitionReader beanDefinitionReader;
    //用来存储bean对象的容器 key存储的是bean的id值，value存储的是bean对象
    protected Map<String,Object> singletonObject = new ConcurrentHashMap<String, Object>();

    protected String classPath;

    public void refresh() throws Exception {
        //加载BeanDefinition
        beanDefinitionReader.loadBeanDefinitions(classPath);
        //初始化bean
        finishBeanInitialization();
    }

    private void finishBeanInitialization() throws Exception {
        BeanDefinitionRegistry registry = beanDefinitionReader.getBeanDefinitionRegistry();
        String[] beanDefinitionsName = registry.getBeanDefinitionsName();
        for (String s : beanDefinitionsName) {
            //经行解析并注册到registry中
            BeanDefinition beanDefinition = registry.getBeanDefinition(s);
            getBean(s);
        }
    }
}

注意：该类finishBeanInitialization()方法中调用getBean()方法使用到了模板方法模式。

ClassPathXmlApplicationContext类

该类主要是加载类路径下的配置文件，并进行bean对象的创建，主要完成以下功能：

在构造方法中，创建BeanDefinitionReader对象。（用它解析xml）
在构造方法中，调用refresh()方法，用于进行配置文件加载、创建bean对象并存储到容器中。
重写父接口中的getBean()方法，并实现依赖注入操作。

public class ClassPathXmlApplicationContext extends AbstractApplicationContext {

    //初始化
    public ClassPathXmlApplicationContext(String configPath) {
        this.classPath = configPath;
        this.beanDefinitionReader = new XmlBeanDefinitionReader();

        try {
            //初始化容器，把解析到的bean加入IOC
            refresh();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //通过名字实例化这个bean
    public Object getBean(String beaName) throws Exception {
        Object bean = singletonObject.get(beaName);
        //如果这个bean存在，则从返回，否则通过反射创建这个对象
        if (bean != null){
            return bean;
        }
        //获取registry来找到这个封装的这个BeanDefinition
        BeanDefinitionRegistry registry = beanDefinitionReader.getBeanDefinitionRegistry();
        BeanDefinition beanDefinition = registry.getBeanDefinition(beaName);
        String className = beanDefinition.getClassName();
        //通过反射构建这个对象
        Class<?> aClass = Class.forName(className);
        bean = aClass.newInstance();

        //依赖注入，如果这个对象有依赖
        MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
        if (!propertyValues.isEmpty()){
            for (PropertyValue propertyValue : propertyValues) {
                String name = propertyValue.getName();
                String ref = propertyValue.getRef();
                String value = propertyValue.getValue();
                //如果是一个引用类型，则递归调用这个方法进行加载
                if (ref != null && !"".equals(ref)){
                    Object refBean = getBean(ref);
                    //然后把这个refBean通过setter方法注入引用的类
                    String methodName = StringUtil.getSetterMethodByFieldName(name);
                    Method[] methods = aClass.getMethods();
                    for (Method method : methods) {
                        if(method.getName().equals(methodName)) {
                            method.invoke(bean,refBean);
                        }
                    }

                }
                if(value != null && !"".equals(value)){
                    //然后把这个value通过setter方法注入引用的类
                    String methodName = StringUtil.getSetterMethodByFieldName(name);
                    Method method = aClass.getMethod(methodName, String.class);
                    method.invoke(bean,value);
                }

            }
        }

        //创建好了就将这个对象加入容器
        singletonObject.put(beaName,bean);
        return bean;
    }

    //强转一下类型就好了
    public <T> T getBean(String name, Class<? extends T> clazz) throws Exception {
        Object bean = getBean(name);
        return clazz.cast(bean);
    }
}