冰冰很社恐

Spring IOC详解

一，什么是耦合

1、耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。

2、在软件工程中，对象之间的耦合度就是对象之间的依赖性。对象之间的耦合越高，维护成本越高，因此对象的设计应使类和构件之间的耦合最小。

程序的耦合

我们创建一个基于三层架构的项目Spring

新建三层架构的包（持久层）dao，（业务层）service，（表现层）web

/**
 * 持久层实现类
 */
public class UserDaoImpl implements UserDao {

    @Override
    public void addUser(){
        System.out.println("insert into tb_user......");
    }
}

/**
 * 业务层实现类
 */
public class UserServiceImpl implements UserService {
    //硬编码：此处有依赖关系
    private UserDao userDao = new UserDaoImpl();

    public void addUser(){
        userDao.addUser();
    }
}

/**
 * 模拟表现层
 */
public class Client {
    public static void main(String[] args) {
        //硬编码：此处有依赖关系
        UserService userService = new UserServiceImpl();
        userService.addUser();
    }
}

上边的代码service层在依赖dao层的实现类，此时如果更改dao了层的实现类或此时没有dao层实现类，编译将不能通过。这里就是因为程序之间的高度耦合导致的，我们需要用到IOC来解耦

二，什么是IOC

IOC (Inverse of Control)即控制反转：由ioc容器来创建依赖对象，程序只需要从IOC容器获取创建好的对象

原来：

我们在获取对象时，都是采用new的方式。是主动的。

现在：

我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。

这种被动接收的方式获取对象的思想就是控制反转，它是spring框架的核心之

三，IOC(工厂模式)解耦：

把所有的dao和service对象使用配置文件配置起来
当服务器启动时读取配置文件
把这些对象通过反射创建出来并保存在容器中
在使用的时候，直接从工厂拿

工厂模式方法一

我们创建一个BeanFactory_v1工厂

/**
 * bean工厂
 */
public class BeanFactory_v1 {

    /**
     * 获得UserServiceImpl对象
     * @return
     */
    public static UserService getUserService(){
        return new UserServiceImpl();
    }

    /**
     * 获得UserDaoImpl对象
     * @return
     */
    public static UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

在UserServiceImpl类中

public class UserServiceImpl implements UserService {
    //高耦合：硬编码（类与接口有很高的依赖性）
    //private UserDao UserDao = new UserDaoImpl();

    //工厂1
    private UserDao userDao=BeanFactory_v1.getUserDao();
    
    @Override
    public void addUser() {
        userDao.addUser();
    }
}

在Client类中

public class Client {
    public static void main(String[] args) {
        //高耦合：硬编码（类与接口有很高的依赖性）
        //UserService userService = new UserServiceImpl();

        //工厂1
        UserService userService= BeanFactory_v1.getUserService();
        userService.addUser();
       
    }
}

问题：我们在开发中会有很多个service和dao，此时工厂类就要添加无数个方法。

工厂模式方法二

配置要使用的dao和service

在resources中配置bean.properties

UserDao=com.by.dao.UserDaoImpl
UserService=com.by.service.UserServiceImpl

我们创建一个BeanFactory_v2工厂

//问题：我们在开发中会有很多个service和dao，此时工厂类就要添加无数个方法。
public class BeanFactory_v2 {
    public static Object getBean(String propertiesKey) {
        try {
            /***********1、读取beans.properties***********/
            //不能使用：项目发布后没有src目录
            //InputStream inputStream=new FileInputStream("src\\main\\resources\\beans.properties");
            InputStream inputStream = BeanFactory_v2.class.getClassLoader().getResourceAsStream("beans.properties");
            //Properties：继承了Hashtable，作用是读取*.properties文件
            Properties properties = new Properties();
            properties.load(inputStream);
            /*************2、根据配置文件中的value值创建(使用反射)对象************/
            return Class.forName(properties.getProperty(propertiesKey)).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        UserService userService = (UserService) BeanFactory_v2.getBean("userService");
        userService.addUser();
    }
}

在UserServiceImpl类中

public class UserServiceImpl implements UserService {
    //高耦合：硬编码（类与接口有很高的依赖性）
    //private UserDao UserDao = new UserDaoImpl();

    //工厂1
   //private UserDao userDao=BeanFactory_v1.getUserDao();

    //工厂2
    private UserDao userDao= (UserDao) BeanFactory_v2.getBean("UserDao");

    @Override
    public void addUser() {
        userDao.addUser();
    }
}

在Client类中

public class Client {
    public static void main(String[] args) {
        //高耦合：硬编码（类与接口有很高的依赖性）
        //UserService userService = new UserServiceImpl();

        //工厂1
        //UserService userService= BeanFactory_v1.getUserService();

        //工厂2
        UserService userService = (UserService) BeanFactory_v2.getBean("UserService");

        userService.addUser();
        for (int i = 0; i < 5; i++) {
            UserService userServicei = (UserService) BeanFactory_v2.getBean("UserService");
            System.out.println(userServicei);
        }
    }
}

测试结果

问题：1.每次都会创建新的对象 2.获得对象时才读取配置文件

工厂模式方法三

我们创建一个BeanFactory_v3工厂

//问题：1.每次都会创建新的对象   2.获得对象时才读取配置文件
public class BeanFactory_v3 {
    private static Map iocMap=new HashMap();
    static {
        try {
            //解决2.获得对象时才读取配置文件
            //InputStream inputStream=new FileInputStream("src\\\\main\\\\resources\\\\beans.properties");
            InputStream inputStream = BeanFactory_v3.class.getClassLoader().getResourceAsStream("beans.properties");
            //Properties：继承了Hashtable，作用是读取*.properties文件
            Properties properties = new Properties();
            properties.load(inputStream);
            //解决1.每次都会创建新的对象：在静态代码块创建对象并装到Map中，每次调用getBean()都直接从Map中获取对象而无需再重新创建了
            Set