Java设计模式之简单工厂 工厂方法 抽象工厂深度总结

Java设计模式之简单工厂 工厂方法 抽象工厂深度总结

目录工厂模式介绍好处常见的应用简单工厂（Simple Factory）适用场景角色分配：应用案例：优缺点：简单工厂实现：工厂方法（Factory Method）适用场景角色分配：应用案例：优缺点：工厂方法实现：抽象工厂（Abstract Factory）适用场景角色分配应用案例：优缺点：抽象工厂实现抽象工厂终极改进（反射+配置文件+简单工厂）

工厂模式介绍

工厂模式也是非常常见的设计模式之一，其属于创建型模式。工厂模式分类：简单工厂（Simple Factory）、工厂方法（Factory Method）、抽象工厂（Abstract Factory），严格来讲，简单工厂不属于工厂设计模式。

好处

解耦：工厂模式主要是为了对象的创建和使用的分离

降低代码重复：如果对象创建很复杂，则每次创建都需要重复很多代码，通过工厂包装起来可以减少重复代码

方便维护：如果创建对象的逻辑有修改，则只需要修改工厂内代码，而不用修改每个创建对象的代码。

常见的应用

Spring中的BeanFactory.getBean(beanName)

日志当中的LoggerFactory.getLogger(name)

java加密时 KeyGenerator keygen=KeyGenerator.getInstance("AES");

RabbitMQ的Java客户端创建连接 ：

//创建连接工厂

ConnectionFactory factory = new ConnectionFactory("192.168.74.4");

// 通过连接工厂获取连接

Connection connection = factory.newConnection();

简单工厂（Simple Factory）

简单工厂并不在23种设计模式之中，属于特殊的工厂模式，应用的相对来说少一点。客户端实例化对象的时候不用通过new Audi()的方式，而是可以通过往统一工厂传入相应的条件返回对应的实例对象（主要通过if-else或者switch-case进行判断，违背了开闭原则），屏蔽了实例化对象的具体逻辑细节。

适用场景

需要创建的对象较少。

客户端不关心对象的创建过程。

角色分配：

工厂(Factory)角色：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

抽象产品(Product)角色 :简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

具体产品(Concrete Product)角色:简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

其UML类图如下所示：

应用案例：

Java加密时 KeyGenerator keygen=KeyGenerator.getInstance("AES");

DateFormat类中的public final static DateFormat getDateInstance(int style)

优缺点：

优点：实现简单，隐藏了创建对象的细节，创建对象的逻辑修改时，客户端不用进行修改。

缺点：违背了开闭原则，每次新增删除子类的时候都要修改工厂的逻辑，而且创建对象的逻辑都包含在工厂内，后面子类太多的话这块代码会非常多，难以维护。

简单工厂实现：

我们创建一个Car接口，里面包含一个getName方法用以返回具体的品牌名称，接口有两个实现类Audi和Bmw，分别返回了品牌名称 "Audi" 和 "Bmw"。

package com.wkp.designpattern.factory;

//汽车接口

public interface Car {

//返回汽车的品牌

public String getName();

}

package com.wkp.designpattern.factory;

public class Audi implements Car {

public String getName() {

return "Audi";

}

}

package com.wkp.designpattern.factory;

public class Bmw implements Car {

public String getName() {

return "Bmw";

}

}

下面是简单工厂的核心，用于创建对象

package com.wkp.designpattern.simple.factory;

import com.wkp.designpattern.factory.Audi;

import com.wkp.designpattern.factory.Bmw;

import com.wkp.designpattern.factory.Car;

public class SimpleFactory {

public Car getCar(String name){

if("Audi".equals(name)){

return new Audi();

}else if("Bmw".equals(name)){

return new Bmw();

}else{

System.out.println("没法生产这个车");

return null;

}

}

}

测试代码如下：

package com.wkp.designpattern.simple.factory;

import com.wkp.designpattern.factory.Car;

public class SimpleFactoryTest {

public static void main(String[] args) {

SimpleFactory factory = new SimpleFactory();

Car car1 = factory.getCar("Audi");

System.out.println(car1.getName());

Car car2 = factory.getCar("Bmw");

System.out.println(car2.getName());

}

}

输出结果如下：

Audi

Bmw

这里每增加一个新的子类，getCar方法就要添加if判断，删除了子类这里也要修改，显然违反了开闭原则，而且创建对象的逻辑全部都在这个方法中，随着创建对象的增加，这里的逻辑会非常多。当然我们可以通过反射的方式对上面的工厂进行改进如下：

//利用反射改进的简单工厂，添加的时候不用修改getCar方法

public class ReflectSimpleFactory {

//参数className为完整类名

public Car getCar(String className){

Car obj=null;

try {

obj=(Car) Class.forName(className).newInstance();

} catch (InstantiationException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

return obj;

}

}

public class ReflectSimpleFactoryTest {

public static void main(String[] args) {

ReflectSimpleFactory factory = new ReflectSimpleFactory();

Car car1 = factory.getCar("com.wkp.designpattern.factory.Audi");

System.out.println(car1.getName());

Car car2 = factory.getCar("com.wkp.designpattern.factory.Bmw");

System.out.println(car2.getName());

}

}

输出结果不变，也符合了开闭原则，但是要传入完整类名也不方便，可以通过xml或者配置文件的方式进行改进。

工厂方法（Factory Method）

工厂方法的应用是最多的，工厂方法中不再提供统一的工厂创建对象，而是针对不同的对象提供不同的工厂。定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，创建过程延迟到子类进行。

适用场景

当一个类不知道它所必须创建的对象的类的时候：工厂方法模式中客户端不需要知道对象的名称，只需要知道要创建的对象对应的工厂即可。

当一个类希望由它的子类来指定它所创建的对象的时候：工厂方法模式中定义了一个Factory接口，该接口包含一个创建对象的抽象方法，具体的创建对象的逻辑由其实现类完成。

当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

角色分配：

抽象工厂(Abstract Factory)角色：是工厂方法模式的核心，提供了创建对象的接口，任何在模式中创建的对象的工厂类必须实现这个接口。

具体工厂(Concrete Factory)角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建某一种产品对象。

抽象产品(AbstractProduct)角色 ：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。

具体产品(Concrete Product)角色 ：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应

其UML类图如下所示：

应用案例：

spring-data-redis中创建redis连接的地方，RedisConnectionFactory接口提供了创建连接的方法RedisConnection getConnection()，该工厂的两个实现类JedisConnectionFactory ，LettuceConnectionFactory分别用于创建jedis和lettuce连接

优缺点：

优点：符合开闭原则，添加子类时只需要添加对应的工厂类即可，而不用修改原有的工厂类，每个对象的创建逻辑都在对应的工厂类中，代码逻辑清晰，易于维护。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

工厂方法实现：

定义一个Factory接口，里面提供了一个getCar（）方法，具体的创建逻辑由其实现类去完成。

public interface Factory {

public Car getCar();

}

下面是Factory接口的具体实现类，用于创建对应的对象

public class AudiFactory implements Factory {

public Car getCar() {

return new Audi();

}

}

public class BmwFactory implements Factory {

public Car getCar() {

return new Bmw();

}

}

测试类如下：

public class FuncFactoryTest {

public static void main(String[] args) {

Car car1 = new AudiFactory().getCar();

System.out.println(car1.getName());

Car car2 = new BmwFactory().getCar();

System.out.println(car2.getName());

}

}

抽象工厂（Abstract Factory）

上面的工厂模式生产的都是一类产品，而抽象工厂模式可以生产产品族。什么是产品族呢？其实就是一组具有关联关系的产品集合，举几个例子：

比如生产电脑，用Intel系列、AMD系列的零件（CPU、主板。。。。。），每个系列的零件就是一个产品族。

比如我们开发过程中会用到mysql、Oracle数据库，而不同的数据库的操作会有不同，比如有User，Order两个类，两个类都有添加、修改操作，那User、Order的操作就要随着数据库的切换而切换，MySQL和Oracle下不同的类就组成了两个产品族。

我们用QQ空间的时候会有换皮肤的功能，而每套皮肤下的背景、按钮、导航、菜单。。。。。。这些也构成了产品族

我们上面用的生产汽车的例子，比如奥迪，宝马不同品牌车的零部件（轮胎、发动机、轴承。。。。。。）

适用场景

和工厂方法一样客户端不需要知道它所创建的对象的类。

需要一组对象共同完成某种功能时，并且可能存在多组对象完成不同功能的情况。（同属于同一个产品族的产品）

系统结构稳定，不会频繁的增加对象。（因为一旦增加就需要修改原有代码，不符合开闭原则）

角色分配

抽象工厂（AbstractFactory）角色 ：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

具体工厂类（ConcreteFactory）角色 ：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建某一种产品对象。

抽象产品（Abstract Product）角色 ：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。

具体产品（Concrete Product）角色 ：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。在抽象工厂中创建的产品属于同一产品族，这不同于工厂模式中的工厂只创建单一产品。

其UML类图如下所示：

应用案例：

QQ空间换肤、更换数据库等

优缺点：

优点：可以创建系列产品，方便切换使用的产品系列。

缺点：扩展产品族较为麻烦，不光要添加所有的抽象产品实现，还要添加产品族对应的工厂；另外添加产品也不简单，要添加抽象产品，所有的产品族实现，还要对原先的工厂实现添加工厂方法以生产新产品。

抽象工厂实现

这个案例我们就以生产电脑为例，众所周知目前电脑的CPU有两大品牌：Intel和AMD。我们就以此为例，如果电脑选用Intel系列，就要用Intel的CPU和主板等，如果用AMD系列，就用AMD系列的零部件。

下面的两个接口就是我们上面提到的抽象产品角色。

//CPU

public interface CPU {

public String getName();

}

//主板

public interface MainBoard {

public String getName();

}

下面的四个类就是我们上面提到的具体产品角色。首先是Intel系列产品

public class IntelCPU implements CPU {

public String getName() {

return "IntelCPU";

}

}

public class IntelMainBoard implements MainBoard{

public String getName() {

return "IntelMainBoard";

}

}

然后是AMD系列产品：

public class AMDCPU implements CPU {

public String getName() {

return "AMDCPU";

}

}

public class AMDMainBoard implements MainBoard{

public String getName() {

return "AMDMainBoard";

}

}

下面的Factory就是抽象工厂角色，提供了生产CPU和主板的抽象方法。

public interface Factory {

//生产CPU

public CPU createCPU();

//生产主板

public MainBoard createMainBoard();

}

然后是具体的工厂类角色，分别生产不同系列的产品。

//Intel系列产品工厂

public class IntelFactory implements Factory {

public CPU createCPU() {

return new IntelCPU();

}

public MainBoard createMainBoard() {

return new IntelMainBoard();

}

}

//AMD系列产品工厂

public class AMDFactory implements FactoasjhQTry {

public CPU createCPU() {

return new AMDCPU();

}

public MainBoard createMainBoard() {

return new AMDMainBoard();

}

}

测试类如下：

public class FactoryTest {

public static void main(String[] args) {

Factory intel = new IntelFactory();

System.out.println(intel.createCPU().getName());

System.out.println(intel.createMainBoard().getName());

Factory amd = new AMDFactory();

System.out.println(amd.createCPU().getName());

System.out.println(amd.createMainBoard().getName());

}

}

运行结果为：

IntelCPU

IntelMainBoard

AMDCPU

AMDMainBoard

抽象工厂终极改进（反射+配置文件+简单工厂）

上面也说过抽象工厂的缺点是扩展产品族比较麻烦，我们对上面的抽象工厂做个改进，使其在添加产品族的时候更简单一些。我们引入简单工厂，但是简单工厂扩展的时候要添加判断条件，所以我们可以通过反射+配置文件去解决这个问题。改动后的UML图如下所示：

改进后的代码如下所示：Configuration类用于读取配置文件(没有具体去实现)

type=Intel

packageName=com.wkp.design.pattern.factory.abst

public class SimpleFactory {

static class Configuration{

public static String get(String key){

String value="";//TODO 读取配置文件得到value

retuasjhQTrn value;

}

}

//通过配置文件读取产品族类型及包名

private static final String type=Configuration.get("type");

private static final String packageName=Configuration.get("packageName");

//生产CPU

public CPU createCPU() throws Exception{

return (CPU)Class.forName(packageName+"."+type+"CPU").newInstance();

}

//生产主板

public MainBoard createMainBoard() throws Exception{

return (MainBoard)Class.forName(packageName+"."+type+"MainBoard").newInstance();

}

}

测试代码如下

public class SimpleFactoryTest {

public static void main(String[] args) throws Exception {

SimpleFactory factory = new SimpleFactory();

System.out.println(factory.createCPU().getName());

System.out.println(factory.createMainBoard().getName());

}

}

我们看到，在调用的时候客户端完全不用管用的是Intel还是AMD，这样如果想切换产品族的话，只需要修改配置文件即可，非常的方便。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。