java设计模式-1工厂模式

1.什么是工厂模式

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

2.使用场景

  • JDK中Calendar的getInstance方法;
  • JDBC中Connection对象的获取;
  • MyBatis中SqlSessionFactory创建SqlSession;
  • SpringIoC容器创建并管理Bean对象;
  • 反射Class对象的newInstance;
  • 。。。。。。

3.三种方式

  • 静态工厂模式
  • 工厂方法模式
  • 抽象工厂模式

4.具体用法

静态工厂模式

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

例如生产不同产品的例子类图结构如下：


简单工厂模式1.jpg

具体代码如下：
1.定义一个产品接口

interface Product {
    void produce();
}

2.实现类

public class ProductA implements Product{
    @Override
    public void produce() {
        System.out.println("生产出了产品A");
    }
}

public class ProductB implements Product{
    @Override
    public void produce() {
        System.out.println("生产出了产品B");
    }
}
public class ProductC implements Product{
    @Override
    public void produce() {
        System.out.println("生产出了产品C");
    }
}
public class ProductD implements Product{
    @Override
    public void produce() {
        System.out.println("生产出了产品D");
    }
}

public class ProductDefault implements Product{
    @Override
    public void produce() {
        System.out.println("生产出了产品-default");
    }
}

3.工厂类

public class ProductFactory {
    public static Product getProduct(String name){
        switch (name){
            case "A" :
                return new ProductA();
            case "B":
                return new ProductB();
            default:
                return new ProductDefault();

        }
    }
}

4.测试类

public class ProductProduceDemo {
    public static void main(String[] args) {
        //硬编码
        ProductFactory.getProduct("A").produce();
        ProductFactory.getProduct("B").produce();
        ProductFactory.getProduct("ggg").produce();
    }
}

优点

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

缺点

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

工厂方法模式

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

工厂方法模式就是与静态工厂的差异就是把原来偶合的一个工厂根据业务逻辑分成独立的工厂，这样在增加新的业务时就不需要反复修改同一个工厂类，更符合开闭原则。

代码：
1.增加抽象工厂接口

public interface Factory {
    Product getProduct();
}

2.每个产品都实现相应工厂

public class ProductAFactory implements Factory {
    @Override
    public Product getProduct() {
        return new ProductA();
    }
}

public class ProductBFactory implements Factory {
    @Override
    public Product getProduct() {
        return new ProductB();
    }
}

public class ProductCFactory implements Factory {
    @Override
    public Product getProduct() {
        return new ProductC();
    }
}

如果想要增加一个新的产品ProductD

public class ProductD implements Product {
    @Override
    public void produce() {
        System.out.println("生产出了产品D");
    }
}

需增加一个产品D的工厂类。

public class ProductDFactory implements Factory {
    @Override
    public Product getProduct() {
        return new ProductD();
    }
}

与静态工厂相比似乎实现相应的功能，似乎代码量增加了。但是，相比而言耦合度降低了，更利于程序的扩展。

总结
优点

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

缺点

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

虽然根据理论原则, 需要使用工厂方法模式, 但实际上是用静态工厂模式还是工厂方法模式还是更具实际情况考虑。

抽象工厂模式

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

抽象工厂模式与工厂方法模式的区别:
抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构. 在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类(如下面的Engine, Seat).
在抽象工厂模式中，提出了产品族的概念：所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族(如Engine, Seat)。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构.

示例:
现在我们要生产两款车: 高档(LuxuryCar)与低档(LowCar), 他们分别配有高端引擎(LuxuryEngine),低端引擎(LowEngine), 高端座椅(LuxurySeat)和低端座椅(LowSeat), 下面我们用抽象工厂实现它:
LuxuryCarFactory与LowCarFactory分别代表一类产品族的两款产品, 类似于数据库产品族中有MySQL, Oracle, SqlServer

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 message();
}

class LowSeat implements Seat {

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

class LuxurySeat implements Seat {

    @Override
    public void message() {
        System.out.println("可提供按摩 ...");
    }
}

产品族Factory

Factory

public interface CarFactory {

    Engine createEngine();

    Seat createSeat();

}

LuxuryCarFactory

public class LuxuryCarFactory implements CarFactory {

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

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

}

LowCarFactory

public class LowCarFactory implements CarFactory {

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

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

}

Client

public class CarTest {

    public static void main(String[] args) {
        CarFactory factory = new LowCarFactory();
        Engine engine = factory.createEngine();
        engine.start();
        engine.run();
        Seat seat = factory.createSeat();
        seat.message();
        System.out.println("---------------separator--------------");

        CarFactory factory2 = new LuxuryCarFactory();
        Engine engine2 = factory.createEngine();
        engine2.start();
        engine2.run();
        Seat seat2 = factory.createSeat();
        seat2.message();

    }
}

总结

优点

封装了产品的创建，使得不需要知道具体是哪种产品，只需要知道是哪个工厂就行了。
可以支持不同类型的产品，使得模式灵活性更强。
可以非常方便的使用一族中间的不同类型的产品。

缺点
结构太过臃肿，如果产品类型比较多，或者产品族类比较多，就会非常难于管理。
每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。

使用静态工厂优化抽象工厂+反射+配置文件

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

CarCreator

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;
    }

}

CarCreatorReflection

public class CarCreatorReflection {
    private static String packName;
    private static String carType;
    private static String engine;
    private static String seat;

    // 读取配置文件内容并判断赋值，初始化变量值
    static {
        try {
            URL resource = Object.class.getResource("/car.json");
            File file = new File(resource.getFile());
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"));
            StringBuffer config = new StringBuffer();
            String s = null;
            while ((s = bufferedReader.readLine()) != null) {
                config.append(s);
            }
            bufferedReader.close();

            JSONObject jsonObject = JSON.parseObject(config.toString());
            packName = jsonObject.getString("packName");
            carType = jsonObject.getString("carType");
        } catch (Exception e) {
            e.printStackTrace();
        }
        //判断赋值
        switch (carType) {
            case "Low":
                engine = "LowEngine";
                seat = "LowSeat";
                break;
            case "Luxury":
                engine = "LuxuryEngine";
                seat = "LuxurySeat";
                break;
            default:
                engine = "LuxuryEngine";
                seat = "LuxurySeat";
        }
    }

    public static Engine createEngine() throws Exception {
        String className = packName + "." + engine;
        return (Engine) Class.forName(className).newInstance();
    }

    public static Seat createSeat() throws Exception {
        String className = packName + "." + seat;
        return (Seat) Class.forName(className).newInstance();

    }
}

配置文件car.json

{
  "packName": "com.d4c.demo.factory.abstract1",
  "carType": "Luxury"
}

测试

public class CarTest2 {
    public static void main(String[] args) throws Exception{
        Engine engine = CarCreator.createEngine();
        engine.run();
        engine.start();
        Seat seat = CarCreator.createSeat();
        seat.message();

        System.out.println("-----------separator-----------");

        Engine engine2 = CarCreatorReflection.createEngine();
        engine2.run();
        engine2.start();
        Seat seat2 = CarCreatorReflection.createSeat();
        seat2.message();
        
    }
}

result

转速慢 ...
启动慢 ...
不能按摩 ...
-----------separator-----------
转速快 ...
启动快 ...
可提供按摩 ...

总结

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

源码 gitee

文章大部分参考(转载)
工厂模式
简单工厂模式（SimpleFactoryPattern）- 最易懂的设计模式解
设计模式之工厂方法模式
设计模式之抽象工厂模式
三种工厂模式的分析以及C++实现
大话设计模式
高淇讲设计模式
设计模式之六大原则
23种设计模式(3) - 抽象工厂模式

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 213,864评论 6赞 494
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 91,175评论 3赞 387
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 159,401评论 0赞 349
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 57,170评论 1赞 286
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 66,276评论 6赞 385
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,364评论 1赞 292
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,401评论 3赞 412
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,179评论 0赞 269
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,604评论 1赞 306
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,902评论 2赞 328
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,070评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,751评论 4赞 337
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,380评论 3赞 319
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,077评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,312评论 1赞 267
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,924评论 2赞 365
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,957评论 2赞 351

推荐阅读更多精彩内容

  • 工厂模式
    工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。通常我们所说的工厂模式是指工厂方法模...
    zfylin阅读 1,312评论 0赞 7
  • Java中23种设计模式详解
    文章部分内容转载自：http://blog.csdn.net/zhangerqing 一、设计模式的分类 总体来说...
    j_cong阅读 2,060评论 0赞 20
  • 这是积木？还是书？
    今天给大家推荐的是葫芦弟弟的《那么高积木书》，这套书有10个正方体每个正方体有五面，有卡通数字、水果、动物、交通工...
    周公子2018阅读 315评论 0赞 0
  • 甘南游记D7:黄龙
    原创：第141篇 本次旅行快接近尾声时，压轴戏才闪亮登场：黄龙&九寨沟。当看到本次旅行行程计划表时，我是比较犹豫的...
    轻寒翦翦阅读 463评论 1赞 4
  • 与国同庆，畅想十年
    七十年岁月如歌，国富民强歌盛世； 九万里江山似画，山清水秀画风光。 在新中国七十华诞的喜庆日子里，在大街小巷飘满《...
    一缕梅香阅读 443评论 0赞 1