工厂模式可以说是设计模式中曝光度比较高的,想想我们的开发框架中,spring中的BeanFactory,日志框架中的LoggerFactory等;而且在日常面试中对于设计模式这部分问的也是比较多。对于工厂这种设计模式,又分为简单工厂模式、工厂方法模式、抽象工厂模式三种,接下来我们通过示例代码分别讲解三种工厂模式的区别。
一、简单工厂模式
通过名称可以知道这是最简单的工厂模式,简单到令人发指,我将简单工厂模式总结为:需要实例化的类都继承同一个父类,通过给工厂传不同的参数来告诉工厂需要实例化哪个具体类。
比如我们定义了一个家用电器抽象类:
/**
* 电器
* @author xingo
*
*/
public abstract class Electric {
/**
* 打开
*/
public abstract void open();
/**
* 关闭
*/
public abstract void close();
}
现在有三个类继承自家用电器:电灯、电脑、电视。
/**
* 电灯
* @author xingo
*
*/
public class Light extends Electric {
@Override
public void open() {
System.out.println("打开电灯");
}
@Override
public void close() {
System.out.println("关闭电灯");
}
}
/**
* 电脑
* @author xingo
*
*/
public class Computer extends Electric {
@Override
public void open() {
System.out.println("打开电脑");
}
@Override
public void close() {
System.out.println("关闭电脑");
}
}
/**
* 电视
* @author xingo
*
*/
public class TV extends Electric {
@Override
public void open() {
System.out.println("打开电视");
}
@Override
public void close() {
System.out.println("关闭电视");
}
}
然后定义一个简单工厂,它的责任就是负责创建家用电器对象:
public class SimpleFactory {
public static Electric getElectric(String name) {
if(null == name) {
return null;
}
Electric electric = null;
switch(name) {
case "light":
electric = new Light();
break;
case "computer":
electric = new Computer();
break;
case "tv":
electric = new TV();
break;
}
return electric;
}
}
在需要使用对象时,只需要调用工厂的方法获取对象:
public class Test {
public static void main(String[] args) {
Electric electric = SimpleFactory.getElectric("light");
electric.open();
}
}
简单工厂模式在我们平时开发中也是经常用到的,比如我们平时使用的logback日志框架,logback-spring.xml中有这么一个配置:
<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">
<contextName>test</contextName>
<!-- 控制台 -->
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS}|%thread|[%-5level]|%logger{36}.%method|%msg%n</pattern>
<charset>UTF-8</charset>
</encoder>
</appender>
<!--业务日志 文件-->
<appender name="test" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>${user.dir}/logs/test.log</file>
<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS}|%m%n</pattern>
<charset>UTF-8</charset>
</encoder>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<FileNamePattern>${user.dir}/logs/test.log.%d{yyyy-MM-dd}</FileNamePattern>
</rollingPolicy>
</appender>
<logger name="test" level="ERROR" additivity="false">
<appender-ref ref="test"/>
</logger>
<!-- 日志级别 決定整体日志的打印级别-->
<root level="info">
<appender-ref ref="console"/>
</root>
</configuration>
在这段配置中指定了一个日志输出到test.log文件配置,在代码中如果我要把日志输出到这个日志文件中,就需要获取对应的日志输出:
private static final Logger logger = LoggerFactory.getLogger("test");
logger.error("输出日志|{}|{}", "light", new Date());
对于简单工厂,我们更多的时候不是通过case或条件语句判断实例哪个对象,可以通过反射技术进行对象实例化。当添加了一个新的类时,只要这个类是继承同一个父类,那么简单工厂也不用做代码修改
public class SimpleFactory {
public static <T> T getElectric(Class<T> classz) {
try {
return classz.newInstance();
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
}
public class Test {
public static void main(String[] args) {
Electric electric = SimpleFactory.getElectric(Light.class);
electric.open();
}
}
二、工厂方法模式
先说结论:工厂方法与简单工厂模式对比,是将对象的创建从一个类分散到各个实现类中,通过接口定义创建对象方法,各个实现类负责对象创建。例如还是电器类,对于工厂方法模式是这样实现的:
/**
* 工厂方法
* @author xingo
*
*/
public interface FactoryMethod {
/**
* 创建电器对象
* @return
*/
Electric createElectric();
}
public class LightFactory implements FactoryMethod {
@Override
public Electric createElectric() {
return new Light();
}
}
public class ComputerFactory implements FactoryMethod {
@Override
public Electric createElectric() {
return new Computer();
}
}
public class TVFactory implements FactoryMethod {
@Override
public Electric createElectric() {
return new TV();
}
}
public class Test {
public static void main(String[] args) {
FactoryMethod fm = new LightFactory();
Electric electric = fm.createElectric();
electric.close();
}
}
这样看来,工厂方法相对于简单工厂非但没有简单,而且还增加了多个类。为什么还要有这个设计模式呢?我们对比简单工厂,比如现在我要增加一种电气:冰箱(Fridge),对于简单工厂我要实现Electric类,还要在简单工厂类中增加一个case;增加类是没有问题的,但是修改简单工厂类就破坏了 开放-封闭 原则。
工厂方法在进行对象变化时也是比简单工厂方便的,比如现在家庭里面有三个灯分别在客厅、卧室、书房,现在我要打开三个灯,使用简单工厂的化要这样写代码:
Electric light1 = SimpleFactory.getElectric("light");
light1.open();
Electric light2 = SimpleFactory.getElectric("light");
light2.open();
Electric light3 = SimpleFactory.getElectric("light");
light13.open();
代码中一旦出现重复的代码,后期的维护工作就会变得麻烦;如果某一天,我要用其他电器替换电灯,用简单工厂模式我要修改三个获取实例对象的地方。那么换为工厂方法模式呢,以上的代码我改动的可能只是一个地方,就是改变为对应的工厂实现类就可以了,其他地方都不需要进行改动
FactoryMethod fm = new LightFactory();
Electric light1 = fm.createElectric();
light1.open();
Electric light2 = fm.createElectric();
light2.open();
Electric light3 = fm.createElectric();
light13.open();
对比一下两种模式:简单工厂模式将对象的创建逻辑进行了封装,客户端只要告诉工厂需要哪个对象工厂就会创建对应的对象;工厂方法模式将判断逻辑转移到了客户端,需要客户端判断决定实例化哪个工厂。
三、抽象工厂
先说抽象工厂的使用场景:是为了解决创建一系列相关或相互依赖对象的接口;说起来比较难理解,下面用一个实例来解释抽象工厂,这个示例也是 程杰所著的《大话设计模式》 中讲解抽象工厂模式时使用的。
比如现在需要对MySQL数据库中两个对象进行操作,分别是UserDao和DepartmentDao,要实现这两个对象的操作,首先要定义两个操作接口:
/**
* 用户操作
* @author xingo
*
*/
public interface UserDao {
/**
* 新增用户
*/
void insertUser();
/**
* 查找用户
* @param id
*/
void findUserById(int id);
}
/**
* 部门操作
* @author xingo
*
*/
public interface DepartmentDao {
/**
* 新增部门
*/
void insertDepartment();
/**
* 查找部门
* @param id
*/
void findDepartmentById(int id);
}
再定义两个MySQL操作实现类:
public class MySqlUserDao implements UserDao {
@Override
public void insertUser() {
System.out.println("MySQL新增用户");
}
@Override
public void findUserById(int id) {
System.out.println("MySQL查找用户-" + id);
}
}
public class MySqlDepartmentDao implements DepartmentDao {
@Override
public void insertDepartment() {
System.out.println("MySQL新增部门");
}
@Override
public void findDepartmentById(int id) {
System.out.println("MySQL查找部门-" + id);
}
}
还需要定义一个工厂用于操作对象的实例化:
/**
* 数据库创建工厂
* @author xingo
*
*/
public interface DbFactory {
/**
* 创建用户操作对象
* @return
*/
UserDao createUserDao();
/**
* 创建部门操作对象
* @return
*/
DepartmentDao createDepartmentDao();
}
/**
* MySQL对象创建工厂
* @author xingo
*
*/
public class MySqlFactory implements DbFactory {
@Override
public UserDao createUserDao() {
return new MySqlUserDao();
}
@Override
public DepartmentDao createDepartmentDao() {
return new MySqlDepartmentDao();
}
}
现在如果需要操作对象,只需要实例化MySQL工厂创建对象进行操作就可以了
public class Test {
public static void main(String[] args) {
DbFactory db = new MySqlFactory();
//操作用户对象
UserDao userDao = db.createUserDao();
userDao.insertUser();
userDao.findUserById(1);
//操作部门对象
DepartmentDao departmentDao = db.createDepartmentDao();
departmentDao.insertDepartment();
departmentDao.findDepartmentById(1);
}
}
现在如果我的需求发生了变化,不打算使用MySQL数据库,要切换到Oracle数据库,这个时候按照设计模式,共需要创建如下几个类:两个接口UserDao和DepartmentDao的Oracle实现类;工厂接口DbFactory的实现类OracleFactory:
public class OracleUserDao implements UserDao {
@Override
public void insertUser() {
System.out.println("Oracle新增用户");
}
@Override
public void findUserById(int id) {
System.out.println("Oracle查找用户-" + id);
}
}
public class OracleDepartmentDao implements DepartmentDao {
@Override
public void insertDepartment() {
System.out.println("Oracle新增部门");
}
@Override
public void findDepartmentById(int id) {
System.out.println("Oracle查找部门-" + id);
}
}
/**
* Oracle对象创建工厂
* @author xingo
*
*/
public class OracleFactory implements DbFactory {
@Override
public UserDao createUserDao() {
return new OracleUserDao();
}
@Override
public DepartmentDao createDepartmentDao() {
return new OracleDepartmentDao();
}
}
这种设计模式看起来是复杂的,增加一个数据库类型要增加三个类,如果数据库中的对象更多那么需要创建的类也会相应增加;但是这样带来的是客户端的简单替换,客户端要切换数据库,只需要修改一个地方:将原来实例化MySqlFactory的地方修改为OracleFactory即可,其他代码不需要改动:
public class Test {
public static void main(String[] args) {
DbFactory db = new OracleFactory();
//操作用户对象
UserDao userDao = db.createUserDao();
userDao.insertUser();
userDao.findUserById(1);
//操作部门对象
DepartmentDao departmentDao = db.createDepartmentDao();
departmentDao.insertDepartment();
departmentDao.findDepartmentById(1);
}
}
总结一下抽象工厂的优点:(1)当代码中需要切换一系列对象的创建时,由于抽象工厂将相关的实现类进行了很好的封装,这就使得改变一个应用的具体实现变得非常容易;(2)创建实例的过程与客户端分离,客户端是通过他们的抽象接口操纵实例,产品的具体实现类被工厂的实现分离,不会出现在客户代码中。
对比以上三种工厂模式,我们可以总结如下内容:
一、简单工厂模式是根据传递参数的不同进行对应对象的实例化,这种设计模式简单,但是当增加相应的类时需要修改简单工厂的case语句,这样就破坏类的封装性,不过我们可以通过反射技术解决这个问题。
二、工厂方法模式有效解决了简单工厂模式的问题,它是将对象的创建过程交给具体的工厂实现类,这样一来具体实现哪个工厂的决定权由客户端来判断,增加了客户端的判断逻辑。
三、抽象工厂解决的是一系列相关或相互依赖对象接口的创建,它只在初始化的时候出现一次,这样带来的好处就是改变一个应用变得非常简单;而且所有操作都是针对抽象接口进行的,有效隔离了具体实现类。缺点就是当增加一个操作接口时,需要增加多个接口实现类。
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
文章由极客之音整理,本文链接:https://www.bmabk.com/index.php/post/181881.html