关于后端:工厂模式

37次阅读

共计 3690 个字符，预计需要花费 10 分钟才能阅读完成。

简略工厂模式
工厂办法模式
形象工厂模式

简略工厂中次要存在以下角色

工厂（Factory）：提供了动态工厂办法，它负责创立所有具体产品的实例。
形象产品（Abstract Product）：负责形容所有具体产品的公共产品，能够用抽象类或接口实现。
具体产品（Concrete Product）：是工厂创立的指标产品。

上面应用一个“颜料”工厂的实例来实现一个简略工厂

形象产品 – 颜料（color）

public interface Color {void draw();
}

具体产品 – 黄色、绿色、红色颜料

public class Green implements Color{
    @Override
    public void draw() {System.out.println("绿色颜料");
    }
}

public class Red implements Color{
    @Override
    public void draw() {System.out.println("红色颜料");
    }
}

public class Yellow implements Color{
    @Override
    public void draw() {System.out.println("黄色颜料");
    }
}

工厂 – 颜料工厂 – 依据传入参数”生产“相干颜料

public class ColorFactory {
    public static String RED = "red";
    public static String GREEN = "green";
    public static String YELLOW = "yellow";

    public static Color getColor(String c){if (RED.equalsIgnoreCase(c)){return new Red();
        }else if (GREEN.equalsIgnoreCase(c)){return new Green();
        }else if (YELLOW.equalsIgnoreCase(c)){return new Yellow();
        }else {return null;}
    }
}

public class ColorFactoryTest {
    @Test
    public void test(){Color color = ColorFactory.getColor(ColorFactory.GREEN);
        color.draw();}
}
======== 后果 ========
绿色颜料

如果对象能够复用，那么就不须要每次创立一个新对象，能够先将其缓存起来，每次申请从缓存中给他拿相应的对象。如下：

public class ColorCacheFactory {
    public static String RED = "red";
    public static String GREEN = "green";
    public static String YELLOW = "yellow";

    private static final Map<String,Color> cacheMap = new HashMap<>();

    static {cacheMap.put(RED,new Red());
        cacheMap.put(GREEN,new Green());
        cacheMap.put(YELLOW,new Yellow());
    }

    public static Color getColor(String s){return cacheMap.get(s);
    }
}

在简略工厂模式中每减少一个具体实例都要对相应工厂进行相应代码的，这就违反了 SOLID 中的开闭准则。所以就呈现了工厂办法模式解决了这个问题。

工厂办法模式中有以下角色

形象工厂(Abstract Factory)
具体工厂(Concrete Factory)
形象产品(Abstract Product)
具体产品(Concrete Product)

相比简略工厂这里将工厂变成了形象工厂 + 具体工厂

上面咱们还应用颜料的例子，形象产品和具体产品和下面一样所以咱们在上面不反复贴代码了

形象工厂

public interface ColorFactory {
    String RED = "red";
    String GREEN = "green";
    String YELLOW = "yellow";

    Color getColor();}

具体工厂

public class GreenColorFactory implements ColorFactory{
    @Override
    public Color getColor() {return new Green();
    }
}
public class RedColorFactory implements ColorFactory{
    @Override
    public Color getColor() {return new Red();
    }
}
public class YellowColorFactory implements ColorFactory{
    @Override
    public Color getColor() {return new Yellow();
    }
}

应用形式

ColorFactory factory = new GreenColorFactory();
factory.getColor().draw();

这样看起来，除了解决了不合乎开闭准则的问题，没有其它任何劣势，反而因为产生了很多新的工厂类会减少肯定代码量。然而如果换个角度看，如果创立一个 Color 的实例不仅仅是 new Red() 这么简略的一行代码，而是一个比较复杂的过程, 那么把这些代码都糅杂在一个简略工厂之中显然不是一个好的抉择。

public static Color getColor(String c){if (RED.equalsIgnoreCase(c)){Red color = new Red();
        ...
        return color;
    }else if (GREEN.equalsIgnoreCase(c)){Green color = new Green();
        ...
        return color;
    }else if (YELLOW.equalsIgnoreCase(c)){Yellow color = new Yellow();
        ...
        return color;
    }else {return null;}
}

形象工厂模式是对一组队友多种雷同主题的工厂进行封装，形象工厂是工厂办法的降级版本，工厂办法模式只生产同一类的产品，而形象工厂模式可生产多个类的产品。

咱们持续在”颜料“这个主题上进行降级，颜料常常用于服饰上色，所以咱们创立一个生产颜料和服饰的形象工厂。

public interface Color {void draw();
}
public class Green implements Color {
    @Override
    public void draw() {System.out.println("绿色颜料");
    }
}

public class Red implements Color {
    @Override
    public void draw() {System.out.println("红色颜料");
    }
}

public interface Apparel {void crop();
}
public class Pants implements Apparel{
    @Override
    public void crop() {System.out.println("裁剪裤子");
    }
}

public class Shirts implements Apparel{

    @Override
    public void crop() {System.out.println("裁剪衬衫");
    }
}

public interface AbstractFactory {Color getColor();
    Apparel getApparel();}
public class GreenPantsFactory implements AbstractFactory {
    @Override
    public Color getColor() {return new Green();
    }

    @Override
    public Apparel getApparel() {return new Pants();
    }
}

public class RedShirtsFactory implements AbstractFactory {
    @Override
    public Color getColor() {return new Red();
    }

    @Override
    public Apparel getApparel() {return new Shirts();
    }
}

public class MethodFactoryTest {
    @Test
    public void test(){AbstractFactory factory = new GreenPantsFactory();
        factory.getColor().draw();
        factory.getApparel().crop();
    }
}
===== 后果 =====
绿色颜料
裁剪裤子

形象共产和工厂办法的区别