web框架编程实验三：工厂模式

一、实验目标

理解工厂模式的设计思想及应用场景；能够实现简单的工厂模式原型。

二、实验内容

1、采用继承/接口方式实现特斯拉、小米、问界三个品牌的汽车生产，鼓励用接口实现；而后实现客户购买逻辑（单一职责）；

2、在上述例子基础上，进一步实现基于工厂模式的客户购买逻辑（需要编写工厂类），要求实现车辆生产细节和购买过程分离（过程解耦、单一职责）；

3、上述例子要求能够做到：当扩展第四个品牌时，购买相关的业务代码不变（开闭原则），仅增加第四个品牌相关代码。

三、实验步骤

1.创建项目，定义一个汽车接口，并为特斯拉、小米、问界三个品牌创建实现类。

1. 打开 IntelliJ IDEA，点击 "New Project"。

2. 选择 "Java"，“Build system”选择“Maven”。

3. 创建项目。

4. 删除原有Test文件夹，在”src/main/java“目录下创建”entity“包。

5. 在”entity“包内创建Car接口，Tesla类，Xiaomi类，Wenjie类。

6. 填写相关代码：

   Car接口：

   public interface Car {
       void produce();
   }

   Tesla类：

   public class Tesla implements Car {
       @Override
       public void produce() {
           System.out.println("Producing a Tesla car.");
       }
   }

   Xiaomi类：

   public class Xiaomi implements Car {
       @Override
       public void produce() {
           System.out.println("Producing a Xiaomi car.");
       }
   }

   Wenjie类：

   public class Wenjie implements Car {
       @Override
       public void produce() {
           System.out.println("Producing a Wenjie car.");
       }
   }

2.实现客户购买逻辑（单一职责）。

1. 在”src/main/java“目录下创建”tools“包。

2. 在”tools“包内创建Customer类。

3. 填写相关代码：

   package tools;
   ​
   import entity.Car;
   ​
   public class Customer {
       private final Car car;
   ​
       public Customer(Car car) {
           this.car = car;
       }
   ​
       public void purchase() {
           car.produce();
           System.out.println("Customer has purchased the car.");
       }
   }

4. 示范用法：

   在”src/main/java“目录下创建”main“包，创建main类，填写以下代码。

   package main;
   ​
   import entity.Tesla;
   import entity.Wenjie;
   import entity.Xiaomi;
   import tools.Customer;
   ​
   public class Main {
       public static void main(String[] args) {
           Customer teslaCustomer = new Customer(new Tesla());
           teslaCustomer.purchase();
   ​
           Customer xiaomiCustomer = new Customer(new Xiaomi());
           xiaomiCustomer.purchase();
   ​
           Customer wenjieCustomer = new Customer(new Wenjie());
           wenjieCustomer.purchase();
       }
   }

   

3.实现基于工厂模式的客户购买逻辑

1. 在”tools“包内创建CarFactory类。

2. 填写相关代码：

   package tools;
   ​
   import entity.*;
   ​
   public class CarFactory {
       public static Car createCar(String brand) {
           switch (brand.toLowerCase()) {
               case "tesla":
                   return new Tesla();
               case "xiaomi":
                   return new Xiaomi();
               case "wenjie":
                   return new Wenjie();
               default:
                   throw new IllegalArgumentException("Unknown car brand: " + brand);
           }
       }
   }

4.实现车辆生产细节和购买过程分离

1. 修改”tools“包下的Customer类。

2. 相关代码如下：

   package tools;
   ​
   import entity.Car;
   ​
   public class Customer {
       private final Car car;
   ​
       // 通过工厂获取汽车实例
       public Customer(String carBrand) {
           this.car = CarFactory.createCar(carBrand);
       }
   ​
       public void purchase() {
           car.produce();
           System.out.println("Customer has purchased the car.");
       }
   }

3. 修改”main“包下的main类。

4. 相关代码如下：

   package main;
   ​
   import tools.Customer;
   ​
   public class Main {
       public static void main(String[] args) {
           Customer teslaCustomer = new Customer("Tesla");
           teslaCustomer.purchase();
   ​
           Customer xiaomiCustomer = new Customer("Xiaomi");
           xiaomiCustomer.purchase();
   ​
           Customer wenjieCustomer = new Customer("Wenjie");
           wenjieCustomer.purchase();
       }
   }

        

5.扩展第四个品牌

1. 在”entity“包内创建新类BrandX类，填写以下代码。

   public class BrandX implements Car {
       @Override
       public void produce() {
           System.out.println("Producing a Brand X car.");
       }
   }

2. 更新工厂以支持新的品牌，代码如下。

   public class CarFactory {
       public static Car createCar(String brand) {
           switch (brand.toLowerCase()) {
               case "tesla":
                   return new Tesla();
               case "xiaomi":
                   return new Xiaomi();
               case "wenjie":
                   return new Wenjie();
               case "brandx":
                   return new BrandX();
               default:
                   throw new IllegalArgumentException("Unknown car brand: " + brand);
           }
       }
   }

3. 更新主函数，代码如下。

   public class Main {
       public static void main(String[] args) {
           Customer teslaCustomer = new Customer("Tesla");
           teslaCustomer.purchase();
   ​
           Customer xiaomiCustomer = new Customer("Xiaomi");
           xiaomiCustomer.purchase();
   ​
           Customer wenjieCustomer = new Customer("Wenjie");
           wenjieCustomer.purchase();
   ​
           Customer brandXCustomer = new Customer("BrandX");
           brandXCustomer.purchase();  // 新品牌示例
       }
   }

4. 结果展示：
   

6.Spring创建bean的过程为什么要使用工厂模式，有什么好处？

1. 解耦合

   工厂模式通过将对象的创建与使用分离，使得代码中的类之间的依赖关系降低。这种解耦合的方式增强了系统的灵活性。

2. 面向接口编程

   使用工厂方法时，开发者通常是依赖于接口而非具体实现。这样能够促进应用遵循面向接口编程的原则，提高系统的可扩展性和可维护性。

3. 统一配置管理

   所有的Bean都由Spring容器统一管理，这意味着可以通过一个中心位置对所有Bean进行配置、更改及管理，提升了整体项目的管理效率。

4. 控制生命周期

   通过工厂模式，Spring能够集中管理Bean的整个生命周期，包括初始化、依赖注入、销毁等。这保证了资源的有效利用以及统一的对象管理策略。

5. 配置灵活性

   Spring容器可以通过配置文件或注解来定义和管理Bean的创建过程，开发者可以在不修改代码的情况下进行配置。这种方式支持多种配置源，如XML、Java配置、属性文件等，以满足不同项目需求。

四、问题总结与体会

在这个实验中，遇到问题如下：

        1.对于工厂模式不熟悉。

        2.对于接口的使用有些遗忘。

以上问题均已解决。

通过这次实验令我收获了很多，对于工厂模式的设计思想及应用场景有了进一步的理解，对于工厂模式原型可以进行简单的实现。