首页 > 编程语言 >Java设计模式之工厂模式详细讲解和案例示范

Java设计模式之工厂模式详细讲解和案例示范

时间：2024-08-28 18:53:08浏览次数：5  
标签：Java 创建 class 模式 工厂 讲解 Order 设计模式 public

在Java的设计模式中，工厂模式（Factory Pattern）是最常见和最有用的一种创建型模式。工厂模式的核心思想是将对象的创建与使用分离，从而提供了一种灵活的方式来创建不同类型的对象。这种模式尤其适用于复杂对象的创建过程，并且可以很好地应对对象类型的变化。本文将详细讲解工厂模式，结合电商交易系统中的实际应用场景，讨论常见问题和解决方案。

工厂模式是一种创建型设计模式，它提供了一种创建对象的方式，但不向客户端暴露具体的创建逻辑。工厂模式有几种常见的变体，包括简单工厂模式、工厂方法模式和抽象工厂模式。每种变体都在不同的场景下提供了特定的优点。

1. 简单工厂模式

1.1 概述

简单工厂模式（Simple Factory Pattern）又称为静态工厂方法（Static Factory Method），它通过一个工厂类来负责创建具体类的实例。客户端不需要关心对象的具体创建过程，只需通过工厂类来获取对象。

1.2 电商交易系统中的示例

在一个电商交易系统中，我们可能需要处理不同类型的订单，比如普通订单（Regular Order）、会员订单（Member Order）和促销订单（Promotion Order）。我们可以使用简单工厂模式来创建这些订单对象。

1.2.1 代码示例
// 抽象订单类
public interface Order {
    void processOrder();
}

// 普通订单实现
public class RegularOrder implements Order {
    public void processOrder() {
        System.out.println("Processing regular order");
    }
}

// 会员订单实现
public class MemberOrder implements Order {
    public void processOrder() {
        System.out.println("Processing member order");
    }
}

// 促销订单实现
public class PromotionOrder implements Order {
    public void processOrder() {
        System.out.println("Processing promotion order");
    }
}

// 简单工厂类
public class OrderFactory {
    public static Order createOrder(String type) {
        if (type.equals("REGULAR")) {
            return new RegularOrder();
        } else if (type.equals("MEMBER")) {
            return new MemberOrder();
        } else if (type.equals("PROMOTION")) {
            return new PromotionOrder();
        } else {
            throw new IllegalArgumentException("Unknown order type");
        }
    }
}

// 客户端代码
public class ECommerceApp {
    public static void main(String[] args) {
        Order order = OrderFactory.createOrder("MEMBER");
        order.processOrder();
    }
}
1.2.2 类图

在这里插入图片描述

1.3 优缺点
  • 优点：
    • 简化了客户端代码，将对象创建逻辑集中到一个地方。
    • 可以很方便地增加新的产品，只需修改工厂类。
  • 缺点：
    • 工厂类集中了所有产品的创建逻辑，可能会变得复杂。
    • 当需要增加新类型的订单时，必须修改工厂类，违背了开闭原则（Open/Closed Principle）。

2. 工厂方法模式

2.1 概述

工厂方法模式（Factory Method Pattern）是工厂模式的一种演进。它将对象的创建延迟到子类中，通过定义一个接口或抽象类来实现具体的对象创建。每个子类负责创建特定类型的对象。

2.2 电商交易系统中的示例

在电商交易系统中，我们可以通过工厂方法模式为不同类型的订单创建不同的工厂类，每个工厂类负责创建一种具体的订单类型。

2.2.1 代码示例
// 抽象工厂类
public abstract class OrderFactory {
    public abstract Order createOrder();
}

// 普通订单工厂
public class RegularOrderFactory extends OrderFactory {
    public Order createOrder() {
        return new RegularOrder();
    }
}

// 会员订单工厂
public class MemberOrderFactory extends OrderFactory {
    public Order createOrder() {
        return new MemberOrder();
    }
}

// 促销订单工厂
public class PromotionOrderFactory extends OrderFactory {
    public Order createOrder() {
        return new PromotionOrder();
    }
}

// 客户端代码
public class ECommerceApp {
    public static void main(String[] args) {
        OrderFactory factory = new MemberOrderFactory();
        Order order = factory.createOrder();
        order.processOrder();
    }
}
2.2.2 类图

在这里插入图片描述

2.3 优缺点
  • 优点：
    • 遵循开闭原则，新增产品时只需增加新的工厂子类，无需修改已有代码。
    • 客户端代码依赖于抽象工厂，而不是具体产品，减少了耦合。
  • 缺点：
    • 需要为每个产品都创建一个工厂类，增加了系统的复杂性。

3. 抽象工厂模式

3.1 概述

抽象工厂模式（Abstract Factory Pattern）是工厂模式中最为复杂的一种。它提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。抽象工厂模式通常用于创建一组相关的产品。

3.2 电商交易系统中的示例

在电商交易系统中，我们可能需要同时创建订单对象和支付对象。可以使用抽象工厂模式来创建这些相关的对象，例如创建会员订单和对应的会员支付服务。

3.2.1 代码示例
// 抽象订单类
public interface Order {
    void processOrder();
}

// 抽象支付类
public interface Payment {
    void processPayment();
}

// 普通订单类
public class RegularOrder implements Order {
    public void processOrder() {
        System.out.println("Processing regular order");
    }
}

// 普通支付类
public class RegularPayment implements Payment {
    public void processPayment() {
        System.out.println("Processing regular payment");
    }
}

// 会员订单类
public class MemberOrder implements Order {
    public void processOrder() {
        System.out.println("Processing member order");
    }
}

// 会员支付类
public class MemberPayment implements Payment {
    public void processPayment() {
        System.out.println("Processing member payment");
    }
}

// 抽象工厂类
public interface ECommerceFactory {
    Order createOrder();
    Payment createPayment();
}

// 普通工厂类
public class RegularECommerceFactory implements ECommerceFactory {
    public Order createOrder() {
        return new RegularOrder();
    }

    public Payment createPayment() {
        return new RegularPayment();
    }
}

// 会员工厂类
public class MemberECommerceFactory implements ECommerceFactory {
    public Order createOrder() {
        return new MemberOrder();
    }

    public Payment createPayment() {
        return new MemberPayment();
    }
}

// 客户端代码
public class ECommerceApp {
    public static void main(String[] args) {
        ECommerceFactory factory = new MemberECommerceFactory();
        Order order = factory.createOrder();
        Payment payment = factory.createPayment();

        order.processOrder();
        payment.processPayment();
    }
}
3.2.2 类图

在这里插入图片描述

3.3 优缺点
  • 优点：
    • 抽象工厂模式提供了一个创建相关对象家族的接口，确保这些对象的组合一致性。
    • 客户端代码依赖于抽象工厂，而不是具体产品类，扩展性强。
  • 缺点：
    • 如果需要增加新的产品家族，可能需要修改抽象工厂接口以及所有的工厂实现类，增加了维护成本。

4. 工厂模式在开源框架中的应用

工厂模式在Java的开源框架中有广泛的应用。它们利用工厂模式的灵活性和扩展性，简化了对象的创建过程，同时提高了代码的可维护性和可读性。以下是工厂模式在几个常见开源框架中的详细应用分析。

4.1 Spring框架中的工厂模式

Spring框架是Java生态系统中最流行的开源框架之一，它在依赖注入（Dependency Injection）和面向切面编程（Aspect-Oriented Programming）中大量使用了工厂模式。Spring中的工厂模式主要体现在BeanFactory和ApplicationContext这两个核心接口中。

4.1.1 BeanFactory

在Spring中，BeanFactory是一个顶层接口，定义了一个管理Bean的容器。BeanFactory通过工厂模式为应用程序提供各种Bean实例的创建和管理功能。

代码示例
// 配置文件：beans.xml
<beans>
    <bean id="orderService" class="com.example.OrderService"/>
    <bean id="paymentService" class="com.example.PaymentService"/>
</beans>

// BeanFactory示例
public class SpringFactoryExample {
    public static void main(String[] args) {
        BeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml"));
        
        // 使用工厂获取Bean实例
        OrderService orderService = (OrderService) factory.getBean("orderService");
        orderService.processOrder();
    }
}

在这个示例中，BeanFactory根据配置文件beans.xml的定义，使用工厂模式来创建并管理OrderService和PaymentService的实例。客户端只需通过getBean()方法获取Bean实例，而不需关心其创建逻辑。

4.1.2 ApplicationContext

ApplicationContext是Spring框架中BeanFactory的扩展接口，提供了更强大的功能，例如国际化支持、事件传播、声明式事务管理等。它也是基于工厂模式来管理和创建Bean的。

代码示例
// ApplicationContext示例
public class SpringContextExample {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        
        // 使用工厂获取Bean实例
        PaymentService paymentService = (PaymentService) context.getBean("paymentService");
        paymentService.processPayment(100.0);
    }
}

在这个示例中，ApplicationContext提供了比BeanFactory更高级的功能，同时仍然使用工厂模式来管理和创建Bean实例。通过使用ApplicationContext，开发者可以轻松地管理应用程序的依赖关系，并将对象创建与应用逻辑分离。

4.1.3 优势
  • 解耦对象创建与使用：Spring的BeanFactory和ApplicationContext通过工厂模式将对象的创建和使用分离，从而实现了松耦合的设计。
  • 配置灵活：开发者可以通过XML或Java注解配置Bean的创建方式，使得应用程序的配置更加灵活。
  • 支持多种对象创建方式：Spring支持单例、原型、工厂方法等多种对象创建方式，极大地提高了框架的适应性。

4.2 Hibernate中的工厂模式

Hibernate是一个广泛使用的Java持久化框架，它利用工厂模式来创建和管理数据库会话（Session）对象。Hibernate中的SessionFactory是工厂模式的一个典型应用。

4.2.1 SessionFactory

SessionFactory是Hibernate框架中用来创建Session对象的工厂类。Session是一个代表与数据库交互的接口，通过SessionFactory可以创建出多个Session实例。

代码示例
// Hibernate配置文件：hibernate.cfg.xml
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydb</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <mapping class="com.example.Order"/>
    </session-factory>
</hibernate-configuration>

// Hibernate工厂模式示例
public class HibernateFactoryExample {
    public static void main(String[] args) {
        // 创建SessionFactory
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        
        // 使用工厂创建Session
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        
        // 操作数据库
        Order order = new Order();
        order.setOrderNumber("12345");
        session.save(order);
        
        session.getTransaction().commit();
        session.close();
    }
}

在这个示例中，SessionFactory通过读取配置文件hibernate.cfg.xml的内容，创建并管理Session对象。客户端通过工厂获取Session实例，并使用它来执行数据库操作。

4.2.2 优势
  • 管理数据库连接：SessionFactory通过工厂模式统一管理数据库连接的创建和释放，避免了手动管理数据库连接的复杂性。
  • 提高性能：SessionFactory是线程安全的，可以被多个线程共享，这样避免了频繁创建SessionFactory实例的开销。
  • 支持多种数据库：通过配置文件，SessionFactory可以适配不同的数据库类型，增强了Hibernate的灵活性。

4.3 Apache Commons Logging中的工厂模式

Apache Commons Logging是一个通用的日志记录框架，广泛应用于许多Java开源项目中。该框架使用工厂模式来创建和管理日志记录器（Logger）实例。

4.3.1 LogFactory

LogFactory是Apache Commons Logging中的核心工厂类，它负责创建和管理Log接口的具体实现。不同的日志实现（如Log4j、JDK Logging等）可以通过工厂模式进行无缝切换。

代码示例
// Apache Commons Logging示例
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class LoggingFactoryExample {
    private static final Log log = LogFactory.getLog(LoggingFactoryExample.class);

    public static void main(String[] args) {
        log.info("This is an info message");
        log.error("This is an error message");
    }
}

在这个示例中，LogFactory通过工厂模式创建Log实例，开发者可以通过LogFactory.getLog()方法获取具体的日志记录器对象。LogFactory根据配置自动选择合适的日志实现，如Log4j或JDK Logging。

4.3.2 优势
  • 兼容性：LogFactory通过工厂模式实现了对多种日志框架的支持，使得Apache Commons Logging成为一个通用的日志接口。
  • 灵活性：开发者可以通过配置文件轻松切换不同的日志实现，而不需要修改代码中的任何日志记录逻辑。
  • 统一接口：通过工厂模式，Apache Commons Logging为各种日志实现提供了统一的接口，简化了日志管理的复杂性。

5. 总结

工厂模式在Java的开源框架中得到了广泛的应用，其主要优势在于解耦对象的创建和使用、提供统一的接口和增强代码的灵活性。Spring、Hibernate和Apache Commons Logging等流行的开源框架都利用工厂模式提高了代码的可维护性和可扩展性。

通过对这些框架中工厂模式的详细分析，我们可以更深入地理解工厂模式在实际项目中的应用，并在自己的项目中更好地应用这一设计模式。

标签：Java,创建,class,模式,工厂,讲解,Order,设计模式,public
From： https://blog.csdn.net/weixin_39996520/article/details/141614492

相关文章

  • Java 入门指南：Java Socket 网络通信编程
    SocketSocket（套接字）是用于网络通信的编程接口、网络通信的基础，通过它可以实现不同计算机之间的数据传输，应用程序可以通过它发送或接收数据；就像操作文件那样可以打开、读写和关闭。它提供了一种机制，使得计算机之间可以进行数据的发送和接收。套接字允许应用程序将I/O应用......
  • 设计模式反模式：UML图示常见误用案例分析
    设计模式反模式：UML图示常见误用案例分析在软件开发中，设计模式是应对常见设计问题的最佳实践，但如果使用不当，设计模式也可能变成反模式，导致系统架构的复杂性增加，甚至引发各种问题。在这篇文章中，我们将探讨在UML图示中常见的设计模式误用案例，尤其是在电商交易系统中的实际应用......
  • 突破编程 C++ 设计模式（组合模式）详尽攻略
    在软件开发中，设计模式为程序员提供了解决特定问题的最佳实践。设计模式不仅提高了代码的可复用性和可维护性，还能帮助团队更好地进行协作。在这篇文章中，我们将深入探讨组合模式——一种结构型设计模式。组合模式允许你将对象组合成树形结构来表示“部分-整体”的层次关系。组合......
  • 【视频讲解】数据挖掘实战：Python金融贷款模型分类潜在贷款客户
    全文链接：https://tecdat.cn/?p=37521原文出处：拓端数据部落公众号分析师：HengtaoFan模型的存在依托于这样一个事实：基于概率的决策乃是最优之选。将概率转化为评分，能够便于对齐风险。而评分则是通过统计的方法来识别潜在客户，进而判断客户是否合乎心意。这里的“合意”由我们预......
  • Java实现学生、班级、年级管理系统
    分层思想DAO层：主要做数据持久层的工作，负责与数据库进行联络的一些任务都封装在此Service层：主要负责业务模块的应用逻辑设计，设计接口、实现类等，Service层的业务层具体要调用已经定义的DAO层接口Controller层：负责具体的业务模块流程的控制，要调用Service层的接口来控制业务流程......
  • java.util.UUID
    概述Aclassthatrepresentsanimmutableuniversallyuniqueidentifier(UUID).一个不可变的通用的唯一标识符的classAUUIDrepresentsa128-bitvalue.一个uuid代表一个128位的值 UUID的版本UUID有多个版本，每个版本有不同的生成方式。常用的......
  • 【Java】多线程创建与管理 （实操图解）
    Java系列文章目录补充内容Windows通过SSH连接Linux第一章Linux基本命令的学习与Linux历史文章目录Java系列文章目录一、前言二、学习内容：三、问题描述四、解决方案：4.1Thread4.2Runnable五、总结：一、前言多线程入门二、学习内容：实现多线程效果三、问题......
  • Java基础-学习笔记15
    15泛型1.泛型泛型的好处编译时，检查添加元素的类型，提高了安全性减少了类型转换的次数，提高效率比如：ArrayListarr=newArrayList();在放入时，如果添加Dog类到arr里，编译器发现添加的类型不满足要求，就会报错；在取出时，直接取出Person类，就不用再转型使用。泛型的......
  • java增加注解实现异步执行任务
    1.首先启动类增加注解@EnableAsync2.增加configpackagecom.xxx.config;importorg.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;importorg.springframework.context.annotation.Configuration;importorg.springframework.scheduling.annotation.A......
  • Effective Java理解笔记系列-第1条-何时考虑用静态工厂方法替代构造器？
    为什么写这系列博客？在阅读《EffectiveJava》这本书时，我发现有许多地方需要仔细认真地慢慢阅读并且在必要时查阅相关资料才能彻底搞懂，相信有些读者在阅读此书时也有类似感受；同时，在解决疑惑的过程中，还存在着有些内容不容易查找、查找到的解答质量不高等问题，于是我决定把我阅读此书......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99