工厂模式
2015-12-13 14:15
260 查看
工厂模式
标签 : Java与设计模式工厂模式
用工厂方法代替了new操作, 将
选择实现类,
创建对象统一管理和控制.从而将调用者(Client)与实现类进行解耦.实现了
创建者与调用者分离;
使用场景
JDK中Calendar的getInstance方法;
JDBC中Connection对象的获取;
MyBatis中SqlSessionFactory创建SqlSession;
SpringIoC容器创建并管理Bean对象;
反射Class对象的newInstance;
….
静态工厂模式
静态工厂模式是工厂模式中最简单的一种,他可以用比较简单的方式隐藏创建对象的细节,一般只需要告诉工厂类所需要的类型,工厂类就会返回需要的产品类,而客户端看到的也只是产品的抽象对象(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)); } }
优点
隐藏了对象创建的细节,将产品的实例化过程放到了工厂中实现。
客户端基本不用关心使用的是哪个产品,只需要知道用工厂的那个方法(或传入什么参数)就行了.
方便添加新的产品子类,每次只需要修改工厂类传递的类型值就行了。
遵循了
依赖倒转原则。
缺点
适用于产品子类型差不多, 使用的方法名都相同的情况.
每添加一个产品子类,都必须在工厂类中添加一个判断分支(或一个方法),这违背了
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,
AddOperator与
MultiOperator与上例相同.
此时, 如果要在静态工厂中新增加一个
开根运算类, 要么需要在
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), 下面我们用抽象工厂实现它:
LuxuryCarFactory与
LowCarFactory分别代表一类产品族的两款产品, 类似于数据库产品族中有MySQL, Oracle, SqlServer
1. 产品
Enginepublic 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(); } }
优点
封装了产品的创建,使得不需要知道具体是哪种产品,只需要知道是哪个工厂就行了。
可以支持不同类型的产品,使得模式灵活性更强。
可以非常方便的使用一族中间的不同类型的产品。
缺点
结构太过臃肿,如果产品类型比较多,或者产品族类比较多,就会非常难于管理。
每次如果添加一组产品,那么所有的工厂类都必须添加一个方法,这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。
使用静态工厂优化抽象工厂
由于抽象工厂模式存在结构臃肿以及改动复杂的缺点(比如我们每次需要构造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(); } }
小结
分类 | 说明 |
---|---|
静态工厂模式 | 用来生成同一等级结构中的任意产品, 对于增加新的产品, 需要修改已有代码 |
工厂方法模式 | 用来生成同一等级结构的固定产品, 支持增加任意产品; |
抽象工厂模式 | 用来生成不同产品族的全部产品, 对于增加新的产品无能为力; |
1. 三种工厂模式的分析以及C++实现
2. 大话设计模式
3. 高淇讲设计模式
4. 设计模式之六大原则
5. 23种设计模式(3) - 抽象工厂模式
相关文章推荐
- 工厂模式
- 输入一串数字输出最大的数字
- 使用Fluent API进行属性映射【Code-First系列】
- poj1852 Ants (模拟)
- PAT程序设计练习——甲级1001(标准格式化数字)
- 白盒测试技术含量不一定比黑盒测试高
- JSP验证码动态生成方法
- start booting from usb device,U盘安装ubuntu无法引导系统
- Android中Animation动画的介绍及用法详解
- linux(fedora) 下dvwa 建筑环境
- eclipse机器硬重启后package和project视图中看不见工作区间中的工程
- 大话设计模式之策略模式(结合简单工厂),程序完善过程蕴含智慧
- leetcode -- Permutation Sequence -- 重点
- 下列代码可以将十进制转换为二进制、八进制和十六进制
- 程序员必须了解的内存知识
- Android UncaughtExceptionHandler捕获Crash
- 微信中 - 发现 - 界面的实现
- c++ 初始化 http://www.nowcoder.com/test/question/done?tid=2198842&qid=25454#summary
- Android ListView网络加载图片之内存缓存
- C/C++ 之 restrict关键字