工厂模式

已于 2023-01-07 17:21:58 修改
阅读量127 收藏
点赞数
分类专栏： 设计模式 文章标签： java 简单工厂模式 抽象工厂模式 工厂方法模式 开闭原则
于 2023-01-07 17:11:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44732432/article/details/128592555
版权
文章介绍了简单工厂模式、工厂方法模式和抽象工厂模式在披萨项目中的应用，强调了这些模式如何遵循设计模式的开闭原则，提高代码的可扩展性和可维护性。简单工厂模式通过一个类来封装实例化对象的行为，而工厂方法模式则将实例化功能抽象成抽象方法，由子类决定要实例化的类。抽象工厂模式则提供一个接口用于创建相关或有依赖关系的对象簇，允许创建对象类型无需指明具体的类。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

1、简单工厂模式

1.1、看一个具体的需求

1.2、使用传统的方式来完成

1.3、传统的方式的优缺点

1.4、基本介绍

1.5、使用简单工厂模式

2、工厂方法模式

2.1、看一个需求

2.2、思路1

2.3、思路2

2.4、工厂方法模式介绍

2.5、工厂方法模式应用案例

3、抽象工厂模式

3.1、基本介绍

4、工厂模式小结

1、简单工厂模式

1.1、看一个具体的需求

看一个披萨的项目： 要便于披萨种类的扩展， 要便于维护
        1) 披萨的种类很多(比如 GreekPizz、 CheesePizz 等)
        2) 披萨的制作有 prepare， bake, cut, box
        3) 完成披萨店订购功能。

1.2、使用传统的方式来完成

        1) 思路分析(类图)

 编写 OrderPizza.java 去订购需要的各种 Pizza

package com.atguigu.factory.simplefactory.pizzastore.order;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


import com.atguigu.factory.simplefactory.pizzastore.pizza.Pizza;

public class OrderPizza {

    // 构造器
	public OrderPizza() {
		Pizza pizza = null;
		String orderType; // 订购披萨的类型
		do {
			orderType = getType();
			if (orderType.equals("greek")) {
				pizza = new GreekPizza();
				pizza.setName(" 希腊披萨 ");
			} else if (orderType.equals("cheese")) {
				pizza = new CheesePizza();
				pizza.setName(" 奶酪披萨 ");
			} else if (orderType.equals("pepper")) {
				pizza = new PepperPizza();
				pizza.setName("胡椒披萨");
			} else {
				break;
			}
			//输出pizza 制作过程
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();

		} while (true);
	}

}

1.3、传统的方式的优缺点

        1) 优点是比较好理解， 简单易操作。

        2) 缺点是违反了设计模式的 ocp 原则， 即对扩展开放， 对修改关闭。 即当我们给类增加新功能的时候， 尽量不修改代码， 或者尽可能少修改代码.

        3) 比如我们这时要新增加一个 Pizza 的种类(Pepper 披萨)，只要是订购 Pizza 的代码都需要修改.

        4) 改进的思路分析
        分析： 修改代码可以接受， 但是如果我们在其它的地方也有创建 Pizza 的代码， 就意味着， 也需要修改， 而创建 Pizza的代码， 往往有多处。思路： 把创建 Pizza 对象封装到一个类中， 这样我们有新的 Pizza 种类时， 只需要修改该类就可， 其它有创建到 Pizza对象的代码就不需要修改了.-> 简单工厂模式

1.4、基本介绍

        1) 简单工厂模式是属于创建型模式， 是工厂模式的一种。 简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。 简单工厂模式是工厂模式家族中最简单实用的模式

        2) 简单工厂模式： 定义了一个创建对象的类， 由这个类来封装实例化对象的行为(代码)

        3) 在软件开发中， 当我们会用到大量的创建某种、 某类或者某批对象时， 就会使用到工厂模式.

1.5、使用简单工厂模式

        1) 简单工厂模式的设计方案: 定义一个可以实例化 Pizaa 对象的类， 封装创建对象的代码。

package com.atguigu.factory.simplefactory.pizzastore.order;

import com.atguigu.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.atguigu.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.atguigu.factory.simplefactory.pizzastore.pizza.PepperPizza;
import com.atguigu.factory.simplefactory.pizzastore.pizza.Pizza;

//简单工厂类
public class SimpleFactory {

	//更加orderType 返回对应的Pizza 对象
	public Pizza createPizza(String orderType) {

		Pizza pizza = null;

		System.out.println("使用简单工厂模式");
		if (orderType.equals("greek")) {
			pizza = new GreekPizza();
			pizza.setName(" 希腊披萨 ");
		} else if (orderType.equals("cheese")) {
			pizza = new CheesePizza();
			pizza.setName(" 奶酪披萨 ");
		} else if (orderType.equals("pepper")) {
			pizza = new PepperPizza();
			pizza.setName("胡椒披萨");
		}
		
		return pizza;
	}
	
	//简单工厂模式 也叫 静态工厂模式 
	
	public static Pizza createPizza2(String orderType) {

		Pizza pizza = null;

		System.out.println("使用简单工厂模式2");
		if (orderType.equals("greek")) {
			pizza = new GreekPizza();
			pizza.setName(" 希腊披萨 ");
		} else if (orderType.equals("cheese")) {
			pizza = new CheesePizza();
			pizza.setName(" 奶酪披萨 ");
		} else if (orderType.equals("pepper")) {
			pizza = new PepperPizza();
			pizza.setName("胡椒披萨");
		}
		
		return pizza;
	}

}

package com.atguigu.factory.simplefactory.pizzastore.order;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


import com.atguigu.factory.simplefactory.pizzastore.pizza.Pizza;

public class OrderPizza {

	// 构造器
//	public OrderPizza() {
//		Pizza pizza = null;
//		String orderType; // 订购披萨的类型
//		do {
//			orderType = getType();
//			if (orderType.equals("greek")) {
//				pizza = new GreekPizza();
//				pizza.setName(" 希腊披萨 ");
//			} else if (orderType.equals("cheese")) {
//				pizza = new CheesePizza();
//				pizza.setName(" 奶酪披萨 ");
//			} else if (orderType.equals("pepper")) {
//				pizza = new PepperPizza();
//				pizza.setName("胡椒披萨");
//			} else {
//				break;
//			}
//			//输出pizza 制作过程
//			pizza.prepare();
//			pizza.bake();
//			pizza.cut();
//			pizza.box();
//			
//		} while (true);
//	}

	//定义一个简单工厂对象
	SimpleFactory simpleFactory;
	Pizza pizza = null;
	
	//构造器
	public OrderPizza(SimpleFactory simpleFactory) {
		setFactory(simpleFactory);
	}
	
	public void setFactory(SimpleFactory simpleFactory) {
		String orderType = ""; //用户输入的
		
		this.simpleFactory = simpleFactory; //设置简单工厂对象
		
		do {
			orderType = getType(); 
			pizza = this.simpleFactory.createPizza(orderType);
			
			//输出pizza
			if(pizza != null) { //订购成功
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			} else {
				System.out.println(" 订购披萨失败 ");
				break;
			}
		}while(true);
	}
	
	// 写一个方法，可以获取客户希望订购的披萨种类
	private String getType() {
		try {
			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("input pizza 种类:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}

}

2、工厂方法模式

2.1、看一个需求

        披萨项目新的需求： 客户在点披萨时， 可以点不同口味的披萨， 比如 北京的奶酪 pizza、 北京的胡椒 pizza 或者是伦敦的奶酪 pizza、 伦敦的胡椒 pizza

2.2、思路1

        使用简单工厂模式， 创建不同的简单工厂类， 比如 BJPizzaSimpleFactory、 LDPizzaSimpleFactory 等等.从当前这个案例来说， 也是可以的， 但是考虑到项目的规模， 以及软件的可维护性、 可扩展性并不是特别好

2.3、思路2

        使用工厂方法模式

2.4、工厂方法模式介绍

        1) 工厂方法模式设计方案： 将披萨项目的实例化功能抽象成抽象方法， 在不同的口味点餐子类中具体实现。

        2) 工厂方法模式： 定义了一个创建对象的抽象方法， 由子类决定要实例化的类。 工厂方法模式将对象的实例化推迟到子类。

2.5、工厂方法模式应用案例

        1) 披萨项目新的需求： 客户在点披萨时， 可以点不同口味的披萨， 比如 北京的奶酪 pizza、 北京的胡椒 pizza 或者是伦敦的奶酪 pizza、 伦敦的胡椒 pizza

        2) 思路分析图解

package com.atguigu.factory.factorymethod.pizzastore.order;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import com.atguigu.factory.factorymethod.pizzastore.pizza.Pizza;




public abstract class OrderPizza {

	//定义一个抽象方法，createPizza , 让各个工厂子类自己实现
	abstract Pizza createPizza(String orderType);
	
	// 构造器
	public OrderPizza() {
		Pizza pizza = null;
		String orderType; // 订购披萨的类型
		do {
			orderType = getType();
			pizza = createPizza(orderType); //抽象方法，由工厂子类完成
			//输出pizza 制作过程
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();
			
		} while (true);
	}

	

	// 写一个方法，可以获取客户希望订购的披萨种类
	private String getType() {
		try {
			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("input pizza 种类:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}

}

package com.atguigu.factory.factorymethod.pizzastore.order;

import com.atguigu.factory.factorymethod.pizzastore.pizza.BJCheesePizza;
import com.atguigu.factory.factorymethod.pizzastore.pizza.BJPepperPizza;
import com.atguigu.factory.factorymethod.pizzastore.pizza.Pizza;


public class BJOrderPizza extends OrderPizza {

	
	@Override
	Pizza createPizza(String orderType) {
	
		Pizza pizza = null;
		if(orderType.equals("cheese")) {
			pizza = new BJCheesePizza();
		} else if (orderType.equals("pepper")) {
			pizza = new BJPepperPizza();
		}
		// TODO Auto-generated method stub
		return pizza;
	}

}

package com.atguigu.factory.factorymethod.pizzastore.order;

import com.atguigu.factory.factorymethod.pizzastore.pizza.BJCheesePizza;
import com.atguigu.factory.factorymethod.pizzastore.pizza.BJPepperPizza;
import com.atguigu.factory.factorymethod.pizzastore.pizza.LDCheesePizza;
import com.atguigu.factory.factorymethod.pizzastore.pizza.LDPepperPizza;
import com.atguigu.factory.factorymethod.pizzastore.pizza.Pizza;


public class LDOrderPizza extends OrderPizza {

	
	@Override
	Pizza createPizza(String orderType) {
	
		Pizza pizza = null;
		if(orderType.equals("cheese")) {
			pizza = new LDCheesePizza();
		} else if (orderType.equals("pepper")) {
			pizza = new LDPepperPizza();
		}
		// TODO Auto-generated method stub
		return pizza;
	}

}

3、抽象工厂模式

3.1、基本介绍

        1) 抽象工厂模式： 定义了一个 interface 用于创建相关或有依赖关系的对象簇， 而无需指明具体的类

        2) 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。

        3) 从设计层面看， 抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。

        4) 将工厂抽象成两层， AbsFactory(抽象工厂) 和 具体实现的工厂子类。 程序员可以根据创建对象类型使用对应的工厂子类。 这样将单个的简单工厂类变成了工厂簇， 更利于代码的维护和扩展

        5) 类图

package com.atguigu.factory.absfactory.pizzastore.order;

import com.atguigu.factory.absfactory.pizzastore.pizza.Pizza;

//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
	//让下面的工厂子类来 具体实现
	public Pizza createPizza(String orderType);
}

package com.atguigu.factory.absfactory.pizzastore.order;

import com.atguigu.factory.absfactory.pizzastore.pizza.BJCheesePizza;
import com.atguigu.factory.absfactory.pizzastore.pizza.BJPepperPizza;
import com.atguigu.factory.absfactory.pizzastore.pizza.Pizza;

//这是工厂子类
public class BJFactory implements AbsFactory {

	@Override
	public Pizza createPizza(String orderType) {
		System.out.println("~使用的是抽象工厂模式~");
		// TODO Auto-generated method stub
		Pizza pizza = null;
		if(orderType.equals("cheese")) {
			pizza = new BJCheesePizza();
		} else if (orderType.equals("pepper")){
			pizza = new BJPepperPizza();
		}
		return pizza;
	}

}

package com.atguigu.factory.absfactory.pizzastore.order;


import com.atguigu.factory.absfactory.pizzastore.pizza.LDCheesePizza;
import com.atguigu.factory.absfactory.pizzastore.pizza.LDPepperPizza;
import com.atguigu.factory.absfactory.pizzastore.pizza.Pizza;


public class LDFactory implements AbsFactory {

	@Override
	public Pizza createPizza(String orderType) {
		System.out.println("~使用的是抽象工厂模式~");
		Pizza pizza = null;
		if (orderType.equals("cheese")) {
			pizza = new LDCheesePizza();
		} else if (orderType.equals("pepper")) {
			pizza = new LDPepperPizza();
		}
		return pizza;
	}

}

package com.atguigu.factory.absfactory.pizzastore.order;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import com.atguigu.factory.absfactory.pizzastore.pizza.Pizza;

public class OrderPizza {

	AbsFactory factory;

	// 构造器
	public OrderPizza(AbsFactory factory) {
		setFactory(factory);
	}

	private void setFactory(AbsFactory factory) {
		Pizza pizza = null;
		String orderType = ""; // 用户输入
		this.factory = factory;
		do {
			orderType = getType();
			// factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
			pizza = factory.createPizza(orderType);
			if (pizza != null) { // 订购ok
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			} else {
				System.out.println("订购失败");
				break;
			}
		} while (true);
	}

	// 写一个方法，可以获取客户希望订购的披萨种类
	private String getType() {
		try {
			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("input pizza 种类:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}
}

4、工厂模式小结

        1) 工厂模式的意义将实例化对象的代码提取出来， 放到一个类中统一管理和维护， 达到和主项目的依赖关系的解耦。 从而提高项目的扩展和维护性。

        2) 三种工厂模式 (简单工厂模式、 工厂方法模式、 抽象工厂模式)

        3) 设计模式的依赖抽象原则

  • 创建对象实例时， 不要直接 new 类, 而是把这个 new 类的动作放在一个工厂的方法中， 并返回。 有的书上说，变量不要直接持有具体类的引用。
  • 不要让类继承具体类， 而是继承抽象类或者是实现 interface(接口)
  • 不要覆盖基类中已经实现的方法。



        

深入解析工厂模式与策略模式的结合：从外卖平台折扣谈起
张彦峰的博客
06-24 5万+
其实在很多的开发设计中，将工厂模式和策略模式的综合使用的案例是很多的，而且解决的实际问题也一样很多，本次对基本的简单工厂模式和策略模式做简单介绍，重点放在两者结合后的具体应用上做分析和讲解。
工厂模式与抽象工厂模式
webeyebody的博客
04-17 1441
复杂系统中可结合两者，例如用抽象工厂管理核心产品族，工厂模式处理辅助对象。：通过一个工厂接口或类创建单一类型的对象，隐藏具体实现类的实例化逻辑。：当系统只需创建单一类型对象，且未来扩展可能性较低时（如工具类库）。：同一应用在不同操作系统下需生成适配的窗口、按钮等组件（如网页5的。：产品类型过多时，工厂类条件分支会臃肿（如网页2的。：确保产品族的兼容性和一致性。：新增产品类型需修改所有工厂类（如网页4中新增。：单一工厂类根据参数返回不同产品（如网页2的。：新增产品族只需新增具体工厂（如网页5中增加。
go的工厂模式
z3551906947的博客
08-06 1126
工厂模式是一种常用的软件设计模式，它属于创建型模式之一，其核心思想是将对象的创建和使用分离，以此来提高代码的模块化和可维护性。定义：创建相关或依赖对象的家族，而不需明确指定具体类。提供一个接口以创建一族相关或依赖的对象，而不需要构造它们的具体类。适用场景：当需要生成多个产品族时。优点：易于扩展新的产品族，同时保持了产品的一致性。缺点：新增产品等级结构困难，增加了系统的复杂度。简单工厂模式是一种创建型设计模式，它使用一个工厂类根据传入的参数来决定创建出哪一种产品类的实例。
设计模式-工厂模式
m0_69323023的博客
10-16 1184
工厂模式
工厂模式和策略模式区别
小白的大数据之旅的博客
08-22 1051
在深入对比工厂模式和策略模式之前，明确研究方法和内容框架至关重要。本文综合采用理论分析与案例分析相结合的研究手段，旨在全面剖析这两种设计模式。理论分析构成了本文研究的基础。通过详细梳理工厂模式和策略模式的定义、分类及特点，本文为后续对比分析提供了坚实的理论支撑。工厂模式，作为一种创建型设计模式，关注于对象的创建过程，通过封装具体的创建逻辑，使得系统无需关注对象是如何被创建和组装的。它分为简单工厂模式、工厂方法模式和抽象工厂模式，每种模式都有其独特的应用场景和优势[5]。
Java工厂模式（随笔）
是个非常热爱生活、乐观、奋斗、努力的逗比青年
06-01 6172
三大工厂都是哪些？简单工厂模式工厂模式抽象工厂模式特殊工厂都是哪些？容器工厂模式超级工厂模式准确的来说工厂模式一共只有三种；但在我们程序员这里不止三种，还有两种，我们把它叫 ‘容器工厂模式’ 和 ‘超级工厂模式为什么它们没有增加到三大模式呢？因为它们都是基于‘简单工厂模式’扩展开辟出来的，解决了简单工厂模式存在违反开闭原则等弊端。Java简单工厂模式是一种创建型设计模式，它提供了一个工厂类，用于根据传入的参数来决定创建哪种类的实例；
工厂模式与策略模式的较量
qq_42538588的博客
08-28 1203
工厂模式是一种创建型设计模式，它定义了一个用于创建对象的接口，让子类决定实例化哪一个类。换句话说，工厂模式将对象的创建过程抽象化，使得客户端不必直接依赖于具体的类。这种设计极大地降低了系统的耦合性，增强了代码的灵活性和可维护性。需要创建的对象具有复杂的创建过程，涉及多个步骤或组件的组合。系统需要根据不同的条件或配置，创建不同类型的对象。客户端不需要知道具体类的内部实现，只关心如何获取一个合适的对象。工厂模式的经典应用包括Java中的类的获取实例方法、数据库连接池的管理等。
Java二十三种设计模式-抽象工厂模式（3/23）
小相探索IT世界
07-15 1344
抽象工厂模式是一种创建型设计模式，用于创建一系列相关或相互依赖的对象，而不需要指定它们具体的类。这种模式提供了一个接口，用于生成一组相关的对象，而客户端不需要知道这些对象的具体类。定义了创建一系列相关或依赖对象的接口。它是一个抽象角色，不实现具体的创建逻辑。定义了产品的接口，是所有具体产品类的共同父类。它是一个抽象角色，不实现具体的产品类。抽象工厂模式是处理复杂系统中对象创建问题的有效工具。通过本文的深入分析，希望读者能够对抽象工厂模式有更全面的理解，并在实际开发中做出合理的设计选择。
软件工程——设计模式之创建型模式（单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。）
batcat560的博客
05-28 1527
本文介绍了设计模式的六大原则以及设计模式中的创建型模式，包含单例模式，建造者模式，工厂模式，抽象工厂模式以及原型模式。
八大常见设计模式-工厂模式
2301_77562764的博客
10-15 1318
抽象工厂模式（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关会相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到“同族的不同等级的产品”的模式结构抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。使用抽象工厂模式一般要满足以下条件。系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品系统一次只可能消费其中某一族产品，即同族的产品一起使用。
qt工厂模式例子qt简单工程模式源码
07-04
3. Qt工厂模式工程 4. Qt工厂模式例程 5. Qt工厂模式例子 6. 简单工厂模式 部分源码实例: // 奔驰工厂 class BenzFactory : public AFactory { public: ICar* CreateCar() { return new BenzCar(); } }; // ...
AOC电视进入酒店模式和工厂模式的方法
06-15
测试机型：32m3095（其它机型未试，大同小异，自行测试） 测试时间：2022.06.15 进入酒店模式好处：可以设置...进入工厂模式好处：可以设置不正常的颜色，声音。恢复系统默认设置。好多功能，是英文的，我看不懂。
长虹LED39C2080i智能电视工程模式详解.doc
01-08
本文详细讲解了长虹LED39C2080i智能电视的工程模式，包括如何进入工程模式、工程模式的作用、工程模式菜单索引详解等内容。 一、如何进入工程模式： 要进入工程模式，需要遥控器按“节目源”出来节目源选择菜单，...
Java设计模式之工厂模式（Factory模式）介绍
09-03
**工厂模式**是一种常见的设计模式，它在Java中被广泛应用于创建对象实例。工厂模式的主要目的是将对象的创建过程封装起来，使得代码更加灵活且易于维护。通过使用工厂模式，我们可以将实例化对象的责任从客户端代码...
Java循环编程常见错误与优化实践
静水深流
06-10 51
值得注意的是，基础的静态分析诊断（如"变量未使用"）无法检测此类问题，因为循环变量。该实现完全封装了索引操作，消除了客户端代码中显式使用索引的风险。建议在代码审查时特别关注循环体内索引变量的使用一致性，并针对边界情况（如空数组、单元素数组、多元素同值数组）设计专项测试用例。），将导致严重的无限循环问题。在需要逆向遍历集合时，开发者常犯的关键错误是修改循环条件后忘记调整递增/递减操作。开发者在循环结构中常犯的一个典型错误是：虽然正确编写了循环结构，但在循环体内错误地使用常量索引（如。停止更新，引发无限循环。
优雅的系统重试
huangyujun9920123的博客
06-05 932
本文探讨了如何优雅实现方法重试机制。程序员A起初采用固定次数的循环重试方式，但发现多个接口存在重复代码。通过分析将重试框架与业务逻辑解耦，最终构建了可复用的重试策略类。该方案使用Supplier函数式接口接收业务逻辑，实现了：1) 统一的最大重试次数控制；2) 状态码判断；3) 异常处理。这种设计既消除了代码冗余，又通过lambda表达式灵活支持不同业务逻辑，为类似场景提供了可扩展的解决方案。
使用java实现蒙特卡洛模拟风险预测功能
最新发布
洒家
06-10 724
巧合下看到了蒙特卡洛模拟风险预测，比较感兴趣，而网上基本上是基于Python处理，没有如何使用java来实现一个实际功能，所以有个基于java去实现实际功能的这样一个想法，这里使用SpringBoot + Vue3来实现这个功能。
《doubao-lite-32k 模型缓存机制使用指南》
lpfasd123的博客
06-05 1630
doubao-lite-32k模型的Session缓存机制专为多轮对话设计，支持最长32K Token的上下文存储。
工厂模式设计模式实现示例
标题和描述表明，我们需要探讨的知识点是“工厂模式”，这是一类在软件工程领域广泛应用的设计模式。工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。 首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值