简单手写Spring框架的IOC和DI源码

Posted 2021-06-09 Code_BinBin

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了简单手写Spring框架的IOC和DI源码相关的知识，希望对你有一定的参考价值。

我们知道，ioc（控制反转）和di（依赖注入）是spring里面很重要的东西，那么，我们如何自己手写出这样的代码呢？

什么是IOC

IOC，Inversion of Control，即控制反转，这个不是一种什么技术，而是一种思想，平时我们写代码，都是把对象自己new出来，而现在我们用控制反转这种思想，把对象的创建交给了程序，那么我们就不需要手动创建对象了，这样降低了程序的耦合度。
这是spring的核心，贯穿始终。对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。这是什么意思呢，举个简单的例子，我们是如何找女朋友的？常见的情况是，我们到处去看哪里有长得漂亮身材又好的mm，然后打听她们的兴趣爱好、qq号、电话号、wx号，想办法认识她们，投其所好送其所要，然后嘿嘿……这个过程是复杂深奥的，我们必须自己设计和面对每个环节。传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁（比如Connection等），对象始终会和其他的接口或类藕合起来。
在这里插入图片描述

那么IoC是如何做的呢？有点像通过婚介找女朋友，在我和女朋友之间引入了一个第三者：婚姻介绍所。婚介管理了很多男男女女的资料，我可以向婚介提出一个列表，告诉它我想找个什么样的女朋友，比如长得像李嘉欣，身材像林熙雷，唱歌像周杰伦，速度像卡洛斯，技术像齐达内之类的，然后婚介就会按照我们的要求，提供一个mm，我们只需要去和她谈恋爱、结婚就行了。
在这里插入图片描述

简单明了，如果婚介给我们的人选不符合要求，我们就会抛出异常。整个过程不再由我自己控制，而是有婚介这样一个类似容器的机构来控制。Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

什么是DI

DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

●谁依赖于谁：当然是应用程序依赖于IoC容器；

●为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源；

●谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；

●注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。

IoC和DI由什么关系呢？其实它们是同一个概念的不同角度描述，由于控制反转概念比较含糊（可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系），所以2004年大师级人物Martin Fowler又给出了一个新的名字：“依赖注入”，相对IoC 而言，“依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”。

IOC也叫依赖注入(DI)

2004年，Martin Fowler探讨了同一个问题，既然IOC是控制反转，那么到底是“哪些方面的控制被反转了呢？”，经过详细地分析和论证后，他得出了答案：“获得依赖对象的过程被反转了”。控制被反转之后，获得依赖对象的过程由自身管理变为了由IOC容器主动注入。于是，他给“控制反转”取了一个更合适的名字叫做“依赖注入（Dependency Injection）”。他的这个答案，实际上给出了实现IOC的方法：注入。所谓依赖注入，就是由IOC容器在运行期间，动态地将某种依赖关系注入到对象之中。

实现IOC和DI

首先，我们需要掌握两项必要的知识

反射
注解

如果对注解和反射没有怎么了解的，可以看看我之前的写的博客，java的反射和注解

建立项目

首先，我们先创建基本的项目，并且分好包

dao
entity
service
Annoation
reflect

在这里插入图片描述

我们模拟的例子是学生借书，所以，我们先创建好每个包下的java文件

实体类下的User,Book

public class Book {
    private int id;
    private String name;

    public Book(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public Book(){}

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\\'' +
                '}';
    }
}

public class User implements Serializable {
    private int id;
    private String username;
    private String password;
    public User(int id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }
    public User(){}
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }



    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\\'' +
                ", password='" + password + '\\'' +
                '}';
    }
}

dao层的UserDao，UserDaoImpl,BookDao,BookDaoImpl

public interface BookDao {
    User findBookById();
    List<User> findAllBook();
    List<User>findBookByBookName(String username);
    void save(Book book);
}

public class BookDaoImpl implements BookDao {
    @Override
    public User findBookById() {
        System.out.println("这里是BookDao-findBookById");
        return null;
    }

    @Override
    public List<User> findAllBook() {
        System.out.println("这里是BookDao-findAllBook");
        return null;
    }

    @Override
    public List<User> findBookByBookName(String username) {
        System.out.println("这里是BookDao-findBookByBookName");
        return null;
    }

    @Override
    public void save(Book book) {
        System.out.println("这里是BookDao-save");

    }
}

public interface UserDao {
    User findUserById();
    List<User>findAllUser();
    List<User>findUserByUserName(String username);
    void save(User user);
}

public class UserDaoImpl implements UserDao {
    @Override
    public User findUserById() {
        System.out.println("这里是UserDao-findUserById");
        return null;
    }

    @Override
    public List<User> findAllUser() {
        System.out.println("这里是UserDao-findAllUser");
        return null;
    }

    @Override
    public List<User> findUserByUserName(String findUserByUserName) {
        System.out.println("这里是UserDao-findUserById");
        return null;
    }

    @Override
    public void save(User user) {
        System.out.println("这里是UserDao-save");
    }
}

service层的UserService,UserserviceImpl,BookService,BookServiceImpl

public interface BookService {
    void  borrow(User user, Book book);
}

public class BookServiceImpl implements BookService {
  
    @Override
    public void borrow(User user,Book book) {
        
    }
}

public interface UserService {
    void  login();
    void regist();
}

public class UserServiceImpl implements UserService {

   private UserDao userDao=new UserDaoImpl();
    @Override
    public void login() {
        userDao.findUserByUserName("刘水龙");
        System.out.println("登录业务的实现");
    }

    @Override
    public void regist() {
        userDao.save(new User(1,"刘水龙","222"));
        System.out.println("注册业务的实现");
    }
}

基本思路

通过配置文件把类放入ioc容器

我们知道ioc有一个ioc容器，把全部的对象放入ioc容器之中，这样我们就不需要自己去手动创建对象了，那么我们是怎么把对象放入ioc容器之中的呢？很简单，在这里我们使用了Map

我们在refect包下创建ApplicationContext的java文件

public class ApplicationContext<T> {

    private  HashMap<Class,Object> beanFactory=new HashMap<>();
    private static String filePath;
    public T getBean(Class clazz){
        return (T)beanFactory.get(clazz);
    }

}

这里我们创建了一个bean工厂，在ApplicationContext被实例化后，就会去自动读取配置类文件，把全部的需要放入ioc的容器放入bean工厂，那么如何把配置类文件放入bean工厂呢？我们需要新建议一个类

我们在ApplicationContext下写一个initContext方法，同时创建一个和com文件同级的config文件夹，写好配置文件

在这里插入图片描述

com.znb.service.BookService=com.znb.service.BookServiceImpl
com.znb.dao.BookDao=com.znb.dao.BookDaoImpl

 public void initContext() throws Exception {
        InputStream resource = ApplicationContext.class.getClassLoader().getResourceAsStream("config/bean.config");
        Properties properties=new Properties();
        properties.load(resource);
        Set<Object> keys=properties.keySet();
        System.out.println(properties);
        System.out.println(keys);
        for (Object key : keys) {
//             System.out.println(key.toString());
            beanFactory.put(Class.forName(key.toString()), Class.forName(properties.getProperty(key.toString())).newInstance());
        }
        System.out.println(beanFactory.keySet());
         System.out.println(beanFactory);

    }

在这里我们通过properties类获取配置文件，然后把properties的文件的key放进set集合中，
然后通过反射，将全部的类放进bean工厂，之后需要的时候，就可以直接从bean工厂获取

现在，我们测试一下，写一个BootStrap类

public class BookStrap {
    public static void main(String[] args) throws Exception {
        ApplicationContext applicationContext=new ApplicationContext();
        applicationContext.initContext();

    }
}

在这里插入图片描述
可以看到，当我们需要的时候，直接从bean工厂里面拿就可以了，这就是通过配置文件把类放入ioc容器

通过注解把类放入ioc容器

我们通过配置文件把类放入ioc容器，但是这样似乎很麻烦，每次需要放入ioc容器的时候，我们都需要自己去写一次配置文件，那么我们也没有什么方法简化这个步骤呢？

新建注解

我们在Annotation文件下新建一个注解 Bean

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

在ApplicationContext下写两个方法，一个initContextByAnnotation，一个loadOne

 public void initContextByAnnotation() throws Exception {
       //扫描包
        filePath = ApplicationContext.class.getClassLoader().getResource("").getFile();
        loadOne(new File(filePath));

    }

private  void loadOne(File fileParent) {
        if (fileParent.isDirectory()) {
            File[] childrenFiles = fileParent.listFiles();
            if(childrenFiles == null || childrenFiles.length == 0){
                return;
            }
            for (File child : childrenFiles) {
                if (child.isDirectory()) {
                    //如果是个文件夹就继续调用该方法,使用了递归
                    loadOne(child);
                } else {
                    //通过文件路径转变成全类名,第一步把绝对路径部分去掉

                    String pathWithClass = child.getAbsolutePath().substring(filePath.length() - 1);
                    //选中class文件
                    if (pathWithClass.contains(".class")) {
                        //    com.xinzhi.dao.UserDao
                        //去掉.class后缀，并且把 \\ 替换成 .
                        String fullName = pathWithClass.replaceAll("\\\\\\\\", ".").replace(".class", "");
                        try {
                            Class<?> aClass = Class.forName(fullName);


                            //把非接口的类实例化放在map中
                            if(!aClass.isInterface()){
                                Bean annotation = aClass.getAnnotation(Bean.class);
                                if(annotation != null){
                                    Object instance = aClass.newInstance();
                                    //判断一下有没有接口
                                    if(aClass.getInterfaces().length > 0) {
                                        //如果有接口把接口的class当成key，实例对象当成value
                                        System.out.println("正在加载【"+ aClass.getInterfaces()[0] +"】,实例对象是：" + instance.getClass().getName());
                                        beanFactory.put(aClass.getInterfaces()[0], instance);
                                    }else{
                                        //如果有接口把自己的class当成key，实例对象当成value
                                        System.out.println("正在加载【"+ aClass.getName() +"】,实例对象是：" + instance.getClass().getName());
                                        beanFactory.put(aClass, instance);
                                    }
                                }
                            }
                        } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

然后，我们给全部的接口实现类写上@Bean注解

@Bean
public class BookDaoImpl implements BookDao {
    @Override
    public User findBookById() {
        System.out.println("这里是BookDao-findBookById");
        return null;
    }

    @Override
    public List<User> findAllBook() {
        System.out.println("这里是BookDao-findAllBook");
        return null;
    }

    @Override
    public List<User> findBookByBookName(String username) {
        System.out.println("这里是BookDao-findBookByBookName");
        return null;
    }

    @Override
    public void save(Book book) {
        System.out.println("这里是BookDao-save");

    }
}

都按照这个格式写，其余的我就省略了，然后我们测试一下

 public static void main(String[] args) throws Exception {
        ApplicationContext applicationContext=new ApplicationContext();
        applicationContext.initContextByAnnotation();
    }

结果：
在这里插入图片描述
这个时候，写了@Bean的类都全部进入了IOC容器，当我们需要，只需要自己调用就可以了

依赖注入

我们已经简单的实现了IOC，那么现在来实现一下依赖注入，我们在ApplicationContext里面新写一个assembleObject方法，然后在initContextByAnnotation调用

 private void assembleObject() {
        for(Map.Entry<Class,Object> entry : beanFactory.entrySet()){
            //就是咱们放在容器的对象
            Object obj = entry.getValue();
            Class<?> aClass = obj.getClass();
            Field[] declaredFields 02Spring源码-手写篇-手写DI实现
 02Spring源码-手写篇-手写DI实现
 03Spring源码-手写篇-手写AOP实现(上)
 03Spring源码-手写篇-手写AOP实现(上)
 01Spring源码-手写篇-手写IoC实现
 01Spring源码-手写篇-手写IoC实现