手写IOC

一切总会归于平淡

发布于 2023-10-30 14:15:41

1490

发布于 2023-10-30 14:15:41

文章被收录于专栏：一切总会归于平淡一切总会归于平淡

本篇博客我们来手写一个IOC，就是模拟出IOC里边的实现过程。这过程怎么做呢？

咱们主要基于java中的反射，再加注解，来实现spring框架中IOC的这个效果。

下面我们来具体看看这个过程。首先因为这里边要用到反射，咱们把反射中的相关内容我们先做一个复习。复习之后最终让我们来手写spring IOC的这个功能。

1、回顾Java反射

java中的反射机制是什么呢？

它指的是对于任何一个类，我们都能够知道这个类里面的属性方法。

对于任何一个对象都能调它的任意方法和属性。

而这种动态获取信息以及动态调用对象方法的功能，就称为java的反射机制。

说的简单点，你要做反射，首先要得到类的卡的对象，就是咱们通俗说的字节码文件。通过字节码文件能够操作类中所有内容，包括你的属性，包括你的方法等等。这个是对于反射一个简单的概述。

自定义类

package com.jie.reflect.model;

/**
 * Car类
 * 用于反射测试
 *
 * @author 阿杰 2416338031@qq.com
 * @version 1.0
 * @date 2023/10/26 6:46
 */
public class Car {

    /**
     * 属性
     */
    private String name;
    private int age;
    private String color;

    /**
     * 无参数构造
     */
    public Car() {
    }

    /**
     * 有参数构造
     */
    public Car(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    /**
     * 私有方法
     */
    private void run() {
        System.out.println("私有方法-run.....");
    }

    /**
     * get和set方法
     */
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }
}

这个是基本准备。下面咱们基于这个类来用一下反射中的相关内容。

1.1 获取Class对象的多种方式

第一个内容，获取Class对象的多种方式。

import com.jie.reflect.model.Car;
import org.junit.jupiter.api.Test;

/**
 * 测试反射类
 *
 * @author 阿杰 2416338031@qq.com
 * @version 1.0
 * @date 2023/10/26 6:51
 */
public class TestCar {

    //1、获取Class对象多种方式
    @Test
    public void test01() throws Exception {
        // 1.1、通过类名.class获取
        Class clazz1 = Car.class;
        
        // 1.2、通过对象.getClass()获取
        Class clazz2 = new Car().getClass();

        // 1.3、通过Class.forName("全类名")获取
        Class clazz3 = Class.forName("com.jie.reflect.model.Car");

        // 1.4、通过类加载器获取
        ClassLoader classLoader = TestCar.class.getClassLoader();
        Class clazz4 = classLoader.loadClass("com.jie.reflect.model.Car");

        //实例化
        Car car = (Car)clazz4.getConstructor().newInstance();
        System.out.println(car);
    }
}

1.2 获取构造方法

刚才咱们完成了第一个操作，获取class对象的多种方式演示，最终进行实例化。下面我们演示第二个内容，通过反射来获取构造方法。

 	// 2 、 获取构造方法
    @Test
    public void test02() throws Exception {
        // 2.1、获取所有的构造方法
        Class clazz = Class.forName("com.jie.reflect.model.Car");
        // getConstructors()获取所有的公有构造方法
        Constructor[] constructors = clazz.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println("方法名称："+constructor.getName()+" 参数个数："+constructor.getParameterCount());
        }
        System.out.println("====================================");
        // getDeclaredConstructors()获取所有的构造方法 包括私有的
        Constructor[] constructors2 = clazz.getDeclaredConstructors();
        for (Constructor constructor : constructors2) {
            System.out.println("方法名称："+constructor.getName()+" 参数个数："+constructor.getParameterCount());
        }

        // 2.2、获取指定有参数的构造方法构造对象
        // getConstructor 获取公有的构造方法
        Constructor constructor = clazz.getConstructor(String.class, int.class, String.class);
        Car car = (Car)constructor.newInstance("奔驰", 20, "黑色");
        System.out.println(car);

        // 2.3、获取私有的构造方法
        // getDeclaredConstructor 获取私有的构造方法
        Constructor c2 = clazz.getDeclaredConstructor(String.class, int.class, String.class);
        c2.setAccessible(true);
        Car car2 = (Car)c2.newInstance("捷达", 15, "白色");
        System.out.println(car2);
    }

1.3 获取属性

下面我们演示第三个获取属性

 // 3、获取属性
    @Test
    public void test03() throws Exception {
        // 3.1、获取所有的属性
        Class clazz = Class.forName("com.jie.reflect.model.Car");
        Car car = (Car) clazz.getDeclaredConstructor().newInstance();
        // getFields()获取所有的公有属性
        System.out.println("获取所有的公有属性");
        System.out.println(clazz.getFields().length);
        // 因为Car类没有公有属性，所以获取不到
//        System.out.println(clazz.getFields()[0].getName());
        System.out.println("====================================");
        // getDeclaredFields()获取所有的属性 包括私有的
        System.out.println("获取所有的属性");
        System.out.println(clazz.getDeclaredFields().length);
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            if (declaredField.getName().equals("name")) {
                // 私有属性需要设置访问权限
                declaredField.setAccessible(true);
                declaredField.set(car, "奔驰");
            }
            System.out.println(declaredField.getName());
            System.out.println(car);
        }

        // 3.2、获取指定的属性
        // getField 获取公有的属性
        // 因为Car类没有公有属性，所以获取不到
//        System.out.println("获取指定的公有属性");
//        System.out.println(clazz.getField("name"));
        System.out.println("====================================");
        // getDeclaredField 获取私有的属性
        System.out.println("获取指定的属性");
        System.out.println(clazz.getDeclaredField("color"));
    }

1.4 获取方法

然后再看第四个，就是如何来操作方法。

 // 4、获取方法
    @Test
    public void test04() throws Exception {
        // 4.1、获取所有的方法
        Class clazz = Class.forName("com.jie.reflect.model.Car");
        Car car = (Car) clazz.getDeclaredConstructor().newInstance();
        car.setName("奔驰");
        car.setAge(20);
        car.setColor("黑色");
        // getMethods()获取所有的公有方法
        System.out.println("获取所有的公有方法");
        System.out.println(clazz.getMethods().length);
        // 因为Car类没有公有方法，所以获取不到
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            // 获取方法名称
//            System.out.println(method.getName());
            // 执行方法 toString
            if(method.getName().equals("toString")) {
                System.out.println(method.invoke(car));
            }
        }
        // 4.2 getDeclaredMethods()获取所有的方法 包括私有的
        System.out.println("获取所有的方法");
        System.out.println(clazz.getDeclaredMethods().length);
        Method[] methodsAll = clazz.getDeclaredMethods();
        for (Method m:methodsAll) {
            //执行方法 run
            if(m.getName().equals("run")) {
                m.setAccessible(true);
                m.invoke(car);
            }
        }
    }

2、实现Spring的IoC

我们知道，IoC（控制反转）和DI（依赖注入）是Spring里面核心的东西，那么，我们如何自己手写出这样的代码呢？下面我们就一步一步写出Spring框架最核心的部分。

2.1 搭建子模块

搭建模块：guigu-spring，搭建方式如其他spring子模块

2.2 准备测试需要的bean

创建UserDao接口

package com.jie.spring.dao;

/**
 * UserDao
 *
 * @author 阿杰 2416338031@qq.com
 * @date 2023/10/27 6:39
 * @version 1.0
*/
public interface UserDao {

    public void print();
}

创建UserDaoImpl实现

package com.jie.spring.dao.impl;


import com.jie.spring.dao.UserDao;

/**
 * UserDaoImpl
 *
 * @author 阿杰 2416338031@qq.com
 * @version 1.0
 * @date 2023/10/27 6:44
 */
public class UserDaoImpl implements UserDao {

    @Override
    public void print() {
        System.out.println("Dao层执行结束");
    }
}

创建UserService接口

package com.jie.spring.service;

/**
 * UserService
 *
 * @author 阿杰 2416338031@qq.com
 * @date 2023/10/27 6:45
 * @version 1.0
*/
public interface UserService {

    public void out();
}

创建UserServiceImpl实现类

package com.jie.spring.service.impl;


import com.jie.spring.service.UserService;

public class UserServiceImpl implements UserService {

    @Override
    public void out() {
        System.out.println("Service层执行结束");
    }
}

2.3 定义注解

我们通过注解的形式加载bean与实现依赖注入。

package com.jie.spring.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Bean 用于创建对象
 * 作用于类上
 * 运行时生效
 *
 * @author 阿杰 2416338031@qq.com
 * @version 1.0
 * @date 2023/10/27 6:51
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Bean {
}

package com.jie.spring.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Di 用于依赖注入
 * 作用于属性上
 * 运行时生效
 *
 * @author 阿杰 2416338031@qq.com
 * @version 1.0
 * @date 2023/10/27 6:52
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Di {
}

说明：上面两个注解可以随意取名

然后我们就可以在我们的UserDaoImpl 使用我们定义的注解。

2.4定义bean容器接口

package com.jie.spring.bean;

/**
 *  ApplicationContext 用于获取bean
 *
 * @author 阿杰 2416338031@qq.com
 * @date 2023/10/27 7:03
 * @version 1.0
*/
public interface ApplicationContext {
    Object getBean(Class clazz);
}

2.5 编写注解bean容器接口实现

AnnotationApplicationContext基于注解扫描bean。

package com.jie.spring.bean;

import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

/**
 * ApplicationContext 用于获取bean
 *
 * @author 阿杰 2416338031@qq.com
 * @version 1.0
 * @date 2023/10/27 7:06
 */
public class ApplicationContextImpl implements ApplicationContext {

    /**
     * 创建Map集合，放Bean对象
     */
    private Map<Class, Object> beanFactory = new HashMap<>();

    @Override
    public Object getBean(Class clazz) {
        return beanFactory.get(clazz);
    }

    /**
     * 创建有参构造器，传递包路径，设置包扫描规则
     * 扫描包路径下的所有类，判断类上是否有Bean注解，如果有，创建对象，放入Map集合
     *
     * @param basePackage 包路径
     */
    public ApplicationContextImpl(String basePackage) {
        
    }
}

2.6 编写扫描bean逻辑

我们通过构造方法传入包的base路径，扫描被@Bean注解的java对象，完整代码如下：

package com.jie.spring.bean;

import com.jie.spring.anno.Bean;

import java.io.File;
import java.net.URL;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

/**
 * ApplicationContext 用于获取bean
 *
 * @author 阿杰 2416338031@qq.com
 * @version 1.0
 * @date 2023/10/27 7:06
 */
public class ApplicationContextImpl implements ApplicationContext {

    /**
     * 创建Map集合，放Bean对象
     */
    private static final Map<Class, Object> BEAN_FACTORY = new HashMap<>();

    private static String rootPath;

    @Override
    public Object getBean(Class clazz) {
        return BEAN_FACTORY.get(clazz);
    }

    /**
     * 创建有参构造器，传递包路径，设置包扫描规则
     * 扫描包路径下的所有类，判断类上是否有Bean注解，如果有，创建对象，放入Map集合
     *
     * @param basePackage 包路径
     */
    public ApplicationContextImpl(String basePackage) {
        try {
            // 包路径都是 com.jie.spring
            // 1 我们需要把 . 替换成 \
            String packagePath = basePackage.replaceAll("\\.", "\\\\");
            // 2 获取包的绝对路径
            Enumeration<URL> urls = Thread.currentThread().getContextClassLoader().getResources(packagePath);
            // 3 遍历包下的所有类
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                // 4 获取类的绝对路径
                String filePath = URLDecoder.decode(url.getPath(), StandardCharsets.UTF_8);
                // 5 获取包前面的路径部分，字符串截取
                rootPath = filePath.substring(0, filePath.length() - packagePath.length());
                // 6 调用方法，获取包下的所有类
                loadBean(new File(filePath));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 包扫描过程 递归
     *
     * @param file 文件
     * @return: void
     * @author 阿杰 2416338031@qq.com
     * @date: 2023/10/29 17:48
     */
    private static void loadBean(File file) throws Exception {
        // 1 判断是否是文件夹
        if (file.isDirectory()) {
            // 2 获取文件夹下的所有文件
            File[] childrenFiles = file.listFiles();

            // 3 判断文件夹里面为空，直接返回
            if (childrenFiles == null || childrenFiles.length == 0) {
                return;
            }

            // 4 如果文件夹里面有文件，遍历文件夹所有内容
            for (File childrenFile : childrenFiles) {
                // 4.1 遍历得到每个File对象，继续判断，如果还是文件夹，递归调用
                if (childrenFile.isDirectory()) {
                    // 递归调用
                    loadBean(childrenFile);
                } else {
                    // 4.2 遍历得到每个File对象不是文件夹，是文件
                    // 4.3 得到包路径+类名称部分（字符串截取过程）
                    String patgWithClass = childrenFile
                            .getAbsolutePath()
                            .substring(rootPath.length() - 1);
                    // 4.4 判断是否是class文件
                    if (patgWithClass.contains(".class")) {
                        // 4.5 如果是class文件，把路径\替换成.，把.class去掉，得到类的全限定名
                        String allName = patgWithClass
                                .replaceAll("\\\\", ".")
                                .replaceAll(".class", "");

                        // 4.6 判断类上是否有Bean注解，如果有，就进行实例化
                        // 4.6.1 获取类的字节码对象
                        Class<?> clazz = Class.forName(allName);
                        // 4.6.2 判断不是接口
                        if (!clazz.isInterface()) {
                            // 4.6.3 判断类上是否有Bean注解
                            Bean annotation = clazz.getAnnotation(Bean.class);
                            if (annotation != null) {
                                // 4.6.4 如果有，创建对象
                                Object instance = clazz.getConstructor().newInstance();
                                // 4.7 把类的全限定名和对象，放入Map集合
                                // 4.7.1 判断当前类如果实现了接口，把接口的class对象作为key
                                if (clazz.getInterfaces().length > 0) {
                                    BEAN_FACTORY.put(clazz.getInterfaces()[0], instance);
                                } else {
                                    // 4.7.2 如果没有实现接口，把当前类的class对象作为key
                                    BEAN_FACTORY.put(clazz, instance);
                                }
                            }
                        }
                    }
                }
            }
        }
    }


    public static void main(String[] args) {
        ApplicationContextImpl applicationContext = new ApplicationContextImpl("com.jie.spring");
    }
}

2.7 java类标识Bean注解

2.8 测试Bean加载

2.9 依赖注入实现

我们实现了Bean 的加载，现在来实现依赖注入

/**
 * 属性注入
 *
 * @return: void
 * @author 阿杰 2416338031@qq.com
 * @date: 2023/10/29 18:50
 */
private void loadDi() {
    // 1 遍历BEAN_FACTORY Map集合
    Set<Map.Entry<Class, Object>> entries = BEAN_FACTORY.entrySet();
    for (Map.Entry<Class, Object> entry : entries) {
        // 2 获取map 集合每个对象（value）,获取每个对象属性
        Object value = entry.getValue();
        // 获取class对象
        Class<?> clazz = value.getClass();
        // 获取每个对象属性
        Field[] declaredFields = clazz.getDeclaredFields();
        // 3 遍历得到每个对象属性数组，得到每个属性
        for (Field field : declaredFields) {
            // 4 判断属性上是否有Di注解，如果有，进行注入
            Di annotation = field.getAnnotation(Di.class);
            if (annotation != null) {
                // 如果有私有属性，需要设置属性可访问
                field.setAccessible(true);
                // 5 如果有 @Di 注解，把对象进行设置（注入）
                try {
                    field.set(value, BEAN_FACTORY.get(field.getType()));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}