综合案例 计算器（模板+命令+责任链）
计算器
一个简单的计算器可以分为3部分。1是校验部分，校验表达式的合法性，这一部分可以通过这责任链来依次校验；2是表达式的解析部分，将表达式中的数据和符号拆分出来；3是运算部分，这一部分直接使用之前写的命令模式的相关代码。
责任链
通过责任链将所有的步骤串起来，切步骤中的节点可以根据自己的想法进行替换，排序，十分灵活。
- 责任链抽象层：用一个模板方法定义好链条的调用流程。向子类暴露一个hand方法实现具体的处理逻辑。
package behavioralpattern.patterncase.caseone.handler;
/**
* @author tx
* @version 1.0
* @date 2024/1/16 9:26
* @description: 责任链抽象层
*
* 表达式合法校验，可以使用责任链模式 合法返回ture，
* 不合法返回false和失败的原因 在抽象层使用模板，
* 规定好流程，具体的流程细节由子类实现。
*/
public abstract class AbsHandler {
private AbsHandler handler;
public void setNext(AbsHandler handler) {
this.handler = handler;
}
// 具体的处理逻辑，交给子类来实现
protected abstract Resp hand(Resp resp);
// 启动方法
public final void start(Resp resp) {
// --清空缓存--
resp.cleanCache();
// 先执行当前的处理逻辑
resp = hand(resp);
// 判断处理结果，根据结果判断是否执行下一步
// if (!resp.ok()) {
// // 中断处理
// return;
// }
// 继续执行
if(handler!=null){
handler.start(resp);
}
}
}
- 处理的对象：定义好处理的状态，返回信息，处理的参数、处理的结果、以及中间过程可能会用到的对象、方面在链路上使用。
package behavioralpattern.patterncase.caseone.handler;
import java.util.Stack;
/**
* @author tx
* @version 1.0
* @date 2024/1/16 9:27
* @description: 处理对象
*/
public class Resp {
//是否校验通过
private boolean ok = true;
// 失败的消息
private final StringBuffer msg = new StringBuffer();
// 校验的数据
private String data;
// 中间数据缓存 数字
public Stack<String> nums = new Stack<>();
// 中间数据缓存 符号
public Stack<Character> opts = new Stack<>();
public Resp(String data) {
this.data = data;
}
// 清空缓存
public void cleanCache() {
nums.clear();
opts.clear();
}
public boolean ok() {
return ok;
}
public Resp setOk(boolean ok) {
this.ok = ok;
return this;
}
public String msg() {
return msg.toString();
}
public Resp setMsg(String msg) {
this.msg.append("\n");
this.msg.append("err:");
this.msg.append(msg);
return this;
}
public String data() {
return data;
}
public Resp setData(String data) {
this.data = data;
return this;
}
// 方便结果显示
@Override
public String toString() {
return "Resp{" +
"ok= " + ok +
", msg= \" " + msg + " \"" +
", data= \" " + data +
" \" }";
}
}
校验部分
- 校验输入的字符串是不是空串，切去除字符串中的空格，便于之后进行解析。
package behavioralpattern.patterncase.caseone.handler;
import behavioralpattern.patterncase.caseone.Utils;
/**
* @author tx
* @version 1.0
* @date 2024/1/16 9:31
* @description: 空串校验,并去除字符串中的空格
*/
public class CheckEmpty extends AbsHandler {
@Override
protected Resp hand(Resp resp) {
String s = Utils.get(resp);
// 去除所有空格
String replace = s.replace(" +", "");
// 判断是不是空串
if (replace == "") {
resp.setOk(false).setMsg("字符串为空字符串");
}
return Utils.set(resp, replace);
}
}
- 校验字符的合法性（ 应该只包含0123456789 . + - * / ( ) ）
package behavioralpattern.patterncase.caseone.handler;
import behavioralpattern.patterncase.caseone.Utils;
/**
* @author tx
* @version 1.0
* @date 2024/1/16 9:36
* @description: 校验字符的合法性,是否只包含 "0123456789 . + - * \/ ( )"
*/
public class CheckChars extends AbsHandler{
@Override
protected Resp hand(Resp resp) {
String s = Utils.get(resp);
String legal = "0123456789.+-*/()";
for (char c : s.toCharArray()) {
if (!legal.contains(String.valueOf(c))) {
resp.setMsg("字符不合法"+c).setOk(false);
}
}
return resp;
}
}
- 加减乘除符号的使用是否合法
package behavioralpattern.patterncase.caseone.handler;
import behavioralpattern.patterncase.caseone.Utils;
/**
* @author tx
* @version 1.0
* @date 2024/1/16 9:35
* @description: 符号合法性校验
*/
public class CheckOpt extends AbsHandler {
@Override
protected Resp hand(Resp resp) {
// 符号前后得有数字或是()
String s = Utils.get(resp);
for (int i = 0; i < s.length(); i++) {
char one = s.charAt(i);
if (Utils.checkOpt(one)) {
if (i > 0 && i < s.length() - 1) {
char before = s.charAt(i - 1);
char after = s.charAt(i + 1);
if(!Utils.checkNum(before) && before!=')'){
if(before!='('){
resp.setMsg("操作符之前不能 不是数字或者')':"+(i+1)).setOk(false);
}
}
if(!Utils.checkNum(after) && after!='('){
resp.setMsg("操作符之后不能 不是数字或者'(':"+(i+1)).setOk(false);
}
}
if(i==0){
if(one=='*' || one=='/'){
resp.setMsg("/ 和 * 不能在开头:"+(i+1)).setOk(false);
}
}
if(i==s.length()-1){
if(Utils.checkOpt(one)){
// 不能以符号结尾
resp.setMsg("不能以符号结尾:"+(i+1)).setOk(false);
}
}
}
}
return resp;
}
}
- 小数点的使用是否合法校验:小数点前后都得是数字
package behavioralpattern.patterncase.caseone.handler;
import behavioralpattern.patterncase.caseone.Utils;
/**
* @author tx
* @version 1.0
* @date 2024/1/16 9:40
* @description: 小数点校验
*/
public class CheckPoint extends AbsHandler{
@Override
protected Resp hand(Resp resp) {
String s = Utils.get(resp);
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if(c=='.'){
// 点的要求，前后都得是数字
if(i==0||i==s.length()-1){
resp.setOk(false).setMsg("小数点使用不符合规范:"+(i+1));
}
if(i>0&&i<s.length()-1){
char before = s.charAt(i - 1);
char after = s.charAt(i+1);
if(!Utils.checkNum(before)&&!Utils.checkNum(after)){
resp.setOk(false).setMsg("小数点使用不符合规范:"+(i+1));
}
}
}
}
return resp;
}
}
- 括号的合法性校验
package behavioralpattern.patterncase.caseone.handler;
import behavioralpattern.commandpattern.command.*;
import behavioralpattern.patterncase.caseone.Utils;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
/**
* @author tx
* @version 1.0
* @date 2024/1/16 10:00
* @description:
* 计算节点，最后一个节点
* 结合命令模式进行计算
*/
public class CalculateHandler extends AbsHandler{
private static final Map<Character, Command> commands = new HashMap<>();
static {
commands.put('+',new AddC());
commands.put('-',new SubC());
commands.put('*',new MulC());
commands.put('/',new DivC());
}
private void exec(Resp resp){
// 获取运算命令
Character opt = resp.opts.pop();
Command command = commands.get(opt);
// 获取2个数值
String towN = resp.nums.pop();
String oneN = resp.nums.pop();
// 进行运算，将结果重新放入数值列表中。
BigDecimal execute = command.execute(new BigDecimal(oneN), new BigDecimal(towN));
resp.nums.push(execute.toString());
}
@Override
protected Resp hand(Resp resp) {
// 前面的处理校验都通过了才进行计算
if(resp.ok()){
String s = Utils.get(resp);
int len = s.toCharArray().length;
// 循环获取字符,通过i和cur截取出数值
int i = 0,cur = 0;
for (; i < len; i++) {
char one = s.charAt(i);
if(Utils.checkOpt(one)||Utils.checkBracket(one)){
// 获取数值
if(i!=cur){
resp.nums.push(s.substring(cur,i));
}
// + - 单独处理，可能是正负号
if(one=='-'||one=='+'){
if(i==0||(s.charAt(i-1)=='(')){
continue;
}
}
cur = i+1;
// 遇到 ) 进行计算，遇到优先级高的，先计算
// 先判断是不是 )
if(one==')'){
if (resp.opts.peek()!='(') {
exec(resp);
}
// 弹出 (
resp.opts.pop();
} else if (Utils.checkOpt(one)) {
if (!resp.opts.isEmpty()&&
(resp.opts.peek()=='*'||resp.opts.peek()=='/')) {
exec(resp);
}
resp.opts.push(one);
}else {
resp.opts.push(one);
}
}
}
// 获取数值
if(i!=cur){
resp.nums.push(s.substring(cur,i));
}
while (!resp.opts.isEmpty()){
exec(resp);
}
resp.setData(resp.nums.peek());
}
return resp;
}
}
计算节点
- 进行表达式的解析，解析之后进行计算
package behavioralpattern.patterncase.caseone.handler;
import behavioralpattern.commandpattern.command.*;
import behavioralpattern.patterncase.caseone.Utils;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
/**
* @author tx
* @version 1.0
* @date 2024/1/16 10:00
* @description:
* 计算节点，最后一个节点
* 结合命令模式进行计算
*/
public class CalculateHandler extends AbsHandler{
private static final Map<Character, Command> commands = new HashMap<>();
static {
commands.put('+',new AddC());
commands.put('-',new SubC());
commands.put('*',new MulC());
commands.put('/',new DivC());
}
private void exec(Resp resp){
// 获取运算命令
Character opt = resp.opts.pop();
Command command = commands.get(opt);
// 获取2个数值
String towN = resp.nums.pop();
String oneN = resp.nums.pop();
// 进行运算，将结果重新放入数值列表中。
BigDecimal execute = command.execute(new BigDecimal(oneN), new BigDecimal(towN));
resp.nums.push(execute.toString());
}
@Override
protected Resp hand(Resp resp) {
// 前面的处理校验都通过了才进行计算
if(resp.ok()){
String s = Utils.get(resp);
int len = s.toCharArray().length;
// 循环获取字符,通过i和cur截取出数值
for (int i = 0,cur = 0; i < len; i++) {
char one = s.charAt(i);
if(Utils.checkOpt(one)||Utils.checkBracket(one)){
// 获取数值
if(i!=cur){
resp.nums.push(s.substring(cur,i));
}
cur = i+1;
// 遇到 ) 进行计算，遇到优先级高的，先计算
// 先判断是不是 )
if(one==')'){
if (resp.opts.peek()!='(') {
exec(resp);
}
// 弹出 (
resp.opts.pop();
} else if (Utils.checkOpt(one)) {
if (!resp.opts.isEmpty()&&
(resp.opts.peek()=='*'||resp.opts.peek()=='/')) {
exec(resp);
}
resp.opts.push(one);
}else {
resp.opts.push(one);
}
}
}
while (!resp.opts.isEmpty()){
exec(resp);
}
resp.setData(resp.nums.peek());
}
return resp;
}
}
模板
定义一个模板，留一个接口供子类选择和组合使用那些节点，定义模板方法获取运行结果。
- 抽象层
package behavioralpattern.patterncase.caseone.handlerconf;
import behavioralpattern.commandpattern.command.*;
import behavioralpattern.patterncase.caseone.handler.AbsHandler;
import behavioralpattern.patterncase.caseone.handler.Resp;
import java.util.HashMap;
import java.util.Map;
/**
* @author tx
* @version 1.0
* @date 2024/1/16 9:45
* @description:
* 计算器模板的抽象层
*/
public abstract class AbsCalculatorTemplate {
// 聚合处理校验责任链
private AbsHandler absHandler;
public AbsCalculatorTemplate() {
this.absHandler = setHandler();
}
// 留个接口给子类配置
protected abstract AbsHandler setHandler();
// 进行运算获取结果
public final String execute(Resp r){
absHandler.start(r);
System.out.println(r);
if (r.ok()){
return r.data();
}
return r.msg();
}
}
- 子类
package behavioralpattern.patterncase.caseone.handlerconf;
import behavioralpattern.patterncase.caseone.handler.*;
/**
* @author tx
* @version 1.0
* @date 2024/1/16 10:30
* @description:
* 计算器本体
*/
public class Calculator extends AbsCalculatorTemplate{
@Override
protected AbsHandler setHandler() {
// 构造责任链,返回给父类使用
// 校验是否为空串，并去除其中的空格
AbsHandler checkEmpty = new CheckEmpty();
// 校验字符是否合法
AbsHandler checkChars = new CheckChars();
// 校验符号使用是否合法
AbsHandler checkOpt = new CheckOpt();
// 校验小数点使用是否合法
AbsHandler checkPoint = new CheckPoint();
// 校验括号使用是否合法
AbsHandler checkBracket = new CheckBracket();
// 计算节点
AbsHandler calculateHandler = new CalculateHandler();
// 串起来
checkEmpty.setNext(checkChars);
checkChars.setNext(checkOpt);
checkOpt.setNext(checkPoint);
checkPoint.setNext(checkBracket);
checkBracket.setNext(calculateHandler);
return checkEmpty;
}
}
客户端
package behavioralpattern.patterncase.caseone;
import behavioralpattern.patterncase.caseone.handler.*;
import behavioralpattern.patterncase.caseone.handlerconf.AbsCalculatorTemplate;
import behavioralpattern.patterncase.caseone.handlerconf.Calculator;
/**
* @author tx
* @version 1.0
* @date 2024/1/16 9:16
* @description:
* 综合示例 命令模式+模板模式+责任链模式
*/
public class CaseOne {
public static void main(String[] args) {
// 构造参数对象
// 表达式
String expression = "(1+1.5)*(2*(5-1)/2)*(1)";
//括号不匹配
Resp stringResp = new Resp(expression);
// 创建一个计算器
AbsCalculatorTemplate calculator = new Calculator();
String execute = calculator.execute(stringResp);
}
}
详细代码见gitee