关闭

应用 Command 模式进行流水号管理的最佳实践

396人阅读 评论(0) 收藏 举报
分类:

本文介绍了一种基于自定义格式字符串, 应用 Command 模式的流水号管理功能,可以让用户灵活设定流水号的格式,具备非常好的灵活性和可扩展性。

摘要

流水号管理作为很多信息系统的一种基础功能,对于一些具有业务含义的流水号,一般由多个具有不同意义的组成部分组成,其格式会相对比较复杂,如何快速灵活的支持不同的流水号格式,十分有现实意义。本文介绍了一种基于自定义格式字符串,应用 Command 模式的流水号管理方案。在本方案中,对复杂的的流水号进行分析分解,拆分为更细小的子序列,再分别调用相应的生成接口生成,最终生成的流水号。使用本方案,流水号的生成规则定义在格式字符串中,如要生成不同格式的流水号,只需要修改格式字符串即可,生成和扩展都十分方便。

---------------------------------------------------------------------------------------------------------------------------------------------------

背景

在信息系统中流水号作为一项必不可少的基础功能,流水号的生成、控制和管理十分重要。一般一个信息系统中,不同的流水号序列有不同的生成规则。如果我们对这些流水号进行进一步分析,这些不同的流水号序列又可细分为多个规则固定的子序列。基于这种分析,对于这种实际应用需求,如何来高效灵活的生成所需的流水号,就显得十分有意义。

---------------------------------------------------------------------------------------------------------------------------------------------------

场景分析

首先看几个我们身边常见的流水号:身份证号、税务票、银行的业务流水号、排队号、国务院办公厅发文号(国办发〔2011〕48 号)等。如果对这些流水号进一步分析,我们可以得出,流水号一般由多个规则固定的子序列组成,常见的子序列规则如下:

  • 1. 数字序列:1,2,3 … 或者 00001,00002,00003
  • 2. 字母序列:如 ‘A-Z’
  • 3. 固定字符串:如固定的字符前缀或后缀
  • 4. 时间戳:如 yyyyMMdd 格式对应的为 20130201
  • 5. 其他序列:如罗马字符 ‘I-X’

从另一个角度我们可以说,一个流水号就是上面子序列的排列组合。

基于这样的分析,我们可以创建一个流水号生成引擎,这个引擎可以读取和解析给定的流水号规则,将流水号规则拆分成多个子序列规则,并根据子序列规则生成子序列串,拼接返回最终的流水号。有了这个流水号生成引擎,在系统实际应用的时候,只需要对所需的流水号配置相应的生成规则即可。并且本方案还预留扩展接口,如果实际中遇到个性化的序列生成规则,开发者也可以根据实际需要进行扩展开发,这样也能有效覆盖个性化的需求。

说了这么多,不如图形展示来得直观,整个解决方案的流程见下图:

图 1. 流水号生成流程图
图 1. 流水号生成流程图
  • 1. 流水号规则读取
  • 2. 流水号规则解析、分割、获取子序列规则
  • 3. 生成子序列任务的派发
  • 4. 子序列汇总和合并
  • 5. 返回最终的生成流水号实例
图 2. 流水号生成过程实例
图 2. 流水号生成过程实例

在上图中,这里需要说明如下几点:

  • 1. 流水号规则用格式字符串表示为:Str@ 国办发〔# DateTime@yyyy # Str@〕# NumSeq@0C0 # Str@ 号,其中: “#” 为子序列间的分隔符,“@” 为子序列内部的分隔符。当然实际应用时,读者也可以按照自己的规则创建格式字符串。
  • 2. 在每个子序列规则定义的内部,用 “@” 分为两部分,前面一部分(Str/DateTime/NumSeq)表明该子序列的类型,用于确定调用哪个类型的 Generator 来生成该子序列串,后面一部分是用于生成子序列串所需的信息。举例来讲,如 “Str@ 国办发〔”,“Str” 表示为固定字符串类型,固定字符串为 “国办发〔”;类似的 “DateTime@yyyy”,“DateTime” 表示时间日期类型,格式为四位的年代号,根据当前时间生成。
  • 3. 在各个 Generator 生成完毕之后,自动拼接并返回最终生成的流水号。

我们可以认为,对于每一个流水号生成规则,似乎可以看做是一个命令队列;对于流水号生成引擎,一方面按照顺序接收生成子序列规则的命令,逐个读取并解析子序列规则,再根据类型分发给各个 Generator 来生成子序列传,最后合并返回最终需要的流水号;每个子序列的 Generator,即为最终的命令的执行者。

经过如上的分析并结合应用场景,我们很容易想到,可以使用 Command 模式来实现。Command 模式,一个典型的应用场景就是处理命令队列,减少行为请求者和动作执行者的耦合,提高灵活性和降低代码冗余。

Command 模式简介

命令(Command)模式属于对象的行为模式【GOF95】。命令模式又称为行动(Action)模式或事务(Transaction)模式。命令模式把一个请求或者操作封装到一个对象中。命令模式允许系统使用不同的请求把客户端参数化,对请求排队或者记录请求日志,可以提供命令的撤销和恢复功能。

适用性:在软件系统中,行为请求者与行为实现者之间通常呈现一种紧耦合的关系。但在某些场合,比如要对行为进行记录撤销重做事务等处理,这种无法抵御变化的紧耦合是不合适的。这种情况下,使用 command 模式将行为请求者与行为实现者进行解耦。

说到这里,我们来看看 Command 模式 UML 类图。

图 3. Command 模式的 UML 类图
图 3. Command 模式的 UML 类图

这里对上图做一个简单的解释,命令模式涉及到五个角色,分别为:

客户(Client)角色:创建一个具体命令(ConcreteCommand)对象,并设置命令的接收者。

命令(Command)角色:定义一个给所有命令类的抽象接口,定义了统一的 execute() 接口方法。

具体命令(ConcreteCommand)角色:定义一个接受者和行为之间的弱耦合;实现 Command 接口,并实现 execute() 方法,负责调用接收者的相应操作。

请求者(Invoker)角色:负责调用由 Client 下达的对象执行请求。

接收者(Receiver)角色:负责具体实施和执行一个请求。任何一个类都可以成为接收者,实施和执行请求的方法为行动方法。

【注意】:在某些简单业务场景下,可在 ConcreteCommand 类的 execute 方法中直接编写实现代码,而省去接收者(Receiver)类以简化代码。如在本应用场景中省去 Receiver 类的创建。

在本应用场景中,正是利用了 Command 模式将行为请求者与行为实现者进行解耦,用于处理命令队列,实现了原子操作上的复用。Command 是对行为进行封装的典型模式,这样做有利于代码的健壮性,可维护性,还有复用性。

实现代码

对应 Command 模式,简单介绍一下本方案中使用到的核心的类和方法:

  • 1. Client - SNGenerateApp.java:

具体的命令请求者,通过调用 addBuildInGenerator() 方法创建内置 generator,暴露 addGenerator() 方法供进一步扩展

  • 2. Invoker - SNGeneratorEngine.java:

为命令的直接接收者和分派者。

  • 3. ICommand - IGenerator.java:

定义生成接口,子类通过实现 generate() 方法来生成具体的子序列串。

  • 4. ConcreteCommand - XXXXGenerator.java:

各个具体的子序列生成类,实现 generate() 方法,负责最终的的子序列生成,为 Command 的最终执行者。这里简单实现了四个 generator。

  • a). 字符序列生成器:CharacterSequenceGenerator.java
  • b). 日期时间生成器:DateTimeGenerator.java
  • c). 数字序列生成器:NumberSequenceGenerator.java
  • d). 固定字符串生成器:StringGenerator.java
  • 5. Receiver

在本例中由于业务场景简单,为简化代码而直接将实现代码写在各 Generator 的 generate() 方法中,无独立的 Receiver 类。

另外还有两个辅助类简单提一下,MockDB.java 用于模拟数据库,存取自增序列;ParamConsts.java 为常量变量类,GeneratorTypeSet.java 定义子序列类型常量。

图 4. 包结构及类清单图
图 4. 包结构及类清单图

下面是具体的代码展示和介绍。

Generator 接口

定义 Generator,这里只有两个方法,一个是 getGeneratorType() 用于返回 Generator 类型,另一个是 generate() 方法用于生成子序列串。

清单 1. Generator 接口
public interface IGenerator {
	/**
	 * 获取子序列类型
	 * @return
	 */
	public String getGeneratorType();
	/**
	 * 生成子序列串
	 * @param formatStr
	 * @return
	 */
	public String generate(String formatStr,Map paraMap);
}

数字序列 Generator

Generator 接口的实现类,用于处理数字序列的生成。下面的代码考虑到变长字符串和定长字符串两种不同情形。在实际中,序列号的生成还需要考虑按照一定的周期重置的情况(如每年都从 1 重新开始计数),可以在扩展实现的时候加以考虑。

清单 2. 数字序列 Generator
public class NumberSequenceGenerator implements IGenerator{
	private static final String type = GeneratorTypeSet.NUMBER_SEQUENCE;
	private String splitC = "C";
	@Override
	public String getGeneratorType() {
		// TODO Auto-generated method stub
		return type;
	}
	@Override
	public String generate(String formatStr,Map paraMap) {
		String seqId = (String)paraMap.get(ParamConsts.PARAM_SEQ_ID);
		//从数据库中获取当前数值,并自动加 1
		int seqNum = MockDB.getSeqNumAndIncrease(seqId);		
		String[] charArray = formatStr.split(splitC);
		int seqNumLength = Integer.parseInt(charArray[0]);
		char prefixChar = charArray[1].charAt(0);
		if(seqNumLength == 0)
			return String.valueOf(seqNum);
		else
			return appendPrefixChar(seqNum,seqNumLength,prefixChar);
	}
	/**
	 * 补足前缀以保证序列定长,如 0001, 保持 4 位,不足 4 位用'0'补齐
	 * @param seqNum 当前数值
	 * @param seqNumLength 需要返回的字符串长度
	 * @param prefixChar 用于补齐的前置字符串
	 * @return
	 */
	private String appendPrefixChar(int seqNum,int seqNumLength,char prefixChar)
	{
		String seqNumStr = String.valueOf(seqNum);
		for(int i = seqNumStr.length();i<seqNumLength;i++)
		{
			seqNumStr = prefixChar + seqNumStr;
		}
		return seqNumStr;
	}
}

字符序列 Generator

Generator 接口的实现类,用于处理字符序列。这里只是一个简单的例子,比如车牌号的生成就可以使用到字符序列。

清单 3. 字符序列 Generator
public class CharacterSequenceGenerator implements IGenerator{
	private static final String type = GeneratorTypeSet.CHARATER_SEQUENCE;
	//从’A’开始,自动增长
	private char c = 'A'; 
	@Override
	public String getGeneratorType() {
		// TODO Auto-generated method stub
		return type;
	}
	@Override
	public String generate(String formatStr,Map paraMap) {
		return String.valueOf((char)c++);
	}
}

日期序列 Generator

Generator 接口的实现类,用于生成时间日期戳。下面的代码基于 java.text.SimpleDateFormat 实现。

清单 4. 日期序列 Generator
public class DateTimeGenerator implements IGenerator{
	private static final String type = GeneratorTypeSet.DATE_TIME;
	@Override
	public String getGeneratorType() {
		// TODO Auto-generated method stub
		return type;
	}
	@Override
	public String generate(String formatStr,Map paraMap) {
		SimpleDateFormat sdf = new SimpleDateFormat();
		sdf.applyPattern(formatStr);
		return sdf.format(new Date());
	}
}

固定字符 Generator

Generator 接口的实现类,用于生成固定字符。固定字符 Generator 比较简单,即直接返回配置的字符串。

清单 5. 固定字符 Generator
public class StringGenerator implements IGenerator{
	private static final String type = GeneratorTypeSet.STRING;
	@Override
	public String getGeneratorType() {
		// TODO Auto-generated method stub
		return type;
	}
	@Override
	public String generate(String format,Map paraMap) {
		return format;
	}	
}

流水号生成引擎 Engine

流水号引擎需要负责接收流水号生成规则,根据类型调用对应的各个 Generator 生成子序列串,最后将子序列串并拼接并返回最终的流水号。

清单 6. 流水号生成引擎 Engine
public class SNGeneratorEngine {
	private static SNGeneratorEngine snGeneratorEngine = new SNGeneratorEngine();
	private static Map<String,IGenerator> generatorMap = new HashMap<String,IGenerator>();
	/**流水号生成规则*/
	private String formatStr; 
	/**子序列间分隔符*/
	private String splitChar = "#";
	/**子序列内部分隔符*/
	private String innerChar = "@";
	/**流水号子序列生成规则*/
	private String[] subFormatStr;
	/**
	 * 按照类型和 Generator 实例存放
	 * @param Generator
	 */
	public void addGenerator(IGenerator Generator)
	{
		generatorMap.put(Generator.getGeneratorType(),Generator);
	}
	private SNGeneratorEngine()
	{
	}
	public static SNGeneratorEngine getInstance()
	{
		return snGeneratorEngine;
	}
	/**
	 * 接收流水号格式字符串,并分割成子序列
	 * @param formatStr
	 */
	public void setFormatStr(String formatStr)
	{
		this.formatStr = formatStr;
		subFormatStr = this.formatStr.split(splitChar);
	}
	/**
	 * 生成流水号:分发给各个子序列 Generator 生成
	 * @param parameterMap
	 * @return
	 */
	public String generate(Map parameterMap)
	{
		StringBuffer seriableNumber = new StringBuffer();
		for(String format:subFormatStr)
		{
			seriableNumber.append(generateSubSN(format,parameterMap));
		}
		return seriableNumber.toString();
	}
	/**
	 * 根据类型调用子序列 Generator 生成
	 * @param generateSubSN
	 * @param parameterMap
	 * @return
	 */
	private String generateSubSN(String subFormatStr,Map parameterMap)
	{
		String[] innerSubStr = subFormatStr.split(innerChar);
		IGenerator Generator = this.getGenerator(innerSubStr[0]);
		return Generator.generate(innerSubStr[1],parameterMap);
	}
	/**根据 GeneratorType 获取 Generator 实例*/
	private IGenerator getGenerator(String generatorType)
	{
		return generatorMap.get(generatorType);
	}
}

流水号生成应用 App

流水号应用 SNGenerateApp.java 类,声明了 SNGeneratorEngine 对象的实例,并通过调用 addBuildInGenerator() 创建内置的 Generator 类并添加到 SNGeneratorEngine 中,通过 generateSN() 方法来发送生成流水号的请求。

清单 7. 流水号生成应用 App
public class SNGenerateApp {
	private SNGeneratorEngine snGenEngine = SNGeneratorEngine.getInstance();
	/**
	 * 设置内置的生成器
	 */
	private void addBuildInGenerator(){
		snGenEngine.addGenerator(new CharacterSequenceGenerator());
		snGenEngine.addGenerator(new DateTimeGenerator());
		snGenEngine.addGenerator(new NumberSequenceGenerator());
		snGenEngine.addGenerator(new StringGenerator());
	}
	/**
	 * 添加 Generator,提供扩展功能
	 * @param generator
	 */
	public void addGenerator(IGenerator generator)
	{
		snGenEngine.addGenerator(generator);
	}
	/**
	 * 生成序列号
	 * @param snFormatStr 流水号格式字符串
	 * @param parameterMap 参数列表
	 * @return
	 */
	public String generateSN(String snFormatStr,Map parameterMap)
	{
		snGenEngine.setFormatStr(snFormatStr);
		return snGenEngine.generate(parameterMap);
	}
}

应用举例

现在,我们就通过创建 SNGenerateApp 实例并执行相应方法来模拟流水号的生成。

这里仍然以前文提到的国务院办公厅发文号(国办发〔2011〕48 号)为例来说明,其格式字符串为:“Str@ 国办发〔#DateTime@yyyy#Str@〕#NumSeq@0C0#Str@ 号”,使用 MockDB.SEQ_ID_1 的 sequence 获取自增数值,示例代码如下:

清单 8. 应用示例代码 1
SNGenerateApp appication = new SNGenerateApp();//创建 App 实例
appication.addBuildInGenerator(); //设置内置 Generator
//1. 设定流水号生成规则 国务院办公厅发文号(国办发〔2014〕48 号)
System.out.println("1. 生成 国务院办公厅发文号(国办发〔2014〕48 号)");
//设定流水号生成规则
String snFormatStr = "Str@ 国办发〔#DateTime@yyyy#Str@〕#NumSeq@0C0#Str@ 号"; 
Map parameterMap1 = new HashMap(); //设定参数
parameterMap1.put(ParamConsts.PARAM_SEQ_ID, MockDB.SEQ_ID_1); //使用 sequence id 1 进行流水自增
for(int i=1;i<=5;i++)//生成 5 个流水号
{
 System.out.println("流水号"+i+":"+appication.generateSN(snFormatStr,parameterMap1));
}

输出结果:

1. 生成 国务院办公厅发文号(国办发〔2014〕48 号)
流水号 1:国办发〔2014〕48 号
流水号 2:国办发〔2014〕49 号
流水号 3:国办发〔2014〕50 号
流水号 4:国办发〔2014〕51 号
流水号 5:国办发〔2014〕52 号

如果我们要模拟生成常见的 ICP 备案号((沪 ICP 备 05172190 号))呢?很简单,只需要规则重新配置流水号的格式字符串,在这里对应的为“Str@ 沪 ICP 备 #NumSeq@8C0#Str@ 号”,无需修改任何代码。注意,一般来讲不同的流水号会用到不同的 sequence 数值,我们也做了模拟,这里传入 MockDB.SEQ_ID_2 的 sequence ID 来获取自增数值。

清单 9. 应用示例代码 2
//2. 例如生成 :ICP 备案号(沪 ICP 备 05172190 号)
System.out.println("2. 生成 ICP 备案号(沪 ICP 备 05172190 号)");
//设定规则
snFormatStr = "Str@ 沪 ICP 备 #NumSeq@8C0#Str@ 号";
Map parameterMap2 = new HashMap();//设定参数
parameterMap2.put(ParamConsts.PARAM_SEQ_ID, MockDB.SEQ_ID_2);//使用 sequence id 2 进行流水自增
for(int i=1;i<=5;i++)//生成 5 个流水号
{
	System.out.println("流水号"+i+":"+ appication.generateSN(snFormatStr,parameterMap2));
}

输出结果:

2. 生成 ICP 备案号(沪 ICP 备 05172190 号)
流水号 1:沪 ICP 备 05172190 号
流水号 2:沪 ICP 备 05172191 号
流水号 3:沪 ICP 备 05172192 号
流水号 4:沪 ICP 备 05172193 号
流水号 5:沪 ICP 备 05172194 号

想必有读者会问,如果我想生成的流水号还有一些其他特殊的生成规则怎么办?也很简单,只需要编写符合你业务要求的 Generator,然后将这个 Generator 通过 SNGenerateApp.addGenerator() 添加进去,最后再配置相应的流水号格式字符串即可。这样我们就会发现,只要新添加了一个 Generator,那么这个应用就具备相应的子序列生成功能,能够为以后生成含有该子序列的任意流水号提供支持。换句话说,我们可以生成出任意流水号,只要其生成规则是基于当前已有的 Generator 的排列组合,所需要做的只是配置一下流水号格式字符串,是不是非常方便和灵活呢?这也正是应用 Command 模式给我们带来的巨大好处。

总结

本文简单介绍了应用 Command 模式及其优点,并通过一个基于自定义的格式字符串的流水号生成的方案,进一步让读者了解应用场景。采用 Command 模式,我们将原本复杂的流水号生成过程化整为零,分解成各个可以重用的子序列,根据各子序列的类型派发给对应的 Generator,最终在拼接返回流水号。该实现方案适用于各种复杂规则流水号的生成,并且十分易于扩展和维护,在实际应用中也取得了不错的效果。通过本例,希望读者能够进一步了解 Command 模式,应用到适合的场景中。

参考资料

学习



0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:839141次
    • 积分:10395
    • 等级:
    • 排名:第1608名
    • 原创:23篇
    • 转载:1197篇
    • 译文:0篇
    • 评论:76条
    最新评论