Spring实战读书笔记 第二章 装配Bean
1，依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在 传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。
2，Spring配置Bean XML解析
如下代码，为对应的配置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:p="http://www.springframework.org/schema/p"xmlns:mvc="http://www.springframework.org/schema/mvc"xmlns:context="http://www.springframework.org/schema/context"xmlns:util="http://www.springframework.org/schema/util"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsd"><bean id="duke" class="chp02.springdol.Juggler"><constructor-arg value="15" /></bean><bean id="poem" class="chp02.springdol.Poem"></bean><bean id="juggle" class="chp02.springdol.PoeticJuggle" ><constructor-arg ref="poem"></constructor-arg><constructor-arg value="15"></constructor-arg></bean></beans>
Spring核心框架自带10个命名空间配置：
-1，aop：为声明切面以及将@AspectJ注解的类代理为Spring切面提供配置元素。
-2，beans：支持声明Bean和装配Bean，是Spring最核心也是最原始的命名空间。
-3，context：为配置Spring上下文提供了配置元素，包括自动检测和自动装配Bean、注入非Spring直接管理的对象。
-4，jee：提供了与Java EE API的集成，例如JNDI和EJB。
-5，jms：为声明消息驱动的POJO提供了配置元素。
-6，lang：支持配置由Grovy、JRuby或BeanShell等脚本实现的bean。
-7，mvc：启用Spring MVC功能。
-8，oxm：支持Spring的对象到XML映射配置。
-9，tx：提供声明式事务配置。
-10，util：提供工具类配置。
3，注入bean对象，并装配：
<bean id="duke" class="chp02.springdol.Juggler"></bean>
package chp02.springdol;
/**
*
* 类功能说明：接口
*
* @author Jing
*
*/
public interface Perform {
/**
*
* 方法说明：
*
* Author： Jing Create Date： Jan 6, 2015 10:19:03 AM History: Jan 6, 2015
* 10:19:03 AM Jing Created.
*
*/
void perform();
}
/**
*
* @(#) Juggler.java
* @Package chp02.springdol
*
* Copyright © JING Corporation. All rights reserved.
*
*/
package chp02.springdol;
/**
* 类描述：
*
* @author: Jing History: Jan 6, 2015 10:43:45 AM Jing Created.
*
*/
public class Juggler implements Perform {
private int beanBags = 3;
public void setBeanBags(int beanBags) {
this.beanBags = beanBags;
}
public void perform() {
System.out.println("Juggler perform(),beanBags : " + this.beanBags);
}
}
测试类：
public class MainTest {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("chp02/springdol/spring.xml");
System.out.println(ctx);
Perform pf = (Perform) ctx.getBean("duke");
pf.perform();
}
}
4，通过构造器注入：
对对应的
Juggler
增加构造方法，代码如下：
public Juggler() {
}
public Juggler(int beanBags) {
this.beanBags = beanBags;
}
对参数进行注入，代码如下：
<bean id="duke" class="chp02.springdol.Juggler">
<constructor-arg value="15" />
</bean>
通过构造参数注入引用对象：
package chp02.springdol;/*** 类描述：引入引用对象** @author: Jing History: Jan 6, 2015 11:28:33 AM Jing Created.**/public class PoeticJuggle extends Juggler {private Poem poem;public PoeticJuggle(Poem poem) {this.poem = poem;}public PoeticJuggle(Poem poem, int beanBags) {super(beanBags);this.poem = poem;}@Overridepublic void perform() {super.perform();System.out.println("this is PoeticJuggle!");poem.sayPoem();}}
package chp02.springdol;/*** 类描述：** @author: Jing* History: Jan 6, 2015 11:29:35 AM Jing Created.**/public class Poem {public void sayPoem(){System.out.println("This is poem!");}}
<bean id="poem" class="chp02.springdol.Poem"></bean>
<bean id="juggle" class="chp02.springdol.PoeticJuggle" >
<constructor-arg ref="poem"></constructor-arg>
<constructor-arg value="15"></constructor-arg>
</bean>
5，通过工厂方法创建Bean
package chp02.springdol;
/**
* 类描述：测试Bean工厂注入
*
* @author: Jing
* History: Jan 6, 2015 2:05:59 PM Jing Created.
*
*/
public class Stage {
private Stage(){
}
private static class ClassHolder {
static Stage stage = new Stage();
}
/*
* 静态方法，返回Stage实例
*/
public static Stage getInstance(){
return ClassHolder.stage;
}
}
<bean id="theStage" class="chp02.springdol.Stage" factory-method="getInstance"></bean>
6，Bean的作用域，通过scope属性指定用户配置Bean的作用域。
-1，singleton：在每一个spring容器中，一个Bean定义只有一个对象实例。
-2，prototype：允许Bean的定义可以被实例化任意次（每次调用创建一个新的实例）。
-3，request：在一次HTTP请求中，每个Bean对应一个实例，该作用域仅在Web的Spring上下文中。
-4，session：在一个HttpSession中，每个Bean对应一个实例。
该作用域仅在Web的Spring上下文中。
-5，global-session：在一个全局HttpSession中，每个Bean对应一个实例。该作用域仅在Portlet上下文中才有效。
7，初始化和销毁Bean：通过init-method和
destroy-method
属性指定Bean创建和销毁时的方法。
package chp02.springdol;/*** 类描述：测试创建和销毁方法** @author: Jing* History: Jan 6, 2015 2:33:05 PM Jing Created.**/public class Auditorium {public void init(){System.out.println("Auditorium init!");}public void destroy(){System.out.println("Auditorium destroy!");}}
<bean id="audit" class="chp02.springdol.Auditorium" init-method="init" destroy-method="destroy"></bean>
public class MainTest {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("chp02/springdol/spring.xml");
Auditorium audit = (Auditorium) ctx.getBean("audit");
System.out.println(audit);
audit =null;
}
}
8，注入Bean属性。
package chp02.springdol;
/**
* 类描述：测试属性注入
*
* @author: Jing History: Jan 6, 2015 2:43:43 PM Jing Created.
*
*/
public class Instrumentalist implements Perform {
private String song;
private Instrument inst;
@Override
public void perform() {
System.out.println("Instrumentalist perform()!");
inst.play();
}
public String getSong() {
return song;
}
public void setSong(String song) {
this.song = song;
}
public Instrument getInst() {
return inst;
}
public void setInst(Instrument inst) {
this.inst = inst;
}
}
public interface Instrument {
void play();
}
/**
* 类描述：
*
* @author: Jing
* History: Jan 6, 2015 2:50:10 PM Jing Created.
*
*/
public class Saxophone implements Instrument{
@Override
public void play() {
System.out.println("Saxophone play()");
}
}
<bean id="saxophone" class="chp02.springdol.Saxophone"></bean>
<bean id="instrumentlist" class="chp02.springdol.Instrumentalist">
<property name="song" value="For Elise!"></property>
<property name="inst" ref="saxophone"></property>
</bean>
public class MainTest {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("chp02/springdol/spring.xml");
Instrumentalist ins = (Instrumentalist) ctx.getBean("instrumentlist");
ins.perform();
}
}
9，装配集合：
-1，list：装配list类型的值，允许重复。
-2，set：装配set类型的值，不允许重复。
-3，map：装配map类型的值，名称和值是任意类型。
-4，props：装配properties类型的值，名称和值必须是String。
package chp02.springdol;
import java.util.Collection;
/**
* 类描述：测试集合
*
* @author: Jing History: Jan 6, 2015 3:07:22 PM Jing Created.
*
*/
public class OneManBand implements Perform {
private Collection<Instrument> instruments;
@Override
public void perform() {
System.out.println("OneManBand perform()");
for(Instrument instrument: instruments){
instrument.play();
}
}
public Collection<Instrument> getInstruments() {
return instruments;
}
public void setInstruments(Collection<Instrument> instruments) {
this.instruments = instruments;
}
}
<bean id="band" class="chp02.springdol.OneManBand">
<property name="instruments">
<list>
<ref bean="saxophone"/>
</list>
</property>
</bean>
public class MainTest {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("chp02/springdol/spring.xml");
OneManBand ins = (OneManBand) ctx.getBean("band");
ins.perform();
}
}
装配Map集合：
package chp02.springdol;
import java.util.Map;
/**
* 类描述：测试Map注入
*
* @author: Jing
* History: Jan 6, 2015 3:20:15 PM Jing Created.
*
*/
public class MapManBand implements Perform{
private Map<String, Instrument> instruments;
public Map<String, Instrument> getInstruments() {
return instruments;
}
public void setInstruments(Map<String, Instrument> instruments) {
this.instruments = instruments;
}
@Override
public void perform() {
System.out.println("MapManBand perform()");
for(String key: instruments.keySet()){
Instrument ins = instruments.get(key);
ins.play();
}
}
}
<bean id="mapBand" class="chp02.springdol.MapManBand">
<property name="instruments">
<map>
<entry key="saxophone" value-ref="saxophone"></entry>
</map>
</property>
</bean>
装配Properties集合：
package chp02.springdol;import java.util.Properties;/*** 类描述：Properties属性注入测试** @author: Jing* History: Jan 6, 2015 3:38:59 PM Jing Created.**/public class PropertiesDI {private Properties pro;public Properties getPro() {return pro;}public void setPro(Properties pro) {this.pro = pro;}public void outputPro(){System.out.println(pro.toString());}}
<bean id="pro" class="chp02.springdol.PropertiesDI">
<property name="pro">
<props>
<prop key="A1">ASDASD</prop>
<prop key="A2">SADADADSASD</prop>
<prop key="A3">ASDASDASDDSDSDSDSASD</prop>
</props>
</property>
</bean>
10，使用表达式装配
Spring引入了表达式语言（Spring Expression Language, SpEL），SpEl特性如下：
-1，使用Bean的ID来引用Bean。
-2，调用方法和访问对象的属性。
-3，对值进行算术、关系和逻辑运算。
-4，正则表达式匹配。
-5，集合操作。