配置环境
我们在开发中,会写很多的类,而有些类之间不可避免的产生依赖关系,这种依赖关系称之为耦合。有些依赖关系是必须的,有些依赖关系可以通过优化代码来解除的。请看下面的示例代码:
1 创建maven工程;
2 导入必要的依赖
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
</dependencies>
2.1 引入log4j的配置文件
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c:/mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### set log levels - for more verbose logging change 'info' to 'debug' ###
log4j.rootLogger=debug, stdout
3 创建UserDao接口
public interface UserDao {
void save();
}
4 创建UserDao接口的实现类UserDaoImpl
public class UserDaoImpl implements UserDao {
@Override
public void save() {
System.out.println("持久层:用户保存...");
}
}
5 创建 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 id="userDao" class="cn.cosco.impl.UserDaoImpl"></bean>
</beans>
6 创建测试类
@Test
public void test1(){
//创建Spring工厂(创建IOC容器)
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");//1
UserDao userDao = (UserDao) ac.getBean("userDao");//2
userDao.save();
}
测试结果:
控制台输出如下结果:
持久层:用户保存...
测试发现:我们可以从spring容器中获取对象,但是,这个对象是如何创建出来的呢?
这其实是利用了 Spring IOC 方法。
Spring IOC
1 什么是 Spring IOC
IOC,它是Inverse of Control的缩写,中文含义是控制反转,表示将对象的创建权力反转给Spring框架!!
IOC解决的问题:使用IOC可以解决的程序耦合性高的问题!!
2 Spring中的工厂
在spring中提供了两个工厂接口:
1、ApplicationContext
2、BeanFactory
2.1 ApplicationContext接口
使用该接口可以获取到具体的Bean对象
该接口下有两个具体的实现类
ClassPathXmlApplicationContext – 加载类路径下的Spring配置文件
FileSystemXmlApplicationContext – 加载本地磁盘下的Spring配置文件
下面演示FileSystemXmlApplicationContext的用法:把src下的applicationContext.xml拷贝到你电脑的某个目录,例如:c:/spring,可以通过FileSystemXmlApplicationContext加载本地磁盘下的spring配置文件
public class TestIOC {
@Test
public void test1(){
//创建Spring工厂(创建IOC容器)
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) ac.getBean("userDao");
userDao.save();
}
@Test
public void test2(){
//创建Spring工厂(创建IOC容器)
ApplicationContext ac = new FileSystemXmlApplicationContext("C:/spring/applicationContext.xml");
UserDao userDao = (UserDao) ac.getBean("userDao");
userDao.save();
}
}
2.2 BeanFactory工厂 ---- 已过时
BeanFactory是Spring框架早期的创建Bean对象的工厂接口。在TestIOC中创建test3测试方法:
/**
* 早期版本的spring工厂:BeanFactory
*/
@Test
public void test3() {
//此方法已经过时
BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
UserDao userDao = (UserDao) factory.getBean("userDao");
userDao.save();
}
2.3 BeanFactory和ApplicationContext的区别 :
BeanFactory – BeanFactory采取延迟加载,第一次getBean时才会初始化Bean
ApplicationContext – 在加载applicationContext.xml时候就会创建具体的Bean对象的实例
修改UserDaoImpl,增加一个无参构造方法,运行test1和test3两个单元测试方法,验证ApplicationContext和BeanFactory这两个工厂到底什么时候创建bean对象??
public class UserDaoImpl implements UserDao {
public UserDaoImpl() {
System.out.println("调用了无参构造方法...");
}
@Override
public void save() {
System.out.println("持久层:用户保存...");
}
}
修改test1单元测试方法:
/**
* 创建ioc容器时就已经把对象创建好了
*/
@Test
public void test1(){
//创建Spring工厂(创建IOC容器)
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println("===============");
UserDao userDao = (UserDao) ac.getBean("userDao");
userDao.save();
}
运行结果:
调用了无参构造方法...
===============
运行test1方法,发现:ApplicationContext是在创建ioc容器时就已经把对象创建好了
修改test3单元测试方法:
/**
* 早期版本的spring工厂:BeanFactory
* 创建ioc容器时并没有创建对象,而是在第一次getBean时再创建对象
*/
@Test
public void test3() {
BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
System.out.println("===============");
UserDao userDao = (UserDao) factory.getBean("userDao");
userDao.save();
}
运行结果:
===============
调用了无参构造方法...
运行test3方法,发现:BeanFactory是创建ioc容器时并没有创建对象,而是在第一次getBean时再创建对象
2.4 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">
<bean id="userDao" class="cn.cosco.impl.UserDaoImpl"></bean>
</beans>
2.4.1 id属性
id属性是bean的唯一标识
2.4.2 class属 性
javaBean 的全路径名
其实,除了 id 属性和 class 属性外,还可以配置如下属性:
2.4.3 scope属性
scope属性代表Bean的作用范围
singleton: 单例(默认值)
prototype: 多例,在Spring框架整合Struts2框架的时候,Action 类也需要交给 Spring 做管理,配置把 Action 类配置成多例!!
request: 应用在 web 工程中,将创建的对象存入到 request 域中。
session: 应用在 web 工程中,将创建的对象存入到 session 域中。
globalsession: 应用在 porlet 环境下使用。将创建的对象存入到全局的 session 中。
后三种比较少见。
在TestIOC中创建单元测试方法test4:
@Test
public void test4() {
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao1 = (UserDao) ac.getBean("userDao");
UserDao userDao2 = (UserDao) ac.getBean("userDao");
System.out.println(userDao1==userDao2);
}
运行结果:
调用了无参构造方法...
true
测试发现:当scope为 singleton 时,无论实例化几次 javaBean 对象,都只会创建一次。
修改 applicationContext.xml,把 UserDaoImpl 的作用域改为 prototype:
<?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="userDao" class="cn.cosco.dao.impl.UserDaoImpl" scope="prototype"></bean>
</beans>
运行结果:
调用了无参构造方法...
调用了无参构造方法...
false
测试发现:当scope为prototype时,每次获取bean,都会重新实例化
2.4.4 init-method属性
当bean被载入到容器的时候调用init-method属性指定的方法
修改 UserDaoImpl ,在其中提供 init 方法
public class UserDaoImpl implements UserDao {
public UserDaoImpl() {
System.out.println("调用了无参构造方法...");
}
public void init(){
System.out.println("调用了init方法...");
}
@Override
public void save() {
System.out.println("持久层:用户保存...");
}
}
修改 applicationContext.xml,为 UserDaoImpl 指定初始化方法
<?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="userDao" class="cn.cosco.dao.impl.UserDaoImpl" init-method="init"></bean>
</beans>
运行 test1 单元测试方法,测试结果:
调用了无参构造方法...
调用了init方法...
===============
持久层:用户保存...
2.4.5 destroy-method属性
当bean从容器中删除的时候调用destroy-method属性指定的方法
想查看destroy-method的效果,有如下条件:
scope= singleton 有效
web容器中会自动调用,但是 main 函数或测试用例需要手动调用(需要使用 ClassPathXmlApplicationContext 的close() 方法)
在applicationContext.xml中为UserDaoImpl指定销毁方法
<?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="userDao" class="cn.cosco.dao.impl.UserDaoImpl" init-method="init" destroy-method="destroy"></bean>
</beans>
修改UserDaoImpl,在其中提供destroy方法
public class UserDaoImpl implements UserDao {
public UserDaoImpl() {
System.out.println("调用了无参构造方法...");
}
public void init(){
System.out.println("调用了init方法...");
}
@Override
public void save() {
System.out.println("持久层:用户保存...");
}
public void destroy(){
System.out.println("调用了销毁方法...");
}
}
修改test1单元测试方法,显示关闭ioc容器。测试结果如下:
调用了无参构造方法...
调用了init方法...
===============
持久层:用户保存...
调用了销毁方法...
3 Spring 生成bean的三种方式
3.1 无参构造方法
默认调用无参构造方法实例化bean。在此之前,都是调用无参构造来实例化的。
3.2 静态工厂实例化方式
通过调用工厂类的静态方法来生成bean
编写DeptDao接口:
public Interface DeptDaoImpl {
public void save();
}
编写DeptDaoImpl实现类:
public class DeptDaoImpl implements DeptDao{
@Override
public void save() {
System.out.println("持久层:部门保存...");
}
}
编写工厂类,在其中创建静态工厂方法
public class Factory {
/**
* 静态工厂方法
*/
public static DeptDao create(){
System.out.println("调用了静态工厂方法");
return new DeptDaoImpl();
}
}
编写applicationContext.xml配置文件,采用静态工厂方式配置DeptDaoImpl类
<?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="userDao" class="cn.cosco.dao.impl.UserDaoImpl" init-method="init" destroy-method="destroy"></bean>
<bean id="deptDao" class="cn.cosco.factory.Factory" factory-method="create"></bean>
</beans>
在配置DeptDaoImpl这个bean时,class属性写的不是DeptDaoImpl的全路径名,而是工厂类的全路径名;
factory-method:指定工厂类中静态方法的名字
在TestIOC类中编写测试方法test5:
@Test
public void test5(){
//创建Spring工厂(创建IOC容器)
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
DeptDao deptDao = (DeptDao) ac.getBean("deptDao");
deptDao.save();
}
测试结果如下:
调用了静态工厂方法
持久层:部门保存...
3.3 实例工厂实例化方式
修改Factory工厂类,创建实例工厂方法:
public class Factory {
/**
* 静态工厂方法
*/
// public static DeptDao create(){
// System.out.println("调用了静态工厂方法");
// return new DeptDaoImpl();
// }
/**
* 实例工厂方法
* @return
*/
public DeptDao create(){
System.out.println("调用了实例工厂方法");
return new DeptDaoImpl();
}
}
编写applicationContext.xml,采用实例工厂方式重写配置DeptDaoImpl
<?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="userDao" class="cn.cosco.dao.impl.UserDaoImpl" init-method="init" destroy-method="destroy"></bean>
<!-- 实例工厂方法来实例化 -->
<bean id="factory" class="cn.cosco.factory.Factory"></bean>
<bean id="deptDao" factory-bean="factory" factory-method="create"></bean>
</beans>
factory-bean:指定工厂bean的id;
Factory-method:指定工厂bean的实例工厂方法的名字
运行test5测试方法,测试结果如下:
调用了实例工厂方法
持久层:部门保存...
4 注入依赖
4.1 什么是注入依赖
IOC和DI的概念:
* IOC – Inverse of Control,控制反转,将对象的创建权反转给Spring!!
* DI – Dependency Injection,依赖注入,在Spring框架负责创建Bean对象时,动态的将依赖对象注入到Bean组件中!!
如果UserServiceImpl的实现类中有一个属性,那么使用Spring框架的IOC功能时,可以通过依赖注入把该属性的值传入进来!!
4.2 构造方法注入
什么是构造方法注入?构造方法注入就是利用bean的构造方法完成对bean中属性的赋值。
创建Car实体类,提供有参构造方法
public class Car implements Serializable{
private String name;
private Double price;
public Car(String name, Double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
创建applicationContext2.xml,在applicationContext2.xml配置Car这个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 id="car" class="cn.cosco.domain.Car">
<constructor-arg name="name" value="兰博基尼"></constructor-arg>
<constructor-arg name="price" value="3000000.0"></constructor-arg>
</bean>
</beans>
创建单元测试类TestDI,在其中创建单元测试方法test1测试,注意此处创建IOC容器时,应该加载applicationContext2.xml
public class TestDI {
@Test
public void test1(){
//创建Spring工厂(创建IOC容器)
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext2.xml");
Car car = (Car) ac.getBean("car");
System.out.println(car);
}
}
运行结果:
Car{name='兰博基尼', price='3000000.0'}
4.3 set方法注入
什么是set方法注入?set方法注入就是利用bean中属性的set方法对属性赋值。
创建People实体类,提供属性的set方法,不需要提供有参构造方法。
public class People implements Serializable{
private String name;//要提供属性所对应的set方法
private String address;
private Car car;//对象属性
public void setName(String name) {
this.name = name;
}
public void setAddress(String address) {
this.address = address;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return "People{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
", car=" + car +
'}';
}
}
在applicationContext.xml2中配置People实体类,普通属性用value指定值,对象属性用ref指定需要注入的bean的id.
<?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="car" class="cn.cosco.domain.Car">
<constructor-arg name="name" value="兰博基尼"></constructor-arg>
<constructor-arg name="price" value="3000000.0"></constructor-arg>
</bean>
<!-- 第二种注入形式:set方法注入 -->
<bean id="people" class="cn.cosco.domain.People">
<property name="name" value="汪峰"></property>
<property name="address" value="北京"></property>
<property name="car" ref="car"></property>
</bean>
</beans>
在TestIOC中创建test2方法
@Test
public void test2(){
//创建Spring工厂(创建IOC容器)
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext2.xml");
People people = (People) ac.getBean("people");
System.out.println(people);
}
运行结果:
People{name='汪峰', address='北京', Car{name='兰博基尼', price='3000000.0'}}
注意:采用set方法注入时,类中一定要有无参构造方法,因为spring会先调用无参构造方法实例化对象。
4.4 set方法其它注入写法
通过set方法注入还有其它两种写法,这两种写法都是spring在新的版本中提供的写法:
1、p命名空间的写法
2、SpEL的写法
4.4.1 p命名空间的写法
在applicationContext2.xml中引入p命名空间
修改applicationContext2.xml,采用p命名空间的写法为People注入值。语法是:
p:简单属性名=”值”
p:对象属性名-ref=”bean的id”
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 构造方法注入 -->
<bean id="car" class="cn.cosco.domain.Car">
<constructor-arg name="name" value="兰博基尼"></constructor-arg>
<constructor-arg name="price" value="3000000.0"></constructor-arg>
</bean>
<!-- 第二种注入形式:set方法注入 p命名空间-->
<bean id="people" class="cn.cosco.domain.People" p:name="汪峰" p:address="北京" p:car-ref="car"></bean>
</beans>
4.4.2 SpEL的写法(spring3.0提供)
什么是SpEl:Spring Expression Language
修改applicationContext2.xml,采用SpEL的写法为People注入值
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 构造方法注入 -->
<bean id="car" class="cn.cosco.domain.Car">
<constructor-arg name="name" value="兰博基尼"></constructor-arg>
<constructor-arg name="price" value="3000000.0"></constructor-arg>
</bean>
<!-- 第二种注入形式:set方法注入 SpEL的写法 -->
<bean id="people" class="cn.cosco.domain.People">
<property name="name" value="#{'汪峰'}"></property>
<property name="address" value="#{'北京'}"></property>
<property name="car" value="#{car}"></property>
</bean>
</beans>
SpEL注入的语法是:
注入字符串:#{‘字符串’}
注入数字:#{数字}
注入其它对象:#{对象id}
SpEL还可以注入其它对象的属性或方法的返回值,创建 CarInfo 类,存储 Car 的信息:
public class CarInfo implements Serializable {
public String getName(){
return "奇瑞QQ";
}
public double calculatePrice(){
return Math.random() * 10000;
}
}
创建Car2实体类
public class Car2 implements Serializable{
private String name;
private Double price;
public void setName(String name) {
this.name = name;
}
public void setPrice(Double price) {
this.price = price;
}
@Override
public String toString() {
return "Car2{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
在applicationContext2.xml配置Car2
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 构造方法注入 -->
<bean id="car" class="cn.cosco.domain.Car">
<constructor-arg name="name" value="兰博基尼"></constructor-arg>
<constructor-arg name="price" value="3000000.0"></constructor-arg>
</bean>
<!-- 第二种注入形式:set方法注入 SpEL的写法 -->
<bean id="people" class="cn.cosco.domain.People">
<property name="name" value="#{'汪峰'}"></property>
<property name="address" value="#{'北京'}"></property>
<property name="car" value="#{car}"></property>
</bean>
<!-- SpEL的写法 -->
<bean id="carInfo" class="cn.cosco.domain.CarInfo"></bean>
<bean id="car2" class="cn.cosco.domain.Car2">
<property name="name" value="#{carInfo.name}"></property>
<property name="price" value="#{carInfo.calculatePrice()}"></property>
</bean>
</beans>
注意:#{carInfo.ame}会调用getName方法获取汽车的名称;而#{carInfo.calculatePrice()}会直接调用calculatePrice方法获取汽车价格。
4.5 数组或list注入
有的时候,bean中的属性是List或数组类型。那么该怎么给List或数组注入值呢?数组和list注入的写法是一样的。
新建bean类:CollectionBean
public class CollectionBean implements Serializable{
private List<String> list;//也可以是数组
public void setList(List<String> list) {
this.list = list;
}
@Override
public String toString() {
return "CollectionBean{" +
"list=" + list +
'}';
}
}
在applicationContext2.xml中配置CollectionBean:
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 构造方法注入 -->
<bean id="car" class="cn.cosco.domain.Car">
<constructor-arg name="name" value="五菱宏光"></constructor-arg>
<constructor-arg name="price" value="30000.0"></constructor-arg>
</bean>
<!-- 第二种注入形式:set方法注入 SpEL的写法 -->
<bean id="people" class="cn.cosco.domain.People">
<property name="name" value="#{'汪峰'}"></property>
<property name="address" value="#{'北京'}"></property>
<property name="car" value="#{car}"></property>
</bean>
<!-- SpEL的写法 -->
<bean id="carInfo" class="cn.cosco.domain.CarInfo"></bean>
<bean id="car2" class="cn.cosco.domain.Car2">
<property name="name" value="#{carInfo.name}"></property>
<property name="price" value="#{carInfo.calculatePrice()}"></property>
</bean>
<!-- 特殊类型的注入 -->
<bean id="cb" class="cn.cosco.domain.CollectionBean">
<property name="list">
<list>
<value>乔峰</value>
<value>段誉</value>
<value>虚竹</value>
</list>
</property>
</bean>
</beans>
在TestDI中创建单元测试方法test3:
@Test
public void test3(){
//创建Spring工厂(创建IOC容器)
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
CollectionBean cb = (CollectionBean) ac.getBean("cb");
System.out.println(cb);
}
测试结果如下:
CollectionBean{list=[乔峰,段誉,虚竹]}
4.6 Set集合的注入
有的时候,bean中的属性是Set类型。那么该怎么给Set类型的属性注入值呢?
修改CollectionBean,在其中添加一个Set类型的属性并提供set方法:
public class CollectionBean implements Serializable{
private List<String> list;//也可以是数组
private Set<String> set;
public void setList(List<String> list) {
this.list = list;
}
public void setSet(Set<String> set) {
this.set = set;
}
@Override
public String toString() {
return "CollectionBean{" +
"list=" + list +
", set=" + set +
'}';
}
}
在applicaitonContext2.xml中为Set类型的属性注入值:
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 构造方法注入 -->
<bean id="car" class="cn.cosco.domain.Car">
<constructor-arg name="name" value="五菱宏光"></constructor-arg>
<constructor-arg name="price" value="30000.0"></constructor-arg>
</bean>
<bean id="people" class="cn.cosco.domain.People">
<property name="name" value="#{'汪峰'}"></property>
<property name="address" value="#{'北京'}"></property>
<property name="car" value="#{car}"></property>
</bean>
<!-- SpEL的写法 -->
<bean id="carInfo" class="cn.cosco.domain.CarInfo"></bean>
<bean id="car2" class="cn.cosco.domain.Car2">
<property name="name" value="#{carInfo.name}"></property>
<property name="price" value="#{carInfo.calculatePrice()}"></property>
</bean>
<!-- 特殊类型的注入 -->
<bean id="cb" class="cn.cosco.domain.CollectionBean">
<property name="list">
<list>
<value>乔峰</value>
<value>段誉</value>
<value>虚竹</value>
</list>
</property>
<property name="set">
<set>
<value>鸠摩智</value>
<value>天山童姥</value>
<value>无崖子</value>
</set>
</property>
</bean>
</beans>
提示:spring在注入set的时,给我们注入的是一个LinkedHashSet,所以在输入set集合中的元素时,是按照我们注入的顺序来的,并不是无序的。
4.7 Map集合的注入
有的时候,bean中的属性是Map类型。那么该怎么给Map类型的属性注入值呢?
修改CollectionBean,在其中添加一个Map类型的属性并提供set方法:
public class CollectionBean implements Serializable{
private List<String> list;//也可以是数组
private Set<String> set;
private Map<String,String> map;
public void setList(List<String> list) {
this.list = list;
}
public void setSet(Set<String> set) {
this.set = set;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
@Override
public String toString() {
return "CollectionBean{" +
"list=" + list +
", set=" + set +
", map=" + map +
'}';
}
}
在applicationContext2.xml中为Map输入注入值:
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 构造方法注入 -->
<bean id="car" class="cn.cosco.domain.Car">
<constructor-arg name="name" value="五菱宏光"></constructor-arg>
<constructor-arg name="price" value="30000.0"></constructor-arg>
</bean>
<!-- 第二种注入形式:set方法注入 -->
<!--<bean id="people" class="cn.cosco.domain.People">-->
<!--<property name="name" value="小明"></property>-->
<!--<property name="address" value="上海"></property>-->
<!--<property name="car" ref="car"></property>-->
<!--</bean>-->
<!--<bean id="people" class="cn.cosco.domain.People" p:name="汪峰" p:address="北京" p:car-ref="car"></bean>-->
<bean id="people" class="cn.cosco.domain.People">
<property name="name" value="#{'汪峰'}"></property>
<property name="address" value="#{'北京'}"></property>
<property name="car" value="#{car}"></property>
</bean>
<!-- SpEL的写法 -->
<bean id="carInfo" class="cn.cosco.domain.CarInfo"></bean>
<bean id="car2" class="cn.cosco.domain.Car2">
<property name="name" value="#{carInfo.name}"></property>
<property name="price" value="#{carInfo.calculatePrice()}"></property>
</bean>
<!-- 特殊类型的注入 -->
<bean id="cb" class="cn.cosco.domain.CollectionBean">
<property name="list">
<list>
<value>乔峰</value>
<value>段誉</value>
<value>虚竹</value>
</list>
</property>
<property name="set">
<set>
<value>鸠摩智</value>
<value>天山童姥</value>
<value>无崖子</value>
</set>
</property>
<property name="map">
<map>
<entry key="id" value="1"></entry>
<entry key="username" value="张三"></entry>
</map>
</property>
</bean>
</beans>
说明:
表示map中的一个键值对;
的key表示键,value表示值;
4.8 Properties的注入(重点)
有的时候,bean中的属性是Properties类型。那么该怎么给Properties类型的属性注入值呢?
修改CollectionBean,在其中添加一个Properties类型的属性并提供set方法:
public class CollectionBean implements Serializable{
private List<String> list;//也可以是数组
private Set<String> set;
private Map<String,String> map;
private Properties properties;
public void setList(List<String> list) {
this.list = list;
}
public void setSet(Set<String> set) {
this.set = set;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
@Override
public String toString() {
return "CollectionBean{" +
"list=" + list +
", set=" + set +
", map=" + map +
", properties=" + properties +
'}';
}
}
在applicationContext2.xml中给Properties类型的属性注入值:
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 构造方法注入 -->
<bean id="car" class="cn.cosco.domain.Car">
<constructor-arg name="name" value="五菱宏光"></constructor-arg>
<constructor-arg name="price" value="30000.0"></constructor-arg>
</bean>
<!-- 第二种注入形式:set方法注入 -->
<!--<bean id="people" class="cn.cosco.domain.People">-->
<!--<property name="name" value="小明"></property>-->
<!--<property name="address" value="上海"></property>-->
<!--<property name="car" ref="car"></property>-->
<!--</bean>-->
<!--<bean id="people" class="cn.cosco.domain.People" p:name="汪峰" p:address="北京" p:car-ref="car"></bean>-->
<bean id="people" class="cn.cosco.domain.People">
<property name="name" value="#{'汪峰'}"></property>
<property name="address" value="#{'北京'}"></property>
<property name="car" value="#{car}"></property>
</bean>
<!-- SpEL的写法 -->
<bean id="carInfo" class="cn.cosco.domain.CarInfo"></bean>
<bean id="car2" class="cn.cosco.domain.Car2">
<property name="name" value="#{carInfo.name}"></property>
<property name="price" value="#{carInfo.calculatePrice()}"></property>
</bean>
<!-- 特殊类型的注入 -->
<bean id="cb" class="cn.cosco.domain.CollectionBean">
<property name="list">
<list>
<value>乔峰</value>
<value>段誉</value>
<value>虚竹</value>
</list>
</property>
<property name="set">
<set>
<value>鸠摩智</value>
<value>天山童姥</value>
<value>无崖子</value>
</set>
</property>
<property name="map">
<map>
<entry key="id" value="1"></entry>
<entry key="username" value="张三"></entry>
</map>
</property>
<property name="properties">
<props>
<prop key="id">2</prop>
<prop key="name">小明</prop>
</props>
</property>
</bean>
</beans>