你的位置:首页 > ASP.net教程

[ASP.net教程]从基础知识到重写Spring的Bean工厂中学习java的工厂模式


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   @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 }

View Code

 



(2)、抽象工厂

1 public abstract class AbstractFactory {2   public abstract Vehicle createVehicle();3   public abstract Food createFood();4 }

View Code

 



(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 }

View Code

 

 

 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 }

View Code

 


(4)、交通工具抽象类以及实现类

1 public abstract class Vehicle {2   public abstract void run();3 }

View Code

 


******************************

1 public class Car extends Vehicle{2 3   public void run(){4     System.out.println("the car is running......");5   }6 }

View Code

 



1 public class Plane extends Vehicle{2   @Override3   public void run() {4     System.out.println("the plane is flying...");5   }6 }

View Code

 


(5)、食物抽象类以及实现类

1 public abstract class Food {2   public abstract void eat();3 }

View Code

 



*****************************

1 public class Apple extends Food{2   public void eat(){3     System.out.println("eating apple...");4   }5 }

View Code

 

 

1 public class Banana extends Food{2   public void eat(){3     System.out.println("eating Banana...");4   }5 }

View Code

 



普通工厂模式与抽象工厂各有优缺点,
在产生对象系类时,普通工厂会有工厂泛滥的现象
抽象工厂在产生新的对象类型时,从上到下都需要改动


4、Spring的Bean工厂
现在就需要运用工厂知识来模拟Spring的Bean工厂了

我们先看看Spring是如何运用Bean工厂的

(1)、applicationContext.

<?

 



(2)、测试类:

 1 import org.springframework.beans.factory.BeanFactory; 2 import org.springframework.context.support.ClassPath 3  4 public class TestForSpring { 5   public static void main(String[] args){ 6     BeanFactory factory = new ClassPath); 7     Object o = factory.getBean("v"); //找到 id = v对应的class, getInstance得到一个Bean对象,返回 8     Moveable m = (Moveable)o; 9     m.run();10 11   }12 }

 


Spring 的applicationContext.
然后其他对象通过该工厂对象,调用getBean得到,以id为参数,得到对象

在理解了这些之后,我们就可以开始模拟了,其实最主要的部分就是在于解析反射得到该类,getInstance()后获得对象。解析
(1)模拟的配置文件 applicationContext_simulation.

<?

 



(2)模拟BeanFactory

 1 public interface BeanFactory_simulation { 2 Object getBean(String id); 3 } 

(3)模拟BeanFactory的实现类ClassPath

 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 ClassPathimplements BeanFactory_simulation{10   //要自定义方法解析applicationContext.11   //Spring 的解析方式为ClassPath12 13   private Map<String,Object> container = new HashMap<String, Object>(); //存放所有对象14 15   public ClassPaththrows 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   @Override36   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 ClassPath);4     Object o = beanFactory_simulation.getBean("v");5     Moveable m = (Moveable)o;6     m.run();7   }8 }

 


这样我们就基本清楚了Spring的Bean工厂的模式了,面向抽象编程,将具体类放在配置文件中。