工厂模式 - 简单工厂

1、简单工厂模式

1.1、什么是简单工厂模式

　　简单工厂模式是类的创建模式，又叫做静态工厂方法模式。简单工厂模式是由一个工厂对象决定创建出哪一类产品类的实例。由一个工厂类根据传入的参数来决定创建出哪一种产品类的实例。

      

1.2、简单工厂模式的结构

       工厂类（Creator）角色：工厂方法模式的核心，含有与应用紧密相关的逻辑。工厂类在客户端的调用下直接创建产品对象。往往由一个具体的Java类实现。

       抽象产品（Product）角色：工厂方法模式所创建的对象的父类，或他们共同拥有的接口。抽象产品角色可以用一个Java接口或者Java抽象类表示。

       具体产品（Concrete Product）角色：工厂方法模式所创建的任何对象都是这个角色的实例，具体产品角色由一个具体Java类实现。

 

/**
 * 简单工厂模式*/
  public class SimpleFactoryClient {
    public static void main(String[] args) {
        Product product = Creator.factory("product1");
    }
}
  
 /**
 * 抽象产品角色1
 */
  interface Product{
}
  
/**
 * 具体产品角色11
 */
  class ConcreteProduct1 implements Product{
}
  /**
 * 具体产品角色21
 */
  class ConcreteProduct2 implements Product{
}

  /**
 * 工厂类角色
 */
  class Creator{
    public static Product factory(String type){
        if("product1".equals(type)){
            return new ConcreteProduct1();
        }else if("product2".equals(type)){
            return new ConcreteProduct2();
        }
        return null;
    }
}

 

1.3、优点 　　　　

       简单工厂模式的核心是工厂类。这个类含有必要的判断逻辑，以决定创建哪一个产品类的实例。客户端免除了直接创建产品类的责任，仅仅负责”消费”产品。

 

1.4、缺点

       工厂类集中了所有的产品创建逻辑，形成一个无所不知的全能类。这个类如果不能正常工作了，那么使用到了这个工厂类的地方都将受到影响。

 

1.5、实例 

这里用了lombok包

抽象产品

/**
 * 抽象产品角色
 * 水果
 */
public interface Fruit {

    /**
     * 默认方法，用于打印
     * @param msg 打印的信息
     */
    default void log(String msg){
        System.out.println(msg);
    }

    /**
     * 生长
     */
    void grow();

    /**
     * 收获
     */
    void harvest();

    /**
     * 种植
     */
    void plant();
}

具体产品：苹果

/**
 * 具体产品
 * 苹果
 */
@Data
public class Apple implements Fruit{

    /**
     * 树龄
     */
    private int treeAge;

    @Override
    public void grow() {
        log("Apple is growing ...");
    }

    @Override
    public void harvest() {
        log("Apple has been harvested ...");
    }

    @Override
    public void plant() {
        log("Apple has been planted ...");
    }
}

具体产品：葡萄

/**
 * 具体产品
 * 葡萄
 */
@Data
public class Grape implements Fruit{

    /**
     * 是否有籽
     */
    private boolean seedless;

    @Override
    public void grow() {
        log("Grape is growing ...");
    }

    @Override
    public void harvest() {
        log("Grape has been harvested ...");
    }

    @Override
    public void plant() {
        log("Grape has been planted ...");
    }
}

具体产品：草莓

/**
 * 具体产品
 * 草莓
 */
public class Strawberry implements Fruit{

    @Override
    public void grow() {
        log("Strawberry is growing ...");
    }

    @Override
    public void harvest() {
        log("Strawberry has been harvested ...");
    }

    @Override
    public void plant() {
        log("Strawberry has been planted ...");
    }
}

工厂类：果农

/**
 * 工厂类
 * 果农
 */
public class FruitGardener {

    /**
     * 静态工厂方法
     * @param which 生产的产品标识
     * @return
     */
    public static Fruit factory(String which){
        if("apple".equalsIgnoreCase(which)){
            return new Apple();
        }
        else if("grape".equalsIgnoreCase(which)){
            return new Apple();
        }
        else if("strawberry".equalsIgnoreCase(which)){
            return new Apple();
        }else{
            throw new RuntimeException("not has fruit");
        }
    }
}

客户端

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        Fruit apple = FruitGardener.factory("apple");
        apple.grow();
        apple.harvest();
        apple.plant();
        System.out.println("");

        Fruit grape = FruitGardener.factory("grape");
        grape.grow();
        grape.harvest();
        grape.plant();
        System.out.println("");

        Fruit strawberry = FruitGardener.factory("strawberry");
        strawberry.grow();
        strawberry.harvest();
        strawberry.plant();
    }
}

运行结果：

 

 1.6、总结

 　　简单工厂模式的核心是通过一个静态的工厂方法，根据入参去判断返回的具体产品对象。降低了客户端与系统之间的耦合，但是同时也加重了这个静态工厂方法的负担。每次拓展都需要修改这个静态工厂方法，违反了开闭原则。同时静态工厂方法的随着具体产品的对象不断增加，静态工厂方法中的判断也相应增加。负担越来越重。

 

 

 

参考：

　　《Java与模式》