利用递归，反射，注解等，手写Spring Ioc和Di 底层（分分钟喷倒面试官）了解一下

再我们现在项目中Spring框架是目前各大公司必不可少的技术，而大家都知道去怎么使用Spring ，但是有很多人都不知道SpringIoc底层是如何工作的，而一个开发人员知道他的源码，底层工作原理，对于我们对项目的理解是有非常大的帮助的，有可能工作了两三年的中级工程师，乃至四五年的，只知其然，却不知其所以然。我的一个盆友，今年年初以实习生的身份去北京面试，面试官让我的朋友说Spring源码，作为一个实习生，就要去知道Spring的源码。虽然我们可以不用知道，也可以做项目，但他会成为我们面试结果的绊脚石，

而各个公司面试喜欢提问都是Spring的原理，底层，源码。而看了今天的文章，再去面试我们就不用怕了。

当面试官问我们，了解Spring吗，我们回答，了解而且对Ioc还很深入，这时候，面试官的兴趣一下子就被你勾引了，心想，一个小菜鸟居然敢说听深入，他必会让你讲，殊不知他已经上当了，这时候我们给他来一手手写SpringIoc和Di的工作原理，而把这些都写完，解释完，怎么的也得半个多小时过去了，而面试官不会去花太多时间去面试一个人，甚至有可能你把这个问题说完，随便问几句，直接就录用你了，（因为面试官都有可能都知道他底层的工作原理）这样即使面试官百分之八十就会高看我们一眼，起始的薪资呢，也不会低。

进入正题：一张图就可以看出我们的整体结构。是用MVC模式，去引出我们的底层代码。

Spring Ioc

首先创建pojo，dao层，service层和controller层

pojo：定义两个属性，加上getset和toString方法

package cn.com.wx.pojo.User;

public class User {
     private Integer id;
     private String name;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }
     
}

dao层：这里我们要模仿数据库的层：写一个selectone的方法，用以调用

package cn.com.wx.Dao;

import cn.com.wx.pojo.User.User;

public class UserDao {
    public User selectone(Integer id,String name) {
        User user =new User();
        user.setId(id);
        user.setName(name);
        return user;
        
    }
}

最后加上Service层和Controller层

package cn.com.wx.Service;

import cn.com.wx.Dao.UserDao;
import cn.com.wx.pojo.User.User;

public class UserService {
    private UserDao userDao;

public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}

public User get(Integer id,String name) {
        
        User user=userDao.selectone(id, name);
        return user;
        
    }
}

package cn.com.wx.Controller;

import cn.com.wx.Service.UserService;
import cn.com.wx.pojo.User.User;

public class UserController {
    private UserService userService ;

public void setUserService(UserService userService) {
this.userService = userService;
}

public User get(Integer id, String name) {
        User user =userService.get(id, name);
        return user;
        
        
    }
}

接下里我们写容器的创建过程，遍历目录，获取所有的class文件，这里我们使用IO和文件Api，利用递归的方式把文件拿出来，

package cn.com.wx.Files;

import java.io.File;
import java.util.List;

public class JUnitFile {
    public static List<String> getFileName(String Dir, List<String> list) {
        File file = new File(Dir);//拿到目录
        File[] f = file.listFiles();//封装在一个数组里面
        for (File name : f) {
            if(name.isDirectory()) {//API isDirectory：判断是否为文件，如果是文件夹，证明文件夹里边还有文件，利用递归的方式进入文件夹
                getFileName(name.getAbsolutePath(), list);
            }else {
                //不是文件夹就是文件，把文件的路径放到集合中
                list.add(name.getAbsolutePath());
            }
        }

        return list;
    }
}

这时我们创建一个测试类来验证下我们的文件是否拿到

package cn.com.wx.test;

import java.util.ArrayList;
import java.util.List;

import cn.com.wx.Files.JUnitFile;

public class Test {
    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();// 创建集合用于接受JUnnitFile的返回值
        // 这个路径是我们项目的路径，一定要根据自己工作空间建的项目的目录
        String Dir = "C:\\Users\\wangxiao\\eclipse-workspace\\BokeSpringIoc\\bin";
        JUnitFile.getFileName(Dir, list);
        for (String string : list) {
            System.out.println(string);
        }
    }
}

输出结果：这样我们bin目录下的所有的class文件就都拿到了

C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\Controller\UserController.class
C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\Dao\UserDao.class
C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\Files\JUnitFile.class
C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\pojo\User\User.class
C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\Service\UserService.class
C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\test\Test.class

这时候拿一个路径过来分析：

C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\test\Test.class
我们整整需要的是包名加上文件名：                            cn\com\wx\test\Test
这样就需要我们干掉bin目录之前的目录和类的后缀.class
这个就非常简单了，我们可以使用基础的Api去截取字符串：

package cn.com.wx.Files;

import java.util.List;

public class Covers {
    // C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\test\Test.class
    // C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\

    // 看着上边的目录我们来分析问题：首选我们已经把标准目录拿到了，放到一个list集合中，集合作为参数传到我的getScanName方法中
    // 这样我只需要一个需要截取的部分的字符串，这里我用scanDir来表示
    public static List<String> getScanName(String scanDir, List<String> list) {
        // scanDir=C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\

        // 下一步分析：假定我们截取完字符串，那我们是不是还要把它放回去，放回去就要知道我们的角标，而普通的foreach循环满足不了，我们用普通的for循环来替代
        for (int i = 0; i < list.size(); i++) {
            String strname = list.get(i);// 逐个去拿他的目录
            // 先替换虽有的斜杠
            strname = strname.replace("\\", "/");
            scanDir = scanDir.replace("\\", "/");
            // 干掉scanDir部分
            strname = strname.replace(scanDir, "");
            // 从后边拿到点出现的位置
            int pos = strname.lastIndexOf(".");
            strname = strname.substring(0, pos);
            // 这样我们就拿到了这样的格式
            // cn/com/wx/test/Test
            // 最后再把斜杠替换成点
            strname = strname.replace("/", ".");
            // 最后再放回集合中
            list.set(i, strname);
        }
        return list;

    }
}

然后我们在来测试：还是用刚才的测试类：

package cn.com.wx.test;

import java.util.ArrayList;
import java.util.List;

import cn.com.wx.Files.Covers;
import cn.com.wx.Files.JUnitFile;

public class Test {
    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();// 创建集合用于接受JUnnitFile的返回值
        // 这个路径是我们项目的路径，一定要根据自己工作空间建的项目的目录
        String Dir = "C:\\Users\\wangxiao\\eclipse-workspace\\BokeSpringIoc\\bin\\";
        JUnitFile.getFileName(Dir, list);
        for (String string : list) {
            System.out.println(string);
        }
        Covers.getScanName(Dir, list);
        for (String string : list) {
            System.out.println(string);
        }
        
    }
}

运行结果：

C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\Controller\UserController.class
C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\Dao\UserDao.class
C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\Files\Covers.class
C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\Files\JUnitFile.class
C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\pojo\User\User.class
C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\Service\UserService.class
C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\test\Test.class
cn.com.wx.Controller.UserController
cn.com.wx.Dao.UserDao
cn.com.wx.Files.Covers
cn.com.wx.Files.JUnitFile
cn.com.wx.pojo.User.User
cn.com.wx.Service.UserService
cn.com.wx.test.Test

这里我们有一处出现了硬编码拿就是测试类：我门把路径写死了，而我们的Spring底层肯定不会出现这种情况，这样就用我们的Api来替代他，让他动态的获取路径

package cn.com.wx;

public class RunApp {
    public static void main(String[] args) {
        //获取主路径（bin之前）
        // String Dir=RunApp.class.getResource("/").getPath()
        //      /C:/Users/wangxiao/eclipse-workspace/BokeSpringIoc/bin/
        //上面是正常的获取主路径但是获取的路径前面会有一个斜杠，所以我们要加上一个subString的API去掉斜杠
        
        //主路径
        String Dir=RunApp.class.getResource("/").getPath().substring(1);
        System.out.println(Dir);
        
        //包路径
        String str=RunApp.class.getPackage().getName();

        System.out.println(str);//cn.com.wx  输出的结果，分割是用点分割的，所有要替换成斜杠
        
        //最后在于我们的主路径拼接
       String scanDir=Dir+str.replace(".", "/");
       System.out.println(scanDir);
        
    }
}

运行结果：

C:/Users/wangxiao/eclipse-workspace/BokeSpringIoc/bin/
cn.com.wx
C:/Users/wangxiao/eclipse-workspace/BokeSpringIoc/bin/cn/com/wx

这样我们的动态获取路径的方法就实现了，正常我们开发一般都是面向接口的开发：所有要把我们得Test方法改成面向接口的格式：创建接口：BeanFactory，写两个方法，让Test类去实现接口，RunApp方法去调用接口

package cn.com.wx.test;

import java.util.List;

public interface BeanFactory {
    public List<String> Fild(String Dir, List<String> list) ;
    
    public void Cover(String scanDir, List<String> list);
}

修改Test类，实现BeanFactory接口

package cn.com.wx.test;

import java.util.ArrayList;
import java.util.List;

import cn.com.wx.Files.Covers;
import cn.com.wx.Files.JUnitFile;

public class Test implements BeanFactory {

    List<String> list = new ArrayList<String>();// 创建集合用于接受JUnnitFile的返回值
    // 这个路径是我们项目的路径，一定要根据自己工作空间建的项目的目录
    // String Dir = "C:\\Users\\wangxiao\\eclipse-workspace\\BokeSpringIoc\\bin\\";

    public List<String> Fild(String Dir, List<String> list) {
        List<String> DirList = JUnitFile.getFileName(Dir, list);
        return DirList;
    }

    public void Cover(String scanDir, List<String> list) {
        List<String> coverlist = Covers.getScanName(scanDir, list);
        
    }

}

RunApp调用：

package cn.com.wx;

import java.util.ArrayList;
import java.util.List;

import cn.com.wx.test.BeanFactory;
import cn.com.wx.test.Test;

public class RunApp {
    public static void main(String[] args) {
        //获取主路径（bin之前）
        // String Dir=RunApp.class.getResource("/").getPath()
        //      /C:/Users/wangxiao/eclipse-workspace/BokeSpringIoc/bin/
        //上面是正常的获取主路径但是获取的路径前面会有一个斜杠，所以我们要加上一个subString的API去掉斜杠
        
        //主路径
        String Dir=RunApp.class.getResource("/").getPath().substring(1);
        //System.out.println(Dir);
        
        //包路径
        String str=RunApp.class.getPackage().getName();

       // System.out.println(str);//cn.com.wx  输出的结果，分割是用点分割的，所有要替换成斜杠
        
        //最后在于我们的主路径拼接
       String scanDir=Dir+str.replace(".", "/");
       // System.out.println(scanDir);
       List<String> list =new ArrayList<String>();
       
       BeanFactory context =new Test();
       context.Fild(scanDir, list);
       context.Cover(Dir, list);
       for (String string : list) {
        System.out.println(string);
    }
       
       
        
    }
}

输出结果：起始正题的思想并没有变，只是我们把开发的过程变成了面向接口的开发：并且将来我们要在在Test方法中建立反射，而获取的结果包名点类名：就是我们所说的全局限定名

cn.com.wx.Controller.UserController
cn.com.wx.Dao.UserDao
cn.com.wx.Files.Covers
cn.com.wx.Files.JUnitFile
cn.com.wx.pojo.User.User
cn.com.wx.RunApp
cn.com.wx.Service.UserService
cn.com.wx.test.BeanFactory
cn.com.wx.test.Test

在我们Spring使用的过程中是使用注解的开发方式，而我们的底层也是注解的方式，用注解去标识三个层：控制层业务层持久层，所以就要建立三个注解去标识他们：

Controller注解

package cn.com.wx.Annotation;

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

@Target(ElementType.TYPE)//注解在类上使用
@Retention(RetentionPolicy.RUNTIME)//运行时使用
public @interface Service {

}

package cn.com.wx.Annotation;

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

@Target(ElementType.TYPE)//注解在类上使用
@Retention(RetentionPolicy.RUNTIME)//运行时使用
public @interface Controller {

}

package cn.com.wx.Annotation;

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

@Target(ElementType.TYPE)//注解在类上使用
@Retention(RetentionPolicy.RUNTIME)//运行时使用
public @interface Repository {

}

并在每一层的类上面去引用注解：

package cn.com.wx.Service;

import cn.com.wx.Annotation.Service;
import cn.com.wx.Dao.UserDao;
import cn.com.wx.pojo.User.User;
@Service//加入注解
public class UserService {
    private UserDao userDao;
    
    public User get(Integer id,String name) {
        
        User user=userDao.selectone(id, name);
        return user;
        
    }
}

package cn.com.wx.Controller;

import cn.com.wx.Annotation.Controller;
import cn.com.wx.Service.UserService;
import cn.com.wx.pojo.User.User;
@Controller//加入注解
public class UserController {
    private UserService userService ;
    public User get(Integer id, String name) {
        User user =userService.get(id, name);
        return user;
        
        
    }
}

package cn.com.wx.Dao;

import cn.com.wx.Annotation.Repository;
import cn.com.wx.pojo.User.User;
@Repository//加入注解
public class UserDao {
    public User selectone(Integer id,String name) {
        User user =new User();
        user.setId(id);
        user.setName(name);
        return user;
        
    }
}

然后通过全局限定名，利用反射Class.forName方法创建类。遍历这些文件，判断其上面有无@Controller注解或者@Service注解，如果没有继续循环，如果有其一，或者@Controller或者@Service就去根据反射获取它的类上注解来判断。对他创建对象，利用反射clazz.newInstance的方法创建对象实例，把它暂存到一个容器中，而容器容器实际是一个Map集合，Map集合有key，有value，key就是类的全路径，value就是对象实例。

这样做有什么好处，对象创建直接就可以通过包扫描机制在类调用之前（初始化阶段）全都放入容器，创建好。

在需要用的时候，直接从容器中获取。对象都创建好了，性能高，代码少。

下面我们在Cover方法中建立反射：

package cn.com.wx.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import cn.com.wx.Annotation.Controller;
import cn.com.wx.Annotation.Repository;
import cn.com.wx.Annotation.Service;
import cn.com.wx.Files.Covers;
import cn.com.wx.Files.JUnitFile;

public class Test implements BeanFactory {
    //创建容器
    private static final Map<String, Object> beans =new HashMap<String, Object>();

    List<String> list = new ArrayList<String>();// 创建集合用于接受JUnnitFile的返回值
    // 这个路径是我们项目的路径，一定要根据自己工作空间建的项目的目录
    // String Dir = "C:\\Users\\wangxiao\\eclipse-workspace\\BokeSpringIoc\\bin\\";

    public List<String> Fild(String Dir, List<String> list) {
        List<String> DirList = JUnitFile.getFileName(Dir, list);
        return DirList;
    }

    public void Cover(String scanDir, List<String> list) throws Exception {
        List<String> coverlist = Covers.getScanName(scanDir, list);
        for (String classname : coverlist) {
            Class<?> clazz = Class.forName(classname);// 需要抛异常，记得把接口和实现的方法都抛异常

            // 通过反射拿到注解标识的类名
            Controller controller = clazz.getAnnotation(Controller.class);
            Service service = clazz.getAnnotation(Service.class);
            Repository repository = clazz.getAnnotation(Repository.class);
            // 判断如果拿到了注解类，就不会是空值，所以这里加上判断
            if (controller != null || service != null || repository != null) {
                //一旦我们拿到注解类，就要创建实例对象
                Object obj = clazz.newInstance();
                beans.put(classname, obj);
                
            }

        }
        for (String key : beans.keySet()) {
            System.out.println(beans.get(key));
        }

    }

}

执行RunApp：输出结果为：可以看见前三个输出就是我们获取的对象

cn.com.wx.Service.UserService@45ee12a7
cn.com.wx.Controller.UserController@330bedb4
cn.com.wx.Dao.UserDao@2503dbd3
cn.com.wx.Annotation.Controller
cn.com.wx.Annotation.Repository
cn.com.wx.Annotation.Service
cn.com.wx.Controller.UserController
cn.com.wx.Dao.UserDao
cn.com.wx.Files.Covers
cn.com.wx.Files.JUnitFile
cn.com.wx.pojo.User.User
cn.com.wx.RunApp
cn.com.wx.Service.UserService
cn.com.wx.test.BeanFactory
cn.com.wx.test.Test

这时候我们放进容器的是class的路径对象，我们定义的时候是定义成 private UserService userService的模式，而我们当控制层去调用业务成和业务层调用持久层的时候是拿的userSevice实例对象，这时候需求来了，我们要吧包名去掉，把首字母变成小写；这时候我们就需要写一个方法，把

反射拿到的类名转换成容器正真需要的格式：在Covers类写一个方法

package cn.com.wx.Files;

import java.util.List;

public class Covers {
    // C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\cn\com\wx\test\Test.class
    // C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\

    // 看着上边的目录我们来分析问题：首选我们已经把标准目录拿到了，放到一个list集合中，集合作为参数传到我的getScanName方法中
    // 这样我只需要一个需要截取的部分的字符串，这里我用scanDir来表示
    public static List<String> getScanName(String scanDir, List<String> list) {
        // scanDir=C:\Users\wangxiao\eclipse-workspace\BokeSpringIoc\bin\

        // 下一步分析：假定我们截取完字符串，那我们是不是还要把它放回去，放回去就要知道我们的角标，而普通的foreach循环满足不了，我们用普通的for循环来替代
        for (int i = 0; i < list.size(); i++) {
            String strname = list.get(i);// 逐个去拿他的目录
            // 先替换虽有的斜杠
            strname = strname.replace("\\", "/");
            scanDir = scanDir.replace("\\", "/");
            // 干掉scanDir部分
            strname = strname.replace(scanDir, "");
            // 从后边拿到点出现的位置
            int pos = strname.lastIndexOf(".");
            strname = strname.substring(0, pos);
            // 这样我们就拿到了这样的格式
            // cn/com/wx/test/Test
            // 最后再把斜杠替换成点
            strname = strname.replace("/", ".");
            // 最后再放回集合中
            list.set(i, strname);
        }
        return list;
    }

    public static String getBeanName(String classname) {
        // 拿去点的最后边的位置加上一
        int pos = classname.lastIndexOf(".") + 1;
        classname = classname.substring(pos);
        
        //把第一个字母变成小写，并且拼接字符串
        classname =classname.toLowerCase().charAt(0)+classname.substring(1);

        return classname;

    }
}

之后我们就需要修改反射的内容，把之前放入容器得classname转成beanname格式：

下面是Test类的反射变化

public void Cover(String scanDir, List<String> list) throws Exception {
        List<String> coverlist = Covers.getScanName(scanDir, list);
        for (String classname : coverlist) {
            Class<?> clazz = Class.forName(classname);// 需要抛异常，记得把接口和实现的方法都抛异常

            // 通过反射拿到注解标识的类名
            Controller controller = clazz.getAnnotation(Controller.class);
            Service service = clazz.getAnnotation(Service.class);
            Repository repository = clazz.getAnnotation(Repository.class);
            // 判断如果拿到了注解类，就不会是空值，所以这里加上判断
            String beanname="";//这里我是方便看，把classname转成beanname
            if (controller != null || service != null || repository != null) {
                //一旦我们拿到注解类，就要创建实例对象
                Object obj = clazz.newInstance();
                beanname=Covers.getBeanName(classname);
                //把转换好的beanname放进容器
                beans.put(beanname, obj);
            }

        }
        for (String key : beans.keySet()) {
            System.out.println(beans.get(key));
        }

    }

这时候只要我们需要容器中key值就可以去取容器中查找，看有没有我需要的实例名称，而容器中value值就是实例名称对应的对象实例，这样，以后我们在使用的时候就不要new了，我们直接从容器中获取就可以了：

首先在我们的接口方法中加上我们的方法：

package cn.com.wx.test;

import java.util.List;

public interface BeanFactory {
    public List<String> Fild(String Dir, List<String> list) ;
    
    public void Cover(String scanDir, List<String> list) throws Exception;
    
    //从容器中调用实例对象
    public<T> T getBean(String beanname);
}

package cn.com.wx.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import cn.com.wx.Annotation.Controller;
import cn.com.wx.Annotation.Repository;
import cn.com.wx.Annotation.Service;
import cn.com.wx.Files.Covers;
import cn.com.wx.Files.JUnitFile;

public class Test implements BeanFactory {
    //创建容器
    private static final Map<String, Object> beans =new HashMap<String, Object>();

    List<String> list = new ArrayList<String>();// 创建集合用于接受JUnnitFile的返回值
    // 这个路径是我们项目的路径，一定要根据自己工作空间建的项目的目录
    // String Dir = "C:\\Users\\wangxiao\\eclipse-workspace\\BokeSpringIoc\\bin\\";

    public List<String> Fild(String Dir, List<String> list) {
        List<String> DirList = JUnitFile.getFileName(Dir, list);
        return DirList;
    }

    public void Cover(String scanDir, List<String> list) throws Exception {
        List<String> coverlist = Covers.getScanName(scanDir, list);
        for (String classname : coverlist) {
            Class<?> clazz = Class.forName(classname);// 需要抛异常，记得把接口和实现的方法都抛异常

            // 通过反射拿到注解标识的类名
            Controller controller = clazz.getAnnotation(Controller.class);
            Service service = clazz.getAnnotation(Service.class);
            Repository repository = clazz.getAnnotation(Repository.class);
            // 判断如果拿到了注解类，就不会是空值，所以这里加上判断
            String beanname="";//这里我是方便看，把classname转成beanname
            if (controller != null || service != null || repository != null) {
                //一旦我们拿到注解类，就要创建实例对象
                Object obj = clazz.newInstance();
                beanname=Covers.getBeanName(classname);
                //把转换好的beanname放进容器
                beans.put(beanname, obj);
            }

        }
        for (String key : beans.keySet()) {
            System.out.println(beans.get(key));
        }

    }
    
    //<T>代表后面出现T就是泛型，T代表返回值
    //也称为泛型方法
    public<T> T getBean(String beanname) {
        return (T) beans.get(beanname);
        
    }

}

这样我们就可以在RunApp方法中去测试，看我们能不能找到实例对象：在最下面测试我们的方法

       UserService us =context.getBean("userService");
       System.out.println("这是从容器中拿到的"+us);

输出结果：可以看见我们的实例对象已经放到容器中了：这样我们Ioc的底层就实现了。

cn.com.wx.Controller.UserController@45ee12a7
cn.com.wx.Dao.UserDao@330bedb4
cn.com.wx.Service.UserService@2503dbd3
这是从容器中拿到的cn.com.wx.Service.UserService@2503dbd3

这样我们就可以通过三个层调用方法了：在RunApp下面加上测试

        UserController uc = context.getBean("userController");
        UserService us = context.getBean("userService");
        UserDao ud = context.getBean("userDao");

        uc.setUserService(us);
        us.setUserDao(ud);
        User user = uc.get(5,"马云");
        System.out.println(user);

我们看下输出结果：

cn.com.wx.Controller.UserController@45ee12a7
cn.com.wx.Dao.UserDao@330bedb4
cn.com.wx.Service.UserService@2503dbd3
User [id=5, name=马云]

Di（依赖注入）

   uc.setUserService(us);
        us.setUserDao(ud);

      注意我上边写的代码，我是在UserController和UserService类中定义了set方法，然后这里才可以调用，继而把参数传过去，其一：这是没有太多的属性，其二：开发过程麻烦，
一不小心忘记写了哪一步，就会报空指针异常。那么近引进我们得Di（依赖注入），也叫自动驻入，我认为自动注入这个名字更能体现他，让我们的Di去帮我们实现注入（也就是去set）
他，那么我们的UserController和UsereService类就不用写set方法了，直接一个注解就搞定，实现的时候，我们也不用去调用了set了。

网上大部分人说Ioc是概念而Di才是真正的去实现Ioc，但是我认为这种说话是不正确的，我认为Di是Ioc的重要实现功能，是在有Ioc的前提下，有容器，有属性

之后Di再去实现，Di它实现了对象之间关系的绑定，判断什么类需要进行诸如，通过我们的@Autowired注解识别，然后从容器中拿到对象。

首先我们来定义注解@Autowired来定义Di：

package cn.com.wx.Annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.net.Authenticator.RequestorType;

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

}

这时候我们就可以把UserController和UserService：中的Set方法直接去掉，然后在私有属性上定义注解：

package cn.com.wx.Controller;

import cn.com.wx.Annotation.Autowired;
import cn.com.wx.Annotation.Controller;
import cn.com.wx.Service.UserService;
import cn.com.wx.pojo.User.User;

@Controller
//加入注解
public class UserController {
    @Autowired
    private UserService userService;

//    public void setUserService(UserService userService) {
//        this.userService = userService;
//    }

    public User get(Integer id ,String name) {
        User user = userService.get(id,name);
        return user;

    }
}

package cn.com.wx.Service;

import cn.com.wx.Annotation.Autowired;
import cn.com.wx.Annotation.Service;
import cn.com.wx.Dao.UserDao;
import cn.com.wx.pojo.User.User;
@Service
public class UserService {
    @Autowired
    private UserDao userDao;
       
//    public void setUserDao(UserDao userDao) {
//        this.userDao = userDao;
//    }

    public User get(Integer id,String name) {
        
        User user=userDao.selectone(id,name);
        return user;
        
    }
}

这时候我满看见RunApp类的set的两个方法报错，我们直接去掉就可以，因为我们已经不需要set去注入了

在我们的接口中加入我们的inject方法：因为这里我们要用倒反射，所以后面呢肯定会抛异常，这里我直接提前抛出异常

package cn.com.wx.test;

import java.util.List;

public interface BeanFactory {
    public List<String> Fild(String Dir, List<String> list) ;
    
    public void Cover(String scanDir, List<String> list) throws Exception;
    
    //从容器中调用实例对象
    public<T> T getBean(String beanname);
    
    //自动注入
    public void inject() throws Exception;
}

先分析放射的步骤：先获取到当前对象，通过当前对象getClass方法就获得Class类，通过Class类的getDeclaredField()获取这个类上的所有的属性，Declea。。这个方法可以获取类的成员变量，而且可以获取私有的。但是私有属性在操作时，

必须先设置其访问权限可用。然后利用反射属性set方法，设置它的值

在Test类中加上我们的inject方法：里边的每一步我都有注释，解释当前这一步的目的

package cn.com.wx.test;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import cn.com.wx.Annotation.Autowired;
import cn.com.wx.Annotation.Controller;
import cn.com.wx.Annotation.Repository;
import cn.com.wx.Annotation.Service;
import cn.com.wx.Files.Covers;
import cn.com.wx.Files.JUnitFile;

public class Test implements BeanFactory {
    //创建容器
    private static final Map<String, Object> beans =new HashMap<String, Object>();

    List<String> list = new ArrayList<String>();// 创建集合用于接受JUnnitFile的返回值
    // 这个路径是我们项目的路径，一定要根据自己工作空间建的项目的目录
    // String Dir = "C:\\Users\\wangxiao\\eclipse-workspace\\BokeSpringIoc\\bin\\";

    public List<String> Fild(String Dir, List<String> list) {
        List<String> DirList = JUnitFile.getFileName(Dir, list);
        return DirList;
    }

    public void Cover(String scanDir, List<String> list) throws Exception {
        List<String> coverlist = Covers.getScanName(scanDir, list);
        for (String classname : coverlist) {
            Class<?> clazz = Class.forName(classname);// 需要抛异常，记得把接口和实现的方法都抛异常

            // 通过反射拿到注解标识的类名
            Controller controller = clazz.getAnnotation(Controller.class);
            Service service = clazz.getAnnotation(Service.class);
            Repository repository = clazz.getAnnotation(Repository.class);
            // 判断如果拿到了注解类，就不会是空值，所以这里加上判断
            String beanname="";//这里我是方便看，把classname转成beanname
            if (controller != null || service != null || repository != null) {
                //一旦我们拿到注解类，就要创建实例对象
                Object obj = clazz.newInstance();
                beanname=Covers.getBeanName(classname);
                //把转换好的beanname放进容器
                beans.put(beanname, obj);
                System.out.println(beanname);
            }

        }
        for (String key : beans.keySet()) {
            System.out.println(beans.get(key));
        }

    }
    
    //<T>代表后面出现T就是泛型，T代表返回值
    //也称为泛型方法
    public<T> T getBean(String beanname) {
        return (T) beans.get(beanname);
    }
    
    public void inject() throws Exception {
        for (String beanname : beans.keySet()) {
            //先从容器中获取对象
            Object obj= getBean(beanname);
            //创建反射
            Class<?> clazz =obj.getClass();
            //遍历所有属性：找到私有属性，然后判断他是否有Autowired注解
            //这里边我只写了一个私有的，但是底层不可能就是只能去获取一个，
            //可能一个Controller层有多个私有的属性，但是不一定每一个属性上都有Autowired注解，这时候我们就需要用一个数组去接受
            //反射的基本ApiDeclared获取私有的 Fields获取属性，最后我们用一个数组作为返回值；
            Field[] field =    clazz.getDeclaredFields();
            //但是不一定每一个属性上都有Autowired注解，所以我们需要去判断一下
            for (Field f : field) {
                //属性是私有的，访问需要开通权限
                f.setAccessible(true);
                
                Autowired autowired =f.getAnnotation(Autowired.class);
                //判断私有属性上是否有注解，有注解就不为空
                if(autowired!=null) {
                    //拿到注解，就证明我们这个私有属性需要去注入，下面就是注入
                    //拿到属性名，这个getName不是我写的方法，他是反射源码自己定义的一个方法，鼠标放上去，看到返回值是String类型，定义一个变量去接收。
                    String claname=f.getName();
                    //注入
                    f.set(obj, getBean(claname));
                }
                
            }
            
        }
    }
    
}

然后在我们的RunApp上调用我们的inject方法（一定不要忘记这一步，不写是不会调用自动注入，自然运行就会空指针异常）

package cn.com.wx;

import java.util.ArrayList;
import java.util.List;

import cn.com.wx.Controller.UserController;
import cn.com.wx.Dao.UserDao;
import cn.com.wx.Service.UserService;
import cn.com.wx.pojo.User.User;
import cn.com.wx.test.BeanFactory;
import cn.com.wx.test.Test;

public class RunApp {
    public static void main(String[] args) throws Exception {
        // 获取主路径（bin之前）
        // String Dir=RunApp.class.getResource("/").getPath()
        // /C:/Users/wangxiao/eclipse-workspace/BokeSpringIoc/bin/
        // 上面是正常的获取主路径但是获取的路径前面会有一个斜杠，所以我们要加上一个subString的API去掉斜杠

        // 主路径
        String Dir = RunApp.class.getResource("/").getPath().substring(1);
        // System.out.println(Dir);

        // 包路径
        String str = RunApp.class.getPackage().getName();

        // System.out.println(str);//cn.com.wx 输出的结果，分割是用点分割的，所有要替换成斜杠

        // 最后在于我们的主路径拼接
        String scanDir = Dir + str.replace(".", "/");
        // System.out.println(scanDir);
        List<String> list = new ArrayList<String>();

        BeanFactory context = new Test();
        context.Fild(scanDir, list);
        context.Cover(Dir, list);
//       for (String string : list) {
//        System.out.println(string);
//      }

//       UserService us =context.getBean("userService");
//       System.out.println("这是从容器中拿到的"+us);
        context.inject();
        UserController uc = context.getBean("userController");
        UserService us = context.getBean("userService");
        UserDao ud = context.getBean("userDao");

//        uc.setUserService(us);
//        us.setUserDao(ud);
        
        
        User user = uc.get(5,"马云");
        System.out.println(user);
    }
}

运行结果：

cn.com.wx.Controller.UserController@45ee12a7
cn.com.wx.Dao.UserDao@330bedb4
cn.com.wx.Service.UserService@2503dbd3
User [id=5, name=马云]

这样一来注入就成功，看到这个底层我们就能明白我上边所说的，Di是在ioc的前提下完成的。

最后说一下，我还是希望大家能耐下心来花几天的时间吧这些代码搞一下，收获还有蛮大的，前几次写可能某一步不能理解，但是多敲几遍，其义自见。

posted @ 2019-08-25 14:07 你是长颈鹿吗阅读(660) 评论(0) 编辑收藏举报

刷新页面返回顶部

菜鸟%码农

利用递归，反射，注解等，手写Spring Ioc和Di 底层（分分钟喷倒面试官）了解一下

Spring Ioc

Di（依赖注入）

公告