Java中的工厂模式

工厂模式的思想：

工厂类自主生产产品，而不用其它类去new一个产品

简单工厂：

需求：构造一个交通工具工厂，可以自定义汽车、飞机及其交通工具跑起来的方式run方法

思路：

     抽象工厂类（父）-----具体工厂类（子）-----》生产具体产品

总工厂抽象类：

TransportToolFactory.java

1

public abstract class TransportToolFactory{

2

    abstract Movable getProduce();

3

}

汽车工厂类

CarFactory.java

1

public class CarFactory extends TransportToolFactory{

2

    @Override

3

    public Car getProduce(){

4

        return new Car();

5

    }

6

}

飞机工厂类

PlaneFactory.java

1

public class PlaneFactory extends TransportToolFactory{

2

    @Override

3

    public Plane getProduce(){

4

        return new Plane();

5

    }

6

}

总产品类的接口（产品的共有特性）

Moveable.java

1

public interface Moveable{

2

    void run();//产品共有的run行为

3

}

汽车产品类

Car.java

1

public class Car implements Moveable{

2

    @Override

3

    run(){

4

       //定制的汽车run行为代码 

5

    }

6

7

}

飞机产品类

Plane.java

1

public class Plane implements Moveable{

2

​

3

    @Override

4

    run(){

5

        //定制的飞机run行为代码

6

    }

7

}

测试类

Test.java

1

public class Test{

2

    public static void main(String[] args){

3

        TransportToolFactory carFactory = new CarFactory();//创建汽车工厂

4

        TransportToolFactory planeFactory = new PlaneFactory();//创建飞机工厂

5

6

        Moveable car = carFactory.getProduce();//得到汽车产品

7

        Moveable plane = planeFactory.getProduce();//得到飞机产品

8

9

        car.run();//产品自定义行为

10

        plane.run();

11

    } 

12

}

抽象工厂：

场景：（用于产生 产品系列）

思路：

    抽象工厂（父）--- 具体工厂（子）----》生产具体产品    

    抽象产品（父）-----具体产品（子）

交通工具类Vehicle：包括汽车A、汽车B

食品类Food：包括苹果A、苹果B

工厂A：生产汽车A，苹果A

工厂B：生产汽车B，苹果B

-----------------------------工厂类---------------------------------

总工厂类（抽象）

AbstractFactory.java

1

public abstract class AbstractFactory{

2

    public abstract Vehicle createVehicle();//汽车工厂

3

    public abstract Food createFood();//食物工厂

4

}

A工厂类（具体）

AFactory.java

1

public class AFactory extends AbstractFactory{

2

    //造汽车A

3

    @Override

4

    Vehicle createVehicle(){

5

        new CarA();

6

    }

7

    //造苹果A

8

    @Override

9

    Food createVehicle(){

10

        new AppleA();

11

    }

12

}

B工厂类（具体）

BFactory.java

1

public class BFactory extends AbstractFactory{

2

    //造汽车B

3

    @Override

4

    public Vehicle createVehicle(){

5

        new CarB();

6

    }

7

    //造苹果B

8

    @Override

9

    public Food createFood(){

10

        new AppleB();

11

    }

12

}

-------------------------- 产品类 ---------------------------

总交通工具类（抽象，代表一系列交通工具）

Vehicle.java

1

public abstract class Vehicle{

2

    //描述交通工具行为

3

}

总食物类（抽象，代表一系列食物）

Food.java

1

public abstract class Food{

2

    //描述食物行为

3

}

抽象产品具体化：

汽车A类继承Vehicle类  CarA extends Vehicle

汽车B类继承 Vehicle类  CarB extends Vehicle

苹果A类继承Food类  AppleA extends Food

苹果B类继承Food类  AppleB extends Food

----------------------------- 测试类 ---------------------------------

Test.java

1

public class Test{

2

    public static void main(String[] args){

3

        AbstractFactory factory = new AFactory();//创建A抽象工厂

4

        //AbstractFactory factory = new BFactory();//创建B抽象工厂，只需修改一行代码

5

6

        factory.createVehicle();//创建该工厂的交通工具

7

        factory.createFood();//创建该工厂的食物

8

    }

9

}

抽象工厂的好处：

如果需要修改工厂，只需修改一行代码new一个新的Factory即可，工厂的生产产品的方法严格按照AbstractFactory这个抽象类写，可以统一create方法，因此生产产品的方法不需要修改

Spring中的BeanFactory工厂模式：

Spring中的IOC用法：

    1.ApplicationContext.xml中加入bean标签

        

1

<bean id="对应这个类的key" class="全类名">

2

</bean>

    2.在main方法中得到类对象

1

public static void(String[] args){

2

    BeanFactory f = new ClassPathXmlApplicationContext("全类名");

3

    Object obj = f.getBean("对应这个类的key"); 

4

}

底层实现：

    工厂接口

    BeanFactory.java

1

public interface BeanFactory{

2

    Object getBean(String id);

3

}

    工厂实现类

    ClassPathXmlApplicationContext.java

1

public class ClassPathXmlApplicationContext implements BeanFactory{

2

    //Bean容器HashMap

3

    private Map<String,Object> container = new HashMap<String, Object>();

4

5

    //从文件名中找到文件并读取

6

    public ClassPathXmlApplicationContext(String classPath){

7

        //使用JDOM、SAX或DOM4J解析XML文件得到bean结点

8

        //得到bean结点的id属性值id

9

        //得到bean结点的class属性值clazz

10

        //反射得到类对象

11

        Object object = Class.forName(clazz).newInstance();

12

        //放入bean容器HashMap

13

        container.put(id,object);

14

    }

15

16

17

    //通过配置文件的bean标签中的id得到全类名---反射--返回类对象

18

    @Override

19

    public Object getBean(String id){

20

        //从bean容器取出Object

21

        container.get(id);

22

    }

23

}