01.手写Spring的IOC容器

01.手写Spring的IOC容器

1.需求：实现service层与dao层代码解耦

步骤：

1. 创建java项目，导入自定义IOC相关坐标
2. 编写Dao接口和实现类
3. 编写Service接口和实现类
4. 编写测试代码

2.传统方式实现

1.导入依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.6</version>
        </dependency>
    </dependencies>

(2)编写Dao接口和实现类

public interface UserDao {
    void save();
}

public class UserDaoImpl implements UserDao {
    public void save(){
        System.out.println("dao被调用了！");
    }
}

（3）编写Service接口和实现类

public interface UserService {
    void save();
}

public class UserServiceImp implements UserService {
    private UserDao userDao;
    @Override
    public void save() {
        userDao = new UserDaoImpl();
        userDao.save();
    }
}

（4）编写测试类

    @org.junit.Test
    public void TestSave(){
        UserService userService = new UserServiceImp();
        userService.save();
    }

（5）结果

（6）问题

• 当前service对象和dao对象耦合度太高，每次new的都是一个新的对象，会导致服务器压力过大。

  解耦合的原则是编译期不依赖，而运行期依赖就行了。

3.解耦实现

（1）编写bean.xml

• 把所有需要创建对象的信息定义在配置文件中

  <?xml version="1.0" encoding="UTF-8"?>
  <bean id ="userDao"  class ="com.weihong.dao.impl.UserDaoImpl"></bean>
  

（2）编写BeanFactory工具类

• 其原理就是利用反射动态创建对象，并动态调用方法的机制。

package com.weihong.util;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import javax.xml.parsers.SAXParser;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class BeanFactory {
    private static Map<String,Object> ioc = new HashMap<>();
    //程序启动时，初始化对象实例
    static{
        try {
            //1.读取配置文件
            //1.1 BeanFactory.class.getClassLoader():得到当前类BeanFactory的class对象
            //1.2 class.getResourceAsStream():获得bean.xml文件对象的输入流
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.xml");
            //2.解析xml
            SAXReader saxReader = new SAXReader();
            Document document = saxReader.read(in);
            //3.编写xpath表达式
            String xpath = "//bean";
            //4.获取所有的bean标签
            List<Element> list = document.selectNodes(xpath);
            //5.遍历并创建对象实例，设置到map集合中
            for (Element element : list) {
                //获取bean对象的id和class值
                String id = element.attributeValue("id");
                String className = element.attributeValue("class");
                //实例化该对象
                Object object = Class.forName(className).newInstance();
                //将该对象保存到map集合中
                ioc.put(id,object);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    //获取指定id的对象实例
    public static Object getBean(String beanId){
        return ioc.get(beanId);
    }
}

（3）修改UserServiceImpl实现类

public class UserServiceImp implements UserService {
    private UserDao userDao;
    @Override
    public void save() {
        userDao = (UserDao) BeanFactory.getBean("userDao");
        userDao.save();
    }
}

4.知识小结

• 其实升级后的BeanFactory就是一个简单的Spring的IOC容器所具备的功能。
• 之前我们需要一个userDao实例，需要开发者自己手动创建 new UserDao();
• 现在我们需要一个userdao实例，直接从spring的IOC容器获得，对象的创建权交给了spring控制
• 最终目标：代码解耦合