标签：
1、静态工厂模式
其他对象不能直接通过new得到某个类，而是通过调用getInstance()方法得到该类的对象
这样，就可以控制类的产生过程。
顺带提一下单例模式和多例模式：
单例模式是指控制其他对象获得该对象永远只有同一个对象
而多例模式则是根据需要从某个具体集合中获取所需的对象
1 import java.util.ArrayList; 2 import java.util.List; 3 4 5 public class Car implements Moveable{ 6 private static Car car = new Car(); //控制其他对象获得该对象永远只有同一个对象 7 private static List<Car> cars = new ArrayList<Car>(); //多例 8 9 //将构造方法私有化，限制其他对象无限制的new出Car对象 10 private Car(){} 11 12 //通过静态方法获得new 出的对象 13 //即在取得该对象的过程由Car本身控制，可以为其添加各类限制 14 public static Car getInstance(){ 15 //if() if。。。。 16 return car; 17 } 18 public void run(){ 19 System.out.println("the car is running......"); 20 } 21 }
2、普通工厂模式
与静态工厂不同，普通工厂将产生的过程交由其他的类处理，而并非类的本身。
1 public class CarFactory { 2 3 @Override 4 Moveable create() { 5 return new Car() ; 6 } 7 }
这样就可以通过获得CarFactory的对象，调用create()得到Car对象
3、抽象工厂模式
抽象工厂是指工厂类要产生一个系列的对象，将工厂类进行抽象，这样就可以通过改变工厂类，从而能够改变一系列的对象。
其实這就慢慢接近面向抽象编程。
这里类就比较多，就从抽象程度由上到下进行介绍：
（1）、测试类
1 public class Test { 2 public static void main(String[] args){ 3 4 AbstractFactory d = new DefaultFactory(); 5 6 /** 7 可以通过AbstractFactory d = new NewFactory() 可以替换系类对象 8 **/ 9 10 Vehicle v = d.createVehicle(); 11 Food f = d.createFood(); 12 13 v.run(); 14 f.eat(); 15 16 } 17 }
（2）、抽象工厂
1 public abstract class AbstractFactory { 2 public abstract Vehicle createVehicle(); 3 public abstract Food createFood(); 4 }
（3）、抽线工厂实现类
1 public class NewFactory extends AbstractFactory{ 2 3 4 @Override 5 public Vehicle createVehicle() { 6 return new Plane(); 7 } 8 9 @Override 10 public Food createFood() { 11 return new Banana(); 12 } 13 }
1 public class DefaultFactory extends AbstractFactory{ 2 3 4 @Override 5 public Vehicle createVehicle() { 6 return new Car(); 7 } 8 9 @Override 10 public Food createFood() { 11 return new Apple(); 12 } 13 }
（4）、交通工具抽象类以及实现类
1 public abstract class Vehicle { 2 public abstract void run(); 3 }
******************************
1 public class Car extends Vehicle{ 2 3 public void run(){ 4 System.out.println("the car is running......"); 5 } 6 }
1 public class Plane extends Vehicle{ 2 @Override 3 public void run() { 4 System.out.println("the plane is flying..."); 5 } 6 }
（5）、食物抽象类以及实现类
1 public abstract class Food { 2 public abstract void eat(); 3 }
*****************************
1 public class Apple extends Food{ 2 public void eat(){ 3 System.out.println("eating apple..."); 4 } 5 }
1 public class Banana extends Food{ 2 public void eat(){ 3 System.out.println("eating Banana..."); 4 } 5 }
普通工厂模式与抽象工厂各有优缺点，
在产生对象系类时，普通工厂会有工厂泛滥的现象
抽象工厂在产生新的对象类型时，从上到下都需要改动
4、Spring的Bean工厂
现在就需要运用工厂知识来模拟Spring的Bean工厂了
我们先看看Spring是如何运用Bean工厂的
（1）、applicationContext.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 id="v" class="com.csu.springFactory.Train">
</bean>
<!--类似 一般配置文件的 v="com.csu.springFactory.Car" 的格式-->
</beans>
（2）、测试类：
1 import org.springframework.beans.factory.BeanFactory; 2 import org.springframework.context.support.ClassPathXmlApplicationContext; 3 4 public class TestForSpring { 5 public static void main(String[] args){ 6 BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml"); 7 Object o = factory.getBean("v"); //找到 id = v对应的class, getInstance得到一个Bean对象，返回 8 Moveable m = (Moveable)o; 9 m.run(); 10 11 } 12 }
Spring 的applicationContext.xml中配置了实体类的信息，通过解析改配置文件，可以得到一个包含了所有类对象的工厂，
然后其他对象通过该工厂对象，调用getBean得到，以id为参数，得到对象
在理解了这些之后，我们就可以开始模拟了，其实最主要的部分就是在于解析xml配置文件，可以通过id获得类名，然后利用
反射得到该类，getInstance()后获得对象。解析xml文件有很对方法，这里就用JDOM.
（1）模拟的配置文件 applicationContext_simulation.xml (简化)
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="v" class="com.csu.springSimulation.Car">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!--类似 spring.properties配置文件的 v="com.csu.springFactory.Car" 的格式-->
</beans>
（2）模拟BeanFactory
1 public interface BeanFactory_simulation { 2 Object getBean(String id); 3 }
（3）模拟BeanFactory的实现类ClassPathXmlApplicationContext_simulation
1 import org.jdom2.Document; 2 import org.jdom2.Element; 3 import org.jdom2.input.SAXBuilder; 4 import java.util.HashMap; 5 import java.util.List; 6 import java.util.Map; 7 8 9 public class ClassPathXmlApplicationContext_simulation implements BeanFactory_simulation{ 10 //要自定义方法解析applicationContext.xml 11 //Spring 的解析方式为ClassPathXmlApplicationContext("applicationContext.xml"); 这个类就是要模拟ClassPathXmlApplicationContext的功能 12 13 private Map<String,Object> container = new HashMap<String, Object>(); //存放所有对象 14 15 public ClassPathXmlApplicationContext_simulation(String filename) throws Exception { 16 SAXBuilder sb=new SAXBuilder(); 17 Document doc=sb.build(this.getClass().getClassLoader().getResourceAsStream(filename)); 18 Element root=doc.getRootElement(); 19 List list=root.getChildren("bean"); 20 21 System.out.println(list.size()); 22 23 for(int i=0;i<list.size();i++){ 24 Element element=(Element)list.get(i); 25 String id=element.getAttributeValue("id"); 26 String clazz = element.getAttributeValue("class"); 27 28 Object o = Class.forName(clazz).newInstance(); 29 container.put(id,o); 30 31 } 32 33 } 34 35 @Override 36 public Object getBean(String id) { 37 return container.get(id); 38 } 39 }
（4）测试类
1 public class Test { 2 public static void main(String[] args) throws Exception { 3 BeanFactory_simulation beanFactory_simulation = new ClassPathXmlApplicationContext_simulation("com/csu/springSimulation/applicationContext_simulation.xml"); 4 Object o = beanFactory_simulation.getBean("v"); 5 Moveable m = (Moveable)o; 6 m.run(); 7 } 8 }
这样我们就基本清楚了Spring的Bean工厂的模式了，面向抽象编程，将具体类放在配置文件中。
从基础知识到重写Spring的Bean工厂中学习java的工厂模式
标签：
原文地址：http://www.cnblogs.com/chentao-cus/p/4820459.html
