spring之IOC模拟实现

使用Spring框架已经有很长时间了，一直没有仔细的想过框架的设计思想是什么样的，底层到底是怎么实现的，这几天调试程序看了些源码，写下来做个记录。由于Spring框架博大精深，个人理解的难免有不正确的地方，希望看到的朋友可以指正，不胜感激。

一 什么是IOC

IOC是Inversion of Control的缩写，即就是所谓的控制反转，它是一种设计思想，主要包含IOC和DI两方面的内容。

IOC：不使用spring框架的时候，当我们需要一个java类对象时，我们需要手动的去创建管理这些对象。使用spring时，我们只把所有的对象同意存放在IOC容器中，要用某个类对象的时候不再需要我们去创建并管理它，完全交给spring做统一管理。

DI：依赖注入，在类加载时从外网里执行，遇到需要的对象时直接去IOC容器中获取，然后赋值给当前注入的类。

二 模拟实现

我们先创建一个项目。要把对象交给容器管理，我们就需要告诉它去管理哪些对象，所以在classpath下创建一个application.properties文件，并配置要交给容器的文件。如下表示我们要把basePackage路径（包含子目录）下的class文件都交给容器管理。

basePackage=org.wl.test.demo

创建注解类，用来标记需要被加载到IOC容器中

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

     String value() default "";

 }

 @Target(ElementType.FIELD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Autowired {

     String value() default "";

 }

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

    String value() default "";

}

 @Target(ElementType.FIELD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Qualifier {

     String value() default "";

 }

创建controller和接口类及接口的实现类，并加入对应的注解

 @Controller
 public class UserController {

     @Autowired
     private UserService userService;

     /**
      * 接口可能会有多个实现类，所以在注入接口时必须用Autowired或者Qualifier指定具体的实现类
      */
     @Autowired
     @Qualifier("userService2")
     private IUserService userService2;

     public void save(){
         UserInfo user = new UserInfo();
         userService.saveUser(user);

         userService2.saveUser(user);
     }

 }

 public interface IUserService {

     /**
      * 保存用户信息
      * @param user
      */
     void saveUser(UserInfo user);

 }

 @Service
 public class UserService implements IUserService {
     @Override
     public void saveUser(UserInfo user) {
         System.out.println("实现类1 保存用户信息到数据库 " + user.toString());
     }
 }

 @Service
 public class UserService2 implements IUserService {
     @Override
     public void saveUser(UserInfo user) {
         System.out.println("实现类2 保存用户信息到数据库 " + user.toString());
     }
 }

创建一个ApplicationContext类，在此类完成相关的方法

 public class ApplicationContext {

     public ApplicationContext() {

     }

 }

解析配置文件中的配置信息，获取要扫描的包路径

 public String getBasePackage(String fileName) throws IOException {
         String basePackage;
         Properties prop = new Properties();
         InputStream in = this.getClass().getClassLoader().getResourceAsStream(fileName);
         prop.load(in);
         basePackage = prop.getProperty("basePackage");
         return basePackage;
     }

定义一个集合，存放在指定的扫描包及其子包中扫描到的class文件

 /**
      * 初始化一个集合，存放扫描到的class对象
      */
     private List<Class<?>> classList = Collections.synchronizedList(new ArrayList<>());

 /**
      * 跟据基础包名读取包及子包中的类对象
      * @param basePackage
      */
     public void scanClasses(String basePackage){
         if(basePackage == null || "".equals(basePackage)){return;}

         doScan(basePackage);
         System.out.println(classList);
     }

 private void doScan(String basePackage) {
         String path = basePackage.replaceAll("\\.","/");
         URL url = this.getClass().getClassLoader().getResource(path);
         File file = new File(url.getFile());
         file.listFiles(new FileFilter() {
             @Override
             public boolean accept(File childFile) {
                 String fileName = childFile.getName();
                 if(childFile.isDirectory()){
                     //当前文件是目录，递归 扫描下级子目录下的class文件
                     doScan(basePackage + "." + fileName);
                 }else{
                     if(fileName.endsWith(".class")){
                         String className = basePackage + "." + fileName.replace(".class", "");
                         try {
                             Class<?> clazz = this.getClass().getClassLoader().loadClass(className);
                             classList.add(clazz);
                         } catch (ClassNotFoundException e) {
                             e.printStackTrace();
                         }
                     }
                 }
                 return false;
             }
         });
     }

将扫描到的class对象中的使用了自定义的注解的类实例，存放到容器中

 /**
      * 初始化map 存放别名与对象实例
      */
     private Map<String, Object> aliasInstanceMap = new HashMap<>();

 /**
      * 完成别名与实例的映射
      */
     public void buildAliasInstanceMap(String basePackage) throws Exception {

         if(classList.size() == 0){return;}

         for(Class<?> clazz : classList){
             if (clazz.isAnnotationPresent(Controller.class) || clazz.isAnnotationPresent(Service.class)
                 || clazz.isAnnotationPresent(Autowired.class)) {
                 String alias = getAlias(clazz);
                 Object obj = aliasInstanceMap.get(alias);

                 //如果别名实例映射关系已经存在，则给出提示
                 if(obj != null){
                     throw new Exception("alias is exist!");
                 }else{
                     aliasInstanceMap.put(alias, clazz.newInstance());
                 }
             }
         }

         System.out.println(aliasInstanceMap);
     }

 /**
      * 获取对象的别名，如果注解中配置了别名，别使用配置的别名，否则默认使用类名首字母小写
      * @param clazz
      * @return
      */
     public String getAlias(Class<?> clazz){
         String alias = "";
         Controller controller = clazz.getAnnotation(Controller.class);
         if(controller != null){
             alias = controller.value();
         }
         Service service = clazz.getAnnotation(Service.class);
         if (service != null) {
             alias = service.value();
         }
         Autowired autowired = clazz.getAnnotation(Autowired.class);
         if(autowired != null){
             alias = autowired.value();
         }

         //注解中没有配置别名
         if("".equals(alias)){
             String simpleName = clazz.getSimpleName();
             alias = simpleName.substring(0, 1).toLowerCase() + simpleName.substring(1);
         }
         return alias;
     }

扫描类，根据类属性中使用了Autowired的类别名，从IOC容器中取得对应的实例赋值给属性类，就是完成依赖注入，

 /**
      * 属性对象的注入
      */
     public void doAutowired(){
         if (aliasInstanceMap.size() == 0) {
             return;
         }

         aliasInstanceMap.forEach((k, v)->{

             Field[] fields = v.getClass().getDeclaredFields();

             for(Field field : fields){
                 if (field.isAnnotationPresent(Autowired.class)) {
                     String alias = "";

                     Autowired autowired = field.getAnnotation(Autowired.class);
                     if(autowired != null){
                         //注入的对象是接口时，由于不知道接口有几个实现类，所以就必须在Autowired或者Qualifier上指定要注解的具体的实现类
                         if(!"".equals(autowired.value())){
                             alias = autowired.value();
                         }else{
                             Qualifier qualifier = field.getAnnotation(Qualifier.class);
                             if(qualifier != null){
                                 alias = qualifier.value();
                             }
                         }
                     }

                     if ("".equals(alias)) {
                         alias = getAlias(field.getType());
                     }

                     Object instance = null;
                     if(!"".equals(alias)){
                         instance = aliasInstanceMap.get(alias);
                     }

                     field.setAccessible(true);

                     try {
                         field.set(v, instance);
                     } catch (IllegalAccessException e) {
                         e.printStackTrace();
                     }
                 }

             }
         });

     }

至此我们就实现了IOC和DI，做测试

 public static void main(String[] args) throws Exception {
         String fileName = "application.properties";
         ApplicationContext context = new ApplicationContext();
         String basePackage = context.getBasePackage(fileName );
         context.scanClasses(basePackage);
         context.buildAliasInstanceMap(basePackage);
         context.doAutowired();
         //测试
         UserController controller = (UserController) context.getBean("userController");
         controller.save();
     }

 /**
      * 根据beanName 获取
      * @param beanName
      * @return
      */
     public Object getBean(String beanName){
         return aliasInstanceMap.get(beanName);
     }

执行main方法后，可以在控制台看到两个接口实现类打印的内容