一步一步实现SpringIoc容器

男娘i 2022-11-18 05:49 334阅读 0赞

IoC**（Inverse of Controll控制反转）：指的是对象的创建方式进行了反转，传统的开发方式是程序员自己 new 对象，IoC就是将这一过程进行了反转，程序员不需要自己 new 对象，而是交给 IoC 容器来创建对象，程序员只需要使用这些对象即可。 控制反转的好处是**解耦合。将创建对象的控制权进行了反转，之前是直接 new 的，现在是接收工厂方法返回的对象，无法控制对象的创建，将对象创建的权力进行了反转，所以叫控制反转。

IOC创建对象的两种方式：

一、**基于XML**

1、创建一个 XML 文件，在文件中将程序中需要用的对象进行配置。

20210412215905675.png

2、加载 IoC 容器，Spring 框架会自动读取 XML 文件，根据 XML 的配置，自动创建各种对象，放入到缓冲池中。

20210412215920403.png

3、开发者只需要根据需求从缓冲池中取出相应对象使用即可。

20210412215952467.png

二、**基于注解**

基于注解的方式和基于 XML 的方式原理是相通的，只不过换了一种形式来处理。

1、在需要注入的 IoC 的类处添加注解，标注一下，告诉Spring 框架，这个类是需要注入的 bean。默认是根据容器中的类型去加载。

方式一：20210412220057339.png20210412220206244.png

方式二：20210412220227291.png2021041222025365.png

2、加载 IoC 容器，Spring 框架会自动读取到所有添加了注解的类，通过反射机制创建 bean，注入到 IoC 容器中，指定要扫描的包。

20210412220310859.png

3、开发者从 IoC 容器中取出需要的 bean。

20210412220333843.png

基于注解的方式，类默认的 id 是类名的首字母小写，User —> user，如果要修改 id，只需要给@Component 注解添加 value 属性即可，属性值就是新的 id 值。

Spring IoC的核心源码原理：

一、基于 XML

1、IoC 容器加载的时候，会自动读取spring.xml。

2、通过 XML 解析，获取到目标数据。

3、通过反射机制，创建目标 bean。

4、将这些 bean 注入到 IoC 缓存中，以 key-value 的形式进行存储。

  1.   5、开发者只需要通过 key/Class 从缓存中取出 bean 使用即可。

二、基于注解

1、IoC 容器加载的时候，要遍历指定包名下的所有类。

2、判断这些类是否添加了@Component，把所有添加了@Component 注解的类进行数据收集（beanId、className），存入集合中。

3、将集合传递给下一个单元，遍历这个集合，获取目标数据。

4、通过反射机制，创建目标 bean。

5、将这些 bean 注入到 IoC 缓存中，以 key-value 的形式进行存储。

6、开发者只需要通过 key/Class 从缓存中取出 bean 使用即可。

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70

首先在指定给目标包中添加注解，然后启动ioc容器，找到添加的注解类，获取类上面的id和class信息然后封装成一个对象，每一个对象用BeanDefinition表示，把每一个BeanDefinition放入BeanDefinitions集合，解析这个集合，遍历每一个元素，拿到每一个id根据class创建对象，最后把对象放入cache中，把id作为key存放进去。

手写一个SpringIoc容器：

步骤：

  1. /**
  2.  * 1、自定义一个AnnotationConfigApplicationContext，构造器中传入目标包。
  3.  * 2、获取这个包下的所有类。
  4.  * 3、遍历这些类，找出添加了 @Component 注解的类，获取对应的 beanName，beanClass，封装成一个BeanDefinition 对象，存入 Set 集合，这些就是 IoC 自动装载的原材料。
  5.  * 4、遍历 Set 集合，通过反射机制创建对象，同时检测属性是否有 @Value 注解，有的话就赋值，没有就不赋值。
  6.  * 5、将上面创建的 bean 以 k-v 的形式存入 cache Map
  7.  * 6、提供 getBean 方法，通过 beanName 从缓存区取出对应的 bean
  8.  */

使用Maven进行创建：

pom.xml文件，引入lombok和jdk版本号

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.projectlombok</groupId>
  4.         <artifactId>lombok</artifactId>
  5.         <version>1.18.12</version>
  6.     </dependency>
  7. </dependencies>
  9. <build>
  10.     <plugins>
  11.         <plugin>
  12.             <groupId>org.apache.maven.plugins</groupId>
  13.             <artifactId>maven-compiler-plugin</artifactId>
  14.             <version>3.8.1</version>
  15.             <configuration>
  16.                 <source>1.8</source>
  17.                 <target>1.8</target>
  18.             </configuration>
  19.         </plugin>
  20.     </plugins>
  21. </build>

创建所需的标注类：

  1. Component.java
  3. // 标注在类上定义的注解
  4. @Target(ElementType.TYPE)
  5. @Retention(RetentionPolicy.RUNTIME)
  6. public @interface Component {
  7.     String value() default "";
  8. }
  10. Autowired.java
  12. // 标注在属性上的注解，按照类型自动注入
  13. @Target(ElementType.FIELD)
  14. @Retention(RetentionPolicy.RUNTIME)
  15. public @interface Autowired {}
  17. Qualifier.java
  19. // 标注在属性上的注解，按照名称注入
  20. @Target(ElementType.FIELD)
  21. @Retention(RetentionPolicy.RUNTIME)
  22. public @interface Qualifier {
  23.     String value();
  24. }
  26. Value.java
  28. // 标注在属性上的注解，用于给属性赋值
  29. @Target(ElementType.FIELD)
  30. @Retention(RetentionPolicy.RUNTIME)
  31. public @interface Value {
  32.     String value();
  33. }

创建BeanDefinition包装类

  1. // 用于包装注解类的id和class
  2. @Data
  3. @AllArgsConstructor
  4. public class BeanDefinition {
  5.     private String beanName;
  6.     private Class beanClass;
  7. }

核心类：ioc容器入口

  1. AnnotationConfigApplicationContext.java
  3. public class AnnotationConfigApplicationContext {
  5.     // 用来存储创建好的bean
  6.     private Map<String,Object> cache = new HashMap<>();
  8.     public AnnotationConfigApplicationContext(String basePackage){
  9.         //遍历包，找到目标类
  10.         Set<BeanDefinition> beanDefinitions = findBeanDefinition(basePackage);
  11.         //根据原料创建bean
  12.         createObject(beanDefinitions);
  13.         //自动装载
  14.         autowiredObject(beanDefinitions);
  15.     }
  17.     /**
  18.      * 遍历包，找到目标类
  19.      * @param basePackage 要扫描的包路径
  20.      * @return 返回包装好的类
  21.      */
  22.     private Set<BeanDefinition> findBeanDefinition(String basePackage) {
  23.         // 获取包下的所有Class
  24.         Set<Class<?>> classes = MyUtil.getClasses(basePackage);
  25.         // 遍历集合
  26.         Iterator<Class<?>> iterator = classes.iterator();
  27.         // 用来存放包装好的BeanDefinition
  28.         Set<BeanDefinition> set = new HashSet<>();
  29.         while (iterator.hasNext()){
  30.             Class<?> clazz = iterator.next();
  31.             // 判断该类是否添加了@Component注解
  32.             Component component = clazz.getAnnotation(Component.class);
  33.             if(component!=null){
  34.                 // 获取注解上的值
  35.                 String beanName = component.value();
  36.                 if ("".equals(beanName)){
  37.                     // 注解值为空，自动给这个bean取一个名字，默认类名首字母小写
  38.                     String packageName = clazz.getPackage().getName();
  39.                     String className = clazz.getName();
  40.                     beanName = className.replace(packageName+".","");
  41.                     beanName = beanName.substring(0,1).toLowerCase()+beanName.substring(1);
  42.                 }
  43.                 // 添加到集合
  44.                 set.add(new BeanDefinition(beanName,clazz));
  45.             }
  46.         }
  47.         return set;
  48.     }
  50.     /**
  51.      * 创建bean对象
  52.      * @param beanDefinitions 包装好的beanDefinitions
  53.      */
  54.     private void createObject(Set<BeanDefinition> beanDefinitions) {
  55.         // 遍历集合
  56.         Iterator<BeanDefinition> iterator = beanDefinitions.iterator();
  57.         while (iterator.hasNext()) {
  58.             BeanDefinition beanDefinition = iterator.next();
  59.             try {
  60.                 // 获取beanClass信息
  61.                 Class beanClass = beanDefinition.getBeanClass();
  62.                 // 创建当前bean的实例
  63.                 Object instance = beanClass.getConstructor(null).newInstance(null);
  64.                 // 给属性赋值
  65.                 Field[] fields = beanClass.getDeclaredFields();
  66.                 for (Field field : fields) {
  67.                     // 判断当前属性是否添加了@Value注解
  68.                     Value fieldAnnotation = field.getAnnotation(Value.class);
  69.                     if(fieldAnnotation!=null){
  70.                         // 有@Value注解，给当前属性赋值
  71.                         // 获取注解上的值
  72.                         String value = fieldAnnotation.value();
  73.                         // 获得属性名字，并找到给当前属性赋值的方法setXxx()
  74.                         String fieldName = field.getName();
  75.                         String methodName = "set"+fieldName.substring(0,1).toUpperCase()+fieldName.substring(1);
  76.                         Method method = beanClass.getMethod(methodName, field.getType());
  77.                         // 得到属性的类型
  78.                         String name = field.getType().getName();
  79.                         Object val = null;
  80.                         switch (name){
  81.                             case "java.lang.Integer":
  82.                                 val = Integer.parseInt(value);
  83.                                 break;
  84.                             case "java.lang.String":
  85.                                 val = value;
  86.                                 break;
  87.                             case "java.lang.Double":
  88.                                 val = Double.parseDouble(value);
  89.                                 break;
  90.                         }
  91.                         // 通过反射给当前属性赋值
  92.                         method.invoke(instance,val);
  93.                     }
  94.                 }
  95.                 // 并将创建好的bean放在缓存中
  96.                 cache.put(beanDefinition.getBeanName(),instance);
  97.             } catch (InstantiationException e) {
  98.                 e.printStackTrace();
  99.             } catch (IllegalAccessException e) {
  100.                 e.printStackTrace();
  101.             } catch (InvocationTargetException e) {
  102.                 e.printStackTrace();
  103.             } catch (NoSuchMethodException e) {
  104.                 e.printStackTrace();
  105.             }
  106.         }
  107.     }
  109.     /**
  110.      * 自动装载
  111.      * @param beanDefinitions 包装好的beanDefinitions
  112.      */
  113.     private void autowiredObject(Set<BeanDefinition> beanDefinitions) {
  114.         // 遍历集合
  115.         Iterator<BeanDefinition> iterator = beanDefinitions.iterator();
  116.         while (iterator.hasNext()) {
  117.             BeanDefinition beanDefinition = iterator.next();
  118.             // 获得当前的类信息
  119.             Class beanClass = beanDefinition.getBeanClass();
  120.             // 获得当前类的所有属性，并遍历它
  121.             Field[] fields = beanClass.getDeclaredFields();
  122.             for (Field field : fields) {
  123.                 // 判断该属性上是否添加了@Autowired注解
  124.                 Autowired autowired = field.getAnnotation(Autowired.class);
  125.                 if(autowired!=null){
  126.                     // 判断该属性上是否添加了@Qualifier注解
  127.                     Qualifier qualifier = field.getAnnotation(Qualifier.class);
  128.                     if(qualifier!=null){
  129.                         // 根据名字进行装载
  130.                         try {
  131.                             // 获取@Qualifier注解上的value值
  132.                             String value = qualifier.value();
  133.                             // 得到缓存中的bean对象
  134.                             Object obj = cache.get(value);
  135.                             Object bean = cache.get(beanDefinition.getBeanName());
  136.                             // 找到要注入的方法setXxx()
  137.                             String name = field.getName();
  138.                             String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);
  139.                             Method method = beanClass.getMethod(methodName, field.getType());
  140.                             // 通过反射注入对象
  141.                             method.invoke(bean,obj);
  142.                         } catch (NoSuchMethodException e) {
  143.                             e.printStackTrace();
  144.                         } catch (IllegalAccessException e) {
  145.                             e.printStackTrace();
  146.                         } catch (InvocationTargetException e) {
  147.                             e.printStackTrace();
  148.                         }
  149.                     } else {
  150.                         // 根据类型进行装载
  151.                         try {
  152.                             // 找到当前对象的类名字，首字母小写
  153.                             Class<?> clazz = field.getType();
  154.                             String packageName = clazz.getPackage().getName();
  155.                             String className = clazz.getName();
  156.                             className = className.replace(packageName+".","");
  157.                             className = className.substring(0,1).toLowerCase()+className.substring(1);
  158.                             // 去缓存中获取bean对象
  159.                             Object obj = cache.get(className);
  160.                             Object bean = cache.get(beanDefinition.getBeanName());
  161.                             // 找到要注入的方法setXxx()
  162.                             String name = field.getName();
  163.                             String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);
  164.                             Method method = beanClass.getMethod(methodName, field.getType());
  165.                             // 通过反射注入对象
  166.                             method.invoke(bean,obj);
  167.                         } catch (NoSuchMethodException e) {
  168.                             e.printStackTrace();
  169.                         } catch (IllegalAccessException e) {
  170.                             e.printStackTrace();
  171.                         } catch (InvocationTargetException e) {
  172.                             e.printStackTrace();
  173.                         }
  174.                     }
  175.                 }
  176.             }
  177.         }
  178.     }
  180.     /**
  181.      * 通过name获取bean
  182.      * @param beanName
  183.      * @return
  184.      */
  185.     public Object getBean(String beanName){
  186.         return cache.get(beanName);
  187.     }
  188. }

工具类：

  1. MyUtil.java
  3. public class MyUtil {
  5.     public static Set<Class<?>> getClasses(String pack) {
  6.         // 第一个class类的集合
  7.         Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
  8.         // 是否循环迭代
  9.         boolean recursive = true;
  10.         // 获取包的名字 并进行替换
  11.         String packageName = pack;
  12.         String packageDirName = packageName.replace('.', '/');
  13.         // 定义一个枚举的集合 并进行循环来处理这个目录下的things
  14.         Enumeration<URL> dirs;
  15.         try {
  16.             dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
  17.             // 循环迭代下去
  18.             while (dirs.hasMoreElements()) {
  19.                 // 获取下一个元素
  20.                 URL url = dirs.nextElement();
  21.                 // 得到协议的名称
  22.                 String protocol = url.getProtocol();
  23.                 // 如果是以文件的形式保存在服务器上
  24.                 if ("file".equals(protocol)) {
  25.                     // 获取包的物理路径
  26.                     String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
  27.                     // 以文件的方式扫描整个包下的文件 并添加到集合中
  28.                     findClassesInPackageByFile(packageName, filePath, recursive, classes);
  29.                 } else if ("jar".equals(protocol)) {
  30.                     // 如果是jar包文件
  31.                     // 定义一个JarFile
  32.                     System.out.println("jar类型的扫描");
  33.                     JarFile jar;
  34.                     try {
  35.                         // 获取jar
  36.                         jar = ((JarURLConnection) url.openConnection()).getJarFile();
  37.                         // 从此jar包 得到一个枚举类
  38.                         Enumeration<JarEntry> entries = jar.entries();
  39.                         findClassesInPackageByJar(packageName, entries, packageDirName, recursive, classes);
  40.                     } catch (IOException e) {
  41.                         // log.error("在扫描用户定义视图时从jar包获取文件出错");
  42.                         e.printStackTrace();
  43.                     }
  44.                 }
  45.             }
  46.         } catch (IOException e) {
  47.             e.printStackTrace();
  48.         }
  49.         return classes;
  50.     }
  52.     private static void findClassesInPackageByJar(String packageName, Enumeration<JarEntry> entries, String packageDirName, final boolean recursive, Set<Class<?>> classes) {
  53.         // 同样的进行循环迭代
  54.         while (entries.hasMoreElements()) {
  55.             // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
  56.             JarEntry entry = entries.nextElement();
  57.             String name = entry.getName();
  58.             // 如果是以/开头的
  59.             if (name.charAt(0) == '/') {
  60.                 // 获取后面的字符串
  61.                 name = name.substring(1);
  62.             }
  63.             // 如果前半部分和定义的包名相同
  64.             if (name.startsWith(packageDirName)) {
  65.                 int idx = name.lastIndexOf('/');
  66.                 // 如果以"/"结尾 是一个包
  67.                 if (idx != -1) {
  68.                     // 获取包名 把"/"替换成"."
  69.                     packageName = name.substring(0, idx).replace('/', '.');
  70.                 }
  71.                 // 如果可以迭代下去 并且是一个包
  72.                 if ((idx != -1) || recursive) {
  73.                     // 如果是一个.class文件 而且不是目录
  74.                     if (name.endsWith(".class") && !entry.isDirectory()) {
  75.                         // 去掉后面的".class" 获取真正的类名
  76.                         String className = name.substring(packageName.length() + 1, name.length() - 6);
  77.                         try {
  78.                             // 添加到classes
  79.                             classes.add(Class.forName(packageName + '.' + className));
  80.                         } catch (ClassNotFoundException e) {
  81.                             // .error("添加用户自定义视图类错误 找不到此类的.class文件");
  82.                             e.printStackTrace();
  83.                         }
  84.                     }
  85.                 }
  86.             }
  87.         }
  88.     }
  90.     private static void findClassesInPackageByFile(String packageName, String packagePath, final boolean recursive, Set<Class<?>> classes) {
  91.         // 获取此包的目录 建立一个File
  92.         File dir = new File(packagePath);
  93.         // 如果不存在或者 也不是目录就直接返回
  94.         if (!dir.exists() || !dir.isDirectory()) {
  95.             // log.warn("用户定义包名 " + packageName + " 下没有任何文件");
  96.             return;
  97.         }
  98.         // 如果存在 就获取包下的所有文件 包括目录
  99.         File[] dirfiles = dir.listFiles(new FileFilter() {
  100.             // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
  101.             @Override
  102.             public boolean accept(File file) {
  103.                 return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
  104.             }
  105.         });
  106.         // 循环所有文件
  107.         for (File file : dirfiles) {
  108.             // 如果是目录 则继续扫描
  109.             if (file.isDirectory()) {
  110.                 findClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive, classes);
  111.             } else {
  112.                 // 如果是java类文件 去掉后面的.class 只留下类名
  113.                 String className = file.getName().substring(0, file.getName().length() - 6);
  114.                 try {
  115.                     // 添加到集合中去
  116.                     // classes.add(Class.forName(packageName + '.' +
  117.                     // className));
  118.                     classes.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
  119.                 } catch (ClassNotFoundException e) {
  120.                     // log.error("添加用户自定义视图类错误 找不到此类的.class文件");
  121.                     e.printStackTrace();
  122.                 }
  123.             }
  124.         }
  125.     }
  126. }

测试用的实体类：Student.java和Class.java类

  1. @Data
  2. @Component("stu")
  3. public class Student {
  4.     @Value("2021100101")
  5.     private Integer sid;
  6.     @Value("张三")
  7.     private String name;
  8.     @Value("男")
  9.     private String sex;
  10.     @Autowired
  11.     @Qualifier("cls")
  12.     private Class clazz;
  13. }
  15. @Data
  16. @Component("cls")
  17. public class Class {
  18.     @Value("1001")
  19.     private Integer cid;
  20.     @Value("精英班")
  21.     private String className;
  22. }

测试：

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         AnnotationConfigApplicationContext ioc = new AnnotationConfigApplicationContext("com.raylei.entity");
  4.         System.out.println(ioc.getBean("stu"));
  5.     }
  6. }

结果：

20210412221748443.png

GitHub：https://github.com/Mr-LeiLei/MySpringIoc

CSDN：https://download.csdn.net/download/qq_36942720/16640502

发表评论

表情：
评论列表 （有 0 条评论，334人围观）

还没有评论，来说两句吧...

相关阅读

    相关 一步一步实现优雅重试

    重试的作用 对于重试是有场景限制的，不是什么场景都适合重试，比如参数校验不合法、写操作等（要考虑写是否幂等）都不适合重试。 远程调用超时、网络突然中断可以重试。在微服务

    超、凢脫俗超、凢脫俗/ 0 赞/ 102 阅读

    相关 一步一步实现SpringIoc容器

    IoC（Inverse of Controll控制反转）：指的是对象的创建方式进行了反转，传统的开发方式是程序员自己 new 对象，IoC就是将这一过程进行了反转，程序员不需要

    男娘i男娘i/ 0 赞/ 335 阅读

    相关 一步一步地配置Spring

    本文旨在从一个空工程一步一步地配置Spring，空工程见上一篇文章[创建Maven父子工程][Maven]。 \\一、spring基本配置 \\\1. 添加spring依赖

    亦凉亦凉/ 0 赞/ 417 阅读