Spring(1-2、基于xml装配Bean)
2017-06-13 14:51
357 查看
注:本文介绍 XML自动装配bean(byType,byName)、bean的继承、依赖bean的配置、Scope的配置、使用外部文件、工厂方法创建Bean。
注:本文用到的jar请到Spring(1-1、基于xml装配Bean)中查找
使用自动装配的优缺点:
在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配Bean 的所有属性. 然而, 若只希望装配个别属性时, autowire 属性就不够灵活了.
autowire 属性要么根据类型自动装配, 要么根据名称自动装配, 不能两者兼而有之.
一般情况下,在实际的项目中很少使用自动装配功能,因为和自动装配功能所带来的好处比起来,明确清晰的配置文档更有说服力一些。
子 Bean 从父 Bean 中继承配置, 包括 Bean 的属性配置
子 Bean 也可以覆盖从父 Bean 继承过来的配置
父 Bean 可以作为配置模板, 也可以作为 Bean 实例. 若只想把父 Bean 作为模板, 可以设置 <bean> 的abstract 属性为 true, 这样 Spring 将不会实例化这个 Bean
并不是 <bean> 元素里的所有属性都会被继承. 比如: autowire, abstract 等.
也可以忽略父 Bean 的 class 属性, 让子 Bean 指定自己的类, 而共享相同的属性配置. 但此时 abstract 必须设为 true。
xml配置:
如果前置依赖于多个 Bean,则可以通过逗号,空格或的方式配置 Bean 的名称
xml配置:<bean id="car" class="org.mybatis.bean.autowite.Car" p:brand="Audi"
p:price="300000">
</bean>
<bean id="person" class="org.mybatis.bean.autowite.Person" p:name="Tom"
p:address-ref="address3" depends-on="car">
</bean>
默认情况下, Spring 只为每个在 IOC 容器里声明的 Bean 创建唯一一个实例, 整个 IOC 容器范围内都能共享该实例:所有后续的 getBean() 调用和 Bean 引用都将返回这个唯一的 Bean 实例.该作用域被称为 singleton, 它是所有 Bean 的默认作用域.
使用外部的属性文件:
在配置文件里配置 Bean 时, 有时需要在 Bean 的配置里混入系统部署的细节信息(例如: 文件路径, 数据源配置信息等). 而这些部署细节实际上需要和 Bean 配置相分离
Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器, 这个处理器允许用户将 Bean 配置的部分内容外移到属性文件中. 可以在 Bean 配置文件里使用形式为${var} 的变量, PropertyPlaceholderConfigurer 从属性文件里加载属性, 并使用这些属性来替换变量.
Spring 还允许在属性文件中使用 ${propName},以实现属性之间的相互引用。
Spring 2.5 之后: 可通过 <context:property-placeholder> 元素简化:
<beans> 中添加 context Schema 定义
要声明通过静态方法创建的Bean, 需要在 Bean 的class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用<constrctor-arg>元素为该方法传递方法参数
xml配置:
测试类:
要声明通过实例工厂方法创建的Bean
在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean
在 factory-method 属性里指定该工厂方法的名称
使用 construtor-arg 元素为工厂方法传递方法参数
javaBean:
xml配置:
测试类:
测试类:
注:本文用到的jar请到Spring(1-1、基于xml装配Bean)中查找
xml配置里的Bean自动装配
public class Person { private String name; private Address address; private Car car; public class Address { private String city; private String street; public class Car{ private String brand; private double price;
byType根据类型自动装配:
<bean id="address" class="org.mybatis.bean.autowite.Address" p:city="BeiJing" p:street="huilongguan"></bean> <bean id="car" class="org.mybatis.bean.autowite.Car" p:brand="haifa" p:price="3245435"></bean> <!-- <bean id="person" class="org.mybatis.bean.autowite.Person" p:name="Tom" p:car-ref="car" p:address-ref="address"></bean> --> <!-- 自动装配:autowire属性指定自动装配的方式, ByName根据名字和当前bean的setter风格的属性名称进行自动装配。若有匹配的,则自动装配,如果没有匹配的,则不装配--> <bean id="person" class="org.mybatis.bean.autowite.Person" p:name="Tom" autowire="byName"></bean>
byName根据名称自动装配:
<!-- 自动装配:autowire属性指定自动装配的方式. ByType:根据bena的类型和当前bean的属性的类型进行自动装配。若IOC容器中有1个以上的类型匹配的bena,则抛异常 --> <bean id="person" class="org.mybatis.bean.autowite.Person" p:name="Tom" autowire="byType"></bean>
使用自动装配的优缺点:
在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配Bean 的所有属性. 然而, 若只希望装配个别属性时, autowire 属性就不够灵活了.
autowire 属性要么根据类型自动装配, 要么根据名称自动装配, 不能两者兼而有之.
一般情况下,在实际的项目中很少使用自动装配功能,因为和自动装配功能所带来的好处比起来,明确清晰的配置文档更有说服力一些。
Bean的继承
Spring 允许继承 bean 的配置, 被继承的 bean 称为父 bean. 继承这个父 Bean 的 Bean 称为子 Bean子 Bean 从父 Bean 中继承配置, 包括 Bean 的属性配置
子 Bean 也可以覆盖从父 Bean 继承过来的配置
父 Bean 可以作为配置模板, 也可以作为 Bean 实例. 若只想把父 Bean 作为模板, 可以设置 <bean> 的abstract 属性为 true, 这样 Spring 将不会实例化这个 Bean
并不是 <bean> 元素里的所有属性都会被继承. 比如: autowire, abstract 等.
也可以忽略父 Bean 的 class 属性, 让子 Bean 指定自己的类, 而共享相同的属性配置. 但此时 abstract 必须设为 true。
public class Address { private String city; private String street;
xml配置:
<!-- 抽象bean: bean的abstract属性为true的bean,这样的bean不能被IOC容器实例化,只用来被继承配置, 若某一个bean的class属性没有指定则该bean必须是一个抽象的bean --> <bean id="address" p:city="BeiJing^" p:street="WuDaoKou" abstract="true"></bean> <!-- 继承bean配置:使用bean的parent属性指定继承那个bean的配置 --> <bean id="address2" class="org.mybatis.bean.autowite.Address" parent="address"></bean> <bean id="address3" class="org.mybatis.bean.autowite.Address" parent="address2" p:street="DaZhongSi"></bean>
依赖Bean的配置:
Spring 允许用户通过 depends-on 属性设定 Bean 前置依赖的Bean,前置依赖的 Bean 会在本 Bean 实例化之前创建好如果前置依赖于多个 Bean,则可以通过逗号,空格或的方式配置 Bean 的名称
public class Car { private String brand; private double price; public class Person { private String name; private Address address; private Car car;
xml配置:<bean id="car" class="org.mybatis.bean.autowite.Car" p:brand="Audi"
p:price="300000">
</bean>
<bean id="person" class="org.mybatis.bean.autowite.Person" p:name="Tom"
p:address-ref="address3" depends-on="car">
</bean>
scope的配置
在 Spring 中, 可以在 <bean> 元素的scope 属性里设置 Bean 的作用域.默认情况下, Spring 只为每个在 IOC 容器里声明的 Bean 创建唯一一个实例, 整个 IOC 容器范围内都能共享该实例:所有后续的 getBean() 调用和 Bean 引用都将返回这个唯一的 Bean 实例.该作用域被称为 singleton, 它是所有 Bean 的默认作用域.
public class Car { private String brand; private double price;xml配置:
<!-- 使用bean的scope属性来配置bean的作用域 singleton:默认值,容器初始化时,创建bean示例,在这个容器的生命周期中值创建一个bean propotype:原型的,每次初始化时不创建bean的示例,而是每次请求时创建一个新的bean示例,并返回。 --> <bean id="car" class="org.mybatis.bean.autowite.Car" scope="singleton""> <property name="brand" value="Audi"></property> <property name="price" value="300000"></property> </bean>
使用外部的属性文件:
在配置文件里配置 Bean 时, 有时需要在 Bean 的配置里混入系统部署的细节信息(例如: 文件路径, 数据源配置信息等). 而这些部署细节实际上需要和 Bean 配置相分离
Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器, 这个处理器允许用户将 Bean 配置的部分内容外移到属性文件中. 可以在 Bean 配置文件里使用形式为${var} 的变量, PropertyPlaceholderConfigurer 从属性文件里加载属性, 并使用这些属性来替换变量.
Spring 还允许在属性文件中使用 ${propName},以实现属性之间的相互引用。
Spring 2.5 之后: 可通过 <context:property-placeholder> 元素简化:
<beans> 中添加 context Schema 定义
在配置文件中加入如下配置
<!—导入context命名空间—> xmlns:context=http://www.springframework.org/schema/context http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd <!-- 导入属性文件 --> <context:property-placeholder location="classpath:db.properties" /> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <!-- 使用外部属性文件的属性 --> <property name="user" value="${user}"></property> <property name="password" value="${password}"></property> <property name="driverClass" value="${driverClass}"></property> <property name="jdbcUrl" value="${jdbcUrl}"></property> </bean>
工厂方法创建Bean
共用的javaBean:public class Car { public Car() { System.out.println("Car's constructor..."); } public Car(String brand, double price) { super(); this.brand = brand; this.price = price; } //提供/set方法
静态工厂方法
调用静态工厂方法创建 Bean是将对象创建的过程封装到静态方法中. 当客户端需要对象时, 只需要简单地调用静态方法, 而不同关心创建对象的细节.要声明通过静态方法创建的Bean, 需要在 Bean 的class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用<constrctor-arg>元素为该方法传递方法参数
/** * 静态工厂方法(直接调用某一个类的静态方法,就可以返回bean的实例) * * @author bin * */ public class StaticCarFactory { public static Map<String, Car> cars = new HashMap<String, Car>(); static { cars.put("Audi", new Car("Audi", 300000)); cars.put("ford", new Car("ford", 400000)); } public static Car getCar(String name) { return cars.get(name); } }
xml配置:
<!-- 通过静态方法方法来配置bean,注意不是配置静态工厂方法示例,而是配置bean示例 --> <!-- class:属性,指向静态工厂方法的全类名 factory-method:指向静态工厂方法的名字 constructor-arg:如果工厂方法需要传入参数,则使用constructor-arg来配置参数 --> <bean id="car1" class="org.mybatis.factory.StaticCarFactory" factory-method="getCar"> <constructor-arg value="Audi"></constructor-arg> </bean>
测试类:
@Test public void test1() { ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext( "beans-factory.xml"); Car car = (Car) ctx.getBean("car1"); System.out.println(car); ctx.close(); }
示例工厂方法
实例工厂方法: 将对象的创建过程封装到另外一个对象实例的方法里. 当客户端需要请求对象时, 只需要简单的调用该实例方法而不需要关心对象的创建细节.要声明通过实例工厂方法创建的Bean
在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean
在 factory-method 属性里指定该工厂方法的名称
使用 construtor-arg 元素为工厂方法传递方法参数
javaBean:
/** * 示例工厂方法,示例工厂方法,即需要实现工厂本身,在调用工厂的实例方法来返回bean的实例 * @author */ public class InstanceCarFactory { private Map<String, Car> cars = null; public InstanceCarFactory() { cars = new HashMap<String, Car>(); cars.put("Audi", new Car("audi", 300000)); cars.put("ford", new Car("ford", 400000)); } public Car getCar(String brand) { return cars.get(brand); } }
xml配置:
<!-- 配置工厂的实例 --> <bean id="carFactory" class="org.mybatis.factory.InstanceCarFactory"> </bean> <!-- 通过实例工厂方法来配置bean --> <!-- factory-bean:属性,指向实例工厂方法的bean factory-method:指向静态工厂方法的名字 constructor-arg:如果工厂方法需要传入参数,则使用constructor-arg来配置参数 --> <bean id="car2" factory-bean="carFactory" factory-method="getCar"> <constructor-arg value="ford"></constructor-arg> </bean>
测试类:
@Test public void test1() { ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext( "beans-factory.xml"); Car car1 = (Car) ctx.getBean("car2"); System.out.println(car1); ctx
factoryBean
public class Car { public Car(String brand, double price) { super(); this.brand = brand; this.price = price; } private String brand; private double price;factoryBean:
/** * 自定义的factoryBean需要实现FactoryBean接口(覆盖里面的3个方法) * @author bin * */ public class CarFactoryBean implements org.springframework.beans.factory.FactoryBean<Car> { private String brand; public void setBrand(String brand) { this.brand = brand; } public Car getObject() throws Exception { return new Car("BMW", 500000); } public Class<?> getObjectType() { return Car.class; } public boolean isSingleton() { return true; } }xml配置:
<!-- 通过FactoryBean来配置Bean的实例 class:指向factoryBean的全类名 property:配置FactoryBean的属性 单实际范湖地恶势力确实FactoryBean的getObject()的方法的实例 --> <bean id="car" class="org.mybatis.factorybean.CarFactoryBean"> <property name="brand" value="BMW"></property> </bean>
测试类:
@Test public void test1() { ApplicationContext ctx = new ClassPathXmlApplicationContext( "beans-beanfactory.xml"); Car car = (Car) ctx.getBean("car"); System.out.println(car); }
相关文章推荐
- Spring(1-1、基于xml装配Bean)
- spring、IoC控制反转和DI依赖注入入门、基于XML的Bean装配、基于注解的Bean装配
- Spring基础——在 Spring Config 文件中基于 XML 的 Bean 的自动装配
- 【Java.Spring.Core】【IoC】基于注解的Bean装配(非XML配置)
- Spring 装配Bean 基于XML
- Spring学习历程---Bean基于xml的装配
- spring笔记(二)---基于XML的Bean装配
- spring装配Bean(基于xml)
- spring基础-Bean的装配方式(一)基于xml的装配
- 【JavaWeb-23】spring、IoC控制反转和DI依赖注入入门、基于XML的Bean装配、基于注解的Bean装配
- Spring In Action(二):基于XML配置装配bean
- Spring基础——在 Spring Config 文件中基于 XML 的 Bean 的自动装配
- Spring装配bean基于XML,注解
- Spring(五)基于XML装配bean(作用域)
- Spring中 基于注解的装配Bean 与 基于xml的对比总结
- Spring学习笔记之通过XML装配Bean的一些细节
- Spring3.2 中 Bean 定义之基于 XML 配置方式的源码解析
- Spring3.2 中 Bean 定义之基于 XML 配置方式的源码解析
- Spring之旅、装配Bean、最小化Spring XML配置、面向切面的Spring、征服数据库、事务管理示例源代码
- web读取spring管理的bean,基于xml