http://www.ibm.com/developerworks/cn/java/j-lo-serialNo/
本文介绍了一种基于自定义格式字符串, 应用 Command 模式的流水号管理功能，可以让用户灵活设定流水号的格式，具备非常好的灵活性和可扩展性。
摘要
流水号管理作为很多信息系统的一种基础功能，对于一些具有业务含义的流水号，一般由多个具有不同意义的组成部分组成，其格式会相对比较复杂，如何快速灵活的支持不同的流水号格式，十分有现实意义。本文介绍了一种基于自定义格式字符串，应用 Command 模式的流水号管理方案。在本方案中，对复杂的的流水号进行分析分解，拆分为更细小的子序列，再分别调用相应的生成接口生成，最终生成的流水号。使用本方案，流水号的生成规则定义在格式字符串中，如要生成不同格式的流水号，只需要修改格式字符串即可，生成和扩展都十分方便。
背景
在信息系统中流水号作为一项必不可少的基础功能，流水号的生成、控制和管理十分重要。一般一个信息系统中，不同的流水号序列有不同的生成规则。如果我们对这些流水号进行进一步分析，这些不同的流水号序列又可细分为多个规则固定的子序列。基于这种分析，对于这种实际应用需求，如何来高效灵活的生成所需的流水号，就显得十分有意义。
场景分析
首先看几个我们身边常见的流水号：身份证号、税务票、银行的业务流水号、排队号、国务院办公厅发文号（国办发〔2011〕48 号）等。如果对这些流水号进一步分析，我们可以得出，流水号一般由多个规则固定的子序列组成，常见的子序列规则如下：
1. 数字序列：1，2，3 … 或者 00001，00002，00003
2. 字母序列：如 ‘A-Z’
3. 固定字符串：如固定的字符前缀或后缀
4. 时间戳：如 yyyyMMdd 格式对应的为 20130201
5. 其他序列：如罗马字符 ‘I-X’
从另一个角度我们可以说，一个流水号就是上面子序列的排列组合。
基于这样的分析，我们可以创建一个流水号生成引擎，这个引擎可以读取和解析给定的流水号规则，将流水号规则拆分成多个子序列规则，并根据子序列规则生成子序列串，拼接返回最终的流水号。有了这个流水号生成引擎，在系统实际应用的时候，只需要对所需的流水号配置相应的生成规则即可。并且本方案还预留扩展接口，如果实际中遇到个性化的序列生成规则，开发者也可以根据实际需要进行扩展开发，这样也能有效覆盖个性化的需求。
说了这么多，不如图形展示来得直观，整个解决方案的流程见下图：
图 1. 流水号生成流程图
1. 流水号规则读取
2. 流水号规则解析、分割、获取子序列规则
3. 生成子序列任务的派发
4. 子序列汇总和合并
5. 返回最终的生成流水号实例
图 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 类图
这里对上图做一个简单的解释，命令模式涉及到五个角色，分别为：
客户（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. 包结构及类清单图
下面是具体的代码展示和介绍。
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 号
流水号 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 号
流水号 2:沪 ICP 备 05172191 号
流水号 3:沪 ICP 备 05172192 号
流水号 4:沪 ICP 备 05172193 号
流水号 5:沪 ICP 备 05172194 号
想必有读者会问，如果我想生成的流水号还有一些其他特殊的生成规则怎么办？也很简单，只需要编写符合你业务要求的 Generator，然后将这个 Generator 通过 SNGenerateApp.addGenerator() 添加进去，最后再配置相应的流水号格式字符串即可。这样我们就会发现，只要新添加了一个 Generator，那么这个应用就具备相应的子序列生成功能，能够为以后生成含有该子序列的任意流水号提供支持。换句话说，我们可以生成出任意流水号，只要其生成规则是基于当前已有的 Generator 的排列组合，所需要做的只是配置一下流水号格式字符串，是不是非常方便和灵活呢？这也正是应用 Command 模式给我们带来的巨大好处。
总结
本文简单介绍了应用 Command 模式及其优点，并通过一个基于自定义的格式字符串的流水号生成的方案，进一步让读者了解应用场景。采用 Command 模式，我们将原本复杂的流水号生成过程化整为零，分解成各个可以重用的子序列，根据各子序列的类型派发给对应的 Generator，最终在拼接返回流水号。该实现方案适用于各种复杂规则流水号的生成，并且十分易于扩展和维护，在实际应用中也取得了不错的效果。通过本例，希望读者能够进一步了解 Command 模式，应用到适合的场景中。
参考资料
学习
阅读 GoF（“四人帮”）《设计模式》书籍，原名《Design Patterns: Elements of Reusable Object-Oriented Software》深入了解更多设计模式。
参考百度百科中关于 Command 模式的词条，可点击 command 模式。
访问 “developerWorks Java 设计模式与建模专题”，了解更多设计模式相关的专题讨论与实践。
developerWorks Java 技术专区：这里有数百篇关于 Java 编程各个方面的文章。