从零手写 IOC容器（通俗易懂）

目录

概述

1.Component注解定义

2.Reject注解定义

3.User对象定义

4.UserService实现

5.UserController实现

6.IocContext ioc bean容器

7.IocUtils ioc的依赖注入

8.模拟调用UserController

结果

---

概述

IOC (Inversion of Control) 控制反转。熟悉Spring的应该都知道。那么具体是怎么实现的呢？下面我们通过一个例子说明。

1.Component注解定义

/**
 * 类上的注解：用来告诉ioc容器哪些类需要托管
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Component {

}

先定义一个Component注解，主要被Component注解修饰的类都是需要被ioc容器管理的类。

2.Reject注解定义

/**
 * 属性上的注解：初始化一个类的时候，如果类中有注解需要注入其他类
 *              去ioc中找，找不到需要再初始化
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Inject {

}

定义一个@Inject注解，只要是被@Inject注解注释的属性都会自动注入，实现IOC功能。

3.User对象定义

@Data
public class User {
    private String userName;
    private int userAge;

    public User(String userName,int userAge){
        this.userAge = userAge;
        this.userName = userName;
    }

    @Override
    public String toString() {
        return "User [userName=" + userName + ", userAge=" + userAge + "]";
    }
}

就是一个普通的模型bean

4.UserService实现

@Component
public class UserService {

    public User getUser(){
        return new User("xl",30);
    }
}

使用@Component注解标注该类是受容器管理的类。

5.UserController实现

@Component
public class UserController {

    @Inject
    private UserService userService;

    public void getUser(){
        User user = userService.getUser();
        System.out.println(user.toString());
    }
}

使用@Component注解标注该类是受容器管理的类。

userService使用了@Inject自定义注解，表示该属性是容器自动注入该实例，实现IOC功能。

6.IocContext ioc bean容器

public class IocContext {
    /**ioc容器 */
    public static final Map<Class<?>,Object> applicationContext =
            new ConcurrentHashMap<>(64);

    static {
        String packName = "com.damai.ioc";
        // 遍历包下面全部的类，看是否有@Component注解，决定是否需要ioc容器托管
        try{
            initBean(packName);
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    private static void initBean(String packName){
        try {
            // 加载到ioc 容器
            Enumeration<URL> urls = Thread.currentThread().
                    getContextClassLoader().getResources(packName.replace(".","/"));
            while (urls.hasMoreElements()){
                addClassByAnnotation(urls.nextElement().getPath(),packName);
            }

            // 实现注入功能
            IocUtils.inject();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    private static void addClassByAnnotation(String path,String packName) throws Exception{
        System.out.println("path : "+path);
        System.out.println("packName : "+packName);
        File[] files = getClassFile(path);

        if(files!=null){
            for(File file : files){
                String fileName = file.getName();
                System.out.println(">>> fileName : "+fileName);
                if(file.isFile()){
                    // 根据类的全名进行加载
                    Class<?> clazz = Class.forName(packName+"."+
                            fileName.substring(0,fileName.lastIndexOf(".")));
                    if(clazz.isAnnotationPresent(Component.class)){
                        // 将类和类的实例加载到容器中
                        applicationContext.put(clazz,clazz.newInstance());
                    }
                }else{
                    addClassByAnnotation(file.getPath(),packName+"."+fileName);
                }
            }
        }
    }

    private static File[] getClassFile(String filePath) {
        return new File(filePath).listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                return file.isFile() && file.getName().endsWith(".class") || file.isDirectory();
            }
        });
    }
}

a.扫描加载指定包路径下的所有Class,并判断该Class 是否是@Component注解的类，如果是，则创建实例，并保存到applicationContext缓存中

b.调用IocUtils.inject()，进行依赖注入

7.IocUtils ioc的依赖注入

public class IocUtils {
    public static void inject() {
        System.out.println("IocUtils inject method");
        // 获取ioc 容器中的map
        Map<Class<?>,Object> map = IocContext.applicationContext;
        try {
            // map 的key 主要是已经加载到容器中的class
            for(Map.Entry<Class<?>, Object> entry : map.entrySet()){
                Class<?> clazz = entry.getKey();
                // map 的value 主要是key 对应的实例
                Object obj = entry.getValue();

                Field[] fields = clazz.getDeclaredFields();
                for(Field field :fields){
                    if(field.isAnnotationPresent(Inject.class)){
                        System.out.println(">>> field : "+field.getName()+field.getType());
                        Class<?> fieldClazz = field.getType();
                        field.setAccessible(true);
                        Object fieldObj = map.get(fieldClazz);
                        // 设置后，属性的实例就会注入，而不是null
                        // 将B 对象的实例fieldObj 注入到  A对象的的实例obj 中
                        field.set(obj,fieldObj);
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

8.模拟调用UserController

public class Main {
    public static void main(String[] args) {
        UserController userController =
                (UserController) IocContext.applicationContext.get(UserController.class);

        userController.getUser();
    }
}

循环遍历 applicationContext中所有的Bean，判断每个Bean中是否有被@Inject注解修饰的属性，如果有则从applicationContext中获取要注入的实例，并使用反射实现自动注入功能。

结果

path : /D:/ideaStudy/springioc/target/classes/com/damai/ioc
packName : com.damai.ioc
>>> fileName : Component.class
>>> fileName : Inject.class
>>> fileName : IocContext$1.class
>>> fileName : IocContext.class
>>> fileName : IocUtils.class
>>> fileName : Main.class
>>> fileName : User.class
>>> fileName : UserController.class
>>> fileName : UserService.class
IocUtils inject method
>>> field : userServiceclass com.damai.ioc.UserService
User [userName=xl, userAge=30]