Spring 核心源码

1.Servlet

1.1

导入Servlet依赖，将Maven的JDK版本改为8，且将Maven打包方式改为war

  1. <dependency>
  2.     <groupId>javax.servlet</groupId>
  3.     <artifactId>javax.servlet-api</artifactId>
  4.     <version>4.0.1</version>
  5. </dependency>
  1. <build>
  2.     <!--    MAVEN默认JDK5,手动改为JDK8-->
  3.     <plugins>
  4.         <plugin>
  5.             <groupId>org.apache.maven.plugins</groupId>
  6.             <artifactId>maven-compiler-plugin</artifactId>
  7.             <version>3.8.1</version>
  8.             <configuration>
  9.                 <source>1.8</source>
  10.                 <target>1.8</target>
  11.                 <encoding>UTF-8</encoding>
  12.             </configuration>
  13.         </plugin>
  14.     </plugins>
  15. </build>
  1. <packaging>war</packaging>

1.2 创建一个Servlet对象

  1. package com.william.servlet;
  3. import javax.servlet.ServletException;
  4. import javax.servlet.annotation.WebServlet;
  5. import javax.servlet.http.HttpServlet;
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletResponse;
  8. import java.io.IOException;
  10. @WebServlet("/hello")
  11. public class HellowServlet extends HttpServlet {
  12.     @Override
  13.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  14.         resp.getWriter().print("Spring");
  15.     }
  16. }

1.3 部署到Tomcat

SpringIoC源码 - 图1

1.4 创建三层架构，并逐层注入

1.5 创建静态工厂类

为了实现解耦合，创建工厂，将创建对象的事情交给工厂，便于维护

  1. package com.william.factory;
  3. import com.william.dao.HellowDao;
  4. import com.william.dao.impl.HellowDaoImpl;
  6. public class BeanFactory {
  7.     public static HellowDao getDao() {
  8.         return new HellowDaoImpl();
  9.     }
  10. }

1.6 实例从工厂获取

  1. // private HellowDao hellowDao =  new HellowDaoImpl();
  2.  private HellowDao hellowDao = BeanFactory.getDao();

1.7 配置文件

工厂中的代码在业务变更的时候还是需要修改，进一步优化为实现类写到配置文件中

  1. 定义一个外部的配置properties文件
  1. helloDao=com.william.dao.impl.HellowDaoImpl
  1. 用java读取配置文件
  1. package com.william.factory;
  3. import com.william.dao.impl.HellowDaoImpl;
  5. import java.io.IOException;
  6. import java.lang.reflect.InvocationTargetException;
  7. import java.util.Properties;
  9. public class BeanFactory {
  11.     private static Properties properties;
  13.     static {
  14.         properties = new Properties();
  15.         try {
  16.             //通过反射，读取配置文件
  17.             properties.load(BeanFactory.class.getClassLoader().getResourceAsStream("factory.properties"));
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         }
  21.     }
  24.     public static Object getDao() {
  25.         //读取到配置文件中的属性
  26.         String value = properties.getProperty("helloDao");
  28.         //反射机制创建对象
  29.         try {
  30.             Class clazz = Class.forName(value);
  31.             Object object = clazz.getConstructor(null).newInstance(null);
  32.             return object;
  34.         } catch (ClassNotFoundException e) {
  35.             e.printStackTrace();
  36.         } catch (InstantiationException e) {
  37.             e.printStackTrace();
  38.         } catch (IllegalAccessException e) {
  39.             e.printStackTrace();
  40.         } catch (InvocationTargetException e) {
  41.             e.printStackTrace();
  42.         } catch (NoSuchMethodException e) {
  43.             e.printStackTrace();
  44.         }
  45.         return null;
  46.     }
  47. }

如果实体类变更，只需修改配置文件factory.properties中的路径

1.8 缓存实现单例

  1. private static Map<String, Object> cache = new HashMap<>();
  1. //判断缓存中是否存在bean
  2. if (!cache.containsKey(beanName))

1.9 保证多线程下单例

  1. public static Object getDao(String beanName) {
  2.     //判断缓存中是否存在bean
  3.     if (!cache.containsKey(beanName)) {
  4.         //加锁
  5.         synchronized (BeanFactory.class) {
  6.             if (!cache.containsKey(beanName)) {
  7.                 //    将bean存入缓存
  8.                 //反射机制创建对象
  9.                 try {
  10.                     //读取到配置文件中的属性
  11.                     String value = properties.getProperty(beanName);
  12.                     Class clazz = Class.forName(value);
  13.                     Object object = clazz.getConstructor(null).newInstance(null);
  14.                     cache.put(beanName, object);
  15.                 } catch (ClassNotFoundException e) {
  16.                     e.printStackTrace();
  17.                 } catch (InstantiationException e) {
  18.                     e.printStackTrace();
  19.                 } catch (IllegalAccessException e) {
  20.                     e.printStackTrace();
  21.                 } catch (InvocationTargetException e) {
  22.                     e.printStackTrace();
  23.                 } catch (NoSuchMethodException e) {
  24.                     e.printStackTrace();
  25.                 }
  26.             }
  27.         }
  28.     }
  29.     return cache.get(beanName);
  30. }

2.Spring IoC 的使用

XML方式已经被淘汰，现主要考虑注解的方式

2.1 导入SpringFramework依赖

  1. <dependency>
  2.     <groupId>org.springframework</groupId>
  3.     <artifactId>spring-context</artifactId>
  4.     <version>5.3.3</version>
  5. </dependency>
  1. package com.william.spring.entity;
  3. import lombok.Data;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.beans.factory.annotation.Value;
  6. import org.springframework.stereotype.Component;
  8. @Data
  9. @Component
  10. public class Account {
  11.     @Value("20193818")
  12.     private Integer id;
  13.     @Value("william")
  14.     private String name;
  15.     @Value("20")
  16.     private Integer age;
  18.     @Autowired
  19.     private Order order;
  20. }
  1. package com.william.spring.entity;
  3. import lombok.Data;
  4. import org.springframework.beans.factory.annotation.Value;
  5. import org.springframework.stereotype.Component;
  7. @Component
  8. @Data
  9. public class Order {
  11.     @Value("123")
  12.     private Integer orderId;
  14.     @Value("1000.0")
  15.     private Float price;
  17. }
  1. package com.william.spring.test;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  6. public class Test {
  7.     public static void main(String[] args) {
  8.         //加载IoC容器
  9.         ApplicationContext applicationContext = new AnnotationConfigApplicationContext("com.william.spring.entity");
  10.         System.out.println(applicationContext.getBean("account"));
  11.     }
  12. }

3. IoC基于注解的执行原理

IoC组件

  • 扫描包的组件
    • 扫描所有添加了注解的目标类
  • 获取原材料的组件
    • 通过Class反射获取目标类
    • 通过beanName注入IoC
  • 根据原材料创建bean并以key-value的方式放入IoC

4. 手写IoC容器

4.1 思路

  1. 自定义一个MyAnnotationConfigApplicationContext，构造器中传入要扫描的包名
  2. 获取包下的所有类
  3. 遍历这些类，找出添加了@Component注解的类，获取其Class和对应的beanName，封装成BeanDefinition对象，存入集合Set(保证单例)，这个集合即为IoC自动装载的原材料
  4. 遍历Set集合，根据原材料创建bean，还需检测属性有无@Value注解，如果有还需给属性赋值，后以k-v的方式存入缓存区
  5. 提供getBean方法，通过beanName得到bean

4.2 代码实现

  1. 先创建一个BeanDefinition对象
  1. package com.william.mySpring;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  6. @Data
  7. @AllArgsConstructor
  8. public class BeanDefinition {
  9.     private String beanName;
  10.     private Class beanClass;
  11. }
  1. 创建注解
  1. package com.william.mySpring;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  8. @Target(ElementType.TYPE)
  9. @Retention(RetentionPolicy.RUNTIME)
  10. public @interface Component {
  11.     String value() default "";
  12. }
  1. package com.william.mySpring;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  8. @Target(ElementType.FIELD)
  9. @Retention(RetentionPolicy.RUNTIME)
  10. public @interface Value {
  11.     String value();
  12. }
  1. 设计一个工具类，能够遍历包下的所有类，返回一个集合
    ```java package com.william.mySpring;

import java.io.File; import java.io.FileFilter; import java.io.IOException; import java.net.JarURLConnection; import java.net.URL; import java.net.URLDecoder; import java.util.Enumeration; import java.util.LinkedHashSet; import java.util.Set; import java.util.jar.JarEntry; import java.util.jar.JarFile;

public class MyTools {

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

}

  2. 4.  创建MyAnnotationConfigApplicationContext类，实现将所有目标类封装成beanDefinition的集合并返回的方法，后创建bean，且根据@Value注解给属性赋值，根据@Autowired和@Qualifier实现给对象类型的属性从容器中获取值，最后注入容器 
  4. ```java
  5. package com.william.mySpring;
  7. import java.lang.reflect.Field;
  8. import java.lang.reflect.InvocationTargetException;
  9. import java.lang.reflect.Method;
  10. import java.util.*;
  12. public class MyAnnotationConfigApplicationContext {
  13.     private Map<String, Object> ioc = new HashMap<>();
  15.     public Object getBean(String beanName) {
  16.         return ioc.get(beanName);
  17.     }
  19.     public MyAnnotationConfigApplicationContext(String pack) {
  20.         //    遍历包，找到所有目标类，并封装成beanDefinition
  21.         Set<BeanDefinition> beanDefinitions = findBeanDefinitions(pack);
  22.         // 根据原材料创建bean
  23.         creatObject(beanDefinitions);
  24.         //    自动装载
  25.         autowiredObject(beanDefinitions);
  26.     }
  28.     private void autowiredObject(Set<BeanDefinition> beanDefinitions) {
  29.         Iterator<BeanDefinition> iterator = beanDefinitions.iterator();
  30.         while (iterator.hasNext()) {
  31.             BeanDefinition beanDefinition = iterator.next();
  32.             Class beanClass = beanDefinition.getBeanClass();
  33.             Field[] declaredFields = beanClass.getDeclaredFields();
  34.             for (Field declaredField : declaredFields) {
  35.                 Autowired annotation = declaredField.getAnnotation(Autowired.class);
  36.                 if (annotation != null) {
  37.                     Qualifier qualifier = declaredField.getAnnotation(Qualifier.class);
  38.                     if (qualifier != null) {
  39.                         // byName
  40.                         try {
  41.                             String beanName = qualifier.value();
  42.                             Object bean = getBean(beanName);
  43.                             String fieldName = declaredField.getName();
  44.                             String setter = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
  45.                             Method method = beanClass.getMethod(setter, declaredField.getType());
  46.                             Object object = getBean(beanDefinition.getBeanName());
  47.                             method.invoke(object, bean);
  48.                         } catch (NoSuchMethodException e) {
  49.                             e.printStackTrace();
  50.                         } catch (IllegalAccessException e) {
  51.                             e.printStackTrace();
  52.                         } catch (InvocationTargetException e) {
  53.                             e.printStackTrace();
  54.                         }
  55.                     } else {
  56.                         // byType
  57.                         try {
  58.                             String typeName = declaredField.getType().getName();
  59.                             String beanName = typeName.replaceAll(declaredField.getType().getPackage().getName() + ".", "");
  60.                             beanName = beanName.substring(0, 1).toLowerCase() + beanName.substring(1);
  61.                             Object bean = getBean(beanName);
  62.                             String fieldName = declaredField.getName();
  63.                             String setter = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
  64.                             Method method = beanClass.getMethod(setter, declaredField.getType());
  65.                             Object object = getBean(beanDefinition.getBeanName());
  66.                             method.invoke(object, bean);
  67.                         } catch (NoSuchMethodException e) {
  68.                             e.printStackTrace();
  69.                         } catch (IllegalAccessException e) {
  70.                             e.printStackTrace();
  71.                         } catch (InvocationTargetException e) {
  72.                             e.printStackTrace();
  73.                         }
  74.                     }
  75.                 }
  76.             }
  77.         }
  78.     }
  80.     /**
  81.      * 创建bean并且注入到IoC
  82.      *
  83.      * @param beanDefinitions
  84.      */
  85.     public void creatObject(Set<BeanDefinition> beanDefinitions) {
  86.         Iterator<BeanDefinition> iterator = beanDefinitions.iterator();
  87.         while (iterator.hasNext()) {
  88.             BeanDefinition beanDefinition = iterator.next();
  89.             Class beanClass = beanDefinition.getBeanClass();
  90.             String beanName = beanDefinition.getBeanName();
  91.             try {
  92.                 Object instance = beanClass.getConstructor().newInstance();
  93.                 //根据@Value给成员变量赋值
  94.                 Field[] declaredFields = beanClass.getDeclaredFields();
  95.                 for (Field declaredField : declaredFields) {
  96.                     Value annotationVar = declaredField.getAnnotation(Value.class);
  97.                     if (annotationVar != null) {
  98.                         //获取注解的值并完成类型转换
  99.                         String value = annotationVar.value();
  100.                         Object val = null;
  101.                         switch (declaredField.getType().getName()) {
  102.                             case "java.lang.Integer":
  103.                                 val = Integer.parseInt(value);
  104.                                 break;
  105.                             case "java.lang.String":
  106.                                 val = value;
  107.                                 break;
  108.                             case "java.lang.Float":
  109.                                 val = Float.parseFloat(value);
  110.                                 break;
  111.                         }
  113.                         String fieldName = declaredField.getName();
  114.                         String setterName = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
  115.                         Method method = beanClass.getMethod(setterName, declaredField.getType());
  116.                         method.invoke(instance, val);
  117.                     }
  118.                 }
  121.                 ioc.put(beanName, instance);
  122.             } catch (InstantiationException e) {
  123.                 e.printStackTrace();
  124.             } catch (InvocationTargetException e) {
  125.                 e.printStackTrace();
  126.             } catch (NoSuchMethodException e) {
  127.                 e.printStackTrace();
  128.             } catch (IllegalAccessException e) {
  129.                 e.printStackTrace();
  130.             }
  131.         }
  132.     }
  134.     /**
  135.      * 将包下的所有类扫描，将带有@Component注解的类封装成BeanDefinition对象放入集合返回
  136.      *
  137.      * @param pack
  138.      * @return
  139.      */
  140.     public Set<BeanDefinition> findBeanDefinitions(String pack) {
  141.         // 1. 获取包下所有类
  142.         Set<Class<?>> classes = MyTools.getClasses(pack);
  143.         Iterator<Class<?>> iterator = classes.iterator();
  144.         Set<BeanDefinition> beanDefinitions = new HashSet<>();
  145.         while (iterator.hasNext()) {
  146.             // 2. 遍历这些类找到添加了@Component的类
  147.             Class<?> clazz = iterator.next();
  148.             Component componentAnnotation = clazz.getAnnotation(Component.class);
  149.             if (componentAnnotation != null) {
  150.                 //    如果添加了@Component，则获取component的value作为beanName
  151.                 String beanName = componentAnnotation.value();
  152.                 // 如果component的value为空，则将类名的首字母小写形式作为beanName
  153.                 if ("".equals(beanName)) {
  154.                     String className = clazz.getName().replaceAll(clazz.getPackage().getName() + ".", "");
  155.                     beanName = className.substring(0, 1).toLowerCase() + className.substring(1);
  156.                 }
  157.                 // 3. 将这些类封装成BeanDefinition，装载到Set中
  158.                 beanDefinitions.add(new BeanDefinition(beanName, clazz));
  159.             }
  160.         }
  161.         return beanDefinitions;
  162.     }
  163. }