SpringIOC

2.1.程序的耦合

• 耦合：耦合指的就是对象之间的依赖关系。对象之间的耦合越高，维护成本越高。

• 案例：没有引入IOC容器时系统的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(工厂模式)解耦：

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

2.2.工程模式的IOC解决程序耦合

2.2.2.什么是IOC

• IOC (Inverse of Control)即控制反转：正传是自己创建依赖对象；反正是有IOC工厂来创建依赖对象；

• 原来：

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

  ​

• 现在：

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

​

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

2.2.3.工厂模式的IOC解耦

• 案例一

  /**
   * bean工厂
   */
  public class BeanFactory_v1 {
  
      /**
       * 获得UserServiceImpl对象
       * @return
       */
      public static UserService getUserService(){
          return new UserServiceImpl();
      }
  
      /**
       * 获得UserDaoImpl对象
       * @return
       */
      public static UserDao getUserDao(){
          return new UserDaoImpl();
      }
  }
  

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

• 案例二

  #1、配置要使用的dao和service
  UserDao=com.by.dao.UserDaoImpl
  UserService=com.by.service.UserServiceImpl
  

  /**
   * bean工厂
   */
  public class BeanFactory_v2 {
  
      private static Properties prop = new Properties();
  
      /**
       * 根据全类名获取bean对象
       * @param beanName
       * @return
       * @throws ClassNotFoundException
       */
      public static Object getBean(String beanName) {
          try {
              //不能使用：web工程发布后没有src目录
              //InputStream is = new FileInputStream("src/bean.properties");
              InputStream is = 
              BeanFactory_v2.class.getClassLoader()
                  .getResourceAsStream("bean.properties");
              prop.load(is);
              return Class.forName(prop.getProperty(beanName)).newInstance();
          } catch (Exception e) {
              e.printStackTrace();
          }
          return null;
      }
  
      public static void main(String[] args) {
          System.out.println(prop.get("UserService"));
          System.out.println(getBean("UserService"));
      }
  }
  

  /**
   * 业务层实现类
   */
  public class UserServiceImpl implements UserService {
      
      private UserDao userDao = (UserDao) BeanFactory.getBean("UserDao");
  
      public void addUser(){
        userDao.addUser();
      }
  }
  

  测试：

  /**
   * 模拟表现层
   */
  public class Client {
      public static void main(String[] args) {
          //直接引用接口实现类
        for (int i = 0; i < 5; i++) {
              UserService userService = 
                (UserService)BeanFactory.getBean("UserService");
              System.out.println(userService);
          }
      }
  }
  

  问题：
  1. 每次都会创建新的对象
  2. 程序运行时才创建对象(读取配置文件)

• 案例三

  package com.by.factory;
  
  import java.io.InputStream;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Properties;
  import java.util.Set;
  
  /**
   * bean工厂
   */
  public class BeanFactory_v3 {
  
      //定义一个容器，用于存放对象
      private static Map<String, Object> beans = new HashMap<>();
  
      /**
       * 加载配置文件
       */
      static {
          try {
              //2、读取配置文件
              //不能使用：web工程发布后没有src目录
              //InputStream is = new FileInputStream("src/bean.properties");
              InputStream is = 
              BeanFactory_v3.class.getClassLoader()
                  .getResourceAsStream("bean.properties");
  
              //3、通过反射创建对象,把对象存到容器中
              Properties prop = new Properties();
              prop.load(is);
              Set<Map.Entry<Object, Object>> entrySet = prop.entrySet();
              for (Map.Entry<Object, Object> entry : entrySet) {
                  String key = entry.getKey().toString();
                  String beanName = entry.getValue().toString();
                  Object value = Class.forName(beanName).newInstance();
                  beans.put(key, value);
              }
  
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  
      /**
       * 4、在使用的时候，直接从工厂拿
       * @param beanName
       * @return
       */
      public static Object getBean(String beanName) {
          try {
              return beans.get(beanName);
          } catch (Exception e) {
              e.printStackTrace();
          }
          return null;
      }
  
      public static void main(String[] args) {
          System.out.println(getBean("UserService"));
      }
  }
  

2.3.Spring的IOC解决程序耦合

2.3.1.创建工程

2.3.1.1.pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <groupId>com.bygroupId>
    <artifactId>Spring_IOC_XmlartifactId>
    <version>1.0-SNAPSHOTversion>
    
    <properties>
        
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
        
        <maven.compiler.source>8maven.compiler.source>
        <maven.compiler.target>8maven.compiler.target>
    properties>
    
    <dependencies>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.1.8.RELEASEversion>
        dependency>
    dependencies>
project>

注意：Jar包彼此存在依赖，只需引入最外层Jar即可由Maven自动将相关依赖Jar引入到项目中。

Spring常用功能的Jar包依赖关系

​ 核心容器由 beans、core、context 和 expression（Spring Expression Language，SpEL）4个模块组成。

• spring-beans和spring-core模块是Spring框架的核心模块，包含了控制反转（Inversion of Control，IOC）和依赖注入（Dependency Injection，DI）。BeanFactory使用控制反转对应用程序的配置和依赖性规范与实际的应用程序代码进行了分离。BeanFactory属于延时加载，也就是说在实例化容器对象后并不会自动实例化Bean，只有当Bean被使用时，BeanFactory才会对该 Bean 进行实例化与依赖关系的装配。
• spring-context模块构架于核心模块之上，扩展了BeanFactory，为它添加了Bean生命周期控制、框架事件体系及资源加载透明化等功能。此外，该模块还提供了许多企业级支持，如邮件访问、远程访问、任务调度等，ApplicationContext 是该模块的核心接口，它的超类是 BeanFactory。与BeanFactory不同，ApplicationContext实例化后会自动对所有的单实例Bean进行实例化与依赖关系的装配，使之处于待用状态。
• spring-expression 模块是统一表达式语言（EL）的扩展模块，可以查询、管理运行中的对象，同时也可以方便地调用对象方法，以及操作数组、集合等。它的语法类似于传统EL，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。EL的特性是基于Spring产品的需求而设计的，可以非常方便地同Spring IoC进行交互。

2.3.1.2.dao

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

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

2.3.1.3.service

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

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

2.3.2.IOC

2.3.2.1.applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    
    <bean id="userDao" class="com.by.dao.UserDaoImpl">bean>
    <bean id="userService" class="com.by.service.UserServiceImpl">bean>
beans>

注意：命名无限制，约定俗成命名有：spring-context.xml、applicationContext.xml、beans.xml