Spring框架学习

文章40 |   阅读 21324 |   点赞0

来源：https://blog.csdn.net/yerenyuan_pku/category_6457009.html

Spring入门第三讲——Spring中Bean的配置与管理以及分模块开发的配置

转x33g5p2x  于2021-12-18 转载在 其他  
字(20.0k)|赞(0)|评价(0)|浏览(513)

在《Spring入门第一讲——Spring框架的快速入门》这一讲中，我们已经快速入门了Spring，现在咱就在第一讲的基础上，讲解一下Spring中Bean的相关配置和管理，不过这都是基于XML文件的这种方式哟！温馨提示：初学者如果第一次学习Spring这个框架，那么还是建议先入门Spring再说，因此初学者可以看看我写的Spring入门第一讲，而在本讲中我写的一些代码都是基于第一讲基础上的，初学者猛然看到这讲，必然会感到很不适应的。

Bean的相关配置

<bean>标签中id和name属性的配置

从之前编写的Spring配置文件中，我们可以发现<bean>标签中有一个id属性，其实它还有一个和id属性类似的name属性，根据它俩的值均能得到配置对象。

  • id属性：在Spring配置文件中会有多个bean标签，但它们的id属性值是不能相同的。Bean起名字时，在约束中采用的是ID约束（唯一约束），而且名字必须以字母开始，可以使用字母、数字、连字符、下划线、句号、冒号等，但id属性值绝对不能有特殊符号；
  • name属性：没有使用约束中的唯一约束，理论上name属性值是可以出现重复的，但是这在实际开发中是不可能出现的，而且它里面可以出现特殊字符。其实，在Spring和Struts1框架进行整合的时候，才有可能会用到，例如：

Bean的生命周期的配置

通过配置<bean>标签上的init-method作为Bean被初始化的时候执行的方法，配置destroy-method作为Bean被销毁的时候执行的方法，要想Bean被销毁的时候执行destroy-method属性中配置的方法，那么Bean得是单例创建的（默认即单例创建），而且只有工厂被关闭时，destroy-method属性中配置的方法才能被执行。下面我会通过一个案例来告诉大家Bean的生命周期是怎样的。
首先，在src目录下创建一个com.meimeixia.spring.demo02包，并在该包下创建一个名为CustomerDao的接口。

  1. package com.meimeixia.spring.demo02;
  3. public interface CustomerDao {
  4. 	
  5. 	public void save();
  7. }

然后，在com.meimeixia.spring.demo02包下创建CustomerDao接口的一个实现类——CustomerDaoImpl.java。

  1. package com.meimeixia.spring.demo02;
  3. public class CustomerDaoImpl implements CustomerDao {
  4. 	
  5. 	public void setup() {
  6. 		System.out.println("CustomerDaoImpl被初始化了......");
  7. 	}
  9. 	@Override
  10. 	public void save() {
  11. 		System.out.println("CustomerDaoImpl中的save方法执行了......");	
  12. 	}
  13. 	
  14. 	/* * 工厂被关闭之后，才会调用该方法 */
  15. 	public void destroy() {
  16. 		System.out.println("CustomerDaoImpl被销毁了......");
  17. 	}
  19. }

接着，将CustomerDaoImpl实现类交给Spring来管理，即在配置文件中配置对象的创建。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <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">
  3.         
  4. 	<!-- Spring入门的配置 -->
  5. 	<bean id="userDao" class="com.meimeixia.spring.demo01.UserDaoImpl">
  6. 		<!-- DI：依赖注入 -->
  7. 		<property name="name" value="李二" />
  8. 	</bean>
  9. 	
  10. 	<!-- Spring的bean的生命周期的配置 -->
  11. 	<bean id="customerDao" class="com.meimeixia.spring.demo02.CustomerDaoImpl" init-method="setup" destroy-method="destroy" />
  12. 	
  13. </beans>

紧接着，在com.meimeixia.spring.demo02包下创建一个SpringDemo02的单元测试类。

  1. package com.meimeixia.spring.demo02;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  6. public class SpringDemo02 {
  8. 	/* * 生命周期的配置 */
  9. 	@Test
  10. 	public void demo01() {
  11. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  12. 		CustomerDao customerDao = (CustomerDao) applicationContext.getBean("customerDao");
  13. 		customerDao.save();
  14. 	}
  15. 	
  16. }

最后，运行以上demo01单元测试方法，Eclipse控制台就会打印如下内容。

咦！咋destroy-method属性中配置的destroy方法没有被执行呢？这是因为咱的工厂类没有被关闭，那工厂类该咋关闭呢？可以调用ApplicationContext接口的ClassPathXmlApplicationContext这个实现类中的close方法。所以，SpringDemo02单元测试类中的demo01测试方法应该修改为下面的样子。

  1. package com.meimeixia.spring.demo02;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. public class SpringDemo02 {
  9. 	/* * 生命周期的配置 */
  10. 	@Test
  11. 	public void demo01() {
  12. 		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  13. 		CustomerDao customerDao = (CustomerDao) applicationContext.getBean("customerDao");
  14. 		customerDao.save();
  15. 		applicationContext.close();//此时，CustomerDaoImpl这个类是被单例创建的，当工厂类被关闭时，destroy-method属性中配置的方法就能被执行了。 
  16. 	}
  17. 	
  18. }

此时，运行以上demo01单元测试方法，Eclipse控制台就会打印出如下内容。

上面我说过，要想Bean被销毁的时候执行destroy-method属性中配置的方法，那么前提Bean得是单例创建的，默认即单例创建，就像下面这样。

如果Bean改为了多例模式创建，就像下面这样。

那么当工厂类被关闭时，destroy-method属性中配置的方法也就不会被执行了。你可以试着运行一下demo01单元测试方法，你会发现Eclipse控制台打印出了如下内容。

Bean的作用范围的配置

<bean>标签上有一个scope属性，它代表Bean的作用范围。该属性有五个属性值，分别是：

其中，singleton和prototype这两个属性取值我们必须要弄得很懂，下面我会单独地讲解一下它俩。

singleton

singleton是scope属性的默认值。在我们把CustomerDaoImpl实现类交给Spring来管理时，明确该Bean的scope属性取值为singleton。

接着，在SpringDemo02的单元测试类中编写如下的一个demo02测试方法。

  1. package com.meimeixia.spring.demo02;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. public class SpringDemo02 {
  9. 	/* * 生命周期的配置 */
  10. 	@Test
  11. 	public void demo01() {
  12. 		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  13. 		CustomerDao customerDao = (CustomerDao) applicationContext.getBean("customerDao");
  14. 		customerDao.save();
  15. 		applicationContext.close();//此时，CustomerDaoImpl这个类是被单例创建的，当工厂类被关闭时，destroy-method属性中配置的方法就能被执行了。 
  16. 	}
  17. 	
  18. 	/* * bean的作用范围的配置 */
  19. 	@Test
  20. 	public void demo02() {
  21. 		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  22. 		CustomerDao customerDao1 = (CustomerDao) applicationContext.getBean("customerDao");
  23. 		System.out.println(customerDao1);
  24. 		CustomerDao customerDao2 = (CustomerDao) applicationContext.getBean("customerDao");
  25. 		System.out.println(customerDao2);
  26. 		
  27. 		System.out.println(customerDao1 == customerDao2);//true，bean默认即单例创建
  28. 		
  29. 		applicationContext.close();
  30. 	}
  31. 	
  32. }

然后，运行以上demo02单元测试方法，你就会发现Eclipse控制台打印了如下内容。

prototype

如果把CustomerDaoImpl实现类交给Spring来管理时，明确该Bean的scope属性取值为prototype，就像下面这样。

那么此时运行以上demo02单元测试方法，你就会发现Eclipse控制台打印了如下内容。

从上图中，我们就能看出Bean现在是多例模式创建的了。而且工厂类关闭之后，它也没被销毁，因为现在内存里面是有很多个对象，它不知道要销毁哪一个具体的CustomerDaoImpl对象，所以，要想工厂类被关闭之后，Bean被销毁（此时将会执行destroy-method属性中配置的方法），那么Bean得是单例创建的（默认即单例创建）！

Bean的管理

通俗一点说，Spring中Bean的管理即指创建对象时不需要new操作代码实现，而是交给Spring进行配置完成。Spring进行Bean的管理有两种方式，分别是：

  1. 使用配置文件方式实现
  2. 使用注解方式实现

本讲将重点放在第一种方式上，后一种方式后面会讲。

Spring中Bean的实例化方式

Bean交给Spring管理之后，它在创建这些Bean的时候，有以下几种方式：

无参构造方法的方式（默认）

这种方式是Spring实例化Bean的默认方式，指的是在创建对象的时候，Spring会调用类里面的无参数的构造方法实现。这里，我会通过一个案例来讲讲这种方式。首先，在src目录下创建一个com.meimeixia.spring.demo03包，并在该包下创建一个名为Bean1的类。

  1. package com.meimeixia.spring.demo03;
  3. /** * 无参构造方法的方式（默认） * @author liayun * */
  4. public class Bean1 {
  5. 	
  6. 	public Bean1() {
  7. 		System.out.println("Bean1的无参数的构造方法执行了......");
  8. 	}
  9. 	
  10. }

然后，将以上类交给Spring来管理，所以Spring配置文件就该下面这样写了。

接着，在com.meimeixia.spring.demo03包下创建一个SpringDemo03的单元测试类。

  1. package com.meimeixia.spring.demo03;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. public class SpringDemo03 {
  9. 	/* * 无参构造方法的方式（默认） */
  10. 	@Test
  11. 	public void demo01() {
  12. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  13. 		Bean1 bean1 = (Bean1) applicationContext.getBean("bean1");
  14. 		System.out.println(bean1);
  15. 	}
  16. 	
  17. }

最后，运行以上demo01单元测试方法，你就会发现Eclipse控制台打印了如下内容。

静态工厂实例化的方式

创建一个工厂类，在工厂类中提供一个静态的方法，这个方法返回类的对象，调用工厂类的方法的时候，直接使用类名.方法名称即可以调用。这里，我会通过一个案例来讲讲这种方式。首先，在com.meimeixia.spring.demo03包下创建一个名为Bean2的类。

  1. package com.meimeixia.spring.demo03;
  3. public class Bean2 {
  4. 	
  5. 	public Bean2() {
  6. 		System.out.println("Bean2类中的无参构造方法执行了......");
  7. 	}
  8. 	
  9. }

然后，在该包下创建一个Bean2Factory工厂类。

  1. package com.meimeixia.spring.demo03;
  3. /* * Bean2的静态工厂 */
  4. public class Bean2Factory {
  6. 	public static Bean2 createBean2() {
  7. 		System.out.println("Bean2Factory中的方法执行了......");
  8. 		return new Bean2();
  9. 	}
  10. 	
  11. }

接着，将以上工厂类交给Spring来管理，所以Spring配置文件就该写成下面这样。

紧接着，在SpringDemo03的单元测试类中编写如下的一个demo02测试方法。

  1. package com.meimeixia.spring.demo03;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. public class SpringDemo03 {
  9. 	/* * 无参构造方法的方式（默认） */
  10. 	@Test
  11. 	public void demo01() {
  12. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  13. 		Bean1 bean1 = (Bean1) applicationContext.getBean("bean1");
  14. 		System.out.println(bean1);
  15. 	}
  16. 	
  17. 	/* * 静态工厂实例化的方式 */
  18. 	@Test
  19. 	public void demo02() {
  20. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  21. 		Bean2 bean2 = (Bean2) applicationContext.getBean("bean2");
  22. 		System.out.println(bean2);
  23. 	}
  24. 	
  25. }

最后，运行以上demo02单元测试方法，你就会发现Eclipse控制台打印了如下内容。

实例工厂实例化的方式

创建一个工厂类，在工厂类里面提供一个普通的方法，这个方法返回类对象，调用工厂类的方法时，创建工厂类对象，使用对象调用方法即可。这里，我也会通过一个案例来讲讲这种方式。首先，在com.meimeixia.spring.demo03包下创建一个名为Bean3的类。

  1. package com.meimeixia.spring.demo03;
  3. public class Bean3 {
  4. 	
  5. 	public Bean3() {
  6. 		System.out.println("Bean3类中的无参构造方法执行了......");
  7. 	}
  8. 	
  9. }

然后，在该包下创建一个Bean3Factory工厂类。

  1. package com.meimeixia.spring.demo03;
  3. /** * Bean3的实例工厂 * @author liayun * */
  4. public class Bean3Factory {
  6. 	public Bean3 createBean3() {
  7. 		System.out.println("Bean3的实例工厂中的方法执行了......");
  8. 		return new Bean3();
  9. 	}
  10. 	
  11. }

接着，将以上工厂类交给Spring来管理，所以Spring配置文件就该写成下面这样。

紧接着，在SpringDemo03的单元测试类中编写如下的一个demo03测试方法。

  1. package com.meimeixia.spring.demo03;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. public class SpringDemo03 {
  9. 	/* * 无参构造方法的方式（默认） */
  10. 	@Test
  11. 	public void demo01() {
  12. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  13. 		Bean1 bean1 = (Bean1) applicationContext.getBean("bean1");
  14. 		System.out.println(bean1);
  15. 	}
  16. 	
  17. 	/* * 静态工厂实例化的方式 */
  18. 	@Test
  19. 	public void demo02() {
  20. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  21. 		Bean2 bean2 = (Bean2) applicationContext.getBean("bean2");
  22. 		System.out.println(bean2);
  23. 	}
  24. 	
  25. 	/* * 实例工厂实例化的方式 */
  26. 	@Test
  27. 	public void demo03() {
  28. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  29. 		Bean3 bean3 = (Bean3) applicationContext.getBean("bean3");
  30. 		System.out.println(bean3);
  31. 	}
  32. 	
  33. }

最后，运行以上demo03单元测试方法，你就会发现Eclipse控制台打印了如下内容。

Spring中Bean的属性注入

实际上，有关Bean的属性注入共有三种方式，下面我分别加以简单的说明。

  • set方法注入

  • 有参数构造注入

  • 接口注入

但是，在Spring框架里面，只支持前两种方式，即set方法注入和有参数构造注入。下面我会对详细地介绍它们。

构造方法的方式注入属性

首先，在src目录下创建一个com.meimeixia.spring.demo04包，并在该包下编写一个Car实体类。

  1. package com.meimeixia.spring.demo04;
  3. public class Car {
  4. 	
  5. 	private String name;
  6. 	private Double price;
  7. 	public Car(String name, Double price) {
  8. 		super();
  9. 		this.name = name;
  10. 		this.price = price;
  11. 	}
  12. 	@Override
  13. 	public String toString() {
  14. 		return "Car [name=" + name + ", price=" + price + "]";
  15. 	}
  16. 	
  17. }

然后，在Spring配置文件中对以上JavaBean进行如下配置。

接着，在com.meimeixia.spring.demo04包下创建一个SpringDemo04的单元测试类。

  1. package com.meimeixia.spring.demo04;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. /** * 属性注入的方式 * @author liayun * */
  8. public class SpringDemo04 {
  9. 	
  10. 	/* * 构造方式的属性注入 */
  11. 	@Test
  12. 	public void demo01() {
  13. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  14. 		Car car = (Car) applicationContext.getBean("car");
  15. 		System.out.println(car);
  16. 	}
  17. 	
  18. }

最后，运行以上demo01单元测试方法，你就会发现Eclipse控制台打印了如下内容。

set方法的方式注入属性

我们同样在com.meimeixia.spring.demo04包下编写一个Car2实体类，在类中定义属性，并生成set方法。

  1. package com.meimeixia.spring.demo04;
  3. /** * set方法的属性注入 * * @author liayun * */
  4. public class Car2 {
  6. 	private String name;
  7. 	private Double price;
  9. 	public void setName(String name) {
  10. 		this.name = name;
  11. 	}
  13. 	public void setPrice(Double price) {
  14. 		this.price = price;
  15. 	}
  17. 	@Override
  18. 	public String toString() {
  19. 		return "Car2 [name=" + name + ", price=" + price + "]";
  20. 	}
  22. }

然后，在Spring配置文件中，使用bean标签创建对象，在bean标签里面使用property标签注入属性。即在Spring配置文件中对以上JavaBean进行如下配置。

接着，在SpringDemo04的单元测试类中编写如下的一个demo02测试方法。

  1. package com.meimeixia.spring.demo04;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. /** * 属性注入的方式 * @author liayun * */
  8. public class SpringDemo04 {
  9. 	
  10. 	/* * 构造方式的属性注入 */
  11. 	@Test
  12. 	public void demo01() {
  13. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  14. 		Car car = (Car) applicationContext.getBean("car");
  15. 		System.out.println(car);
  16. 	}
  17. 	
  18. 	/* * set方法方式的属性注入 */
  19. 	@Test
  20. 	public void demo02() {
  21. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  22. 		Car2 car2 = (Car2) applicationContext.getBean("car2");
  23. 		System.out.println(car2);
  24. 	}
  25. 	
  26. }

最后，运行以上demo02单元测试方法，你就会发现Eclipse控制台打印了如下内容。

set方法的方式注入对象类型的属性

首先，在com.meimeixia.spring.demo04包下编写一个Employee实体类，在类中定义属性（其中包括一个对象类型的属性），并生成set方法。

  1. package com.meimeixia.spring.demo04;
  3. public class Employee {
  5. 	private String name;
  6. 	private Car2 car2;
  7. 	public void setName(String name) {
  8. 		this.name = name;
  9. 	}
  10. 	public void setCar2(Car2 car2) {
  11. 		this.car2 = car2;
  12. 	}
  13. 	@Override
  14. 	public String toString() {
  15. 		return "Employee [name=" + name + ", car2=" + car2 + "]";
  16. 	}
  17. 	
  18. }

然后，在Spring配置文件中对以上JavaBean进行如下配置。

接着，在SpringDemo04的单元测试类中编写如下的一个demo03测试方法。

  1. package com.meimeixia.spring.demo04;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. /** * 属性注入的方式 * @author liayun * */
  8. public class SpringDemo04 {
  9. 	
  10. 	/* * 构造方式的属性注入 */
  11. 	@Test
  12. 	public void demo01() {
  13. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  14. 		Car car = (Car) applicationContext.getBean("car");
  15. 		System.out.println(car);
  16. 	}
  17. 	
  18. 	/* * set方法方式的属性注入 */
  19. 	@Test
  20. 	public void demo02() {
  21. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  22. 		Car2 car2 = (Car2) applicationContext.getBean("car2");
  23. 		System.out.println(car2);
  24. 	}
  25. 	
  26. 	/* * set方法注入对象的类型 */
  27. 	@Test
  28. 	public void demo03() {
  29. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  30. 		Employee employee = (Employee) applicationContext.getBean("employee");
  31. 		System.out.println(employee);
  32. 	}
  33. 	
  34. }

最后，运行以上demo03单元测试方法，你就会发现Eclipse控制台打印了如下内容。

p名称空间的属性注入方式（Spring2.5版本后提供的方式）

在Spring2.5版本以后，提供了一种p名称空间的属性注入方式。使用这种方式，需要在Spring核心配置文件中的schema约束位置定义p名称空间。

如果使用了这种方式，那么注入属性时就应该像下面这样写。

  • 普通属性：p:属性名称=“值”
  • 对象类型的属性：p:属性名称-ref=“值”

如果要将下面的配置改为p名称空间的属性注入方式，那么该咋改呢？

我们可以像下面这样子改。

如果是下面这样的配置，那么又该怎么改呢？

我们可以像下面这样子改为p名称空间的属性注入方式。

SpEL表达式语言的属性注入（Spring3.0版本后提供的方式）

在Spring3.0版本以后，提供了一种SpEL表达式语言的属性注入方式。SpEL，即Spring Expression Language，翻译过来就是Spring的表达式语言，其语法格式是#{SpEL}。大家可以去Google一下这种SpEL表达式语言的使用案例，下面我也会稍稍举几个案例来讲讲这种方式。
如果要将下面的配置改为SpEL表达式语言的属性注入方式，那么该咋改呢？

我们可以像下面这样子改。

如果是下面这样的配置，那么又该怎么改呢？

我们可以像下面这样子改为SpEL表达式语言的属性注入方式。

除此之外，使用了这种SpEL表达式语言的属性注入方式，还可以调用其他类的属性或者方法。为了验证这一点，这里，我会举一个案例。首先，在com.meimeixia.spring.demo04包下编写一个CarInfo实体类。

  1. package com.meimeixia.spring.demo04;
  3. public class CarInfo {
  4. 	
  5. 	private String name;
  7. 	public String getName() {
  8. 		return "摩托车";
  9. 	}
  10. 	
  11. 	public Double calculatorPrice() {
  12. 		return Math.random() * 3000;
  13. 	}
  14. 	
  15. }

然后，在Spring配置文件中对以上JavaBean进行如下配置。

接着，运行以上SpringDemo04单元测试类中的demo02方法，你就会发现Eclipse控制台打印了如下内容。

复杂类型的属性注入（仅做了解）

注入数组类型的属性

首先，在src目录下创建一个com.meimeixia.spring.demo05包，并在该包下编写一个CollectionBean实体类。

  1. package com.meimeixia.spring.demo05;
  3. import java.util.Arrays;
  5. /** * 集合属性的注入 * @author liayun * */
  6. public class CollectionBean {
  8. 	private String[] arrs;
  9. 	
  10. 	public void setArrs(String[] arrs) {
  11. 		this.arrs = arrs;
  12. 	}
  13. 	
  14. 	@Override
  15. 	public String toString() {
  16. 		return "CollectionBean [arrs=" + Arrays.toString(arrs) + "]";
  17. 	}
  19. 	
  20. }

然后，在Spring配置文件中对以上JavaBean进行如下配置。

接着，在com.meimeixia.spring.demo05包下创建一个SpringDemo05的单元测试类。

  1. package com.meimeixia.spring.demo05;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. /** * 集合类型的属性注入 * @author liayun * */
  8. public class SpringDemo05 {
  10. 	@Test
  11. 	public void demo01() {
  12. 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  13. 		CollectionBean collectionBean = (CollectionBean) applicationContext.getBean("collectionBean");
  14. 		System.out.println(collectionBean);
  15. 	}
  16. 	
  17. }

最后，运行以上demo01单元测试方法，你就会发现Eclipse控制台打印了如下内容。

注入List集合类型的属性

首先，将com.meimeixia.spring.demo05包下的CollectionBean类的代码修改成下面这个样子。

  1. package com.meimeixia.spring.demo05;
  3. import java.util.Arrays;
  4. import java.util.List;
  6. /** * 集合属性的注入 * @author liayun * */
  7. public class CollectionBean {
  9. 	private String[] arrs;
  11. 	private List<String> list;
  12. 	
  13. 	public void setArrs(String[] arrs) {
  14. 		this.arrs = arrs;
  15. 	}
  16. 	
  17. 	public void setList(List<String> list) {
  18. 		this.list = list;
  19. 	}
  21. 	@Override
  22. 	public String toString() {
  23. 		return "CollectionBean [arrs=" + Arrays.toString(arrs) + ", list=" + list + "]";
  24. 	}
  25. 	
  26. }

然后，在Spring配置文件中对以上JavaBean进行如下配置。

接着，运行以上SpringDemo05单元测试类的demo01方法，你就会发现Eclipse控制台打印了如下内容。

注入Set集合类型的属性

首先，将com.meimeixia.spring.demo05包下的CollectionBean类的代码修改成下面这个样子。

  1. package com.meimeixia.spring.demo05;
  3. import java.util.Arrays;
  4. import java.util.List;
  5. import java.util.Set;
  7. /** * 集合属性的注入 * @author liayun * */
  8. public class CollectionBean {
  10. 	private String[] arrs;
  12. 	private List<String> list;
  13. 	
  14. 	private Set<String> set;
  15. 	
  16. 	public void setArrs(String[] arrs) {
  17. 		this.arrs = arrs;
  18. 	}
  19. 	
  20. 	public void setList(List<String> list) {
  21. 		this.list = list;
  22. 	}
  23. 	
  24. 	public void setSet(Set<String> set) {
  25. 		this.set = set;
  26. 	}
  28. 	@Override
  29. 	public String toString() {
  30. 		return "CollectionBean [arrs=" + Arrays.toString(arrs) + ", list=" + list + ", set=" + set + "]";
  31. 	}
  32. 	
  33. }

然后，在Spring配置文件中对以上JavaBean进行如下配置。

接着，运行以上SpringDemo05单元测试类的demo01方法，你就会发现Eclipse控制台打印了如下内容。

注入Map集合类型的属性

首先，将com.meimeixia.spring.demo05包下的CollectionBean类的代码修改成下面这个样子。

  1. package com.meimeixia.spring.demo05;
  3. import java.util.Arrays;
  4. import java.util.List;
  5. import java.util.Map;
  6. import java.util.Set;
  8. /** * 集合属性的注入 * @author liayun * */
  9. public class CollectionBean {
  11. 	private String[] arrs;
  13. 	private List<String> list;
  14. 	
  15. 	private Set<String> set;
  16. 	
  17. 	private Map<String, String> map;
  18. 	
  19. 	public void setArrs(String[] arrs) {
  20. 		this.arrs = arrs;
  21. 	}
  22. 	
  23. 	public void setList(List<String> list) {
  24. 		this.list = list;
  25. 	}
  26. 	
  27. 	public void setSet(Set<String> set) {
  28. 		this.set = set;
  29. 	}
  30. 	
  31. 	public void setMap(Map<String, String> map) {
  32. 		this.map = map;
  33. 	}
  35. 	@Override
  36. 	public String toString() {
  37. 		return "CollectionBean [arrs=" + Arrays.toString(arrs) + ", list=" + list + ", set=" + set + ", map=" + map
  38. 				+ "]";
  39. 	}
  41. }

然后，在Spring配置文件中对以上JavaBean进行如下配置。

接着，运行以上SpringDemo05单元测试类的demo01方法，你就会发现Eclipse控制台打印了如下内容。

注入Properties类型的属性

首先，将com.meimeixia.spring.demo05包下的CollectionBean类的代码修改成下面这个样子。

  1. package com.meimeixia.spring.demo05;
  3. import java.util.Arrays;
  4. import java.util.List;
  5. import java.util.Map;
  6. import java.util.Properties;
  7. import java.util.Set;
  9. /** * 集合属性的注入 * @author liayun * */
  10. public class CollectionBean {
  12. 	private String[] arrs;
  14. 	private List<String> list;
  15. 	
  16. 	private Set<String> set;
  17. 	
  18. 	private Map<String, String> map;
  19. 	
  20. 	private Properties properties;
  21. 	
  22. 	public void setArrs(String[] arrs) {
  23. 		this.arrs = arrs;
  24. 	}
  25. 	
  26. 	public void setList(List<String> list) {
  27. 		this.list = list;
  28. 	}
  29. 	
  30. 	public void setSet(Set<String> set) {
  31. 		this.set = set;
  32. 	}
  33. 	
  34. 	public void setMap(Map<String, String> map) {
  35. 		this.map = map;
  36. 	}
  37. 	
  38. 	public void setProperties(Properties properties) {
  39. 		this.properties = properties;
  40. 	}
  42. 	@Override
  43. 	public String toString() {
  44. 		return "CollectionBean [arrs=" + Arrays.toString(arrs) + ", list=" + list + ", set=" + set + ", map=" + map
  45. 				+ ", properties=" + properties + "]";
  46. 	}
  48. }

然后，在Spring配置文件中对以上JavaBean进行如下配置。

接着，运行以上SpringDemo05单元测试类的demo01方法，你就会发现Eclipse控制台打印了如下内容。

Spring的分模块开发的配置

Spring中的分模块开发有两种配置方式，为了讲清楚这两种配置方式，咱还得做一些准备工作，将applicationContext.xml文件中有关复杂类型的属性注入的配置单独抽取成另一个名为applicationContext02.xml的配置文件，而且该配置同样在src目录下。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:p="http://www.springframework.org/schema/p" 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">
  3.         
  4. 	<!-- Spring的集合属性的注入 -->
  5. 	<bean id="collectionBean" class="com.meimeixia.spring.demo05.CollectionBean">
  6. 		<!-- 注入数组类型（和注入List类型是一样的） -->
  7. 		<property name="arrs">
  8. 			<list>
  9. 				<value>狄仁杰</value>
  10. 				<value>李元芳</value>
  11. 				<value>武则天</value>
  12. 			</list>
  13. 		</property>
  14. 		
  15. 		<!-- 注入List集合 -->
  16. 		<property name="list">
  17. 			<list>
  18. 				<value>王朝</value>
  19. 				<value>马汉</value>
  20. 				<value>张龙</value>
  21. 			</list>
  22. 		</property>
  23. 		
  24. 		<!-- 注入set集合 -->
  25. 		<property name="set">
  26. 			<set>
  27. 				<value>aaa</value>
  28. 				<value>bbb</value>
  29. 				<value>ccc</value>
  30. 			</set>
  31. 		</property>
  32. 		
  33. 		<!-- 注入Map集合（这是一种简单的方式） -->
  34. 		<property name="map">
  35. 			<map>
  36. 				<entry key="神探狄仁杰（第一部）" value="狄仁杰" />
  37. 				<entry key="神探狄仁杰（第二部）" value="李元芳" />
  38. 				<entry key="神探狄仁杰（第三部）" value="武则天" />
  39. 			</map>
  40. 		</property>
  41. 		
  42. 		<!-- 注入Properties类型的属性 -->
  43. 		<property name="properties">
  44. 			<props>
  45. 				<prop key="name">宫本一郎</prop>
  46. 				<prop key="address">日本</prop>
  47. 			</props>
  48. 		</property>
  49. 	</bean>
  50. 	
  51. </beans>

第一种配置方式：在加载配置文件的时候，一次加载多个配置文件

Spring分模块开发的第一种配置方式就是指在加载配置文件的时候，一次加载多个配置文件。

第二种配置方式：在一个配置文件中引入多个配置文件

Spring分模块开发的第二种配置方式就是指在一个配置文件中引入多个配置文件。这样说的话，我们可以在applicationContext.xml文件中引入applicationContext02.xml文件。

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://liayun.blog.csdn.net/article/details/100179932

内容来源于网络，如有侵权，请联系作者删除！

spring框架学习

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com