Spring IOC详解

Spring 笔记

官网：https://spring.io/

核心功能：当你的项目启动的时候，自动的将当前项目的各种 Bean 都自动的注册到 Spring 容器中，然后在项目的其他地方，如果需要用到这些 Bean，直接去 Spring 容器中查找需要的对象即可。

Spring 家族的产品：

• Spring Framework：Spring 框架的基础，我们一般所说的 Spring、SpringMVC 其实都是 Spring Framework。
• Spring Boot：简化 Spring 配置，可以一键创建一个带有各种配置的 Spring 环境。
• Spring Data：简化数据库配置/简化数据库访问。
• Spring Cloud：微服务。
• Spring Security：安全管理框架。
• Spring Session：session 共享。

Spring Framework：

• Ioc
• Aop
• JdbcTemplate
• 事务

Spring 容器注册 Bean

正常情况

1. 创建一个 Maven 工程。

2. 引入 Spring 依赖：

   1. <dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.20</version></dependency>
      </dependencies>
      

3. 加入 Spring 的配置。

4. 创建一个 Bean 并注册。

   public class User {public void sayHello() {System.out.println("hello zhangsan");}
   }
   

   <?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"><!--class 指定类的全路径id 指定类的名称Spring 拿到这两个关键信息，就可以自动的创建一个 User 对象出来了--><bean class="com.qfedu.demo.model.User" id="user"/>
   </beans>
   

5. 启动 Spring 容器，并加载配置文件，当 Spring 容器启动之后，无论你是否跟 Spring 容器去要 User 对象，此时 User 对象都是已经创建好的状态，并保存在 Spring 容器中。

   public class MainDemo01 {public static void main(String[] args) {//这里只需要写配置文件的文件名即可，系统会自动去 classpath 下查找配置文件//这个就是加载 Spring 容器，只要 Spring 容器启动了，那么配置文件中的所有 Bean 就会完成初始化ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");//根据名字去查找一个 user 对象，这个方法返回一个 Object，需要进行类型转换User u1 = (User) ctx.getBean("user");u1.sayHello();//去查找 User 类型的对象//这种方式有一个缺陷：Spring 容器中如果存在多个 User 对象，那么这个方法执行就会报错User u2 = ctx.getBean(User.class);u2.sayHello();//告诉 Spring 容器，查找一个名为 user 的 bean，并且类型是 UserUser u3 = ctx.getBean("user", User.class);u3.sayHello();}
   }
   

异常情况

NoSuchBeanDefinitionException：

没有找到需要的 Bean：

1. 先检查注册的时候，Bean 的名称是否正确。
2. 检查跟 Spring 容器要的时候，Bean 的名称是否正确。
3. 检查一下启动 Spring 容器时，Spring 的配置文件名称是否正确。

NoUniqueBeanDefinitionException:

这表示要查找的目标 Bean 有多个，查找异常。这种时候就不要按照类型去查找，而应该按照名字去查找。

Bean 注册的细节

属性注入方式

1. 构造器注入

   1. 默认情况下，如果我们向 Spring 容器注入一个 Bean 的时候，不指定构造方法，那么默认使用的构造方法就是无参构造方法，所以如果你的类里边没有无参构造方法，就会出错。

      1. public class Book {private Integer id;private String name;private String author;public Book(Integer id, String name, String author) {this.id = id;this.name = name;this.author = author;}
         }
         

      2. 由于这个 Java 类没有无参构造方法，所以在注入 Bean 的时候，如果按照下面的方式注入，就会出错：

      3. <bean class="com.qfedu.demo.p2.model.Book" id="book"/>
         

      4. 在 bean 标签中，如果没有指定构造方法，默认就使用无参构造方法。

   2. 开发者也可以自己指定要使用哪一个构造方法：

      1. <!--这里没有指定使用哪个构造方法，默认就使用无参构造方法-->
         <bean class="com.qfedu.demo.p2.model.Book" id="book"/>
         <!--也可以指定要用哪个构造方法-->
         <bean class="com.qfedu.demo.p2.model.Book" id="book2"><constructor-arg name="id" value="1"/><constructor-arg name="name" value="三国演义"/><constructor-arg name="author" value="罗贯中"/>
         </bean>
         

2. set 方法注入

   <!--
   这里没有设置构造方法参数，所以默认使用的就是无参构造方法
   -->
   <bean class="com.qfedu.demo.p2.model.Book" id="book3"><!--这个配置将来会调用到 setId 这个方法--><property name="id" value="2"/><property name="name" value="红楼梦"/><property name="author" value="曹雪芹"/>
   </bean>
   

3. p 名称空间注入

   1. p 名称空间注入，本质上其实就是 set 方法注入。

   2. <!--没有指定构造方法，依然是使用默认的构造方法-->
      <bean class="com.qfedu.demo.p2.model.Book" id="book4" p:id="3" p:name="水浒传" p:author="施耐庵"></bean>
      

复杂属性的注入

List、数组、对象、Map、Set、Properties 等。

首先定义 User 类：

public class User {private Integer id;private String name;private String address;private Cat cat;private List<String> favorites;private List<Cat> cats;private Book[] books;private Map<String, Object> info;private Properties school;
}

属性注入：

<?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 class="com.qfedu.demo.model.Cat" id="cat"><property name="name" value="小白"/><property name="color" value="白色"/></bean><bean class="com.qfedu.demo.model.User" id="user"><property name="id" value="1"/><property name="name" value="zhangsan"/><property name="address" value="广州"/><!--用 set 方法给 cat 赋值的时候，有两种方式：Cat cat = new Cat();setCat(cat);setCat(new Cat());ref 表示这里的值是引用了一个提前定义好的 cat 对象--><property name="cat" ref="cat"/><property name="favorites"><!--list 标签表示数据类型是一个 List如果 list 中存放的数据是字符串，那么这里就直接使用 value如果 list 中存放的数据库是对象，那么可以使用 ref 去引用外部的 对象，也可以使用 bean 标签现场定义 Bean--><list><value>足球</value><value>篮球</value></list></property><property name="cats"><list><!--引用外部定义的 cat--><ref bean="cat"/><bean class="com.qfedu.demo.model.Cat"><property name="name" value="小黑"/><property name="color" value="黑色"/></bean></list></property><property name="books"><array><bean class="com.qfedu.demo.model.Book"><property name="id" value="1"/><property name="name" value="三国演义"/><property name="author" value="罗贯中"/></bean><bean class="com.qfedu.demo.model.Book"><property name="id" value="2"/><property name="name" value="红楼梦"/><property name="author" value="曹雪芹"/></bean></array></property><property name="info"><!--map 的定义--><map><entry key="gender" value="男"/><entry key="age" value="99"/></map></property><property name="school"><props><prop key="name">广州千锋</prop><prop key="address">广州市白云区</prop></props></property></bean>
</beans>

如果是通过构造方法注入：

<bean class="com.qfedu.demo.model.User" id="user2"><constructor-arg name="books"><!--这个标签中的内容和 set 方法注入时的一模一样--></constructor-arg>
</bean>

注意属性的名字

内省。

对于框架而言，并不是看对象定义的属性叫什么名字，而是根据对象的 get/set 方法来推断属性名称，无论是 MyBatis、Spring、SpringMVC，所有框架，只要用到反射，都是这样的。所以，定义 get/set 方法的时候，不要写错，另一方面，变量的命名要符合规范。

Java 代码配置 Spring

用一个 Java 配置类，去代替 XML 配置即可：

/*** 这个是 Java 配置类，它的作用类似于 applicationContext.xml** @Configuration 表示这是一个配置类*/
@Configuration
public class JavaConfig {/*** @Bean 就表示将当前方法的返回值注册到 Spring 容器中** 默认情况下，方法名称就是 bean 的名字** 如果需要自定义 bean 的名称，那么在注解中配置即可** @return*/@Bean("u")User user() {User user = new User();user.setAddress("广州");user.setName("zhangsan");return user;}}

启动 Spring 容器时，加载这个配置类即可：

public class Demo01 {public static void main(String[] args) {//启动 Spring 容器，加载一个 Java 配置类，构造方法中指定配置类即可AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(JavaConfig.class);User user = ctx.getBean("u", User.class);System.out.println("user = " + user);}
}

参数自动注入

• @Configuration：这个注解表示当前类是一个配置类，那么当前类中，所有添加了 @Bean 注解的方法都会被注册到 Spring 容器中，如果有其他方法调用到一个添加了 @Bean 注解的方法，那么不会立马执行对应的方法，而是先去 Spring 容器中查看是否有对应的对象，如果有，则直接从容器中获取即可，如果容器中没有的话，才回去执行对应的方法。

• @Component 虽然也可以加在配置类上，但是，如果有其他方法调用到一个添加了 @Bean 注解的方法，那么不会先去 Spring 容器中查看是否有对应的对象，而是直接执行对应的方法。所以一般在配置类中不使用 @Component 注解。如果一定要使用 @Component 注解，可以通过依赖注入来代替方法调用，类似下面这样：

  /*** 向 Spring 容器注册一个 Author 对象** @return*/
  @Bean
  Author author() {Author author = new Author();author.setName("鲁迅");author.setAge(55);return author;
  }
  /*** 向 Spring 容器中注册一个 Book 对象** book 中有一个 author 对象，book 中的 author 和 spring 容器中的 author 是否是同一个对象？* @return*/
  @Bean
  Book book2(Author author) {Book book = new Book();book.setName("故事新编");book.setAuthor(author);book.setPrice(18.0);return book;
  }
  

  在这里，所有的方法都是 Spring 容器调用的，当 Spring 容器调用 book2 这个方法的时候，就会发现这个方法的执行需要一个 Author 类型的参数，那么此时 Spring 容器就会去查找是否有一个 Author，如果有，则直接作为参数传进来，如果 Spring 容器中没有这个对象，那么直接抛出异常。

条件注解

条件注解是多环境配置的核心，思路就是提前准备好环境，所谓的环境，实际上就是 Condition 接口的实现类，然后在注册 Bean 的时候，通过 @Conditional 注解去指定环境，当满足某种条件的时候，bean 才会注入到 Spring 容器中。

两个非常经典的使用场景：

• 项目中的多环境配置。
• SpringBoot 中的自动化配置。

多环境切换

提前准备好生产环境、开发环境等的配置信息，将来通过 Profile 可以一键切换。

通过 Java 代码实现

主要是使用 @Profile 注解，这个注解的本质就是 @Conditional 条件注解，用到的条件实际上就是 ProfileCondition。

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ProfileCondition.class)
public @interface Profile {/*** The set of profiles for which the annotated component should be registered.*/String[] value();}

条件注解：

class ProfileCondition implements Condition {@Overridepublic boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {//获取 Profile 注解的所有属性，其实这个注解只有一个 value 属性，属性的值是一个数组MultiValueMap<String, Object> attrs = metadata.getAllAnnotationAttributes(Profile.class.getName());if (attrs != null) {//将属性中的 value 读取出来，这个 value 的值实际上是一个 String 数组，遍历 String 数组for (Object value : attrs.get("value")) {//判断当前环境中，有没有 value 中的值if (context.getEnvironment().acceptsProfiles(Profiles.of((String[]) value))) {return true;}}return false;}return true;}}

具体配置：

@Configuration
public class JavaConfig {/*** 开发环境的数据源** 通过 @Profile("dev") 注解可以指定当前的环境是开发环境* @return*/@Profile("dev")@Bean("ds")DataSource devDataSource() {DataSource ds = new DataSource();ds.setUsername("root");ds.setPassword("123");ds.setUrl("jdbc:mysql:///test01");return ds;}/*** 配置生产环境的数据源* @return*/@Profile("prod")@Bean("ds")DataSource prodDataSource() {DataSource ds = new DataSource();ds.setUsername("zhangsan");ds.setPassword("jdfkslajfl890324");ds.setUrl("jdbc:mysql://114.132.43.22/prod01");return ds;}
}

注册 Bean 的时候，通过 @Profile(“prod”) 注解来指定当前 Bean 在哪个环境下生效。

当启动 Spring 容器的时候，要为 Spring 容器指定当前的环境信息：

public class Demo01 {public static void main(String[] args) {//注意先不要写配置类，要先设置环境信息AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();//设置当前的环境信息ctx.getEnvironment().addActiveProfile("prod");ctx.register(JavaConfig.class);ctx.refresh();DataSource ds = ctx.getBean(DataSource.class);System.out.println("ds = " + ds);}
}

通过 XML 配置实现

首先在 xml 文件中，通过 beans 标签来指定环境：

<?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"><beans profile="dev"><!--将来写在这个标签中的 Bean，都是在 dev 环境下才会生效的 Bean--><bean class="com.qfedu.demo.p1.model.DataSource" id="dataSource"><property name="username" value="root"/><property name="password" value="123"/><property name="url" value="jdbc:mysql:///test01"/></bean></beans><beans profile="prod"><!--将来写在这个标签中的 Bean，都是在 prod 环境下才会生效的 Bean--><bean class="com.qfedu.demo.p1.model.DataSource" id="dataSource"><property name="username" value="root"/><property name="password" value="jkld3u$%^"/><property name="url" value="jdbc:mysql://11.22.11.22/test01"/></bean></beans>
</beans>

将来 Spring 容器启动的时候，会根据当前的环境信息去注册不同的 beans 标签中的 Bean。

启动容器的时候，设置一下当前环境即可：

public class Demo02 {public static void main(String[] args) {//先不要加载配置文件ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext();ctx.getEnvironment().addActiveProfile("dev");//设置好当前环境之后，再去设置配置文件的位置ctx.setConfigLocation("applicationContext.xml");ctx.refresh();DataSource ds = ctx.getBean(DataSource.class);System.out.println("ds = " + ds);}
}

配置文件的注入

主要是指 properties 配置文件的注入。

Java 代码配置

主要就是两个配置：

• @PropertySource：项目启动的时候，将配置文件中的内容注册到 Spring 容器中。
• @Value：从 Spring 容器要一个字符串回来。

@Configuration
@PropertySource("classpath:db.properties")
public class DsConfig {//跟 Spring 容器要一个字符串回来@Value("${db.username}")String username;@Value("${db.password}")String password;@Value("${db.url}")String url;@BeanDataSource dataSource() {DataSource ds = new DataSource();ds.setPassword(password);ds.setUsername(username);ds.setUrl(url);return ds;}
}

要能够从 Spring 容器中要到字符串，或者对象，有一个前提，当前 Bean 必须处于 Spring 容器中，不可以自己手动 new 一个 Bean。

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"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"><!--这个配置的作用类似于 @PropertySource，就是将配置文件注册到 Spring 容器中--><context:property-placeholder location="classpath:db.properties"/><!--${db.url} 表示引用 Spring 容器中，key 为 db.url 的变量--><bean class="com.qfedu.demo.p1.model.DataSource" id="dataSource"><property name="url" value="${db.url}"/><property name="password" value="${db.password}"/><property name="username" value="${db.username}"/></bean>
</beans>

包扫描

前面的 Bean 的注册方式，都是一个一个 Bean 去注册的。

Java 配置包扫描

官方推荐写法

整体上来说，三个方面：

1. 将 Bean 注册到 Spring 容器中：@Repository、@Service、@Controller 以及 @Component。

   /*** 将 UserDao 注册到 Spring 容器中，将来谁需要使用 UserDao，就直接跟 Spring 容器去查找即可*** @Repository：一般是加在 Dao 层* @Service：一般是加在 Service 层* @Controller：一般是加在控制层，也就是 servlet* @Component：身份不明的 Bean 注册到 Spring 容器中时，使用这个注解** 技术上来说，这四个注解并没有差异，即实际上除了 @Controller 之外，其他几个注解是可以混用的。** 实际开发中，不要混用**/
   @Repository
   public class UserDao {public User getUserByUsername(String username) {User user = new User();user.setUsername(username);user.setAddress("广州");return user;}
   }
   

2. 从 Spring 容器中要一个 Bean 回来，官方推荐的方式，是通过构造器来注入。

   /*** UserService 想要使用 UserDao* 1. UserService 自己需要在 Spring 容器* 2. 跟 Spring 容器去要一个 UserDao*/
   @Service
   public class UserService {UserDao userDao;/*** 官方推荐使用构造器注入。因为 UserService 要注册到 Spring 容器，要生成一个对象，必然就要调用它的构造方法，现在它只有这一个构造法方法，那么 Spring 容器只能通过这个构造方法来获取一个 UserService 的实例，那么 Spring 容器会自动去查找容器中是否有一个 UserDao 的实例，如果有，就作为这个方法的参数传入进来* @param userDao*/public UserService(UserDao userDao) {this.userDao = userDao;}public User getUserById(String username) {return userDao.getUserByUsername(username);}}
   

   这里又涉及到一个问题：如果有多个构造器怎么办？@Autowired 注解可解决。

   @Service
   public class UserService {UserDao userDao;/*** 官方推荐使用构造器注入。因为 UserService 要注册到 Spring 容器，要生成一个对象，必然就要调用它的构造方法，现在它只有这一个构造法方法，那么 Spring 容器只能通过这个构造方法来获取一个 UserService 的实例，那么 Spring 容器会自动去查找容器中是否有一个 UserDao 的实例，如果有，就作为这个方法的参数传入进来* * 如果有多个构造方法，那么可以通过 @Autowired 注解来告诉 Spring 容器，应该调用哪一个构造方法去初始化当前对象* @param userDao*/@Autowiredpublic UserService(UserDao userDao) {this.userDao = userDao;}public User getUserById(String username) {return userDao.getUserByUsername(username);}}
   

3. 配置包扫描。

   @ComponentScan(basePackages = "com.qfedu.demo")
   @Configuration
   public class JavaConfig {
   }
   

   通过 @ComponentScan 注解指定组件的路径即可。

日常使用较多的写法

和前面的步骤相比，主要是第二步不一样，其他都是一样的。

@Controller
public class UserServlet {/*** @Autowired 表示根据类型去 Spring 容器中查找到相应的 Bean，并赋值给 userService 变量*/@AutowiredUserService userService;public User getUserById(String username) {return userService.getUserById(username);}
}

直接在属性上添加 @Autowired 注解就可以完成属性的注入了。

这种写法是我们在实际开发中使用较多的一种方式。

构造方法注入：

• 官方考虑的是，这个类将来使用的时候，不一定就是跟 Spring 容器去要的，可能就是用户自己 new 出来的，例如用户如果直接 new 一个 UserServlet，那么此时 userService 变量就为 null，并且用户没有办法给 userService 赋值，导致 userService 为 null。但是如果用户是 new 一个 UserService 实例的话，那么就必须传递一个 UserDao 的实例。核心思想就是：这个 Bean 既可以跟 Spring 去要，也可以直接 new。
• 大部分情况下，一个类的属性都特别多，导致类的构造方法特别长，所以这种方式在实际项目中用的少。

注解注入：

• 简单便捷。
• 如果用户使用不规范，自己 new 了一个该对象，可能会导致对象中的很多属性没有赋值，为 null。

XML 配置包扫描

XML 配置包扫描跟 Java 配置包扫描，区别在于第三步。即包扫描用 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"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"><context:component-scan base-package="com.qfedu.demo"/>
</beans>

工厂 Bean

这个主要是解决一些第三方的 Bean，一些无法通过构造方法正常初始化、或者无法通过 set 方法正常为属性的赋值的 Bean，可以通过工厂 Bean 的方式将之注册到 Spring 容器中。

静态工厂

工厂方法是一个静态方法。

public class OkHttpClientFactory {private static OkHttpClient okHttpClient;public static OkHttpClient getInstance() {if (okHttpClient == null) {okHttpClient = new OkHttpClient.Builder()//设置服务端的读取超时时间.readTimeout(5000, TimeUnit.SECONDS)//连接超时.connectTimeout(5000, TimeUnit.SECONDS).build();}return okHttpClient;}
}

在 XML 文件中，直接配置工厂 Bean 即可：

<?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，将来会自动调用 getInstance 方法，并将该方法的返回值注入到 Spring 容器中--><bean class="com.qfedu.demo.OkHttpClientFactory" factory-method="getInstance" id="client01"/>
</beans>

需要注意的是，这里将来注册到 Spring 容器中的 Bean，不是 class 对应的类的对象，而是 getInstance 方法返回的对象。

实例工厂

工厂方法变为实例方法，执行的时候，必须要现有工厂对象，然后才能调用对应的方法。

public class OkHttpClientFactory2 {private OkHttpClient okHttpClient;public OkHttpClient getInstance() {if (okHttpClient == null) {okHttpClient = new OkHttpClient.Builder()//设置服务端的读取超时时间.readTimeout(5000, TimeUnit.SECONDS)//连接超时.connectTimeout(5000, TimeUnit.SECONDS).build();}return okHttpClient;}
}

Bean 的注册：

<!--
对于实例工厂方法，必须得先有一个工厂的实例，将来要通过这个实例才能调用工厂方法
-->
<bean class="com.qfedu.demo.OkHttpClientFactory2" id="clientFactory2"/>
<!--此时配置工厂的时候，既需要指定工厂的 Bean，也需要指定工厂方法-->
<bean class="okhttp3.OkHttpClient" factory-bean="clientFactory2" factory-method="getInstance" id="client02"/>

FactoryBean

这是 Spring 官方推荐的工厂 Bean 的实现方式。

public class OkHttpClientFactoryBean implements FactoryBean<OkHttpClient> {/*** 返回真正的对象* @return* @throws Exception*/@Overridepublic OkHttpClient getObject() throws Exception {return new OkHttpClient.Builder()//设置服务端的读取超时时间.readTimeout(5000, TimeUnit.SECONDS)//连接超时.connectTimeout(5000, TimeUnit.SECONDS).build();}/*** 返回对象的类型* @return*/@Overridepublic Class<?> getObjectType() {return OkHttpClient.class;}/*** 这个对象是否是单例的* @return*/@Overridepublic boolean isSingleton() {return true;}
}

然后在 XML 文件中注册即可：

<bean class="com.qfedu.demo.OkHttpClientFactoryBean" id="client03"/>

Bean 的作用域

默认情况下，注册到 Spring 容器中的 Bean 是单例的：

<?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 class="com.qfedu.demo.User" id="user"/>
</beans>

如果不希望这个 Bean 是单例的，那么可以通过如下方式进行修改：

<?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 class="com.qfedu.demo.User" id="user" scope="prototype"/>
</beans>

scope 有五种取值：

• singleton：表示这个 bean 是单例的，从 Spring 容器中多次获取，拿到的是同一个 Bean。
• prototype：每一次去 Spring 容器中，都可以获取到一个全新的 Bean。
• request：在同一个请求中，如果多次获取同一个 Bean，获取到的是同一个（web 环境下生效）
• session：在同一个 session 中，如果多次获取同一个 Bean，获取到的是同一个（web 环境下生效）
• application：在同一个 web 应用中，如果多次获取同一个 Bean，获取到的是同一个（web 环境下生效）（web 环境下生效）

也可以通过 Java 代码配置 scope，通过 @Scope 注解，可以指定一个 Bean 的作用域：

@Configuration
public class JavaConfig {@Bean@Scope("prototype")User user() {return new User();}
}

Bean 的初始化和销毁

主要是两个方法：

public class User {private String username;private String address;public User() {System.out.println("构造方法。。。");}/*** 假设这个方法用来初始化当前 Bean*/public void init() {System.out.println("初始化方法。。。");}/*** 当当前 Bean 销毁的时候，可以在当前方法中做一些资源回收操作*/public void destroy() {System.out.println("销毁方法。。。");}
}

如果在 Spring 容器完成注册之后，还想要做一些配置，那么可以在 init 方法中完成，当 Spring 容器销毁的时候，可以在 destroy 方法中完成一些资源回收操作。

<bean class="com.qfedu.demo.User" init-method="init" destroy-method="destroy" id="user"/>

IoC 小结

控制反转，指的是对象的控制权反转。本来，UserService 需要一个 UserDao，那么直接在 UserSerivce 中 new 一个 UserDao，那么此时 UserDao 的对象的控制权就在 UserService 中；有了 Spring 之后，系统启动的时候，UserDao 会将自己的各种信息告诉 Spring 容器，Spring 利用这些信息，就可以结合反射创建一个 UserDao 对象，此时 UserDao 对象处于 Spring 容器中，这个对象的控制权在 Spring 容器中，对象的控制权从 UserService 中转移到了 Spring 容器中，就是控制（权）反正。利用 IoC 可以实现对象之间的解耦。