Spring -- 入门，装备集合，自动装配，分散装配，自定义编辑器

1. 概要

struts2:web
hibernate:持久化
spring:业务层.管理bean的,容器.List Map Set.

体验spring:
	1.创建java项目.
	2.引入spring的类库.
		${spring解压目录}/dist/spring.jar
		${spring解压目录}/lib/jakarta-commons/commons-logging.jar
	2'.创建业务类.
		/**
		 * GreetingService
		 */
		public class GreetingService {
			private String greeting ;//get/set
			private String greeting2 ;//get/set

			/* byeService */
			private ByeService bs ;//get/set
			public void  sayGreeting(){
				bs.sayBye();
			}
		}

		/**
		 * ByeService
		 */
		public class ByeService {
			private String bye ;

			public String getBye() {
				return bye;
			}

			public void setBye(String bye) {
				this.bye = bye;
			}

			public void sayBye(){
				System.out.println(bye);
			}
		}
	3.配置spring的配置文件.src/applicationContext.xml
		schema:${spring解压目录}\docs\reference\html_single\index.html\3.2.1.1
		<?xml version="1.0"?>
		<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-2.5.xsd">
			<!-- 欢迎服务 -->
			<bean id="greetingService" class="cn.itcast.spring.service.GreetingService">
				<property name="greeting">
					<value>hello world</value>
				</property>
				<property name="greeting2" value="tom" />
				<property name="bs" ref="byeService" />
			</bean>
			<!-- 欢送服务 -->
			<bean id="byeService" class="cn.itcast.spring.service.ByeService">
				<property name="bye">
					<value>later</value>
				</property>
			</bean>
		</beans>
	4.创建app.
		ApplicationContext ac = new ClassPathXmlApplicationContext(
				"applicationContext.xml");
		GreetingService gs = (GreetingService) ac.getBean("greetingService");
		gs.sayGreeting();
		gs.sayGreeting2();

		ByeService bs = (ByeService) ac.getBean("byeService");
		bs.sayBye();

spring:
	ioc: inverse of control,反转控制.获得依赖对象的方式被反转了. （不要手动new bean对象）
		 1.new.(spring负责对象实例化)
		 2.组装对象的出发点是反的(相对于bean的依赖关系是反的).
		 DI:dependency injection,依赖注入.  <==> ioc
	aop: aspect oriented program,面向方面编程.

oop:面向对象编程.

soa:

GreetingService gs = new ...();

gs.setByeService(bs);

ByeService bs = new ...();
gs.sayGreeting();

BeanFactory:实例化bf时,不会实例化任何bean,只有getBean的时候,才实例化相关的bean.节省资源.
ApplicationContext:实例化ac时,实例化单例bean.
懒汉式:
public class A{
	private A(){}

	public static A instance = null ;
	public static A getInstance(){
		if(instance == null){
			instance = new A();
		}
		return instance ;
	}
}

饿汉式:
	public static A instance = new A();

spring单利bean,对应的bean的叫做prototype(原型bean).

ac.getBean("bs"); == new ByeService();

生命周期:
	1.new
	2.set DI
	3.BeanNameAware:bean名关注
	4.BeanFactoryAware:bean工厂关注
	5.BeanPostProcessor.beforeInitialization();
	5'.调用InitializingBean.afterPropertySet()方法.
	6.init-method
	7.BeanPostProcessor.afterInitialization();

spring()框架. 代码的入侵.
1.高侵入性
2.低侵入
3.非侵入行

jee:jsp servlet jpa jta ejb(enterprise javabean),jndi
pojo:plain old java object.

BeanDefinition:bean的定义,spring对bean的信息的封装.
Root bean: class [cn.itcast.spring.service.GreetingService]; scope=singleton; abstract=false; lazyInit=false;
autowireMode=0; dependencyCheck=0; autowireCandidate=true; primary=false; factoryBeanName=null;
factoryMethodName=null; initMethodName=ini; destroyMethodName=release; defined in class path resource
[applicationContext.xml]

Class clazz = Class.forName("cn.itcast.spring.service.GreetingService");
clazz.newInstance();

scope:prototype singleton request session global_session

<struts>
	<package namepace extends="">

在ide下注册spring中的schema文件.
	${spring解压目录}\dist\resources\*.xsd.

List Set Map:
Properies:
.properties

<hibernate-mapping>
	<class name table lazy>
		<id >
			<generator class="" />
		</id>
		<property name="age" column access="field">
	</class>

spring通过构造函数参数注入依赖强化依赖关系.

自动装配:
	1.byName:按照名称自动装配,寻找和bean的属性名相一致的bean的id.(bean必须有空的构造,通过set方法注入)
	2.byType:按照属性的类型来自动装配,如果找到多个,抛异常.(bean必须有空的构造,通过set方法注入)
	3.constructor:按照构造函数参数的类型自动装配,如果找不到或者找多个,都抛异常.
	4.autodetact:自动检测,在(2)和(3)之间选择一个	5.no.
	6.default,跟<beans default-autowire属性>保持一致.

分散配置:
	把需要在上下文硬编码的属性拿到外部的属性文件中定义,让上下文从外部文件提取值.

自定义编辑器:
	将字符串转换成相应的对象,

2. Spring中bean的生命周期， 及其工作流程

bean被载入到容器中时，他的生命周期就开始了。bean工厂在一个bean可以使用前完成很多工作：

1).容器寻找bean的定义信息并实例化。

2).使用依赖注入，spring按bean定义信息配置bean的所有属性。

3).若bean实现了BeanNameAware接口，工厂调用Bean的setBeanName（）方法传递bean的ID。

4).若bean实现了BeanFactoryAware接口，工厂调用setBeanFactory（）方法传入工厂自身。

5).若BeanPostProcessor和bean关联，则它们的postProcessBeforeInitialization()方法被调用。

6).若bean指定了ini-method方法、，它将被调用。

7).最后，若有BeanPostProcessor和bean关联，则它们的postProcessAfterInitialization()方法被调用、。

示例代码一： BeanPostProcessor 注册bean后处理器，能给所有bean做初始和收尾工作，等效于在xml文件中配置init-method="ini"  destroy-method="release"。

如果bean构造时 需要调用有参的构造函数，可以在constructor-arg 中配置。

ByeService.java ， javabean

public class ByeService {
	private String bye ;
	public String getBye() {
		return bye;
	}
	public void setBye(String bye) {
		this.bye = bye;
	}
	public void sayBye(){
		System.out.println(bye);
	}
}

GreetingService.java, javabean

public class GreetingService implements BeanNameAware,BeanFactoryAware{
	private String greeting ;
	private String greeting2 ;

	/* byeService */
	private ByeService bs ;

	public GreetingService(ByeService bs){
		this.bs = bs ;
		System.out.println("Constructor: new GreetingService()");
	}
	public GreetingService(String str1,String str2){
		System.out.println("1111");
	}
	public GreetingService(String str1,Integer str2){
		System.out.println("2222");
	}
	public GreetingService(String str1,int str2){
		System.out.println("3333");
	}
	public GreetingService(int str1,String str2){
		System.out.println("4444");
	}

	/**
	 * beannameAware,注入bean的id
	 */
	public void setBeanName(String name) {
		System.out.println("BeanNameAware:setBeanName() : " + name);
	}

	/**
	 * bean工厂关注
	 */
	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
		System.out.println("BeanFactoryAware:setBeanFactory() : " + beanFactory);
	}

	public ByeService getBs() {
		return bs;
	}

	public void setBs(ByeService bs) {
		this.bs = bs;
		System.out.println("DI:setBs() : " + bs);
	}

	public String getGreeting() {
		return greeting;
	}

	public void setGreeting(String greeting) {
		this.greeting = greeting;
		System.out.println("DI:setGreeting() : " + greeting);
	}

	public void sayGreeting(){
		bs.sayBye();
	}
	public void sayGreeting2(){
		System.out.println(greeting2);
	}

	public String getGreeting2() {
		return greeting2;
	}

	public void setGreeting2(String greeting2) {
		this.greeting2 = greeting2;
		System.out.println("DI:setGreeting2() : " + greeting2);
	}

	/**
	 * 定制初始化方法
	 */
	public void ini(){
		System.out.println("ini");
	}

	/**
	 * 定制销毁方法
	 */
	public void release(){
		System.out.println("release");
	}
}

MyBeanPostProcessor.java, bean的后处理器

public class MyBeanPostProcessor implements BeanPostProcessor {

	/**
	 * 后处理
	 */
	public Object postProcessAfterInitialization(Object bean, String beanName)
			throws BeansException {
		System.out.println("BeanPostProcessor:after:" + beanName);
		return bean;
	}

	/**
	 * 之前处理
	 */
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		System.out.println("BeanPostProcessor:before:"+beanName);
		return bean;
	}
}

applicationContext.xml 配置文件

<?xml version="1.0"?>
<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-2.5.xsd">
    <!-- 欢迎服务 -->
    <bean id="greetingService" class="cn.itcast.spring.service.GreetingService"
        scope="singleton"
        init-method="ini"
        destroy-method="release">
        <constructor-arg index="1" type="java.lang.String" value="12" />
        <constructor-arg index="0" type="int" value="24" />
        <property name="greeting">
            <value>hello world</value>
        </property>
        <property name="greeting2" value="tom" />
        <property name="bs" ref="byeService" />
    </bean>
    <!-- 欢送服务 -->
    <bean id="byeService" class="cn.itcast.spring.service.ByeService">
        <property name="bye">
            <value>later</value>
        </property>
    </bean>

    <!-- 注册bean后处理器 -->
    <bean id="myBeanPostProcessor" class="cn.itcast.spring.beanprocessor.MyBeanPostProcessor" />
</beans>

App.java

public class App {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext(
				"applicationContext.xml");//src下 不需要加全路径
		GreetingService gs = (GreetingService) ac.getBean("greetingService");
		gs.sayGreeting();
		gs.sayGreeting2();
		ByeService bs = (ByeService) ac.getBean("byeService");
		bs.sayBye();
		((ClassPathXmlApplicationContext)ac).destroy();
	}
}

3.  集合装配bean

单例和原型模式：
prototype、singleton、request session、global-session ，spring中的bean缺省情况下是单例模式。始终返回一个实例。若想返回不同的实例的话需要定义成原型模式。bean的singleton属性告诉上下文该bean是否为单例的。缺省为true。若为false的话，为原型bean。

<bean id="foo" class="...Foo" singleton="false"/>

<!– spring2.5 -->

<bean scope="prototype|single|..">

 

自动装配：

<bean id="foo" class="...Foo" autowire="autowire type">

有四种自动装配类型：

1.byName:寻找和属性名相同的bean,若找不到，则装不上。

2.byType:寻找和属性类型相同的bean,找不到,装不上,找到多个抛异常。

3.constructor:查找和bean的构造参数一致的一个或多个bean，若找不到或找到多个，抛异常。按照参数的类型装配

4.autodetect:(3)和(2)之间选一个方式。不确定性的处理与(3)和(2)一致。(选择标准：是否有含参的构造函数，没有则是byType)

<bean id="bar" class="Bar" autowire="byName"/>

<!-- spring2.5 -->

@Autowired

<bean class="...
AutowiredAnnotationBeanPostProcessor">

示例代码二： （通过util定义集合bean需要手动添加 spring-util-2.5.xsd）

PopSet.java， javabean

public class PopSet {
	private String[] ss ;
	private List list ;
	private Set set ;
	private Map map ;
	private Properties prop ;
         .....省略 get set方法
}

popSet.xml 配置文件， java bean中的 prop 对应到配置文件中用标签<prop> </prop>配置。

<?xml version="1.0"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:util="http://www.springframework.org/schema/util"
    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-2.5.xsd
                        http://www.springframework.org/schema/util
                        http://www.springframework.org/schema/util/spring-util-2.5.xsd ">
    <bean id="popSet" class="cn.itcast.spring.popset.PopSet">
        <property name="ss">
            <list>
                <value>1</value>
                <value>tom</value>
            </list>
        </property>
        <property name="list" ref="myList" />
        <property name="set">
            <set>
                <value>1</value>
                <value>tom</value>
                <ref bean="byeService"/>
                <ref bean="byeService"/>
                <bean class="cn.itcast.spring.service.ByeService">
                    <property name="bye" value="kk" />
                </bean>
                <bean class="cn.itcast.spring.service.ByeService">
                    <property name="bye" value="kk" />
                </bean>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="key001" value="tom" />
                <entry key="key002" value-ref="byeService" />
                <entry key="key003">
                    <bean class="cn.itcast.spring.service.ByeService" />
                </entry>
            </map>
        </property>
        <property name="prop">
            <props>
                <prop key="key001">tom</prop>
                <prop key="key002">tom1</prop>
                <prop key="key003">tom2</prop>
            </props>
        </property>
    </bean>

    <bean id="byeService" class="cn.itcast.spring.service.ByeService">
        <property name="bye" value="over" />
    </bean>

    <!-- 通过util定义集合bean -->
    <util:list id="myList">
        <value>1</value>
        <value>2</value>
        <value>tom</value>
        <ref bean="byeService"/>
        <ref bean="byeService"/>
        <bean class="cn.itcast.spring.service.ByeService">
            <property name="bye" value="kk" />
        </bean>
        <bean class="cn.itcast.spring.service.ByeService">
            <property name="bye" value="kk" />
        </bean>
    </util:list>
</beans>

App.java

public class App {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext(
				"cn/itcast/spring/popset/popSet.xml");
		ac.getBean("popSet");
	}
}

4.分散装配

将配置文件分成几个分散的配置文件。如配置数据库的 jdbc.properties文件。使用占位符变量代替bean装配文件中的硬编码配置。占位符采${variable}形式。

定制属性编辑器 , 如下利用自定义的编辑器能将 省市县装配到homeAddress对应的属性中去。

<property name="homeAddress">

            <value>湖南省.长沙市.宁乡县.花明楼镇</value>

</property>

示例代码三：

Address.java， javabean

public class Address {
	private String province;
	private String city;
	private String street;
	private String zipCode;
	......省略 set get方法
}

Scatter.java， javabean

public class Scatter {
	private String driverClass ;
	private String url ;
	private String username ;
	private String password ;

	private Address comAddress ;//公司地址
	private Address homeAddress ;//家庭地址

}

jdbc.properties 分散配置的 prop文件

jdbc.driverclass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

AddressEditor.java 自定义编辑器

public class AddressEditor extends PropertyEditorSupport {

	public void setAsText(String text) throws IllegalArgumentException {
		if(text != null && text.length() > 0){
			String[] ss = text.split("\\.");
			if(ss != null && ss.length > 3){
				Address a = new Address();
				a.setProvince(ss[0]);
				a.setCity(ss[1]);
				a.setStreet(ss[2]);
				a.setZipCode(ss[3]);
				//将转换成的地址对象设置给相应的属性上
				setValue(a);
			}
			else{
				setValue(null);
			}
		}
		else{
			setValue(null);
		}
	}
}

scatter.xml 配置文件

<?xml version="1.0"?>
<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-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd ">
    <!-- 分散配置(属性占位符配置器)
    <bean id="propertyPlaceholderConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:cn/itcast/spring/scatter/jdbc.properties</value>
            </list>
        </property>
    </bean>
     -->

    <!-- 自定义编辑器配置器 -->
    <bean id="customEditorConfigurer" class="org.springframework.beans.factory.config.CustomEditorConfigurer">
        <!-- 自定义编辑器集 -->
        <property name="customEditors">
            <map>
                <entry key="cn.itcast.spring.scatter.Address">
                    <bean class="cn.itcast.spring.editor.AddressEditor" />
                </entry>
            </map>
        </property>
    </bean>

    <bean id="scatter" class="cn.itcast.spring.scatter.Scatter">
        <property name="driverClass" value="${jdbc.driverclass}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <!--  -->
        <property name="comAddress">
            <bean class="cn.itcast.spring.scatter.Address">
                <property name="province" value="jilin" />
                <property name="city" value="cc" />
                <property name="street" value="${jdbc.url}" />
            </bean>
        </property>
        <property name="homeAddress">
            <value>${jdbc.driverclass}.cc.renmin.139988</value>
        </property>
    </bean>

    <!-- 分散配置,加载分散配置的文件 -->
    <context:property-placeholder location="classpath:cn/itcast/spring/scatter/jdbc.properties"/>
</beans>

App.java

public class App {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext(
				"cn/itcast/spring/scatter/scatter.xml");
		ac.getBean("scatter");
	}
}