二、游戏工厂的设计
ONEGAME游戏公司计划开发一条游戏生产线，该生产线可以向玩家提供不同类型的游戏，例如：RGP游戏、MMORGP游戏、MOBA游戏以及FPS游戏等。为了提供这些游戏，游戏公司需要创建一个游戏工厂，来创建这些游戏的实例。
ONEGAME游戏公司提出了初始设计方案，就是将所有类型的游戏的实现代码封装到一个Game类中，然后通过Game工厂来创建实例。实现代码如下：
class Game{
private type: string;//游戏类别
constructor(type: string, data: any) {
this.type = type;
if(type.toLocaleLowerCase() === 'fps'){
// 初始化FPS游戏
}else if(type.toLocaleLowerCase() === 'rpg'){
// 初始化RPG游戏
}else if(type.toLocaleLowerCase() === 'moba'){
// 初始化MOBA游戏
}
}
play(){
if(this.type.toLocaleLowerCase() === 'fps'){
// 玩FPS游戏
}else if(this.type.toLocaleLowerCase() === 'rpg'){
// 玩RPG游戏
}else if(this.type.toLocaleLowerCase() === 'moba'){
// 玩MOBA游戏
}
}
}上面的代码实现了游戏的创建和玩游戏的功能，但是这样的设计存在以下问题：
- Game类的代码会越来越臃肿，而且违反了单一职责原则，不利于代码的维护和扩展。
- 在需要对Game类进行扩展新游戏的时候，需要对源码进行修改，这就违反了开闭原则。
- 用户只能通过new关键字来直接创建实例，而不是通过Game工厂来创建实例，耦合性高，对象创建和使用无法分离。
为了解决上面的问题，我们可以对Game类进行重构，将其拆分成多个游戏类，每个游戏类只负责自己的初始化和玩游戏的功能，这样就可以避免代码臃肿和违反单一职责原则的问题。但是这样做还是无法解决对象创建和使用无法分离的问题，我们可以通过简单工厂模式来解决这个问题。
三、简单工厂模式
简单工厂的设计思想就是，将创建不同对象的相关的代码封装到不同的类中，即具体产品类，这样就可以避免代码的臃肿和违反单一职责原则的问题。将它们的公共代码抽象到和封装到一个抽象产品类中，每个具体类都是抽象产品类的子类。然后通过一个工厂类来创建这些具体产品类的实例，通过传入的参数不同创建对应的具体产品对象。
什么是简单工厂模式
简单工厂模式：定义一个工厂类，通过传入参数来创建不同的具体产品类的实例，被创建的实例都具有共同的父类。
简单工厂模式结构包括三个角色：
- 工厂类：创建具体产品类的实例的工厂类，负责实现创建具体产品实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
- 抽象产品类：创建具体产品类的实例的抽象产品类，它是需要工厂类所创建的所有具体产品类的公共父类，封装了各种产品对象的公有方法。
- 具体产品类：具体产品类的实例，是简单工厂模式的创建目标，它继承抽象产品类的公共父类，所有被创建的对象都是这个产品对应的具体产品类的实例。
使用简单工厂模式优化上面的代码，以实现一个游戏工厂为为例，实现可以生产不同类型的游戏为目的。首先定义一个抽象产品类Game，然后定义具体产品类FPSGame、RPGGame、MOBAGame，最后定义一个工厂类GameFactory，通过传入不同的参数来创建不同的游戏实例。
// 游戏接口：抽象产品类
interface Game {
play(): void;
}
// 各种游戏的具体实现类：具体产品类
// FPS游戏
class FPSGame implements Game{
play() {
console.log('FPS游戏');
}
}
// RPG游戏
class RPGGame implements Game {
play() {
console.log('RPG游戏');
}
}
// MOBA游戏
class MOBAGame implements Game {
play() {
console.log('MOBA游戏');
}
}
// 游戏工厂：创建具体产品类的实例的工厂类
class GameFactory {
static createGame(type: string): Game {
this.type = type;
switch (this.type) {
case 'RPG':
return new RPGGame();
case 'MOBA':
return new MOBAGame();
case 'FPS':
return new FPSGame();
default:
throw new Error('Unknown game type');
}
}
}用户实际使用创建对应的游戏：
// 获取RGP游戏
const rgpGame = GameFactory.createGame('RPG');
rgpGame.play();
// 获取MOBA游戏
const mobaGame = GameFactory.createGame('MOBA');
mobaGame.play();在实际使用中，客户端代码只需要传入类型参数，就可以获取得到对应的游戏对象，而不需要关系对象的具体实现。这就符合简单工厂模式的设计思想。
简单工厂模式的优点
- 封装实例化过程：简单工厂模式在一个工厂类中封装了实例化对象的过程，创建对象的细节被隐藏在工厂类中，外界无需关心对象是如何被创建出来的。
- 定义统一接口：工厂类所创建的对象都实现了一个共同的接口，对外提供一致的使用方式。
- 通过参数创建不同实例：客户端只需要传入不同的参数给工厂类，就可以获取不同的对象实例，而不需要知道具体类名。
- 实现解耦：简单工厂模式实现了客户端与产品类的解耦，客户端不需要知道所创建对象的具体实现，只需要知道参数即可。
- 优化开闭原则：当需要新增一个产品类时，只需要实现统一接口，然后在工厂类中添加对应类型即可，无需修改客户端代码。
- 高内聚，低耦合：每个产品类只关心自己的功能实现，不关心实例化过程;客户端不依赖具体类。使代码内聚性高、耦合度低。
四、简单工厂模式的优化
使用泛型优化工厂类
在上面的实现中，工厂类的创建方法返回的是Game接口类型，缺点是客户端得到的对象类型信息不全，对此可以使用泛型来改进：
// 游戏接口：抽象产品类
interface Game {
play(): void;
}
class FPSGame implements Game {
//...
}
class RPGGame implements Game {
//...
}
class MOBAGame implements Game {
//...
}
class GameFactory{
static createGame(type: string): T{
//...
}
} 这样在客户端代码得到的对象类型信息更加准确。
const rgpGame = GameFactory.createGame('RPG');
// rgpGame的类型是RPGGame，而不是Game 使用泛型优化工厂类的优化
上面的代码中，所有的产品类都需要实现 Game 接口，这样会存在代码重复的问题。我们可以引入一个泛型接口 IGame来改进：
interface IGame {
play(): void;
info(): T;
}
class RPGGame implements IGame {
play() {
// ...
}
info() {
return 'RPG';
}
}
class MOBAGame implements IGame {
play() {
// ...
}
info() {
return 'MOBA';
}
}
class FPSGame implements IGame {
// ...
} 这样每个产品类就可以定制自己的 info 方法返回值类型了。
使用抽象类改进产品类
上面的代码还存在问题：所有产品类都需要实现 play 方法，这会导致重复代码。我们可以使用抽象类来解决这个问题：
abstract class GameBase {
play() {
// 默认游戏逻辑
}
}
class RPGGame extends GameBase implements IGame {
info() {
return 'RPG';
}
}
class MOBAGame extends GameBase implements IGame {
// ...
}
class FPSGame extends GameBase implements IGame {
// ...
} 这样产品类就不需要重复实现 play 方法了，只需要继承 GameBase 并实现 info 方法即可。
使用配置文件创建工厂类
上面的代码中，工厂类的创建方法需要传入一个类型参数，这样会导致客户端代码需要知道具体的类型参数，这样就会破坏简单工厂模式的封装性。我们可以使用配置文件来解决这个问题：
class GameConfig {
static gameTypes = {
'RPG': RPG,
'MOBA': MOBA,
'FPS': FPS
}
}工厂类读取配置创建对象：
class GameFactory {
static createGame(type: string) {
const Constructor = GameConfig.gameTypes[type];
if (!Constructor) {
throw new Error('Unknown type');
}
return new Constructor();
}
}这样当需要新增游戏类型时，只需要在配置类中添加新的类型和类即可，工厂类的代码无需修改。
利用依赖注入实现解耦
我们还可以通过依赖注入进一步解耦:
@injectable()
class GameFactory {
constructor(
@inject(GameConfig.gameTypes.RPG) private rpgGame: Game,
@inject(GameConfig.gameTypes.MOBA) private mobaGame: Game,
@inject(GameConfig.gameTypes.FPS) private fpsGame: Game
) {}
createGame(type: string) {
switch(type) {
// ...
}
}
}这样工厂类不再负责创建对象，而是通过注入的方式获取对象实例，大大提升了灵活性。
五、完整代码示例
下面是使用 TypeScript 深入解析简单工厂模式的示例，通过工厂类和产品类的抽象与解耦，可以实现创建对象逻辑的集中和优化，提高代码的灵活性和扩展性。TypeScript 通过接口、泛型和抽象类等特性增强了简单工厂模式的实现。掌握设计模式对编写优雅可扩展的 TypeScript 代码很有帮助。
// 游戏接口
interface Game {
play(): void;
}
// 泛型游戏接口
interface IGame {
play(): void;
info(): T;
}
// 抽象游戏类
abstract class GameBase {
play() {
console.log('Playing game...');
}
}
// RPG游戏类
class RPG extends GameBase implements IGame {
info() {
return 'RPG';
}
}
// MMORPG游戏类
class MMORPG extends GameBase implements IGame {
info() {
return 'MMORPG';
}
}
// FPS游戏类
class FPS extends GameBase implements IGame {
info() {
return 'FPS';
}
}
// 配置类
class GameConfig {
static gameTypes = {
'RPG': RPG,
'MMORPG': MMORPG,
'FPS': FPS
}
}
// 工厂类
class GameFactory {
static createGame(type: string) {
const Constructor = GameConfig.gameTypes[type];
if (!Constructor) {
throw new Error('Unknown type');
}
return new Constructor();
}
}
// 客户端
const rpgGame = GameFactory.createGame('RPG');
rpgGame.play();
console.log(rpgGame.info());
const fpsGame = GameFactory.createGame('FPS');
fpsGame.play();
console.log(fpsGame.info()); 六、简单工厂模式和单例模式的区别
1. 用途不同
简单工厂模式是一种创建对象的设计模式，它通过工厂类来创建产品对象，主要目的是将对象创建的过程封装起来，便于管理和维护。
而单例模式是一种确保某个类只有一个实例的设计模式，它的目的是在整个软件系统中，对某个类只创建一个对象实例，避免浪费资源。
2. 实现方式不同
简单工厂模式是通过工厂类的静态方法创建对象实例，可以创建多个实例。
单例模式是在类中定义一个静态变量保存单例实例，并通过一个静态方法来获取这个实例，确保只创建一个实例。
3. 使用场景不同
简单工厂模式用于创建同一类产品的不同对象实例，客户端无需知道具体产品类的类名。
单例模式用于创建对唯一实例有需求的对象，如线程池、缓存、日志对象等。
小结一下，简单工厂模式关注创建不同实例，单例模式关注如何只创建一个实例。二者解决的问题和应用场景不同，但可以结合使用，工厂类可以返回单例对象。
七、总结
通过上面的示例，我们使用 TypeScript 从多个方面对简单工厂模式进行了深入解析，包括:
- 使用泛型优化工厂方法的返回类型
- 使用泛型接口减少产品类代码重复
- 使用抽象类提取产品类公共代码
- 使用配置文件动态创建产品类实例
简单工厂模式的优点:
- 将对象创建的过程封装在工厂类中，实现了解耦
- 客户端无须知道所创建具体产品类的类名
- 可以方便地扩展新的具体产品类
简单工厂模式的缺点:
- 工厂类职责较重，所有产品创建逻辑都集中在工厂类
- 如果产品类型较多，工厂类会变得很复杂
- 扩展新的产品困难，需要修改工厂类代码
简单工厂模式通过工厂类和产品类的解耦，可以实现创建对象逻辑的集中化和优化，是非常常用和灵活的一种设计模式。TypeScript 通过接口、泛型和抽象类等特性，可以更优雅地实现简单工厂模式，提高代码的复用性和扩展性。
