Spring入门

一、IoC（Inversion of Control）控制反转

1. 基本概念：

1. IoC（Inversion of Control）控制反转

   使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建的控制权由程序转移到外部，此思想称为控制反转。

   Spring技术对IoC思想进行了实现：

   • Spring提供了一个容器，称为IoC容器，用来充当IoC思想中的外部。
   • IoC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为Bean

2. DI（Dependency Injection）依赖注入

   在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入

2. 核心概念

1. 目标：充分解耦
   • 使用IoC容器管理bean（IoC）
   • 在IoC容器内将有依赖关系的bean进行关系绑定（DI）
2. 最终效果：
   • 使用对象时不仅可以直接从IoC容器中获取，并且获取到的bean已经绑定了所有的依赖关系

二、入门案例

1. IoC

1. pom.xml导入spring坐标

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

2. 创建spring配置文件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">
   
   <!--    1. 导入坐标-->
   
   <!--    2. 配置bean-->
       <bean id="bookDao" class="org.example.dao.impl.BookDaoImpl" />
       <bean id="bookService" class="org.example.service.impl.BookServiceImpl" />
   </beans>
   

3. 实现

   package org.example;
   import org.example.dao.BookDao;
   import org.example.service.BookService;
   import org.example.service.impl.BookServiceImpl;
   import org.springframework.context.ApplicationContext;
   import org.springframework.context.support.ClassPathXmlApplicationContext;
   
   public class App {
       public static void main(String[] args) {
           // 获取IoC容器
           ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
           // 从容器中获取对象
           BookDao bookDao = (BookDao) context.getBean("bookDao");
           // 调用方法
           bookDao.save();
           BookService bookService = (BookService) context.getBean("bookService");
           bookService.save();
       };
   };
   

2. DI

1. 使用setter注入

   <?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 id="bookDao" class="org.example.dao.impl.BookDaoImpl"/>
       <bean id="userDao" class="org.example.dao.impl.UserDao"/>
       <bean id="bookService" class="org.example.service.impl.BookServiceImpl" autowire="byType">
           <property name="bookDao" ref="bookDao"/>
           <property name="userDao" ref="userDao"/>
       </bean>
   
   </beans>
   

   public class BookServiceImpl implements BookService {
       private BookDao bookDao;
       private UserDao userDao;
   
       public BookServiceImpl(BookDao bookDao) {
           this.bookDao = bookDao;
       };
   
       public BookServiceImpl() {
       };
       
       // setter方法
       public void setUserDao(UserDao userDao) {
           this.userDao = userDao;
       };
   
       public void setBookDao(BookDao bookDao) {
           this.bookDao = bookDao;
       };
   
       public void save(){
           System.out.println("Service层调用Dao层的方法...");
           bookDao.save();
           userDao.save();
       };
   
   };
   

   使用setter注入时，需要给每一个依赖项设置setter方法，配置文件中的 <property> 坐标中name属性的值实为setter方法的变量名，如：setter方法为 public void setBookDao()，则name属性的值为bookDao。ref属性的值为一个bean，所以需要注入的bean首先要配置bean。

   如果是基本数据类型和String，则不用ref属性，改为value属性。

2. 构造器注入

   <?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 id="bookDao" class="org.example.dao.impl.BookDaoImpl"/>
       <bean id="userDao" class="org.example.dao.impl.UserDao"/>
       <bean id="bookService" class="org.example.service.impl.BookServiceImpl" autowire="byType">
           <constructor-arg ref="bookDao"/>
           <constructor-arg ref="userDao"/>
       </bean>
   </beans>
   

   使用构造器注入时，需要有相应的构造方法，如在bookServiceImpl类中，应该有 public BookServiceImpl(BookDao bookDao, UserDao userDao) 构造方法，同时在配置文件中，应用 <constructor-arg> 标签，其属性与 <property> 基本类似。

3. 自动装配

   <bean id="bookService" class="org.example.service.impl.BookServiceImpl" autowire="byType"> 在bean标签中添加 autowire 属性，即可实现自动装配。其中byType为按类型装配，常用的还有byName按照名字自动装配。

三、容器相关

1. 获取容器的方式

1. 类路径加载配置文件

   ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

2. 文件路径加载配置文件

   ClassPathXmlApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\applicationContext.xml");

3. 加载多个配置文件

   ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("a1.xml","a2.xml");

2. Tips

• BeanFactory是Ioc容器的顶层接口，初始化BeanFactory对象时，bean为延迟加载
• ApplicationContext接口时Spring容器的核心接口，初始化时bean立即加载
• ApplicationContext接口提供基础的bean操作相关方法，通过其他接口扩展其功能
• ApplicationContext接口常用初始化类：
  1. ClassPathXmlApplicationContext
  2. FileSystemXmlApplicationContext

四、bean相关

1. 配置

<bean id="bookDao"
      name="bd BD"
      class="dao.impl.BookDaoImpl" 
      scope="singleton" 
      init-method="init"
      destroy-method="destroy"
      autowire="byType"
      factory-method="getInstance"
      factory-bean="factory.BookDaoFactory"
      lazy-init="true"
      />
<!--
    依次对应：
    bean的ID
    bean的别名
    bean类型，静态工厂类，FactoryBean类
    控制bean的实例化数量（单例、非单例）
    生命周期初始化方法
    生命周期销毁方法
    自动装配类型
    bean工厂方法，应用于静态工厂或实例工厂
    实例工厂bean
    控制bean是否延迟加载
-->

2. 获取bean的方式

1. 使用bean名称

   BookDao bookDao = (BookDao) ctx.getBean("bookDao");

2. 使用bean名称并指定类型

   BookDao bookDao = ctx.getBean("bookDao", BookDao.class);

3. 使用bean类型获取

   BookDao bookDao = ctx.getBean(BookDao.class);

五、依赖注入相关

1. 配置