您的位置：首页 > 编程语言 > Java开发

工厂模式

2015-12-13 14:15 661 查看

工厂模式

标签 : 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. 产品

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

优点

封装了产品的创建，使得不需要知道具体是哪种产品，只需要知道是哪个工厂就行了。

可以支持不同类型的产品，使得模式灵活性更强。

可以非常方便的使用一族中间的不同类型的产品。

缺点

结构太过臃肿，如果产品类型比较多，或者产品族类比较多，就会非常难于管理。

每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。

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

由于抽象工厂模式存在结构臃肿以及改动复杂的缺点(比如我们每次需要构造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) - 抽象工厂模式

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签： 工厂模式 java 设计模式创建模式

相关文章推荐

新的分享

章节导航