Spring常用到的几种设计模式--工厂模式

最新推荐文章于 2025-06-16 10:18:23 发布
最新推荐文章于 2025-06-16 10:18:23 发布
阅读量1.2k 收藏 4
点赞数
CC 4.0 BY-SA版权
分类专栏： 设计模式 文章标签： 工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_39827145/article/details/98873747
本文详细解析了工厂模式在软件设计中的应用，包括简单工厂、方法工厂和抽象工厂的概念、实现及优缺点，通过汽车制造场景生动阐述了不同模式的分工与协作。

一、工厂模式

工厂模式核心思想：只关心结果，隐藏复杂的过程

二、简单的工厂模式

在这里插入图片描述

BaoMa

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory;

/**
 * @author yangjikang
 * @date 2019/8/8 11:49
 * @modified By yangjikang
 * @since
 */
public class BaoMa implements Car {

    private String name = "宝马";

    @Override
    public String getName() {
        return this.name;
    }
}

BenChi

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory;

/**
 * @author yangjikang
 * @date 2019/8/8 11:49
 * @modified By yangjikang
 * @since
 */
public class BenChi implements Car {

    private String name = "奔驰";

    @Override
    public String getName() {
        return this.name;
    }
}

Car

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory;

/**
 * @author yangjikang
 * @date 2019/8/8 11:40
 * @modified By yangjikang
 * @since
 */
public interface Car {

    public String getName();
}

QiRui

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory;

/**
 * @author yangjikang
 * @date 2019/8/8 11:49
 * @modified By yangjikang
 * @since
 */
public class QiRui implements Car {

    private String name = "奇瑞";

    @Override
    public String getName() {
        return this.name;
    }
}

SimpleFactory

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory;

/**
 * @author yangjikang
 * @date 2019/8/8 11:55
 * @modified By yangjikang
 * @since
 */
public class SimpleFactory {
    public Car getCar(String name){
        if ("奔驰".equals(name)){
            return new BenChi();
        }else if ("奇瑞".equals(name)){
            return new QiRui();
        }else if ("宝马".equals(name)){
            return new BaoMa();
        }else{
             return new Car() {
                @Override
                public String getName() {
                    return "不能生产该产品....";
                }
            };
        }
    }
}

TestEnter

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory;

/**
 * @author yangjikang
 * @date 2019/8/8 11:59
 * @modified By yangjikang
 * @since
 */
public class TestEnter {

    public static void main(String[] args) {
        Car baoma = new SimpleFactory().getCar("宝马");
        System.out.println(baoma.getName());

    }
}

在这里插入图片描述
在这里插入图片描述

简单工厂可以造很多种汽车品牌的车子。奔驰、宝马、奇瑞、、、、、

这样不符合实际生活，你见过哪个工厂能造这么多汽车品牌 的车子的？

下面就引伸出了 方法工厂

三、方法工厂

上面我们说了，一个汽车制造厂不可能造出很多汽车品牌的车子。所以现实生活中每个汽车品牌都有自己的工厂。
宝马有宝马汽车工厂、奥迪有奥迪汽车工厂、、、、、、

但是这些汽车工厂需要一个标准吧？不可能奥迪汽车生产的汽车有三个轮子，宝马生产的有五个轮子？

所以我们要有一个约束规则。就好比你们平时手机数据线一样，安卓的、苹果的、现在好像还有Type-c的。你见过第四种？

这就是一种约束。

在这里插入图片描述

BaoMaFactory

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory.func;

import com.jikang.factory.BaoMa;
import com.jikang.factory.Car;

/**
 * @author yangjikang
 * @date 2019/8/8 14:06
 * @modified By yangjikang
 * @since
 */
public class BaoMaFactory implements CarFactory{

    @Override
    public Car getCar() {
        return new BaoMa();
    }
}

BenChiFactory

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory.func;

import com.jikang.factory.BenChi;
import com.jikang.factory.Car;
import com.jikang.factory.QiRui;

/**
 * @author yangjikang
 * @date 2019/8/8 14:06
 * @modified By yangjikang
 * @since
 */
public class BenChiFactory implements CarFactory{

    @Override
    public Car getCar() {
        return new BenChi();
    }
}

CarFactory

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory.func;

import com.jikang.factory.Car;

/**
 * 汽车工厂约束规则
 *
 * @author yangjikang
 * @date 2019/8/8 14:07
 * @modified By yangjikang
 * @since
 */
public interface CarFactory {
    Car getCar();
}

QiRuiFactory

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory.func;

import com.jikang.factory.BaoMa;
import com.jikang.factory.Car;
import com.jikang.factory.QiRui;

/**
 * @author yangjikang
 * @date 2019/8/8 14:06
 * @modified By yangjikang
 * @since
 */
public class QiRuiFactory implements CarFactory{

    @Override
    public Car getCar() {
        return new QiRui();
    }
}

TestFuncFactory

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory.func;

import com.jikang.factory.Car;

/**
 * 方法工厂测试类
 *
 * @author yangjikang
 * @date 2019/8/8 14:09
 * @modified By yangjikang
 * @since
 */
public class TestFuncFactory {

    public static void main(String[] args) {
        Car car = new BenChiFactory().getCar();
        System.out.println(car.getName());
    }
}

需要什么车子就去找哪个工厂造。

那么显示生活中，你想买个奔驰车，不可能还要跑到奔驰生产厂，让它去上产吧？

一般你都会去店里，跟老板说，我想买个奔驰、老板就会从奔驰厂去进货，你说你想要宝马，老板就回去宝马厂商进货。

所以你想买什么车子，直接找老板就行了。

所以就引申出了 抽象工厂

四、抽象工厂

抽象工厂肯定要有一个抽象方法。为什么要用抽象工厂呢？为什么不用简单类和接口呢？

这就说为什么我们讲问题要循序渐进。

我们一开始讲的简单工厂，缺点是什么？缺少分工，大杂烩，一个工厂做了所有工厂的事。

所以我们用方法工厂来分工。每个工厂做自己的事。

再然后我们讲了抽象工厂，就是简单工厂和方法工厂的结合。

好处是什么呢？

以前用户有简单工厂的时候用户很方便，想要什么直接跟工厂说，但是这个工厂压力肯定大啊，全国那么多人，买个车还要排队等？

后来用了方法工厂 ，工厂是方便了，但是用户复杂了，要自己去某某工厂要车子。

现在的抽象工厂模式，工厂方便了，用户也方便了。

在这里插入图片描述
AbstractFactory

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory.abstr;

import com.jikang.factory.BaoMa;
import com.jikang.factory.BenChi;
import com.jikang.factory.Car;
import com.jikang.factory.QiRui;

/**
 * @author yangjikang
 * @date 2019/8/8 14:31
 * @modified By yangjikang
 * @since
 */
public abstract class AbstractFactory {

     abstract Car getCar();

     public Car getCar(String name){
         if ("奔驰".equals(name)){
             return new BenChiFactory().getCar();
         }else if ("奇瑞".equals(name)){
             return new QiRuiFactory().getCar();
         }else if ("宝马".equals(name)){
             return new BaoMaFactory().getCar();
         }else{
             return new Car() {
                 @Override
                 public String getName() {
                     return "不能生产该产品....";
                 }
             };
         }
     }
}

AbstractFactoryTest

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory.abstr;

/**
 * @author yangjikang
 * @date 2019/8/8 14:36
 * @modified By yangjikang
 * @since
 */
public class AbstractFactoryTest {
    public static void main(String[] args) {
        DefaultAbstractFactory defaultAbstractFactory = new DefaultAbstractFactory();
        System.out.println(defaultAbstractFactory.getCar("asdasd").getName());
    }
}

BaoMaFactory

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory.abstr;

import com.jikang.factory.BaoMa;
import com.jikang.factory.Car;
import com.jikang.factory.func.CarFactory;

/**
 * @author yangjikang
 * @date 2019/8/8 14:06
 * @modified By yangjikang
 * @since
 */
public class BaoMaFactory extends AbstractFactory{

    @Override
    Car getCar() {
        return null;
    }
}

BenChiFactory

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory.abstr;

import com.jikang.factory.BenChi;
import com.jikang.factory.Car;
import com.jikang.factory.func.CarFactory;

/**
 * @author yangjikang
 * @date 2019/8/8 14:06
 * @modified By yangjikang
 * @since
 */
public class BenChiFactory extends AbstractFactory{

    @Override
    public Car getCar() {
        return new BenChi();
    }

}

DefaultAbstractFactory

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory.abstr;

import com.jikang.factory.Car;

/**
 * @author yangjikang
 * @date 2019/8/8 14:36
 * @modified By yangjikang
 * @since
 */
public class DefaultAbstractFactory extends AbstractFactory{

    private QiRuiFactory qiRuiFactory = new QiRuiFactory();

    @Override
    Car getCar() {
        return this.qiRuiFactory.getCar();
    }
}

QiRuiFactory

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */
package com.jikang.factory.abstr;

import com.jikang.factory.Car;
import com.jikang.factory.QiRui;
import com.jikang.factory.func.CarFactory;

/**
 * @author yangjikang
 * @date 2019/8/8 14:06
 * @modified By yangjikang
 * @since
 */
public class QiRuiFactory extends AbstractFactory{

    @Override
    public Car getCar() {
        return new QiRui();
    }
}
Spring 框架中都用到了哪些设计模式?
A_aspectJ的博客
10-24 2013
Spring框架中的设计模式是多种多样的，它们共同构成了Spring强大的功能和灵活性。学习和理解这些设计模式不仅有助于我们更好地使用Spring框架，也有助于我们提高软件设计和开发的能力。Spring框架运用多种设计模式，如工厂、单例、代理、模板方法、观察者、策略和适配器等，实现其强大的功能和灵活性。这些设计模式使得Spring更加易于扩展和使用，同时也为学习和实践设计模式提供了机会。
【spring里面都用到了哪些设计模式】
学无止境
02-28 2625
【spring里面都用到了哪些设计模式】
Spring中使用到的设计模式 - 工厂模式
chepeizan7683的博客
02-15 366
转载于:https://my.oschina.net/caizhukui/blog/839082
如何基于Spring使用工厂模式实现程序解耦
08-25
主要介绍了如何基于Spring使用工厂模式实现程序解耦,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring用到的10种设计模式，真巧妙！
最新发布
06-16 1115
作为一名有多年开发经验的老司机，每次翻看Spring源码都让我感叹："这哪是框架，分明是设计模式的百科全书！有些小伙伴在工作中可能只会用@Autowired，却不知背后藏着多少精妙设计。今天这篇文章跟大家一起聊聊Spring中最常用的10种设计模式，希望对你会有所帮助。苏三的宝藏网站（常见面试题、简历模版、项目实战什么都有）：http://解耦的艺术工厂模式解耦创建/使用，观察者模式解耦事件/处理扩展性的智慧策略模式支持算法扩展，装饰器模式支持功能扩展复杂性的封装。
Java（SpringBoot）框架实现工厂模式的几种方法
IT_Wallace的博客
05-30 2563
该方法一共核心文件包括4个类，下面4个类时具体的使用方式，下面来逐一讲解 1、工厂的核心方法（BaseFactory） public class BaseFactory<T extends FactoryService<?>> implements InitializingBean, ApplicationContextAware { private ApplicationContext applicationContext; private Map<Fa
Spring中常用的设计模式：工厂模式
蓝田日暖玉生烟
11-15 1116
文章目录工厂模式实例1. 先实现简单工厂2. 工厂类(修改)3. 增加配置文件4. 测试类5. 总结 工厂模式 Beanfactory是一个类工厂，但和传统的类工厂不同。传统的类工厂仅负责构造一个或几个类的实例；而BeanFactory是类的通用工厂，不仅提供了创建Bean的功能，还提供了Bean实例缓存、生命周期管理、Bean实例代理等服务，最重要的是还管理着Bean和Bean之间的依赖关系。在...
【设计模式精讲】开源实战之剖析Spring框架：Spring中工厂模式的应用
专注上位机开发、机器视觉、机器学习、嵌入式软硬件开发
02-28 1万+
FactoryBean表现的是一个工厂的职责,如果一个BeanA 是实现FactoryBean接口,那么A就是变成了一个工厂,根据A的名称获取到的实际上是工厂调用getObject()方法返回的对象,而不是对象本身,如果想获取工厂对象本身,需要在名称前面加上 '&'符号。BeanFactory，以Factory结尾，表示它是一个工厂(接口)， 它负责生产和管理bean的一个工厂。在Spring中，BeanFactory是工厂的顶层接口，也是IOC容器的核心接口，因此BeanFactory中定义了。
23种设计模式-行为型模式.docx
12-16
在给定的文档中，提到了23种设计模式中的几种行为型模式，包括责任链模式、迭代器模式、中介者模式、命令模式、解释器模式、访问者模式、策略模式、模板方法模式、状态模式、观察者模式以及备忘录模式。下面将对这些...
Spring框架中都用到了哪些设计模式？
Java Punk
07-15 1万+
控制反转(IoC)和依赖注入(DI) 工厂设计模式 单例设计模式 代理设计模式 代理模式在 AOP 中的应用 Spring AOP 和 AspectJ AOP 有什么区别? 模板方法 观察者模式 Spring 事件驱动模型中的三种角色 事件角色 事件监听者角色 事件发布者角色 Spring 的事件流程总结 适配器模式 spring AOP中的适配器模式 spring MVC...
设计模式 笔记7 | 抽象工厂模式 在源码中的应用 Spring篇
希望每天都能进步一点点
07-25 1063
Spring 中 BeanFactory 接口声明了关于获取 Bean信息的方法，其他所有的工厂都是 BeanFactory 的子类，虽然在 BeanFactory 里没有显式地声明具体有哪些工厂，但是那些工厂都需要实现这个接口，这也是一种抽象工厂模式的设计方法，BeanFactory相当于抽象工厂，而其继承子类就相当于产品，不同的工厂类就相当于不同的产品。...
工厂设计模式（java版本、spring源码中使用的工厂模式）
hongtaolong的博客
12-07 2099
最近在学习spring源码，发现在IoC容器初始化的时候创建各种bean，然后在代码中看到各种beanFactory和factoryBean，很显然spring容器在创建bean的过程是使用了工厂设计模式，那么正好总结一下工厂设计模式。 工厂模式分为简单工厂、工厂方法、抽象工厂三种 一、简单工厂 简单工厂的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类 spring中创建b...
01-Spring中的工厂模式
欢迎阅读我的博客
11-12 701
工厂模式的三种形态: 工厂模式是解决对象创建问题的属于创建型设计模式,Spring框架底层使用了大量的工厂模式
Spring 工厂模式创建 Bean 深度解析
m0_75107803的博客
06-01 1020
场景推荐方案简单无状态对象静态工厂方法需配置的复杂对象实例工厂方法精细生命周期控制FactoryBean接口条件化创建实例工厂+策略模式集成第三方SDKFactoryBean+Builder模式高性能原型对象@Lookup方法注入优先使用简单方案(静态工厂>实例工厂>FactoryBean)保持工厂方法幂等性复杂初始化逻辑放在工厂中充分利用Spring生命周期管理掌握这些模式可提升Spring应用的灵活性和可维护性，有效解决复杂对象创建问题。
系列二：Spring框架中工厂模式的灵活应用
weixin_43172297的博客
06-09 1467
在软件开发中，工厂模式是一种常用的创建型设计模式，用于通过一个共同的接口创建不同类型的对象。在Spring框架中，工厂模式被广泛应用，以解耦对象的创建过程，提供更灵活的对象创建和配置方式。本篇博客将介绍Spring框架中的工厂模式的不同变体，包括简单工厂、工厂方法和抽象工厂，并探讨它们的适用场景和最佳实践。工厂模式是Spring框架中常用的设计模式之一，它可以帮助我们实现松耦合、可扩展和可配置的对象创建过程。
Spring常用设计模式--简单工厂模式
热门推荐
想着百万年薪努力的小赵
03-15 3万+
工厂模式的由来：   在现实生活中我们都知道，原始社会自给自足（没有工厂）、农耕社会有了小作坊（简单工厂）、工业革命后有了流水线（工厂方法）、现代产业链有代工厂（抽象工厂）等。   我们的项目代码同样是由简到繁一步一步迭代来的，但是对于调用者来说却是越来越简单化了。 简单工厂模式：   是指由一个工厂对象决定创建哪一种产品类的实例，但它不属于23种常用设计模式，简单工厂模式适用于工厂类负责创建的对象较少的场景，切客户端只需要传入工厂类的参数，对于如何创建对象不需要关心。   话不多说，以代码举例：   现在
spring笔记（2）|三种工厂模式
qq_37630282的博客
11-03 270
PART1 Spring中常用的设计模式 工厂，装饰者，代理，委派，策略，适配器，模板，观察者模式。 设计模式非独立使用，实际运用中通常为多个设计模式混合 PART2 简单工厂模式 由一个工厂对象决定创建哪一种类的实例，简单工厂模式适用于工厂类负责创建对象较少的场景，传入工厂类的参数，由工厂类来创建对象。 实例：开放课程 ...
Spring中使用设计模式（策略模式+工厂模式）
jyq2kh的博客
08-29 721
在Spring中使用设计模式（策略模式+工厂模式）策略模式工厂模式测试 策略模式 设计模式，若使用得当，将会使我们的代码更简洁，并且更具扩展性。下面以支付为例 抽象一个支付接口 // 支付接口 public interface IPay { // 是否支持 boolean support(WorkOrder workOrder); // 支付 ...
spring用到了那些设计模式
AAA821的专栏
10-17 1389
1.工厂模式：这个很明显，在各种BeanFactory以及ApplicationContext创建中都用到了 2.代理模式：在Aop实现中用到了动态代理； 3.单例模式：spring默认是单例 4.适配器模式：Spring里，HandlerAdapter用的就是适配器模式 5.观察者模式：Spring中Observer模式常用的地方是listener的实现。如ApplicationList...
Spring框架中都用到了哪些设计模式?
04-23
Spring框架中使用了许多设计模式，其中最常用的包括： 1.工厂模式（Factory）：...除了以上几种设计模式之外，Spring框架还使用了很多其他的设计模式。这些模式的使用使得Spring框架具有了更好的灵活性和可扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值