项目背景：

首先这篇文章是总结了OJ项目和AI答题平台项目（和一点点的聚合搜索项目）中设计模式的文章

在项目中也用了很多次的设计模式，我感觉起来，这些设计模式的作用就是提高项目的扩展性和降低耦合性

工厂模式：

设计模式（工厂模式，模板方法模式，单例模式）_工厂方法模式与模板方法模式-CSDN博客

关于工厂模式的介绍，贴一篇文章，里面有跑一些demo

OJ项目工厂模式

直接开始对OJ项目开始记录：

首先我们这里有一个沙箱的接口，并且三个实现类

分别对应

实例代码沙箱（纯属给自己测试用的）

远程调用代码沙箱（项目的核心流程）

第三方代码沙箱（可接入第三方的代码沙箱）

这三个沙箱都需要去实现这个沙箱接口。

接着我们循序渐进，我们看第一版的调用沙箱的代码：

这里先粘贴一张自己的工厂模式的文章中的一张图片

对应到OJ项目中

/*** 第一版代码* 最朴实无华的自己去创建对应沙箱的实体类*/public static void firstCode(String[] args) {CodeSandBox codeSandBox = new RemoteCodeSandBox();ExecuteCodeRequest executeCodeRequest = ExecuteCodeRequest.builder().code("System.out.println(\"hello world\");").language("java").inputList(new ArrayList<>()).build();ExecuteResponse executeResponse = codeSandBox.executeCode(executeCodeRequest);System.out.println(executeResponse);}

 看到代码中我们自己想要什么沙箱，就自己去new

这样肯定很麻烦嘛，所以我们进行优化：

根据这个demo所说，我们只需要关系我们需要什么类型，往里传一个type即可

这个工厂就会自动帮我们把这个对象new出来，给我们，我们只需要用每个产品都是实现的接口来接收。

@Value("${codeSandBox.type:example}")
private String type;
/***  第二版代码* 使用工厂模式，根据语言创建对应的沙箱实体类* 这里其实还用了一个注册器模式（单例模式）在Bean对象创建之后将对应的实体类加入到map中，直接调用* 第三版代码* 参数配置化，将这个type配置到yml文件中，使用者直接修改即可* @Value 注解不能用于 static 字段*/public void ThirdCode() {Map<String, CodeSandBox> codeSandboxMap = new HashMap<>();codeSandboxMap.put("example",new ExampleCodeSandBox());codeSandboxMap.put("remote",new RemoteCodeSandBox());codeSandboxMap.put("thirdParty",new ThirdPartyCodeSandBox());System.out.println(type);CodeSandBox codeSandBox = codeSandboxMap.get(type);ExecuteCodeRequest executeCodeRequest = ExecuteCodeRequest.builder().code("System.out.println(\"hello world\");").language("java").inputList(new ArrayList<>()).build();ExecuteResponse executeResponse = codeSandBox.executeCode(executeCodeRequest);System.out.println(executeResponse);}

这里有注意点：

将这个type可以配置到yml文件中，这也是让别人更好调用我们这个开源项目的小技巧

代码中还缓存了一个map，这一段可以放到一个类中，在Bean对象都加载之后再缓存

这个在聚合搜索文章有讲聚合平台项目优化（门面模式，适配器模式，注册器模式）_聚合平台适配器-CSDN博客 

通过上面的操作，我们就可以不用自己去new对应的沙箱对象了

只需要关心我们的type就行。

代理模式：

这里OJ项目还用到了一个代理模式对调用代码沙箱这个逻辑进行增强

在调用之前和调用之后都打上了日志

这里的这个代理模式很好理解：就是和AOP一起理解即可

具体代码实现：

代理类：

/*** 代码沙箱代理* 这里的代理听起来很复杂,实现起来就是写一个类.* 调用代码沙箱的用户不需要自己去手动打日志,只需要去调用这个代理类即可* 代理类会自动打日志* 说到代理类,就经典的案例就是房屋中介,房屋中介就是代理类,租房子的人不需要自己去找房子,只需要去找中介即可*/
@Slf4j
@AllArgsConstructor
@NoArgsConstructor
public class CodeSandBoxProxy implements CodeSandBox {private CodeSandBox codeSandBox;@Overridepublic ExecuteResponse executeCode(ExecuteCodeRequest executeCodeRequest) {log.info("代码沙箱执行前");ExecuteResponse executeResponse = codeSandBox.executeCode(executeCodeRequest);log.info("代码沙箱执行后");return executeResponse;}
}

工厂类：

@Component
public class CodeSandFactory {private Map<String, CodeSandBox> codeSandboxMap = new HashMap<>();@PostConstructprivate void init() {codeSandboxMap.put("example",new ExampleCodeSandBox());codeSandboxMap.put("remote",new RemoteCodeSandBox());codeSandboxMap.put("thirdParty",new ThirdPartyCodeSandBox());}public CodeSandBox getCodeSandBox(String type) {return codeSandboxMap.get(type);}
}

 这里就把每个沙箱缓存到一个map中

 具体调用代码：

/***  第四版代码*  利用代理模式对调用沙箱功能进行优化*  调用前和调用后自动打上日志*/@Testvoid ForthCode() {CodeSandBox codeSandBox = codeSandFactory.getCodeSandBox(type);System.out.println(type);CodeSandBoxProxy codeSandBoxProxy = new CodeSandBoxProxy(codeSandBox);ExecuteCodeRequest executeCodeRequest = ExecuteCodeRequest.builder().code("System.out.println(\"hello world\");").language("java").inputList(new ArrayList<>()).build();ExecuteResponse executeResponse = codeSandBoxProxy.executeCode(executeCodeRequest);System.out.println(executeResponse);}

AI答题平台项目工厂模式

这里的代码逻辑就会更复杂一点。可以将这里的一个一个策略类看成一个个对象，你只需要传app进来，我就读取你的app中的两个字段，就可以判断出你给你这个app判题的是那种评分策略（AI评分，自定义评分，得分评分）

这里代码复杂得原因就是涉及到了Java中的注解和反射的使用

首先还是定义一个策略接口：

public interface ScoringStrategy {public UserAnswer doScoring(List<String> choices, App app);
}

后面的三个策略都需要去实现这个接口 

定义注解类：

这段代码定义了一个名为 ScoringStrategyConfig 的 Java 注解（Annotation）。注解是一种元数据，用于为代码元素（如类、方法、变量等）提供额外的信息。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface ScoringStrategyConfig {/*** 应用类型* @return*/int appType();/*** 评分策略* @return*/int scoringStrategy();
}

这个注解上还有两个注解：

 @Target(ElementType.TYPE)：指定这个注解的作用域：类，接口和枚举
@Retention(RetentionPolicy.RUNTIME) 指定了注解在运行时可用，

在自己的每个策略上加入注解，并指定应用类型和评分策略 

 工厂类实现：

@Service
public class ScoringStrategyExecutor {@Resourceprivate List<ScoringStrategy> strategies;public UserAnswer doScore(List<String> choices, App app) {final Integer appType = app.getAppType();final AppTypeEnum enumByValue = AppTypeEnum.getEnumByValue(appType);ThrowUtils.throwIf((enumByValue == null||appType==null), ErrorCode.PARAMS_ERROR,"appType参数错误");for (ScoringStrategy strategy : strategies) {if(strategy.getClass().isAnnotationPresent(ScoringStrategyConfig.class)){ScoringStrategyConfig annotation = strategy.getClass().getAnnotation(ScoringStrategyConfig.class);if(annotation.appType()==app.getAppType()&&annotation.scoringStrategy()==app.getScoringStrategy())return strategy.doScoring(choices,app);}}throw new BusinessException(ErrorCode.SYSTEM_ERROR, "应用配置有误，未找到匹配的策略");}
}

代码逻辑分析：

    @Resourceprivate List<ScoringStrategy> strategies;

在你的代码中，你使用了 @Resource 注解来注入 List<ScoringStrategy>。这个注解会自动扫描并注入所有实现了 ScoringStrategy 接口的 Bean。这意味着，只要你的 Spring 容器中存在实现了 ScoringStrategy 接口的 Bean，它们就会被自动注入到 strategies 列表中。

接着就是对传进来的app的内容进行判断

随后遍历这个 strategies 列表

if(strategy.getClass().isAnnotationPresent(ScoringStrategyConfig.class)){

这行代码检查当前策略类是否包含ScoringStrategyConfig注解。isAnnotationPresent方法用于判断某个类是否被指定注解修饰

判断你这个类是有这个注解的：

获取注解并检查条件：

ScoringStrategyConfig annotation = strategy.getClass().getAnnotation(ScoringStrategyConfig.class);
if(annotation.appType()==app.getAppType()&&annotation.scoringStrategy()==app.getScoringStrategy())

如果策略类包含ScoringStrategyConfig注解，代码会获取该注解的实例，并检查注解中的appType和scoringStrategy属性是否与当前应用app的类型和评分策略匹配。

最后就是执行这个具体的评分策略

return strategy.doScoring(choices, app);

小思考小总结

工厂模式就是简化你创建对象的这个过程

你不想自己去new对象，你就搞个“工厂”，让这个工厂给你new对象

你只需要传值，你要说清楚你想要什么样的对象

那工厂怎么根据你传的值来new对应的对象呢？

最简单的办法就是在工厂类中写switch或者if-else

OJ项目就是用了一个注册器的设计模式，将所有沙箱对象缓存到map中

AI答题平台呢就是用了注解+放射的方式，在策略对象上＋注解，最后遍历列表返回对应的策略对象

工厂模式和这个门面模式之间的一些思考

我在整理笔记的时候，感觉都是从前端传一个type，或者什么值巴拉巴拉的

然后简化过程

后面问了GPT，我的理解其实差不会特别大

工厂模式更注重对象的创建，你传我一个值，我还你一个对象

但是门面模式呢，更注重接口或者系统的调用，在聚合搜索中，我有三个接口，分别调用文章，用户，图片。

我前端传个参数，我后端就对应去调那个接口。

策略模式：

策略模式就是用来解决很多if else分支的问题

但是策略模式通常是要搭配一些其它东西才能比较好的使用

OJ项目策略模式应用：

为什么在OJ项目中要用策略模式：

我们知道，每个语言做相同的题目的耗时和空间都不一样，如果不指定的话，那对Java非常不公平

首先也是不变先来个策略接口：每种策略都需要实现这个接口

/*** 判题策略接口*/
public interface JudgeStrategy {JudgeInfo doJudge(JudgeContext judgeContext);}

下面只写了两个策略：默认编程语言策略和Java编程语言策略：

这里还有一个JudgeContext上下文这个类，用来(用于定义在策略中传递的参数)

package com.ljh.oj.judge.strategy;import com.ljh.oj.judge.model.JudgeInfo;
import com.ljh.oj.model.entity.Question;
import com.ljh.oj.model.entity.QuestionSubmit;
import lombok.Builder;
import lombok.Data;import java.util.List;/*** 上下文(用于定义在策略中传递的参数)*/
@Data
@Builder
public class JudgeContext {/*** 这个是调用代码沙箱之后所返回的判题结果的信息*/private JudgeInfo judgeInfo;/*** 调用代码沙箱之后所返回的输出列表*/private List<String> outputList;/*** 题目信息*/private Question question;/*** 用户提交信息* 主要作用就是获取当前提交的语言给JudgeManager使用*/private QuestionSubmit questionSubmit;
}

下面问题就来了：

我们定义好了策略，我们怎么来调用哪一种策略嘞？

首先我们要肯定知道从这个QuestionSubmit中来获取对应用户提交的语言

我们上面总结过：

注解啊，缓存一个map，或者在工厂类中写if-else

我们这里就采用if-else，另外两种方式都用过了

/*** 判题模块简化封装* 对doJudge方法进行更上一层封装*/
@Service
public class JudgeManager {public JudgeInfo doJudge(JudgeContext judgeContext){String language = judgeContext.getQuestionSubmit().getLanguage();JudgeStrategy judgeStrategy = new DefaultJudgeStrategy();if(QuestionSubmitLanguageEnum.JAVA.getValue().equals(language)){judgeStrategy = new JavaLanguageJudgeStrategy();}return judgeStrategy.doJudge(judgeContext);}
}

这样就比较简单，只要在这个JudgeManager中添加代码即可

AI项目策略模式应用：

已经在上面都已经讲差不多了。