源码 - 01 简易版 Spring IOC 容器的实现

文章目录

• • 1. 框架具备的基本功能
  • 2. IOC 容器的实现
  • • 1. 自定义注解
    • • 1. 自定义注解 @Controller
      • 2. 自定义注解 @Service
      • 3. 自定义注解 @Repository
      • 4. 自定义注解 @Component
    • 2. ClassUtil 工具类封装
    • • 1. 获取类加载器
      • 2. 获取扫描包下的类集合
      • 3. 实例化class
      • 4. 设置类的属性值
    • 3. 单例模式
    • • 1. 恶汉模式
      • 2. 懒汉模式
      • 3. 枚举方式实现单例
    • 4. 容器 BeanContainer
    • • 1. 获取Bean容器实例
      • 2. 扫描加载所有Bean
      • 3. 容器的增删改查操作
  • 3. 容器的依赖注入
  • • 1. 自定义注解 @Autowired
    • 2. 实现依赖注入
    • 3. 测试

1. 框架具备的基本功能

1. 解析配置
2. 定位和注册对象
3. 注入对象
4. 提供通用的工具类

2. IOC 容器的实现

1. 创建注解
2. 提取标记对象
3. 实现容器
4. 依赖注入

1. 自定义注解 1. 自定义注解 @Controller

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Controller {
}

2. 自定义注解 @Service

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Service {
}

3. 自定义注解 @Repository

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Repository {
}

4. 自定义注解 @Component

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
}

2. ClassUtil 工具类封装 1. 获取类加载器

@Slf4j
public class ClassUtil {
    
    public static  ClassLoader getClassLoader(){
        return Thread.currentThread().getContextClassLoader();
    }
}

2. 获取扫描包下的类集合

@Slf4j
public class ClassUtil {

    public static final String FILE_PROTOCOL = "file";

    
    public static Set> extractPackageClass(String packageName){
        //1.获取到类的加载器。
        ClassLoader classLoader = getClassLoader();
        //2.通过类加载器获取到加载的资源
        URL url = classLoader.getResource(packageName.replace(".", "/"));
        // url:file:/D:/source_study/spring_source/simpleframework-master/simpleframework/target/classes/com/imooc/entity
        if (url == null){
            log.warn("unable to retrieve anything from package: " + packageName);
            return  null;
        }
        //3.依据不同的资源类型，采用不同的方式获取资源的集合
        Set> classSet = null;
        //过滤出文件类型的资源
        if (url.getProtocol().equalsIgnoreCase(FILE_PROTOCOL)){
            classSet = new HashSet>();
            // /D:/source_study/spring_source/simpleframework-master/simpleframework/target/classes/com/imooc/entity
            File packageDirectory = new File(url.getPath());
            extractClassFile(classSet, packageDirectory, packageName);
        }
        return classSet;
    }

    
    private static void extractClassFile(Set> emptyClassSet, File fileSource, String packageName) {
        // 如果不是目录（是文件），停止递归
        if(!fileSource.isDirectory()){
            return;
        }
        // 如果是一个文件夹，则调用其listFiles方法获取文件夹下的文件或文件夹
        File[] files = fileSource.listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                if(file.isDirectory()){
                    return true;
                } else{
                    //获取文件的绝对值路径
                    String absoluteFilePath = file.getAbsolutePath();
                    if(absoluteFilePath.endsWith(".class")){
                        //若是class文件，则直接加载
                        addToClassSet(absoluteFilePath);
                    }
                }
                return false;
            }
            //根据class文件的绝对值路径，获取并生成class对象，并放入classSet中
            private void addToClassSet(String absoluteFilePath) {
                //1.从class文件的绝对值路径里提取出包含了package的类名
                // D:source_studyspring_sourcesimpleframework-mastersimpleframeworktargetclassescomimoocentityboHeadLine.class
                // D:.source_study.spring_source.simpleframework-master.simpleframework.target.classes.com.imooc.entity.bo.ShopCategory.class
                absoluteFilePath = absoluteFilePath.replace(File.separator, ".");
                // com.imooc.entity.bo.HeadLine.class
                String className = absoluteFilePath.substring(absoluteFilePath.indexOf(packageName));
                // com.imooc.entity.bo.ShopCategory
                className = className.substring(0, className.lastIndexOf("."));
                //2.通过反射机制获取对应的Class对象并加入到classSet里
                Class targetClass = loadClass(className);
                emptyClassSet.add(targetClass);
            }
        });
        if(files != null){
            for(File f : files){
                //递归调用
                extractClassFile(emptyClassSet, f, packageName);
            }
        }
    }
    
    public static Class loadClass(String className){
        try {
            return Class.forName(className);
        } catch (ClassNotFoundException e) {
            log.error("load class error:", e);
            throw new RuntimeException(e);
        }
    }
}

测试：

public class ClassUtilTest {
    @DisplayName("提取目标类方法：extractPackageClassTest")
    @Test
    public void extractPackageClassTest(){
        Set> classSet =  ClassUtil.extractPackageClass("com.imooc.entity");
        System.out.println(classSet);
        Assertions.assertEquals(4, classSet.size());
    }
}

输出：

[class com.imooc.entity.dto.MainPageInfoDTO, class com.imooc.entity.bo.ShopCategory, class com.imooc.entity.dto.Result, class com.imooc.entity.bo.HeadLine]

3. 实例化class

public static  T newInstance(Class clazz, boolean accessible){
    try {
        Constructor constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(accessible);
        return (T)constructor.newInstance();
    } catch (Exception e) {
        log.error("newInstance error", e);
        throw new RuntimeException(e);
    }
}

4. 设置类的属性值

public static void setField(Field field, Object target, Object value, boolean accessible){
    field.setAccessible(accessible);
    try {
        field.set(target, value);
    } catch (IllegalAccessException e) {
        log.error("setField error", e);
        throw new RuntimeException(e);
    }
}

3. 单例模式 1. 恶汉模式

public class StarvingSingleton {
    private static final StarvingSingleton starvingSingleton = new StarvingSingleton();
    private StarvingSingleton(){ }
    public static StarvingSingleton getInstance(){
        return starvingSingleton;
    }
}

2. 懒汉模式

public class LazyDoubleCheckSingleton {
    private volatile static LazyDoubleCheckSingleton instance;
    private LazyDoubleCheckSingleton(){}
    public static LazyDoubleCheckSingleton getInstance(){
        //第一次检测
        if (instance==null){
            //同步
            synchronized (LazyDoubleCheckSingleton.class){
                if (instance == null){
                    //memory = allocate(); //1.分配对象内存空间
                    //instance(memory);    //2.初始化对象
                    //instance = memory;   //3.设置instance指向刚分配的内存地址，此时instance！=null
                    instance = new LazyDoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
    public static void main(String[] args) {
        System.out.println(LazyDoubleCheckSingleton.getInstance());
        System.out.println(LazyDoubleCheckSingleton.getInstance());
    }
}

3. 枚举方式实现单例

public class EnumStarvingSingleton {
    private EnumStarvingSingleton(){}

    public static EnumStarvingSingleton getInstance(){
        return ContainerHolder.HOLDER.instance;
    }
    private enum ContainerHolder{
        
        HOLDER;
        private EnumStarvingSingleton instance;
        ContainerHolder(){
            instance = new EnumStarvingSingleton();
        }
    }
}

4. 容器 BeanContainer 1. 获取Bean容器实例

@Slf4j
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class BeanContainer {
    
    public static BeanContainer getInstance() {
        return ContainerHolder.HOLDER.instance;
    }

    
    private enum ContainerHolder {
        // 容器
        HOLDER;
        private BeanContainer instance;

        ContainerHolder() {
            instance = new BeanContainer();
        }
    }
}

2. 扫描加载所有Bean

@Slf4j
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class BeanContainer {
    
    private final Map, Object> beanMap = new ConcurrentHashMap<>();
    
    
    public static BeanContainer getInstance() {
        return ContainerHolder.HOLDER.instance;
    }

    
    private enum ContainerHolder {
        // 容器
        HOLDER;
        private BeanContainer instance;

        ContainerHolder() {
            instance = new BeanContainer();
        }
    }
    
    
    public int size() {
        return beanMap.size();
    }

    
    private boolean loaded = false;

    
    public boolean isLoaded() {
        return loaded;
    }
    
    
    private static final List> BEAN_ANNOTATION
            = Arrays.asList(Component.class, Controller.class, Service.class, Repository.class, Aspect.class);

    
    public synchronized void loadBeans(String packageName) {
        //判断bean容器是否被加载过
        if (isLoaded()) {
            log.warn("BeanContainer has been loaded.");
            return;
        }
        Set> classSet = ClassUtil.extractPackageClass(packageName);
        if (ValidationUtil.isEmpty(classSet)) {
            log.warn("extract nothing from packageName" + packageName);
            return;
        }
        for (Class clazz : classSet) {
            for (Class annotation : BEAN_ANNOTATION) {
                //如果类上面标记了定义的注解
                if (clazz.isAnnotationPresent(annotation)) {
                    //将目标类本身作为键，目标类的实例作为值，放入到beanMap中
                    beanMap.put(clazz, ClassUtil.newInstance(clazz, true));
                }
            }
        }
        loaded = true;
    }
}

测试：

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class BeanContainerTest {
    private static BeanContainer beanContainer;
    
    @BeforeAll
    static void init(){
        beanContainer = BeanContainer.getInstance();
    }
    
    @DisplayName("加载目标类及其实例到BeanContainer：loadBeansTest")
    @Order(1)
    @Test
    public void loadBeansTest(){
        Assertions.assertEquals(false, beanContainer.isLoaded());
        beanContainer.loadBeans("com.imooc");
        Assertions.assertEquals(6, beanContainer.size());
        Assertions.assertEquals(true, beanContainer.isLoaded());
    }
}

3. 容器的增删改查操作

@Slf4j
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class BeanContainer {
    
    private final Map, Object> beanMap = new ConcurrentHashMap<>();

    
    public static BeanContainer getInstance() {
        return ContainerHolder.HOLDER.instance;
    }

    
    private enum ContainerHolder {
        // 容器
        HOLDER;
        private BeanContainer instance;

        ContainerHolder() {
            instance = new BeanContainer();
        }
    }

    
    public int size() {
        return beanMap.size();
    }

    
    private boolean loaded = false;

    
    public boolean isLoaded() {
        return loaded;
    }

    
    private static final List> BEAN_ANNOTATION
            = Arrays.asList(Component.class, Controller.class, Service.class, Repository.class, Aspect.class);

    
    public synchronized void loadBeans(String packageName) {
        //判断bean容器是否被加载过
        if (isLoaded()) {
            log.warn("BeanContainer has been loaded.");
            return;
        }
        Set> classSet = ClassUtil.extractPackageClass(packageName);
        if (ValidationUtil.isEmpty(classSet)) {
            log.warn("extract nothing from packageName" + packageName);
            return;
        }
        for (Class clazz : classSet) {
            for (Class annotation : BEAN_ANNOTATION) {
                //如果类上面标记了定义的注解
                if (clazz.isAnnotationPresent(annotation)) {
                    //将目标类本身作为键，目标类的实例作为值，放入到beanMap中
                    beanMap.put(clazz, ClassUtil.newInstance(clazz, true));
                }
            }
        }
        loaded = true;
    }

    
    public Object addBean(Class clazz, Object bean) {
        return beanMap.put(clazz, bean);
    }

    
    public Object removeBean(Class clazz) {
        return beanMap.remove(clazz);
    }

    
    public Object getBean(Class clazz) {
        return beanMap.get(clazz);
    }
    
    
    public Set> getClasses(){
        return beanMap.keySet();
    }
    
    
    public Set