IoC和DI

一、 Spring是什么？

Spring是分层的Java SE/EE应用full-stack轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和
AOP（Aspect Oriented Programming：面向切面编程）为内核。

提供了展现层 SpringMVC 和持久层 Spring JDBCTemplate 以及业务层事务管理等众多的企业级应用技术
，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

二、发展历程（了解）

三、优势

1. 方便解耦，简化开发
   
   通过 Spring 提供的 IoC容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度耦合。
   用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
2. 对AOP编程支持
   
   通过 Spring的 AOP 功能，方便进行面向切面编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松实现。
3. 声明式事务的支持
   
   可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务管理，提高开发效率和质量。
4. 方便程序测试
   
   可以用非容器依赖的编程方式进行几乎所有的测试工作，随手可做。
5. 方便集成各种优秀框架
   
   Spring对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的支持。
6. 降低JavaEE的一些API的使用难度
   
   Spring对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了封装，使这些 API 的使用难度大为降低。

四、Spring的体系结构

五、Spring的简单使用

1. 开发步骤
   1. 导入Spring开发的基本包坐标
   2. 创建接口和实现类
   3. 创建Spring核心配置文件applicationContext.xml
   4. 在Spring配置文件中配置实现类
   5. 使用Spring的API获得Bean实例
2. 导入Spring开发的基本包坐标

   <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-context</artifactId>
           <version>5.0.5.RELEASE</version>
   </dependency>
   

3. 创建接口和实现类

   package Dao.Impl;
   import Dao.UserDao;
   public class UserDaoImpl implements UserDao {
   
       @Override
       public void save() {
           System.out.println("hahaha");
       }
   }
   

   package Dao;
   public interface UserDao {
       public void save();
   }
   

4. 创建Spring核心配置文件applicationContext.xml
   
   在resource中创建applicationContext.xml

   <?xml version="1.0" encoding="UTF-8" ?>
   <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>
   

5. 在Spring配置文件中配置UserDaoImpl

   <bean id="userDao" class="Dao.Impl.UserDaoImpl" scope="singleton"></bean>
   

6. 使用Spring的API获得Bean实例

   @Testpublic void test1(){
   ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
   UserDao userDao = (UserDao)applicationContext.getBean("userDao");
   userDao.save();
   

Spring配置文件

1. Bean标签的基本配置
   用于配置对象交由Spring 来创建。
   
   默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。
   
   基本属性
   • id：Bean在spring容器中的唯一标识。
   • class：Bean的全称限定词
   • scope：对象的作用范围
     
2. Bean标签范围配置
   

取值范围	说明
singleton	默认值，单例的
prototype	多例的
request	WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
session	WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
global session	WEB 项目中，应用在Portlet环境，如果没有Portlet环境那么globalSession相当于session

1. 当scope的取值为singleton时
   
   • Bean的实例化个数：1个
   • Bean的实例化时机：当Spring核心文件被加载时，实 例化配置的Bean实例
   • Bean的生命周期：
     • 对象创建：当应用加载，创建容器时，对象就被创建了。
     • 对象运行：只要容器在，对象就一直活着。
     • 对象销毁，当应用卸载时，容器销毁时，对象就被销毁了。
2. 当scope的取值为prototype时
   • Bean的实例化个数：多个
   • Bean实例化时机：当调用getBean方法的时候
     • 对象创建：当使用对象时，创建新的对象实例。
     • 对象运行：只要对象在使用中，就一直活着。
     • 对象销毁：当对象长时间不用时，被Java的垃圾回收器回收了。
3. Bean生命周期配置
   • init-method：指定类中的初始化方法名称
   • destroy-method：指定类中销毁方法名称
4. Bean实例化的三种方式
   • 无参构造方法实例化（就是前面入门所展示的）
   • 工厂静态方法实例化

   //1.编写工厂类StaticFactory
   public class StaticFactory {
       public static UserDao getUserDao(){
           return new UserDaoImpl();
       }
   }
   

   //2.在applicationContext.xml里面配置
   <bean id="userDao" class="factory.StaticFactory" factory-method="getUserDao"></bean>
   

   • 工厂实例方法实例化

   //1. 编写工程类
   public class DynamicFactory {
       public UserDao getUserDao(){
           return new UserDaoImpl();
       }
   }
   

   //2.在applicationContext.xml里面配置
   <bean id="factory" class="factory.DynamicFactory"></bean>
   <bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>
   

5. Bean的依赖注入入门

   //1.创建UserService，UserService内部调用UserDao的save()方法
   public class UserServiceImpl implements UserService {
       public void save() {
           ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
           UserDao userDao = (UserDao) app.getBean("userDao");
           userDao.save();
       }
   }
   

   //2.将UserServiceImpl的创建权交给Spring
   <bean id="userService" class="service.Impl.UserServiceImpl"></bean>
   

   //3.从Spring容器中获得UserService进行操作
   ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
       UserService userService = (UserService) app.getBean("userService");
       userService.save();
   

6. Bean的依赖注入分析
   

目前UserService实例和UserDao实例都存在Spring容器中，当前的做法是在容器外部获得UserService和UserDao实例，然后在程序中结合

因为UserService和UserDao都在Spring容器中，而最终程序直接使用的是UserService，所以可以在
Spring容器中，可以将UserDao设置到UserService内部。

7. Bean的依赖注入概念

依赖注入：是Spring框架核心IOC的具体实现。

在编写程序的过程中，通过控制反转，将对象的创建交给了Spring，但是代码中不可能出现完全没有依赖的情况，IOC解耦只是降低了他们的依赖关系，并不会消除。

而这些依赖关系，在使用Spring后，就让Spring来进行维护，而不是自己去获取。

8. Bean的依赖注入方式

• 构造方法
• set方法
  
  构造方法：

  //1.创建有参构造
  private UserDao userDao;
  public UserServiceImpl(UserDao userDao) {
      this.userDao = userDao;
  }
  

  //配置有参构造
  <bean id="userDao" class="Dao.Impl.UserDaoImpl"></bean>
  <bean id="userService" class="service.Impl.UserServiceImpl">
      <constructor-arg name="userDao" ref="userDao"></constructor-arg>
  </bean>
  

  set方法

  //1.配置set方法
  private UserDao userDao;
  public void setUserDao(UserDao userDao) {
      this.userDao = userDao;
  }
  

  //2. 将UserDao配置到UserService中
  <bean id="userDao" class="Dao.Impl.UserDaoImpl"></bean>
  <bean id="userService" class="service.Impl.UserServiceImpl">
      <property name="userDao" ref="userDao"></property>
  </bean>
  

9.Bean依赖注入的数据类型

• 普通数据类型
• 引用数据类型
• 集合数据类型
  1. 普通数据类型
     

  public class UserDaoImpl implements UserDao {
  private String company;
  private int age;
  
  public void setCompany(String company) {
      this.company = company;
  }
  
  public void setAge(int age) {
      this.age = age;
  }
  
  @Override
  public void save() {
      System.out.println(company + "====" + age);
      System.out.println("UserDao save me method running......");
      }
  }
  
  

  2. 集合数据类型
     1. List
     2. List
     3. Map<String,User>
     4. Properties

10. 引入其他配置文件(分模块开发)
    放在resource目录中

    <import resource="applicationContext-xxx.xml"/>
    

11. Spring相关API

    • ApplicationContext继承体系
      applicationContext:接口类型，代表应用上下文，可以通过其实例获得Spring中的Bean对象
      

    • ApplicationContext的实现类

      1. ClassPathXmlApplicationContext(推荐)
      2. FileSystemXmlApplicationContext(通过磁盘路径)
      3. AnnotationConfigApplicationContext(通过注解)

    • getBean()方法使用

      public Object getBean(String name) throws BeansException {
          assertBeanFactoryActive();
          return getBeanFactory().getBean(name);
      }
          public <T> T getBean(Class<T> requiredType) throws BeansException {
          assertBeanFactoryActive();
          return getBeanFactory().getBean(requiredType);
      }
      

      其中，当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。

      当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，
      则此方法会报错。

      ApplicationContext applicationContext = new 
      ClassPathXmlApplicationContext("applicationContext.xml");
      UserService userService1 = (UserService) 
      applicationContext.getBean("userService");
      UserService userService2 = applicationContext.getBean(UserService.class);