Spring原理模拟实现(java基础实战)-1

项目使用技术

使用java基础技术栈完成，包括但不限于：反射、集合、String等

项目完成效果

基于Spring框架通过在类上配置注解(@Component, @Controller等注解)，在xml中配置扫描包，完成直接在容器中获取对象的特性。本项目使用java基础模拟实现该特性。
解读输出内容：
monsterService类和monsterDao两个类被扫描进SpringApplicationContext容器中，monsterService的Scope为prototype，所以两次获取monsterService是两个不同的类对象(多例)，monsterDao的Scope默认值为singleton，所以两次获取的monsterDao是同一个的对象(单例), 单例也是Spring框架在获取Bean的默认配置。monsterDao的@Component注解中配置Bean的名字，默认名为类名小写 作为key存在SpringApplicationContext的map中。

        SpringApplicationContext ioc = new SpringApplicationContext(SpringConfig.class);

        MonsterService monsterService = (MonsterService) ioc.getBean("monsterService");
        MonsterService monsterService2 = (MonsterService) ioc.getBean("monsterService");
        System.out.println("monsterService:" + monsterService);
        System.out.println("monsterService2:" + monsterService2);

        MonsterDao monsterDao = (MonsterDao) ioc.getBean("monsterDao");
        MonsterDao monsterDao2 = (MonsterDao) ioc.getBean("monsterDao");
        System.out.println("monsterDao:" + monsterDao);
        System.out.println("monsterDao2:" + monsterDao2);
        System.out.println("ok");

项目结构

结构说明

@Component

加上该注解可以加载类到容器, 其value属性指定对象的名字

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
    //通过value可以给注入的bean/对象指定名字
    String value() default "";
}

@ComponentScan

在value属性中写上包路径，指明要扫描的包

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ComponentScan {
    //指定要扫描的包
    String value() default "";
}

@Scope

指定Bean的作用范围[singleton, prototype], singleton为单例，在扫描时创建，prototype为多例，在获取Bean时创建。

// Scope 可以指定Bean的作用范围[singleton, prototype]
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Scope {
    String value() default "";
}

MonsterDao和MonsterService

是我们要加载到容器中的类对象

@Component
public class MonsterDao {
}

@Component(value = "monsterService")
@Scope(value = "prototype")
public class MonsterService {
}

SpringConfig

模拟Spring框架中的xml文件，可以在该类上加上@ComponentScan来指定要扫描的包

@ComponentScan(value = "com.cwh.spring.component")
public class SpringConfig {
}

BeanDefinition

记录bean信息（单例还是多例），反射生成对应对象

package com.cwh.spring.ioc;

//记录bean信息（单例还是多例），反射生成对应
public class BeanDefinition {
    private String scope;
    private Class clazz;

    public BeanDefinition() {
    }

    public BeanDefinition(String scope, Class clazz) {
        this.scope = scope;
        this.clazz = clazz;
    }

    public String getScope() {
        return scope;
    }

    public void setScope(String scope) {
        this.scope = scope;
    }

    public Class getClazz() {
        return clazz;
    }

    public void setClazz(Class clazz) {
        this.clazz = clazz;
    }

    @Override
    public String toString() {
        return "BeanDefinition{" +
                "scope='" + scope + '\'' +
                ", clazz=" + clazz +
                '}';
    }
}

SpringApplicationContext

最重要的容器类，模拟Spring中的 ClassPathXmlApplicationContext。SpringApplicationContext完成 存放被扫描进来的Bean(封装成BeanDefinition对象)放入map中，存放singleton类型的bean放入map, createBean, getBean等方法。

public class SpringApplicationContext {
    private Class configClass;
    //存放BeanDefinition对象
    // 先把 有 Bean注解的类 生成 BeanDefinition对象，再放入beanDefinitionMap
   private ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
    //存放单例对象
    private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>();


    public SpringApplicationContext(Class configClass) {
        beanDefinitionByScan(configClass);

        //将Scope是singleton(默认)的放到singletonObjects
        Enumeration<String> keys = beanDefinitionMap.keys();
        while (keys.hasMoreElements()) {
            String beanName = keys.nextElement();
            BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
            if("singleton".equalsIgnoreCase(beanDefinition.getScope())) {
                //将该bean实例放入到singletonObjects 集合
                Object bean = createBean(beanDefinition);
                singletonObjects.put(beanName, bean);
            }
        }

        //System.out.println("single:" + singletonObjects);
        //System.out.println("map:" + beanDefinitionMap);
    }



    //扫描指定包，创建BeanDefinition对象，并放入Map
    private void beanDefinitionByScan(Class configClass) {
        this.configClass = configClass;
        ComponentScan componentScan =
                (ComponentScan) this.configClass.getDeclaredAnnotation(ComponentScan.class);
        String path = componentScan.value(); //得到要扫描的包
        System.out.println("path:" + path);

        //得到类加载器
        ClassLoader classLoader = SpringApplicationContext.class.getClassLoader();

        path = path.replace(".", "/");
        URL resource = classLoader.getResource(path);
        File file = new File(resource.getFile());

        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                String absolutePath = f.getAbsolutePath();
                if (absolutePath.endsWith(".class")) {
                    String className = absolutePath.substring(
                            absolutePath.lastIndexOf("\\") + 1,
                            absolutePath.lastIndexOf(".class"));
                    String classFullName = path.replace("/", ".") + "." + className;

                    try {
                        Class<?> aClass = classLoader.loadClass(classFullName);
                        //如果该类使用了@Component, 说明是Spring bean
                        if (aClass.isAnnotationPresent(Component.class)) {
                            System.out.println("可以加载到容器：" + className);

                            //得到beanName
                            Component component = aClass.getDeclaredAnnotation(Component.class);
                            String beanName = component.value();
                            //value可以没有设置，是默认值 "", 需要再处理一下
                            if ("".equalsIgnoreCase(beanName)) {
                                // 类名首字母小写作为key, 放入map
                                beanName = StringUtils.uncapitalize(className);
                            }
                            BeanDefinition beanDefinition = new BeanDefinition();
                            beanDefinition.setClazz(aClass);
                            if (aClass.isAnnotationPresent(Scope.class)) {
                                //如果配置了Scope, 获取他配置的值
                                Scope scope = aClass.getDeclaredAnnotation(Scope.class);
                                beanDefinition.setScope(scope.value());
                            } else {
                                //如果没有配置Scope, 就用默认的值singleton
                                beanDefinition.setScope("singleton");
                            }
                            //将beanDefinition 对象放入到Map
                            beanDefinitionMap.put(beanName, beanDefinition);
                        } else {
                            System.out.println("不可以加载到容器：" + className);
                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    //完成createBean，因为map中还是BeanDefinition对象
    private Object createBean(BeanDefinition beanDefinition) {
        Class clazz = beanDefinition.getClazz();
        try {
            Object instance = clazz.getDeclaredConstructor().newInstance();
            return instance;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        //反射创建对象失败
        return null;
    }


    //编写方法返回容器中的对象
    public Object getBean(String name) {
        if (beanDefinitionMap.containsKey(name)) {
            BeanDefinition beanDefinition = beanDefinitionMap.get(name);
            if ("singleton".equalsIgnoreCase(beanDefinition.getScope())) {
                return singletonObjects.get(name); //在单例map中获取
            } else {
                return createBean(beanDefinition);
            }
        } else {
            throw new NullPointerException("没有该bean");
        }
    }
}

TestSpirng

创建SpringApplicationContext对象，然后获取Bean, 测试效果

public class TestSpring {
    public static void main(String[] args) {
        SpringApplicationContext ioc = new SpringApplicationContext(SpringConfig.class);

        MonsterService monsterService = (MonsterService) ioc.getBean("monsterService");
        MonsterService monsterService2 = (MonsterService) ioc.getBean("monsterService");
        System.out.println("monsterService:" + monsterService);
        System.out.println("monsterService2:" + monsterService2);

        MonsterDao monsterDao = (MonsterDao) ioc.getBean("monsterDao");
        MonsterDao monsterDao2 = (MonsterDao) ioc.getBean("monsterDao");
        System.out.println("monsterDao:" + monsterDao);
        System.out.println("monsterDao2:" + monsterDao2);
        System.out.println("ok");
    }
}