Spring（1-2、基于xml装配Bean）

最新推荐文章于 2024-09-12 08:22:34 发布

Koma-forever

最新推荐文章于 2024-09-12 08:22:34 发布

阅读量371

点赞数

文章标签： spring

本文链接：https://blog.csdn.net/www1056481167/article/details/73178871

版权

注：本文介绍 XML自动装配bean(byType,byName)、bean的继承、依赖bean的配置、Scope的配置、使用外部文件、工厂方法创建Bean。

注：本文用到的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);
	}

Koma-forever

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring（1-2、基于xml装配Bean）

注：本文介绍 XML自动装配bean(byType,byName)、bean的继承、依赖bean的配置、Scope的配置、使用外部文件、工厂方法创建Bean。需要添加的jar包在同类文章的（Spring（1-1、基于xml装配Bean））中查看xml配置里的Bean自动装配public class Person { private String name;
复制链接

扫一扫