java设计模式之工厂模式-个人学习历程
文章目录
- 本文主要是对工厂模式的进行介绍举例,同时根据一些资料进行相关总结,最后简单的探讨spirng ioc 对于工厂模式的应用。本文纯属个人学习记录,如有错误之处希望各位能够帮忙指正。。
1. 工厂模式介绍
- 工厂模式由一个接口类加一个对应的工厂类实现的,接口类提供所有要创建出来的实体所需要的方法,创建对象时,使用该接口指向新创建的对象。工厂类只负责一件事:提供创建实体类的对象的方法。
- 简单来说通过工厂类提供的方法帮助我们创建类实例对象,省去我们平时创建对象new的过程,从而达到减少对象调用方和实现类之间的耦合关系的目的。将创建的这个动作交由工厂,调用方不再和实现类产生关联。
例如业务里:
Student student = new Student();
这个过程,直接与Student实现类产生关联。
现在仅需使用相应的引用接收对象实例即可:
Student student = beanFactory.create(params);
工厂类根据传入参数来判断具体创建哪种实体类
beanFacotry是我们的工厂类,create()方法就是创建对象的方法。
2.工厂模式的分类
- 工厂模式分为三种,简单工厂模式,工厂方法模式以及抽象工厂模式。下面会进行相关的介绍。
3.简单工厂模式
- 当我们要创建的对象种类不多时,仅仅需要一个工厂类便能完成所有的创建工作,这种模式叫做简单工厂模式,在简单工厂模式中创建实例的方法通常为静态方法,因此又叫作静态工厂方法模式。
- 简单工厂模式包含三种角色:工厂角色,抽象产品角色以及具体产品角色,下面是它们的介绍:
工厂(Creator)角色
简单工厂模式的核心,它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用,创建所需的产品对象。
抽象产品(Product)角色
简单工厂模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。
具体产品(Concrete Product)角色
是简单工厂模式的创建目标,所有创建的对象都是充当这个角色的某个具体类的实例。这里贴一张网上常见的结构图:
其中product对应抽象产品角色,ConcreteProduct-X对应具体产品角色,而Factory就是我们的工厂角色。
- 下面通过代码示例来展示着三种角色的实现以及对象的产生过程:
- 抽象产品角色
//抽象产品类( 抽象产品角色 )
interface Student {
void disPlay();
}- 具体产品角色
//班长具体实现类( 具体产品角色1 )
class Monitor implements Student {
@Override
public void disPlay() {
System.out.println("我是班长!");
}
}
//普通学生具体实现类( 具体产品角色2 )
class Ordinary implements Student {
@Override
public void disPlay() {
System.out.println("我是普通学生!");
}
}- 工厂角色
//工厂类( 工厂角色 )
class StudentFactory {
//学生对象创建静态方法
public static Student create(String params) {
//通过接口引用接收实现类的实例对象
Student student = null;
switch (params) {
case "ordinary":
student = new Ordinary();
break;
case "monitor":
student = new Monitor();
break;
}
return student;
}
}- 调用方
public class FactoryTest {
//业务方法
public static void main(String[] args) {
//业务中仅需传入约定好的参数,便可直接获取相对应的对象实例
Student ordinary = StudentFactory.create("ordinary");
ordinary.disPlay();
Student monitor = StudentFactory.create("monitor");
monitor.disPlay();
}
}- 执行结果

- 简单工厂模式的优缺点:
优点:
客户端不与实现类直接关联,仅进行消费产品(调用对象方法),降低调用方与实现类之间的耦合性。
引入配置文件,可以在不修改客户端代码的情况下引入新的产品类,提高系统的灵活性。
(这里我的理解是-->例如:monitor = "com.xxx.xxx.Monitor",获取配置文件的key(monitor),
value(com.xxx.xxx.Monitor),当我们需要获取某一类的对象时,通过传入的params(也就是配置文件的key),
查询到value,通过反射进行对象实例化,获取我们想要的对象)
-----有一点疑问,不修改客户端代码,难道不修改params吗,what? 感觉只是不用修改工厂类。
直接根据对应类相关的参数直接获取对象实例,通过参数替代长类名。缺点:
实例化对象的逻辑封装在一个工厂类中,一旦工厂类出了问题,将导致所有的产品类无法实例化(一个人干多个人的活,这个人请假了多个活没人干了)。
使用简单工厂模式会增加系统中类的个数(引入新的工厂类),增加系统的复杂度和理解难度(工厂类太多,调过去调过来整昏了。。)。
系统扩展麻烦,增加新产品时需修改工厂逻辑,违背了开闭原则(每次添加新产品都需要去增加传参params的判断逻辑)。
简单工厂模式使用了 static 工厂方法,造成工厂角色无法形成基于继承的等级结构。
适用场景:
业务产品类相对较少的情况。4.工厂方法模式
- 工厂方法模式是对简单工厂模式的进一步抽象化,其好处是可以使系统在不修改原来代码的情况下引进新的产品,即满足开闭原则。
- 简单的说就是为每个实现类都创建了一个具体工厂,由具体工厂来进行对象实例的创建(从多个对象由一个工厂创建变为了多个对象由各自对应的具体工厂创建,这样我们需要添加新产品时,只需添加新的具体工厂,而不用修改原来的工厂类,符合只扩展不修改的开闭原则)
工厂方法模式和简单工厂模式角色略有不同,简单工厂的工厂角色分化为抽象工厂和具体工厂两个角色:
抽象工厂(Abstract Factory):提供了创建产品的接口,调用者通过它访问具体工厂的工厂方法 newStudent() 来创建产品。
具体工厂(ConcreteFactory):主要是实现抽象工厂中的抽象方法,完成具体产品的创建。这里贴一张别处复制的结构图
其中concreteFacotry对应具体工厂角色,提供具体的对象创建方法。AbstactFactory接口对应抽象工厂角色,提供客户端调用的方法。其他角色和简单工厂模式角色一致。
- 下面通过示例展示四种角色的实现以及对象的产生过程:
- 抽象产品角色
//抽象产品类( 抽象产品角色 )
interface Student {
void disPlay();
}- 具体产品角色
//班长具体实现类( 具体产品角色1 )
class Monitor implements Student {
@Override
public void disPlay() {
System.out.println("我是班长!");
}
}
//普通学生具体实现类( 具体产品角色2 )
class Ordinary implements Student {
@Override
public void disPlay() {
System.out.println("我是普通学生!");
}
}- 抽象工厂角色
//抽象工厂接口( 抽象工厂角色 )
interface AbstractFactory {
Student newStudent();
}- 具体工厂角色
//普通学生工厂类( 具体工厂角色 )
class OrdinaryFactory implements AbstractFactory{
//生成普通学生实例对象
@Override
public Student newStudent() {
return new Ordinary();
}
}
//班长工厂类( 具体工厂角色 )
class MonitorFactory implements AbstractFactory{
//生成班长实例对象
@Override
public Student newStudent() {
return new Monitor();
}
}- 调用方
//业务方法
public static void main(String[] args) {
//通过抽象工厂指向具体工厂
AbstractFactory factory1 = new OrdinaryFactory();
AbstractFactory factory2 = new MonitorFactory();
//调用接口方法,根据工厂具体类型创建具体的实例对象
Student student1 = factory1.newStudent();
Student student2 = factory2.newStudent();
//调用对象方法
student1.disPlay();
student2.disPlay();
/*在此基础上,当我们引入新的学生类型时,仅需添加新的具体工厂类以及对应的学生实现类
不需要单独对抽象工厂类进行修改,符合仅拓展,不修改的开闭原则*/
}- 执行结果

- 工厂方法模式的优缺点:
优点:
典型的解耦框架。高层模块只需要知道产品的抽象类,无须关心其他实现类,满足迪米特法则、依赖倒置原则和里氏替换原则。
(我的理解-->
调用方无需和实现类直接通讯,中间存在具体工厂这一第三方转发调用,符合迪米特法则;
无论是调用者还是具体实现类,中间都有着抽象这一层次,符合依赖倒置原则。调用方依赖于抽象工厂,实现类依赖于抽象产品;
每一个具体工厂类都有对应的抽象工厂类,而非多个具体工厂类对应一个抽象工厂类,这个所有具体工厂类内部的重写方法时不会对彼此产生影响,符合里氏替换原则。
)这里不了解这几种原则的可以先百度一下。
灵活性强,创建新的实现类仅需多写一个对应的具体工厂类。(用来创建实现类对象 xxxFactory.newStudent();)
调用方根据工厂名称创建相应的实例对象。(Factory factory = new xxxFactory(); 中的这个xxxFactory)
缺点:
随着具体产品类的增多,类的个数越来越多,系统会变得复杂。
抽象产品只能生产一种产品。(Student student = factory.newStudent();这里的student只能创建出一种学生。
)
增加了系统的抽象性和理解难度。(这个就是抽象类,具体类整多了搞复杂了嘛。)适用场景:
调用方只知道具体工厂名,不知道产品名的时候。(比如你知道某个公司的名称,不知道它的产品名,也不关心产品名的时候。)
5.抽象工厂模式
- 是一种为访问类提供一个创建一组相关或相互依赖对象的接口,且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
- 由于工厂方法模式扩展时会新增很多工厂类,为了在扩展实现类时减少工厂类的产生,使用抽象工厂模式,使用一个工厂类生成多种实现类对象(但这儿的实现类是有等级划分的,下面进行介绍)。
- 产品等级划分图:

- 这里的同一品牌下的产品为一产品族,可以定义为一个haiErFactory工厂类,负责创建海尔电视机和海尔空调对象(具体工厂类可以创建属于同一族非同一等级的对象)。以产品类型来区分等级,同种类型为同一等级。
(比如xx学校有学生和老师,属于同一个产品族,cc学校有学生和老师,属于同一个产品族,由同一具体工厂类创建。xx学校的学生和cc学校的学生就属于同一个产品等级,实现同一抽象产品类)。
- 抽象工厂模式角色与工厂方法模式角色一样,不过具体的角色任务略有不同。
抽象工厂(Abstract Factory):
提供了创建产品的接口,它包含多个创建产品的方法,可以创建多个(工厂方法模式只能创建一个)不同等级的产品(同族产品)。
具体工厂(Concrete Factory):
主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建(负责实现抽象工厂创建同族各产品的方法,返回实例对象)。
抽象产品(Product):
定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品(同一等级具体产品实现同一抽象产品接口)。
具体产品(ConcreteProduct):
实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间是多对一的关系(同一工厂可以创建多种同族产品)。这里贴一张复制的结构图:
其中ConcreteProduct11,ConcreteProduct21属于同族不同等级产品,由同一具体工厂类创建。ConcreteProduct11,ConcreteProduct12属于同等级不同族产品,实现同一Product1接口。
- 下面进行代码示例:
- 抽象产品角色(对标结构图Product1,Product2接口)
//抽象产品类:学生( 抽象产品角色 )
interface Student {
void learn();
}
//抽象产品类:老师( 抽象产品角色 )
interface Teacher {
void teach();
}- 具体产品角色
//xx学校学生具体实现类( 具体产品角色1 )
class XxStudent implements Student {
@Override
public void learn() {
System.out.println("xx学校学生学习!");
}
}
//cc学校学生具体实现类( 具体产品角色2 )
class CcStudent implements Student {
@Override
public void learn() {
System.out.println("cc学校学生学习!");
}
}
//上面属于同一等级
--------------------------------------------
//下面属于同一等级
//xx学校老师具体实现类( 具体产品角色1 )
class XxTeacher implements Teacher {
@Override
public void teach() {
System.out.println("xx学校老师教学!");
}
}
//cc学校老师具体实现类( 具体产品角色2 )
class CcTeacher implements Teacher {
@Override
public void teach() {
System.out.println("cc学校老师教学!");
}
}- 抽象工厂角色
//抽象工厂接口( 抽象工厂角色 )
interface AbstractFactory {
//包含同一产品族对象创建方法
Student newStudent();
Teacher newTeacher();
}- 具体工厂角色(同一产品族的创建对象的实现)
//xx学校工厂类( 具体工厂角色 )
class XxSchoolFactory implements AbstractFactory{
//生成xx学校学生实例对象
@Override
public Student newStudent() {
return new XxStudent();
}
//生成xx学校老师实例对象
@Override
public Teacher newTeacher() {
return new XxTeacher();
}
}
//cc学校工厂类( 具体工厂角色 )
class CcSchoolFactory implements AbstractFactory{
//生成cc学校学生实例对象
@Override
public Student newStudent() {
return new CcStudent();
}
//生成cc学校老师实例对象
@Override
public Teacher newTeacher() {
return new CcTeacher();
}
}- 调用方
//业务方法
public static void main(String[] args) {
//获取指定族具体工厂对象
AbstractFactory factory1 = new XxSchoolFactory();
//同一工厂类获取多个具体产品
Student student1 = factory1.newStudent();
Teacher teacher1 = factory1.newTeacher();
//调用产品相关方法
student1.learn();
teacher1.teach();
AbstractFactory factory2 = new CcSchoolFactory();
Student student2 = factory2.newStudent();
Teacher teacher2 = factory2.newTeacher();
student2.learn();
teacher2.teach();
}- 运行结果:

- 抽象工厂模式的优缺点:
优点:
当一个族中的多个对象被设计成一起工作时, 它能够保证客户端始终只使用同一个族中的对象(通过同一个具体工厂类就可以获取多个公共工作的同族对象,不需要多余的工厂类,有一定的分隔作用)。
添加一个新的族(一系列产品)很方便,仅需添加具体工厂类即可,无需修改其他类,符合开闭原则。
缺点:
若想在各工厂类中添加新的等级会非常麻烦,不仅仅只是新增具体的实现类,还需要去修改所有的抽象,具体工厂类。
(比如学校工厂中添加一个助教等级,是不是对应的所有抽象工厂需要添加创建接口,所有具体工厂需要添加实现方法)适用场景:
需要强调一系列相关的产品对象的设计以便进行联合使用时(也就是xx学校老师和学生对象需要配合适用的时候)。
提供一个产品类库,而只想显示它们的接口而不是实现时。(我的理解是调用方仅通过接口获取对象,不暴露对象创建的实现)6.总结
- 总的来说,我觉得工厂方法模式就是当简单工厂模式的产品类增多后来方便扩展的一种实现,也是开闭原则的一种体现。而抽象工厂模式就是对工厂方法模式中工厂角色职责单一的一种补充。所以,使用哪种模式还是要根据实际的产品种类等实际情况来考虑,胡乱使用反倒会使系统变得复杂难懂。
7.spring ioc对工厂模式的应用
- 这里简单探讨一下spring ioc是怎么应用工厂模式的。
- spring ioc 基于工厂模式,但并不是像普通工厂模式内部通过new来创建对象的,而是基于反射来动态创建对象。也就是类似于前面介绍简单工厂模式时,通过配置文件创建对象一样,通过xml等配置文件获取相关bean的定义,然后通过反射获取相关的类,再实例化对象(当然,其中还有很多复杂的过程)。
ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml","spring-xxxxx.xml"});
BeanFactory factory = (BeanFactory)context;
StudentServer ss = (StudentServer) factory.getBean("studentServer");- 相信这样的代码大家都看过,我认为上面的BeanFactory也就是我们的抽象工厂类,StudentServer也就是和我们的具体产品类咯,也就是目标对象。
- 不过这个过程内部其实是很复杂的,比如获取应用上下文context,其中就包括了解析、定位、加载xml文件,获取配置文件bean的定义,创建bean工厂等。而getBean的过程也涉及到各种缓存,有兴趣的可以自己查阅资料去了解一下。
- 这里贴一张BeanFactory相关的结构图,以前根据spring源码深度解析画的:

- 参考文献
https://zhuanlan.zhihu.com/p/...
https://www.jianshu.com/p/5cb...
http://c.biancheng.net/view/8...
https://blog.csdn.net/zyhlwzy...
https://www.haoid.cn/m/?post=...
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论