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
     
       cars = new ArrayList
      
       ();  //多例 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     @Override4     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     @Override10     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     @Override10     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     @Override3     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

 

（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 (简化)

 

（2）模拟BeanFactory

 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.xml11     //Spring 的解析方式为ClassPathXmlApplicationContext("applicationContext.xml");  这个类就是要模拟ClassPathXmlApplicationContext的功能12 13     private Map
     
       container = new HashMap
      
       ();  //存放所有对象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
      
     

 

（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工厂的模式了，面向抽象编程，将具体类放在配置文件中。