Spring_通过工厂方法配置bean 和 Spring_通过FactoryBean方式配置bean学习总结

Spring_通过工厂方法配置bean

前提:  Car 类

public class Car {

	private String brand;
	private double price;
	
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	
	@Override
	public String toString() {
		return "Car [brand=" + brand + ", price=" + price + ", getBrand()=" + getBrand() + ", getPrice()=" + getPrice()
				+ ", getClass()=" + getClass() + ", hashCode()=" + hashCode() + ", toString()=" + super.toString()
				+ "]";
	}
	
	public Car() {
		System.out.println("Car's Contructor....");
	}
	
	public Car(String brand, double price) {
		super();
		this.brand = brand;
		this.price = price;
	}
	
	
}

实现： 通过静态工厂方法来配置 bean  和 通过实例工厂方法来配置 bean

引入 StaticCarFactory.java

import java.util.HashMap;
import java.util.Map;

public class StaticCarFactory {
	private static Map<String, Car> cars = new HashMap<String,Car>();
	
	static {
		cars.put("audi", new Car("audi",300000) );
		cars.put("bmw", new Car("audi",300000) );
	}
	
	public static Car getCar(String name) {
		return cars.get(name);
	}
	
}

引入 InstanceCarFactory.java

import java.util.HashMap;
import java.util.Map;

public class InstanceCarFactory {
	
	/*
	 * 实例工厂方法: 实例工厂的方法,即先需要工厂本身,再调用工厂方法的实例来返回bean实例
	 * */
	private Map<String, Car> cars = null;
	public InstanceCarFactory() {
		cars = new HashMap<String,Car>();
		cars.put("audi", new Car("audi", 300000) );
		cars.put("dazhong", new Car("dazhong", 250000) );
	}
	
	public Car getCar(String brand) {
		return cars.get(brand);
	}
	
}

引入配置文件 beans-factory.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.注意不是配置静态工厂方式实例，而是配置bean实例 -->
	
	<!-- 
		class 属性: 指向静态工厂方法的bean
		factory-method :  指向静态工厂方法的名字
		constructor-arg:  如果工厂方法需要传入参数，则使用constructor-arg 来配置参数
	 -->
	
	
	<bean id="car1" class="com.atguigu.spring.beans.factory.StaticCarFactory"
		factory-method="getCar">
		<constructor-arg value="audi"></constructor-arg>
	</bean>
	
	<!-- 配置工厂的实例 -->
	<bean id="carFactory" class="com.atguigu.spring.beans.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="dazhong"></constructor-arg>
	</bean>
	
</beans>

运行效果：

这里是尚硅谷的spring4 的学习小结，所以源码全部都是照着视频一字一眼打出来的，主要是对概念还不是很清晰，所以不敢轻易总结

Spring_通过FactoryBean方式配置bean

 

前提： Car类

public class Car {

	private String brand;
	private double price;
	
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public double getPrice() {
		return price;
	}
	
	public Car(String brand, double price) {
		//super();
		this.brand = brand;
		this.price = price;
	}
	
	@Override
	public String toString() {
		return "Car [brand=" + brand + ", price=" + price + "]";
	}
	
	
	
	
}

CarFactoryBean 类

import org.springframework.beans.factory.FactoryBean;


//自定义的factoryBean需要实现FactoryBean接口
public class CarFactoryBean implements FactoryBean<Car> {

	private String brand;
	
	public void setBrand(String brand) {
		this.brand = brand;
	}
	
	//返回bean的对象 
	@Override
	public Car getObject() throws Exception {
		// TODO Auto-generated method stub
		return new Car(brand, 500000);
	}

	//返回bean的类型
	@Override
	public Class<?> getObjectType() {
		// TODO Auto-generated method stub
		return Car.class;
	}

	@Override
	public boolean isSingleton() {
		// TODO Auto-generated method stub
		return true;
	} 

}

Main类

package com.atguigu.spring.beans.factorybean;


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class Main {


	public static void main(String[] args) {
		
		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-beanfactory.xml");
		
		Car car = (Car) ctx.getBean("car");
		System.out.println(car);
		
	}


}

配置文件beanfactory.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">


	<!-- 
		通过FactoryBean 来配置Bean的实例
		class : 指向FactoryBean的全类名
		property : 配置FactoryBean的属性
		
		但实际返回的实例确实 FactoryBean 的 getObject() 方法返回的实例
	 -->

	<bean id="car" class="com.atguigu.spring.beans.factorybean.CarFactoryBean">
		<property name="brand" value="BMW"></property>
	</bean>
</Spring_通过工厂方法配置bean 和 Spring_通过FactoryBean方式配置bean

Spring_通过工厂方法配置bean 和 Spring_通过FactoryBean方式配置bean  小结

主要是对以下两个属性应用的示例

constructor-arg：通过构造函数注入。 
property：通过setter对应的方法注入。

Spring_通过工厂方法配置bean更多注重在  constructor-arg：通过构造函数注入

Spring_通过FactoryBean方式配置bean property：通过setter对应的方法注入。 

两者各有千秋，前者主要是配置构造函数的参数来实现对工厂里Car的信息配置，后者主要是通过setter对应的方法注入实现对CarFactory的配置，最后实现说直接配置工厂里某辆车信息的效果。

由于才学Spring 框架，很多地方都不清楚和明白，望看到此博客的大佬们能给在下一些建议，真心的谢谢.