必威体育Betway必威体育官网
当前位置:首页 > IT技术

工厂模式——三种方式

时间:2019-08-17 21:43:13来源:IT技术作者:seo实验室小编阅读:74次「手机版」
 

工厂模式

工厂模式

用工厂方法代替了new操作, 将选择实现类, 创建对象统一管理和控制.从而将调用者(Client)与实现类进行解耦.实现了创建者与调用者分离;

  • 使用场景
    1. JDK中calendar的getinstance方法;
    2. JDBC中Connection对象的获取;
    3. MyBATis中sqlsessionfactory创建SqlSession;
    4. SpringIoC容器创建并管理Bean对象;
    5. 反射Class对象的newInstance;
    6. ….

静态工厂模式

静态工厂模式是工厂模式中最简单的一种,他可以用比较简单的方式隐藏创建对象的细节,一般只需要告诉工厂类所需要的类型,工厂类就会返回需要的产品类,而客户端看到的也只是产品的抽象对象(interface),因此无需关心到底是返回了哪个子类

  • 我们以运算符类为例, 解释静态工厂模式.

  • Operator接口

/**
 * 运算符接口
 * Created by jifang on 15/12/7.
 */
public interface Operator<T> {
    T getResult(T... args);
}
  • 实现类
public class AddOperator implements Operator<integer> {

    @Override
    public Integer getResult(Integer... args) {
        int result = 0;
        for (int arg : args) {
            result += arg;
        }
        return result;
    }
}
public class MultiOperator implements Operator<Integer> {

    @Override
    public Integer getResult(Integer... args) {
        int result = 1;
        for (int arg : args) {
            result *= arg;
        }

        return result;
    }
}
  • 工厂
/**
 * 静态工厂(注: 只返回产品的抽象[即接口])
 * 包含两种实现策略
 * 1. 根据传入的operator名进行实例化对象
 * 2. 直接调用相应的构造实例的方法
 * Created by jifang on 15/12/7.
 */
public class OperatorFactory {

    public static Operator<Integer> createOperator(String operName) {
        Operator<Integer> operator;
        switch (operName) {
            case "+":
                operator = new AddOperator();
                break;
            case "*":
                operator = new MultiOperator();
                break;
            default:
                throw new runtimeexception("Wrong Operator Name: " + operName);
        }
        return operator;
    }

    /* ** 第二种实现策略 ** */
    public static Operator<Integer> createAddOper() {
        return new AddOperator();
    }

    public static Operator<Integer> createMultiOper() {
        return new MultiOperator();
    }
}
  • Client
public class Client {

    @Test
    public void testAdd() {
        Operator<Integer> operator = OperatorFactory.createOperator("+");
        System.out.println(operator.getResult(1, 2, 3, 4, 6));
    }

    @Test
    public void testMultiplication() {
        Operator<Integer> operator = OperatorFactory.createOperator("*");
        System.out.println(operator.getResult(1, 2, 3, 4, 6));
    }

    @Test
    public void testAddName(){
        Operator<Integer> operator = OperatorFactory.createAddOper();
        System.out.println(operator.getResult(1, 2, 3, 4, 6));
    }

    @Test
    public void testMultiplicationName() {
        Operator<Integer> operator = OperatorFactory.createMultiOper();
        System.out.println(operator.getResult(1, 2, 3, 4, 6));
    }
}
  • 优点

    1. 隐藏了对象创建的细节,将产品的实例化过程放到了工厂中实现。
    2. 客户端基本不用关心使用的是哪个产品,只需要知道用工厂的那个方法(或传入什么参数)就行了.
    3. 方便添加新的产品子类,每次只需要修改工厂类传递的类型值就行了。
    4. 遵循了依赖倒转原则。
  • 缺点

    1. 适用于产品子类型差不多, 使用的方法名都相同的情况.
    2. 每添加一个产品子类,都必须在工厂类中添加一个判断分支(或一个方法),这违背了OCP(开放-封闭原则)

工厂方法模式

由于静态工厂方法模式不满足OCP, 因此就出现了工厂方法模式; 工厂方法模式和静态工厂模式最大的不同在于: 静态工厂模式只有一个(对于一个项目/独立模块)只有一个工厂类, 而工厂方法模式则有一组实现了相同接口的工厂类.

  • 工厂
/**
 * Created by jifang on 15/12/7.
 */
public interface Factory<T> {
    Operator<T> createOperator();
}
  • 工厂实现
/**
 * 加法运算符工厂
 * Created by jifang on 15/12/7.
 */
public class AddFactory implements Factory<Integer> {

    @Override
    public Operator<Integer> createOperator() {
        return new AddOperator();
    }
}
/**
 * 乘法运算符工厂
 * Created by jifang on 15/12/7.
 */
public class MultiFactory implements Factory<Integer> {

    @Override
    public Operator<Integer> createOperator() {
        return new MultiOperator();
    }
}

Operator, AddOperatorMultiOperator与上例相同.

此时, 如果要在静态工厂中新增加一个开根运算类, 要么需要在createOperator方法中增加一种case, 要么得增加一个createSqrtOper方法, 都是需要修改原来的代码的. 而在工厂方法中只需要再添加一个SqrtFactory即可:

/**
 * 开根运算符
 * Created by jifang on 15/12/7.
 */
public class SqrtOperator implements Operator<Double> {

    @Override
    public Double getResult(Double... args) {
        if (args != null && args.length >= 1) {
            return Math.sqrt(args[0]);
        } else {
            throw new RuntimeException("params Number ERROR " + args.length);
        }
    }
}
/**
 * 开根工厂
 * Created by jifang on 15/12/7.
 */
public class SqrtFactory implements Factory<Double> {

    @Override
    public Operator<Double> createOperator() {
        return new SqrtOperator();
    }
}

优点

基本与静态工厂模式一致,多的一点优点就是遵循了开放-封闭原则,使得模式的灵活性更强。

缺点

与静态工厂模式差不多, 但是增加了类组织的复杂性;

小结

虽然根据理论原则, 需要使用工厂方法模式, 但实际上, 常用的还是静态工厂模式.


抽象工厂模式

抽象工厂模式: 提供一个创建一系列相关或相互依赖对象的接口, 而无需指定他们具体的类.

抽象工厂模式与工厂方法模式的区别:

  • 抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则是针对的多个产品等级结构. 在编程中,通常一个产品结构,表现为一个接口或者抽象类,也就是说,工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类,而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类(如下面的Engine, Tyre, Seat).

在抽象工厂模式中,提出了产品族的概念:所谓的产品族,是指位于不同产品等级结构中功能相关联的产品组成的家族(如Engine, Tyre, Seat)。抽象工厂模式所提供的一系列产品就组成一个产品族;而工厂方法提供的一系列产品称为一个等级结构.

示例:

  • 现在我们要生产两款车: 高档(LuxuryCar)与低档(LowCar), 他们分别配有高端引擎(LuxuryEngine), 高端座椅(LuxurySeat), 高端轮胎(LuxuryTyre)和低端引擎(LowEngine), 低端座椅(LowSeat), 低端轮胎(LowTyre), 下面我们用抽象工厂实现它:

    LuxuryCarFactoryLowCarFactory分别代表一类产品族的两款产品, 类似于数据库产品族中有mysql, oracle, SqlServer

1. 产品

  • Engine
public interface Engine {

    void start();

    void run();
}

class LowEngine implements Engine {

    @Override
    public void start() {
        System.out.println("启动慢 ...");
    }

    @Override
    public void run() {
        System.out.println("转速慢 ...");
    }
}

class LuxuryEngine implements Engine {

    @Override
    public void start() {
        System.out.println("启动快 ...");
    }

    @Override
    public void run() {
        System.out.println("转速快 ...");
    }
}
  • Seat
public interface Seat {
    void massage();
}

class LowSeat implements Seat {

    @Override
    public void massage() {
        System.out.println("不能按摩 ...");
    }
}

class LuxurySeat implements Seat {

    @Override
    public void massage() {
        System.out.println("可提供按摩 ...");
    }
}
  • Tyre
public interface Tyre {
    void revolve();
}

class LowTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("旋转 - 不耐磨 ...");
    }
}

class LuxuryTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("旋转 - 不磨损 ...");
    }
}

注意: 其中并没有车类

2. 产品族Factory

  • Factory
/**
 * Created by jifang on 15/12/7.
 */
public interface CarFactory {

    Engine createEngine();

    Seat createSeat();

    Tyre createTyre();
}
  • 低端车
public class LowCarFactory implements CarFactory {

    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }
}
  • 高端车
public class LuxuryCarFactory implements CarFactory {

    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}

3. Client

/**
 * Created by jifang on 15/12/7.
 */
public class Client {

    @Test
    public void testLow(){
        CarFactory factory = new LowCarFactory();

        Engine engine = factory.createEngine();
        engine.start();
        engine.run();

        Seat seat = factory.createSeat();
        seat.massage();

        Tyre tyre = factory.createTyre();
        tyre.revolve();
    }

    @Test
    public void testLuxury(){
        CarFactory factory = new LuxuryCarFactory();

        Engine engine = factory.createEngine();
        engine.start();
        engine.run();

        Seat seat = factory.createSeat();
        seat.massage();

        Tyre tyre = factory.createTyre();
        tyre.revolve();
    }
}
  • 优点
    1. 封装了产品的创建,使得不需要知道具体是哪种产品,只需要知道是哪个工厂就行了。
    2. 可以支持不同类型的产品,使得模式灵活性更强。
    3. 可以非常方便的使用一族中间的不同类型的产品。
  • 缺点
    1. 结构太过臃肿,如果产品类型比较多,或者产品族类比较多,就会非常难于管理。
    2. 每次如果添加一组产品,那么所有的工厂类都必须添加一个方法,这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。

使用静态工厂优化抽象工厂

由于抽象工厂模式存在结构臃肿以及改动复杂的缺点(比如我们每次需要构造Car, 都需要进行CarFactory factory = new XxxCarFactory();, 而一般一个项目中只会生产一种Car, 如果我们需要更改生产的车的类型, 那么客户端的每一处调用都需要修改), 因此我们可以使用静态工厂对其进行改造, 我们使用CarCreator来统一创建一个产品族不同产品, 这样如果我们的工厂将来更改了产品路线, 改为生产高端车时, 我们仅需改变CAR_TYEP的值就可以了:

/**
 * Created by jifang on 15/12/7.
 */
public class CarCreator {
    private static final String CAR_TYPE = "low";
    private static final String CAR_TYPE_LOW = "low";
    private static final String CAR_TYPE_LUXURY = "luxury";

    public static Engine createEngine() {
        Engine engine = null;
        switch (CAR_TYPE) {
            case CAR_TYPE_LOW:
                engine = new LowEngine();
                break;
            case CAR_TYPE_LUXURY:
                engine = new LuxuryEngine();
                break;
        }
        return engine;
    }

    public static Seat createSeat() {
        Seat seat = null;
        switch (CAR_TYPE) {
            case CAR_TYPE_LOW:
                seat = new LowSeat();
                break;
            case CAR_TYPE_LUXURY:
                seat = new LuxurySeat();
                break;
        }
        return seat;
    }

    public static Tyre createTyre() {
        Tyre tyre = null;
        switch (CAR_TYPE) {
            case CAR_TYPE_LOW:
                tyre = new LowTyre();
                break;
            case CAR_TYPE_LUXURY:
                tyre = new LuxuryTyre();
                break;
        }
        return tyre;
    }
}

其实我们还可以通过反射, 将CarCreator中的switch-case去掉, 而且在实际开发中, 字符串的值我们还可以从配置文件中读取, 这样, 如果需要更改产品路线, 我们连程序代码都懒得改了, 只需要修改配置文件就可以了.

/**
 * Created by jifang on 15/12/7.
 */
public class CarCreatorReflect {

    /**
     * 在实际开发中, 下面这些常量可以从配置文件中读取
     */
    private static final String PACKAGE = "com.feiqing.abstractfactory";
    private static final String ENGINE = "LuxuryEngine";
    private static final String TYRE = "LuxuryTyre";
    private static final String SEAT = "LuxurySeat";

    public static Engine createEngine() {
        String className = PACKAGE + "." + ENGINE;
        try {
            return (Engine) class.forname(className).newInstance();
        } catch (instantiationexception e) {
            e.printstacktrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassnotfoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Seat createSeat() {
        String className = PACKAGE + "." + SEAT;
        try {
            return (Seat) Class.forName(className).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Tyre createTyre() {
        String className = PACKAGE + "." + TYRE;
        try {
            return (Tyre) Class.forName(className).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

这样, 客户端调起来就清爽多了

/**
 * Created by jifang on 15/12/7.
 */
public class StaticClient {

    @Test
    public void testLow() {
        Engine engine = CarCreator.createEngine();
        engine.run();
        engine.start();

        Seat seat = CarCreator.createSeat();
        seat.massage();

        Tyre tyre = CarCreator.createTyre();
        tyre.revolve();
    }

    @Test
    public void testLuxury() {
        Engine engine = CarCreatorReflect.createEngine();
        engine.run();
        engine.start();

        Seat seat = CarCreatorReflect.createSeat();
        seat.massage();

        Tyre tyre = CarCreatorReflect.createTyre();
        tyre.revolve();
    }
}

小结

分类 说明
静态工厂模式 用来生成同一等级结构中的任意产品, 对于增加新的产品, 需要修改已有代码
工厂方法模式 用来生成同一等级结构的固定产品, 支持增加任意产品;
抽象工厂模式 用来生成不同产品族的全部产品, 对于增加新的产品无能为力;

转自:https://blog.csdn.net/hanqing280441589/article/details/50282773

相关阅读

简单工厂模式、工厂模式以及抽象工厂模式(具体)

工厂方法模式:工厂方法模式定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。一、简

工厂模式的作用,为什么要用工厂模式?

工厂模式的实现方式和原理都不难理解和掌握。但是,在学习完之后,发现网上给的例子,根本体现不了工厂模式的作用。先不说存在有的例子

JAVA工厂模式

一、引子话说十年前,有一个爆发户,他家有三辆汽车(Benz(奔驰)、Bmw(宝马)、Audi(奥迪)看来这人比较爱国,没有日本车),还雇了司机为他开车。不

简单工厂模式:真正的“封装隔离”

一、举例 特别喜欢王宝强主演的电视剧“士兵突击”,他那样老实憨厚一根筋,却凭着那份执着,成就了自己的不平凡。 其中有一段,许三多

分享到:

栏目导航

推荐阅读

热门阅读