设计模式之工厂模式

感觉慕课网的卜奇老师讲解http://www.imooc.com/learn/261

1.工厂模式概述

工厂模式概念：
  实例化对象，用工厂方式代替new操作
  工厂模式包括工厂方法模式和抽象工厂模式
  抽象工厂模式就是工厂方法模式的扩展

工厂模式的意图：
  定义一个接口来创建对象，但是让子类来决定哪些类需要被实例化。
  工厂模式把实例化的工作推迟到子类中去实现。

什么情况下适合工厂模式？
  有一组类似的对象需要创建
  在编码时不能预见需要创建哪种类的实例
  系统需要考虑扩展性，不应依赖于产品类实例如何被创建、组合和表达的细节。

工厂模式的动机：
  在软件系统中经常面临着“对象”的创建工作，由于需求的变化，这个对象可能随之发生变化，但它却拥有比较稳定的接口。
  为此我们需要提供一种封装机制来隔离出这个易变对象的变化，从而保持系统中其他依赖该对象的对象不随着需求变化而变化。

设计：
  1、尽量松耦合，一个对象的依赖对象的变化与本身无关。
  2、具体产品与客户端剥离，责任分割。

2.工厂方法模式

我们想实现一个发型工厂，由客户端决定生产什么样的发型

2.1 一般多态方式创建

首先写一个发型的接口

package com.productfactory.project;
/**
 * 发型接口
 */
public interface HairInterface {

    //实现画发型
    public void draw();


}

创建一个左偏分类，实现发型接口

package com.productfactory.project;
/**
 * 左偏分发型
 */
public class LeftHair implements HairInterface{


    /**
     * 画一个左偏分发型
     */
    @Override
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println("====这是一个左偏分发型======");
    }

}

同理，可以写一个右偏分类。

package com.productfactory.project;
/**
 * 右偏分发型
 */
public class RightHair implements HairInterface{


    /**
     * 画一个右偏分发型
     */
    @Override
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println("====这是一个右偏分发型======");
    }

}

此时可以在main方法中测试

package com.productfactory.project;

public class TestDemo {
    public static void main(String[] args) {

        HairInterface left = new LeftHair();
        left.draw();

    }
}

但这种方式需要直接对子类进行创建。客户端与产品没有分离。
我们可以把它放在工厂中集中管理。

2.2 通过工厂实现发型创建

创建一个工厂类

package com.productfactory.project;

import java.util.Map;

/**
 * 发型工厂
 * @author Administrator
 *
 */
public class HairFactory {

    /**
     * 根据类型来创建对象
     * @param key
     * @return
     */
    public HairInterface getHair(String key){
        if("left".equals(key)){
            return new LeftHair();
        }else if ("right".equals(key)){
            return new RightHair();
        }
        return null;
    }

}

在main方法中进行测试

package com.productfactory.project;

public class TestDemo {
    public static void main(String[] args) {

        HairFactory factory = new HairFactory();
        HairInterface left = factory.getHair("left");
        left.draw();
    }
}

这种方式有一个缺点，每多一种发型，都要在工厂中新增加一个else if。还可以通过类的反射来创建发型。

2.3 通过类的反射来创建

我们可以修改HairFactory发型工厂类

package com.productfactory.project;

import java.util.Map;

/**
 * 发型工厂
 * @author Administrator
 *
 */
public class HairFactory {

    public HairInterface getHairByClass(String className){

        try {
            HairInterface hair = (HairInterface) Class.forName(className).newInstance();
            return hair;
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }   
        return null;
    }

}

在main方法中进行测试

package com.productfactory.project;

public class TestDemo {
    public static void main(String[] args) {
        HairFactory factory = new HairFactory();
        HairInterface left = factory.getHairByClass("com.productfactory.project.LeftHair");
        left.draw();
    }
}

这种方法的优点是，当新增加一种发型时，不需要修改HairFactory类，但是客户端需要知道想要生成的类的全名。
我们可以通过在配置文件中配置的方法简化客户端。

2.4 通过properties文件配置来创建特定的类。

新建一个配置文件type.properties

left=com.productfactory.project.LeftHair
right=com.productfactory.project.RightHair

增加一个读取配置文件的类

package com.productfactory.project;

import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * properties文件的读取类
 * @author Administrator
 *
 */
public class PropertiesReader {
    public Map<String, String> getProperties() {

        Properties props = new Properties();
        Map<String, String> map = new HashMap<String, String>();
        try {

            InputStream in = getClass().getResourceAsStream("type.properties");
            props.load(in);
            Enumeration en = props.propertyNames();
            while (en.hasMoreElements()) {
                String key = (String) en.nextElement();
                String property = props.getProperty(key);
                map.put(key, property);
//              System.out.println(key + "  " + property);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }

}

修改HairFactory类

package com.productfactory.project;

import java.util.Map;

/**
 * 发型工厂
 * @author Administrator
 *
 */
public class HairFactory {

public HairInterface getHairByClassKey(String key){

        try {
            Map<String, String> map = new PropertiesReader().getProperties();
            HairInterface hair = (HairInterface) Class.forName(map.get(key)).newInstance();
            return hair;
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return null;
    }
}

在main方法中测试

package com.productfactory.project;

public class TestDemo {
    public static void main(String[] args) {
        HairFactory factory = new HairFactory();
        HairInterface right = factory.getHairByClassKey("right");
        right.draw();
    }
}

此时想生成发型就非常容易了，想增加新的发型，也只需要实现发型接口，并在配置文件中注册一下就可以了。

3. 抽象工厂模式

抽象工厂模式的类图如下

我们以不同节日生产不同男孩女孩玩具为例。

package com.productfactory.project;
/**
 * 女孩接口
 *
 */
public interface Girl {
    public void drawGirl();
}

package com.productfactory.project;
/**
 * 男孩接口
 *
 */
public interface Boy {
    public void drawBoy();
}

圣诞系列男女孩实体类

package com.productfactory.project;
/**
 * 圣诞系列的女孩
 * @author Administrator
 *
 */
public class MCGirl implements Girl{

    @Override
    public void drawGirl() {
        // TODO Auto-generated method stub
        System.out.println("====圣诞系列的女孩=====");

    }

}

package com.productfactory.project;

public class MCBoy implements Boy {

    @Override
    public void drawBoy() {
        // TODO Auto-generated method stub
        System.out.println("=====圣诞系列的男孩=====");
    }

}

新年系列男女孩实体类

package com.productfactory.project;
/**
 * 新年系列的女孩子
 * @author Administrator
 *
 */
public class HNGirl implements Girl {

    @Override
    public void drawGirl() {
        // TODO Auto-generated method stub
        System.out.println("====新年系列的女孩====");
    }

}

package com.productfactory.project;

public class HNBoy  implements Boy{

    @Override
    public void drawBoy() {
        // TODO Auto-generated method stub
        System.out.println("====新年系列的男孩=====");
    }
}

玩具生产工厂接口

package com.productfactory.project;
/**
 * 任务的实现接口
 * @author Administrator
 *
 */
public interface PersonFactory {

    //男孩接口
    public Boy getBoy();

    //女孩接口
    public Girl getGirl();
}

圣诞工厂，实现工厂接口

package com.productfactory.project;
/**
 * 圣诞系列加工厂
 * @author Administrator
 *
 */
public class MCFactory implements PersonFactory{

    @Override
    public Boy getBoy() {
        // TODO Auto-generated method stub
        return new MCBoy();
    }

    @Override
    public Girl getGirl() {
        // TODO Auto-generated method stub
        return new MCGirl();
    }

}

新年工厂，实现工厂接口

package com.productfactory.project;
/**
 * 新年系列的加工厂
 * @author Administrator
 *
 */
public class HNFactory implements PersonFactory {

    @Override
    public Boy getBoy() {
        // TODO Auto-generated method stub
        return new HNBoy();
    }

    @Override
    public Girl getGirl() {
        // TODO Auto-generated method stub
        return new HNGirl();
    }

}

在main方法中测试一下

package com.productfactory.project;

public class TestDemo02 {
    public static void main(String[] args) {
         PersonFactory factory = new MCFactory();
         Girl girl = factory.getGirl();

         girl.drawGirl();

         PersonFactory factory2 = new HNFactory();
         Boy boy = factory2.getBoy();
         boy.drawBoy();

    }
}

4.工厂模式总结

4.1 工厂模式常见应用

1、JDBC
  JDBC是一种用于执行SQL语句的JAVA API，可以为多种关系数据库提供统一访问，它由一组用java语言编写的类和接口组成。

2.spring beanfactory
  BeanFactory，作为Spring基础的IOC容器，是Spring的一个Bean工厂，如果单从工厂模式的角度思考，它就是用来“生产Bean”，然后提供给客户端。

4.2 工厂方法模式和抽象工厂模式的对比

   工厂模式是一种极端情况的抽象工厂模式，而抽象工厂模式可以看成是工厂模式的推广。
  工厂模式用来创建一个产品的等级结构，而抽象工厂模式用来创建多个产品的等级结构。
  工厂模式只有一个抽象产品类，而抽象工厂模式有多个抽象产品类。

4.3 工厂模式的实现的好处

  系统可以在不修改具体工厂角色的情况下引进新的产品
  客户端不必关心对象如何创建，明确了职责。
  更好的理解面向对象的原则，面向对象接口编程，而不要面向实现编程。

4.4 工厂模式适用于那些场景

  一个系列应当不依赖于产品类实例被创建、组成和表示的细节。这对于所有形态的工厂模式都是重要的。
  这个系统的产品至少有一个产品族
  同属于同一个产品组的产品是设计称在一起使用的，这一约束必须在系统的设计中体现出来。
  不同的产品以一系列的接口的面貌出现，从而使系统不依赖于接口实现的细节。