yhl452493373/seq
1
0
Fork 0
Code Issues Pull Requests Projects Releases 11 Wiki Activity

调整 增加固定字符串占位符

Browse Source 
调整 解析序列号时，增加根据固定字符串长度解析 Sequences parse(String formatted, String pattern, Integer fixLength);
This commit is contained in:
杨黄林
2023-05-08 17:48:37 +08:00
parent 9f7baadf7a
commit 9104af2923
7 changed files with 161 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
README.md
View File

@@ -4,7 +4,9 @@
用于生成全局自增序号，跳过的序号可以回收使用。 用于生成全局自增序号，跳过的序号可以回收使用。
***本生成器内部使用transactionTemplate进行事务管理，如果你项目中给使用此生成器的方法或类加了`@Transactional`注解，则需将新建一个Service来专门负责调用此生成器的方法，同时要给新建的类增加`@Transactional`注解，并设置`propagation = Propagation.NOT_SUPPORTED`*** ***本生成器内部使用transactionTemplate进行事务管理，如果你项目中给使用此生成器的方法或类加了`@Transactional`
注解，则需将新建一个Service来专门负责调用此生成器的方法，同时要给新建的类增加`@Transactional`
注解，并设置`propagation = Propagation.NOT_SUPPORTED`***
--- ---
@@ -205,7 +207,7 @@ TableConfig配置项，通过set方法设置（一般不用改，如果已有相
GeneratorConfig配置项，通过set方法设置 GeneratorConfig配置项，通过set方法设置
| 配置项 | 类型 | 默认值 | 说明 | | 配置项 | 类型 | 默认值 | 说明 |
|---------------------|------------------------------------------------------------------|------------------|------------------| |------------------|---------------------------------------------|------------------|------------------|
| dataSource | javax.sql.DataSource | null | 数据源 | | dataSource | javax.sql.DataSource | null | 数据源 |
| monthZeroFilling | Boolean | true | 月份不足2位时自动补零 | | monthZeroFilling | Boolean | true | 月份不足2位时自动补零 |
| dayZeroFilling | Boolean | true | 当前日期不足2位时自动补零 | | dayZeroFilling | Boolean | true | 当前日期不足2位时自动补零 |
@@ -299,7 +301,7 @@ public interface Generator {
/** /**
* 将{@link #generate(String, String, Boolean)}得到的序号对象格式化为补零后的序号字符串，其最小长度通过{@link BaseConfig#getMinLength()}设定。实际上只会用到{@link Sequences#getSeq()}属性 * 将{@link #generate(String, String, Boolean)}得到的序号对象格式化为补零后的序号字符串，其最小长度通过{@link BaseConfig#getMinLength()}设定。实际上只会用到{@link Sequences#getSeq()}属性
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}}(当前月份)、{@link FormatPlaceholder#DAY}}(当前日期)、{@link FormatPlaceholder#SEQ}}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* *
* @param sequences 生成的序号对象 * @param sequences 生成的序号对象
* @param pattern 格式 * @param pattern 格式
@@ -310,7 +312,7 @@ public interface Generator {
/** /**
* 将{@link #generate(String, String, Boolean)}得到的序号对象格式化为补零后的序号字符串。实际上只会用到{@link Sequences#getSeq()}属性 * 将{@link #generate(String, String, Boolean)}得到的序号对象格式化为补零后的序号字符串。实际上只会用到{@link Sequences#getSeq()}属性
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}}(当前月份)、{@link FormatPlaceholder#DAY}}(当前日期)、{@link FormatPlaceholder#SEQ}}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* *
* @param sequences 生成的序号对象 * @param sequences 生成的序号对象
* @param minLength 序号数字最小长度 * @param minLength 序号数字最小长度
@@ -322,7 +324,7 @@ public interface Generator {
/** /**
* 将生成的序号对象格式化为指定格式，格式化后字符串最小长度为{@link BaseConfig#getMinLength()}，不足则补零 * 将生成的序号对象格式化为指定格式，格式化后字符串最小长度为{@link BaseConfig#getMinLength()}，不足则补零
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR#getPlaceholder()}(当前年份)、{@link FormatPlaceholder#MONTH#getPlaceholder()}(当前月份)、{@link FormatPlaceholder#DAY#getPlaceholder()}(当前日期)、{@link FormatPlaceholder#SEQ#getPlaceholder()}(生成的字符串序号)四个变量 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/> * <p/>
* seq为1，pattern为#year##month##day#6#seq#，则会格式化为2022013061。此序号含义如下： * seq为1，pattern为#year##month##day#6#seq#，则会格式化为2022013061。此序号含义如下：
* <p/> * <p/>
@@ -337,7 +339,7 @@ public interface Generator {
/** /**
* 将生成的序号对象格式化为指定格式 * 将生成的序号对象格式化为指定格式
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}}(当前年份)、{@link FormatPlaceholder#MONTH}}(当前月份)、{@link FormatPlaceholder#DAY}}(当前日期)、{@link FormatPlaceholder#SEQ}}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/> * <p/>
* seq为1，minLength为4，pattern为#year##month##day#6#seq#，则会格式化为2022013060001。此序号含义如下： * seq为1，minLength为4，pattern为#year##month##day#6#seq#，则会格式化为2022013060001。此序号含义如下：
* <p/> * <p/>
@@ -353,47 +355,47 @@ public interface Generator {
/** /**
* 将生成的序号对象格式化为指定格式，格式化后字符串最小长度为{@link BaseConfig#getMinLength()}，不足则补零 * 将生成的序号对象格式化为指定格式，格式化后字符串最小长度为{@link BaseConfig#getMinLength()}，不足则补零
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}}(当前月份)、{@link FormatPlaceholder#DAY}}(当前日期)、{@link FormatPlaceholder#SEQ}}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/> * <p/>
* seq为1,start为6，minLength为4，pattern为#year##month##day##seq#，则会格式化为2022013061。此序号含义如下： * seq为1,fix为6，minLength为4，pattern为#year##month##day##seq#，则会格式化为2022013061。此序号含义如下：
* <p/> * <p/>
* 序号格式：[年][月][日][固定6开头][序号1，最小位数为{@link BaseConfig#getMinLength()}设置，默认为1，不足则补零] * 序号格式：[年][月][日][固定6开头][序号1，最小位数为{@link BaseConfig#getMinLength()}设置，默认为1，不足则补零]
* *
* @param seq 需要格式化的序号 * @param seq 需要格式化的序号
* @param start 序号格式化后以什么字符串开头 * @param fix 序号中的固定字符串
* @param pattern 序号格式 * @param pattern 序号格式
* @return 格式化后的序号字符串 * @return 格式化后的序号字符串
*/ */
String format(Long seq, String start, String pattern); String format(Long seq, String fix, String pattern);
/** /**
* 将生成的序号对象格式化为指定格式 * 将生成的序号对象格式化为指定格式
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}}(当前月份)、{@link FormatPlaceholder#DAY}}(当前日期)、{@link FormatPlaceholder#SEQ}}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/> * <p/>
* seq为1,start为6，minLength为4，pattern为#year##month##day##seq#，则会格式化为2022013060001。此序号含义如下： * seq为1,fix为6，minLength为4，pattern为#year##month##day##seq#，则会格式化为2022013060001。此序号含义如下：
* <p/> * <p/>
* 序号格式：[年][月][日][固定6开头][序号1，最小位数为4位，不足4位则补零] * 序号格式：[年][月][日][固定6开头][序号1，最小位数为4位，不足4位则补零]
* *
* @param seq 需要格式化的序号 * @param seq 需要格式化的序号
* @param start 序号格式化后以什么字符串开头 * @param fix 序号中的固定字符串
* @param minLength 序号最小长度，不足的会补零 * @param minLength 序号最小长度，不足的会补零
* @param pattern 序号格式 * @param pattern 序号格式
* @return 格式化后的序号字符串 * @return 格式化后的序号字符串
*/ */
String format(Long seq, String start, Integer minLength, String pattern); String format(Long seq, String fix, Integer minLength, String pattern);
/** /**
* 将生成的序号对象格式化为指定格式 * 将生成的序号对象格式化为指定格式
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}}(当前月份)、{@link FormatPlaceholder#DAY}}(当前日期)、{@link FormatPlaceholder#SEQ}}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/> * <p/>
* seq为1,start为6，minLength为4，pattern为#year##month##day##seq#，则会格式化为2022013060001。此序号含义如下： * seq为1,fix为6，minLength为4，pattern为#year##month##day##seq#，则会格式化为2022013060001。此序号含义如下：
* <p/> * <p/>
* 序号格式：[年][月][日][固定6开头][序号1，最小位数为4位，不足4位则补零] * 序号格式：[年][月][日][固定6开头][序号1，最小位数为4位，不足4位则补零]
* *
* @param seq 需要格式化的序号 * @param seq 需要格式化的序号
* @param start 序号格式化后以什么字符串开头 * @param fix 序号中的固定字符串
* @param minLength 序号最小长度，不足的会补零 * @param minLength 序号最小长度，不足的会补零
* @param pattern 序号格式 * @param pattern 序号格式
* @param year 格式化时使用的年 * @param year 格式化时使用的年
@@ -401,16 +403,16 @@ public interface Generator {
* @param day 格式化时使用的日 * @param day 格式化时使用的日
* @return 格式化后的序号字符串 * @return 格式化后的序号字符串
*/ */
String format(Long seq, String start, Integer minLength, String pattern, Integer year, Integer month, Integer day); String format(Long seq, String fix, Integer minLength, String pattern, Integer year, Integer month, Integer day);
/** /**
* 将已格式化的序号解析为序号对象 * 将已格式化的序号解析为序号对象
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}}(当前月份)、{@link FormatPlaceholder#DAY}}(当前日期)、{@link FormatPlaceholder#SEQ}}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/> * <p/>
* 返回的序号对象{@link Sequences#getKey()}为null，{@link Sequences#getType()}为{@link GeneratorConfig#getType()}的默认值，但是临时字段{@link Sequences#getYear()}、{@link Sequences#getMonth()}、{@link Sequences#getDay()}可能有值 * 返回的序号对象{@link Sequences#getKey()}为null，{@link Sequences#getType()}为{@link GeneratorConfig#getType()}的默认值，但是临时字段{@link Sequences#getYear()}、{@link Sequences#getMonth()}、{@link Sequences#getDay()}、{@link Sequences#getFix()}可能有值
* <p/> * <p/>
* 如果生成序号时，序号的key在年、月、日上有关联（如每年每月的序号要从1开始），则需要自行用序号字符串与{@link Sequences#getYear()}、{@link Sequences#getMonth()}、{@link Sequences#getDay()}进行组合，进而得到key * 如果生成序号时，序号的key在年、月、日上有关联（如每年每月的序号要从1开始），则需要自行用序号字符串与{@link Sequences#getYear()}、{@link Sequences#getMonth()}、{@link Sequences#getDay()}、{@link Sequences#getFix()}进行组合，进而得到key
* <p/> * <p/>
* 例如：SNT序号每年都从1开始，则key应该是类似SNT2021、SNT2022这种格式，而在配置中，该序号的代码只是SNT，但是由于每年都要从1开始，所有应该每年有一个key，这个key就为SNT+年份，而这个年份就是此处解析后返回的对象中的{@link Sequences#getYear()} * 例如：SNT序号每年都从1开始，则key应该是类似SNT2021、SNT2022这种格式，而在配置中，该序号的代码只是SNT，但是由于每年都要从1开始，所有应该每年有一个key，这个key就为SNT+年份，而这个年份就是此处解析后返回的对象中的{@link Sequences#getYear()}
* <p/> * <p/>
@@ -422,6 +424,26 @@ public interface Generator {
*/ */
Sequences parse(String formatted, String pattern); Sequences parse(String formatted, String pattern);
/**
* 将已格式化的序号解析为序号对象
* <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/>
* 返回的序号对象{@link Sequences#getKey()}为null，{@link Sequences#getType()}为{@link GeneratorConfig#getType()}的默认值，但是临时字段{@link Sequences#getYear()}、{@link Sequences#getMonth()}、{@link Sequences#getDay()}、{@link Sequences#getFix()}可能有值
* <p/>
* 如果生成序号时，序号的key在年、月、日上有关联（如每年每月的序号要从1开始），则需要自行用序号字符串与{@link Sequences#getYear()}、{@link Sequences#getMonth()}、{@link Sequences#getDay()}、{@link Sequences#getFix()}进行组合，进而得到key
* <p/>
* 例如：SNT序号每年都从1开始，则key应该是类似SNT2021、SNT2022这种格式，而在配置中，该序号的代码只是SNT，但是由于每年都要从1开始，所有应该每年有一个key，这个key就为SNT+年份，而这个年份就是此处解析后返回的对象中的{@link Sequences#getYear()}
* <p/>
* 注意：序号格式和格式化后的字符串占位一定要匹配。如：处〔#year#〕#month#10801第#seq#号 对应 处〔2022〕0210801第10001号，而不能对应 处〔2022〕021110801第10001号
*
* @param formatted 格式化后的序号字符串
* @param pattern 序号格式
* @param fixLength 序号中的固定字符串的长度
* @return 包含了序号字符串对应年（如果有）、月（如果有）、日（如果有）、固定字符串（如果有）、序号的序号对象，其key需要根据情况手动设置，type为{@link GeneratorConfig#getType()}的默认值
*/
Sequences parse(String formatted, String pattern, Integer fixLength);
/** /**
* 锁定指定序号，在序号生成后，调用该序号的逻辑完成后需要执行此方法 * 锁定指定序号，在序号生成后，调用该序号的逻辑完成后需要执行此方法
* <p/> * <p/>
@@ -517,5 +539,4 @@ public interface Generator {
*/ */
void clearBefore(Date end); void clearBefore(Date end);
} }
``` ```

2
pom.xml
View File

@@ -8,7 +8,7 @@
<name>seq</name> <name>seq</name>
<description>seq</description> <description>seq</description>
<properties> <properties>
<java.version>1.8</java.version> <java.version>1.9</java.version>
</properties> </properties>
<dependencies> <dependencies>
<dependency> <dependency>

5
src/main/java/com/yanghuanglin/seq/enums/FormatPlaceholder.java
View File

@@ -22,6 +22,11 @@ public enum FormatPlaceholder {
*/ */
DAY("#day#"), DAY("#day#"),
/**
* 序号格式字符中的固定字符串
*/
FIX("#fix#"),
/** /**
* 序号格式字符中的格式化后的序号 * 序号格式字符中的格式化后的序号
*/ */

58
src/main/java/com/yanghuanglin/seq/generator/Generator.java
View File

@@ -78,7 +78,7 @@ public interface Generator {
/** /**
* 将{@link #generate(String, String, Boolean)}得到的序号对象格式化为补零后的序号字符串，其最小长度通过{@link BaseConfig#getMinLength()}设定。实际上只会用到{@link Sequences#getSeq()}属性 * 将{@link #generate(String, String, Boolean)}得到的序号对象格式化为补零后的序号字符串，其最小长度通过{@link BaseConfig#getMinLength()}设定。实际上只会用到{@link Sequences#getSeq()}属性
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* *
* @param sequences 生成的序号对象 * @param sequences 生成的序号对象
* @param pattern 格式 * @param pattern 格式
@@ -89,7 +89,7 @@ public interface Generator {
/** /**
* 将{@link #generate(String, String, Boolean)}得到的序号对象格式化为补零后的序号字符串。实际上只会用到{@link Sequences#getSeq()}属性 * 将{@link #generate(String, String, Boolean)}得到的序号对象格式化为补零后的序号字符串。实际上只会用到{@link Sequences#getSeq()}属性
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* *
* @param sequences 生成的序号对象 * @param sequences 生成的序号对象
* @param minLength 序号数字最小长度 * @param minLength 序号数字最小长度
@@ -101,7 +101,7 @@ public interface Generator {
/** /**
* 将生成的序号对象格式化为指定格式，格式化后字符串最小长度为{@link BaseConfig#getMinLength()}，不足则补零 * 将生成的序号对象格式化为指定格式，格式化后字符串最小长度为{@link BaseConfig#getMinLength()}，不足则补零
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR#getPlaceholder()}(当前年份)、{@link FormatPlaceholder#MONTH#getPlaceholder()}(当前月份)、{@link FormatPlaceholder#DAY#getPlaceholder()}(当前日期)、{@link FormatPlaceholder#SEQ#getPlaceholder()}(生成的字符串序号)四个变量 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/> * <p/>
* seq为1，pattern为#year##month##day#6#seq#，则会格式化为2022013061。此序号含义如下： * seq为1，pattern为#year##month##day#6#seq#，则会格式化为2022013061。此序号含义如下：
* <p/> * <p/>
@@ -116,7 +116,7 @@ public interface Generator {
/** /**
* 将生成的序号对象格式化为指定格式 * 将生成的序号对象格式化为指定格式
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/> * <p/>
* seq为1，minLength为4，pattern为#year##month##day#6#seq#，则会格式化为2022013060001。此序号含义如下： * seq为1，minLength为4，pattern为#year##month##day#6#seq#，则会格式化为2022013060001。此序号含义如下：
* <p/> * <p/>
@@ -132,47 +132,47 @@ public interface Generator {
/** /**
* 将生成的序号对象格式化为指定格式，格式化后字符串最小长度为{@link BaseConfig#getMinLength()}，不足则补零 * 将生成的序号对象格式化为指定格式，格式化后字符串最小长度为{@link BaseConfig#getMinLength()}，不足则补零
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/> * <p/>
* seq为1,start为6，minLength为4，pattern为#year##month##day##seq#，则会格式化为2022013061。此序号含义如下： * seq为1,fix为6，minLength为4，pattern为#year##month##day##seq#，则会格式化为2022013061。此序号含义如下：
* <p/> * <p/>
* 序号格式：[年][月][日][固定6开头][序号1，最小位数为{@link BaseConfig#getMinLength()}设置，默认为1，不足则补零] * 序号格式：[年][月][日][固定6开头][序号1，最小位数为{@link BaseConfig#getMinLength()}设置，默认为1，不足则补零]
* *
* @param seq 需要格式化的序号 * @param seq 需要格式化的序号
* @param start 序号格式化后以什么字符串开头 * @param fix 序号中的固定字符串
* @param pattern 序号格式 * @param pattern 序号格式
* @return 格式化后的序号字符串 * @return 格式化后的序号字符串
*/ */
String format(Long seq, String start, String pattern); String format(Long seq, String fix, String pattern);
/** /**
* 将生成的序号对象格式化为指定格式 * 将生成的序号对象格式化为指定格式
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/> * <p/>
* seq为1,start为6，minLength为4，pattern为#year##month##day##seq#，则会格式化为2022013060001。此序号含义如下： * seq为1,fix为6，minLength为4，pattern为#year##month##day##seq#，则会格式化为2022013060001。此序号含义如下：
* <p/> * <p/>
* 序号格式：[年][月][日][固定6开头][序号1，最小位数为4位，不足4位则补零] * 序号格式：[年][月][日][固定6开头][序号1，最小位数为4位，不足4位则补零]
* *
* @param seq 需要格式化的序号 * @param seq 需要格式化的序号
* @param start 序号格式化后以什么字符串开头 * @param fix 序号中的固定字符串
* @param minLength 序号最小长度，不足的会补零 * @param minLength 序号最小长度，不足的会补零
* @param pattern 序号格式 * @param pattern 序号格式
* @return 格式化后的序号字符串 * @return 格式化后的序号字符串
*/ */
String format(Long seq, String start, Integer minLength, String pattern); String format(Long seq, String fix, Integer minLength, String pattern);
/** /**
* 将生成的序号对象格式化为指定格式 * 将生成的序号对象格式化为指定格式
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/> * <p/>
* seq为1,start为6，minLength为4，pattern为#year##month##day##seq#，则会格式化为2022013060001。此序号含义如下： * seq为1,fix为6，minLength为4，pattern为#year##month##day##seq#，则会格式化为2022013060001。此序号含义如下：
* <p/> * <p/>
* 序号格式：[年][月][日][固定6开头][序号1，最小位数为4位，不足4位则补零] * 序号格式：[年][月][日][固定6开头][序号1，最小位数为4位，不足4位则补零]
* *
* @param seq 需要格式化的序号 * @param seq 需要格式化的序号
* @param start 序号格式化后以什么字符串开头 * @param fix 序号中的固定字符串
* @param minLength 序号最小长度，不足的会补零 * @param minLength 序号最小长度，不足的会补零
* @param pattern 序号格式 * @param pattern 序号格式
* @param year 格式化时使用的年 * @param year 格式化时使用的年
@@ -180,16 +180,16 @@ public interface Generator {
* @param day 格式化时使用的日 * @param day 格式化时使用的日
* @return 格式化后的序号字符串 * @return 格式化后的序号字符串
*/ */
String format(Long seq, String start, Integer minLength, String pattern, Integer year, Integer month, Integer day); String format(Long seq, String fix, Integer minLength, String pattern, Integer year, Integer month, Integer day);
/** /**
* 将已格式化的序号解析为序号对象 * 将已格式化的序号解析为序号对象
* <p/> * <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串 * pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/> * <p/>
* 返回的序号对象{@link Sequences#getKey()}为null，{@link Sequences#getType()}为{@link GeneratorConfig#getType()}的默认值，但是临时字段{@link Sequences#getYear()}、{@link Sequences#getMonth()}、{@link Sequences#getDay()}可能有值 * 返回的序号对象{@link Sequences#getKey()}为null，{@link Sequences#getType()}为{@link GeneratorConfig#getType()}的默认值，但是临时字段{@link Sequences#getYear()}、{@link Sequences#getMonth()}、{@link Sequences#getDay()}、{@link Sequences#getFix()}可能有值
* <p/> * <p/>
* 如果生成序号时，序号的key在年、月、日上有关联（如每年每月的序号要从1开始），则需要自行用序号字符串与{@link Sequences#getYear()}、{@link Sequences#getMonth()}、{@link Sequences#getDay()}进行组合，进而得到key * 如果生成序号时，序号的key在年、月、日、固定字符串上有关联（如每年每月的序号要从1开始），则需要自行用序号字符串与{@link Sequences#getYear()}、{@link Sequences#getMonth()}、{@link Sequences#getDay()}、{@link Sequences#getFix()}进行组合，进而得到key
* <p/> * <p/>
* 例如：SNT序号每年都从1开始，则key应该是类似SNT2021、SNT2022这种格式，而在配置中，该序号的代码只是SNT，但是由于每年都要从1开始，所有应该每年有一个key，这个key就为SNT+年份，而这个年份就是此处解析后返回的对象中的{@link Sequences#getYear()} * 例如：SNT序号每年都从1开始，则key应该是类似SNT2021、SNT2022这种格式，而在配置中，该序号的代码只是SNT，但是由于每年都要从1开始，所有应该每年有一个key，这个key就为SNT+年份，而这个年份就是此处解析后返回的对象中的{@link Sequences#getYear()}
* <p/> * <p/>
@@ -201,6 +201,26 @@ public interface Generator {
*/ */
Sequences parse(String formatted, String pattern); Sequences parse(String formatted, String pattern);
/**
* 将已格式化的序号解析为序号对象
* <p/>
* pattern支持：{@link FormatPlaceholder#YEAR}(当前年份)、{@link FormatPlaceholder#MONTH}(当前月份)、{@link FormatPlaceholder#DAY}(当前日期)、{@link FormatPlaceholder#FIX}(固定字符串)、{@link FormatPlaceholder#SEQ}(生成的字符串序号)几个枚举值通过{@link FormatPlaceholder#getPlaceholder()}得到的字符串
* <p/>
* 返回的序号对象{@link Sequences#getKey()}为null，{@link Sequences#getType()}为{@link GeneratorConfig#getType()}的默认值，但是临时字段{@link Sequences#getYear()}、{@link Sequences#getMonth()}、{@link Sequences#getDay()}、{@link Sequences#getFix()}可能有值
* <p/>
* 如果生成序号时，序号的key在年、月、日、固定字符串上有关联（如每年每月的序号要从1开始），则需要自行用序号字符串与{@link Sequences#getYear()}、{@link Sequences#getMonth()}、{@link Sequences#getDay()}、{@link Sequences#getFix()}进行组合，进而得到key
* <p/>
* 例如：SNT序号每年都从1开始，则key应该是类似SNT2021、SNT2022这种格式，而在配置中，该序号的代码只是SNT，但是由于每年都要从1开始，所有应该每年有一个key，这个key就为SNT+年份，而这个年份就是此处解析后返回的对象中的{@link Sequences#getYear()}
* <p/>
* 注意：序号格式和格式化后的字符串占位一定要匹配。如：处〔#year#〕#month#10801第#seq#号 对应 处〔2022〕0210801第10001号，而不能对应 处〔2022〕021110801第10001号
*
* @param formatted 格式化后的序号字符串
* @param pattern 序号格式
* @param fixLength 序号中的固定字符串的长度
* @return 包含了序号字符串对应年（如果有）、月（如果有）、日（如果有）、固定字符串（如果有）、序号的序号对象，其key需要根据情况手动设置，type为{@link GeneratorConfig#getType()}的默认值
*/
Sequences parse(String formatted, String pattern, Integer fixLength);
/** /**
* 锁定指定序号，在序号生成后，调用该序号的逻辑完成后需要执行此方法 * 锁定指定序号，在序号生成后，调用该序号的逻辑完成后需要执行此方法
* <p/> * <p/>

55
src/main/java/com/yanghuanglin/seq/generator/impl/SequencesGenerator.java
View File

@@ -170,20 +170,20 @@ public class SequencesGenerator implements Generator {
} }
@Override @Override
public String format(Long seq, String start, String pattern) { public String format(Long seq, String fix, String pattern) {
return format(seq, start, minLength, pattern); return format(seq, fix, minLength, pattern);
} }
@Override @Override
public String format(Long seq, String start, Integer minLength, String pattern) { public String format(Long seq, String fix, Integer minLength, String pattern) {
return format(seq, start, minLength, pattern, null, null, null); return format(seq, fix, minLength, pattern, null, null, null);
} }
@Override @Override
public String format(Long seq, String start, Integer minLength, String pattern, Integer year, Integer month, Integer day) { public String format(Long seq, String fix, Integer minLength, String pattern, Integer year, Integer month, Integer day) {
if (start == null) if (fix == null)
start = ""; fix = "";
String seqString = start + new Sequences(seq).format(minLength); String seqString = new Sequences(seq).format(minLength);
Calendar calendar = Calendar.getInstance(); Calendar calendar = Calendar.getInstance();
if (year == null) if (year == null)
year = calendar.get(Calendar.YEAR); year = calendar.get(Calendar.YEAR);
@@ -194,14 +194,24 @@ public class SequencesGenerator implements Generator {
pattern = pattern.replaceAll(YEAR.getPlaceholder(), String.valueOf(year)); pattern = pattern.replaceAll(YEAR.getPlaceholder(), String.valueOf(year));
pattern = pattern.replaceAll(MONTH.getPlaceholder(), monthZeroFilling ? String.format("%02d", month) : String.valueOf(month)); pattern = pattern.replaceAll(MONTH.getPlaceholder(), monthZeroFilling ? String.format("%02d", month) : String.valueOf(month));
pattern = pattern.replaceAll(DAY.getPlaceholder(), dayZeroFilling ? String.format("%02d", day) : String.valueOf(day)); pattern = pattern.replaceAll(DAY.getPlaceholder(), dayZeroFilling ? String.format("%02d", day) : String.valueOf(day));
pattern = pattern.replaceAll(FIX.getPlaceholder(), fix);
pattern = pattern.replaceAll(SEQ.getPlaceholder(), seqString); pattern = pattern.replaceAll(SEQ.getPlaceholder(), seqString);
return pattern; return pattern;
} }
@Override @Override
public Sequences parse(String formatted, String pattern) { public Sequences parse(String formatted, String pattern) {
return parse(formatted, pattern, null);
}
@Override
public Sequences parse(String formatted, String pattern, Integer fixLength) {
//如果解析时的格式中包含了固定字符串的占位符，则其固定字符串占位符的长度必须大于0，否则抛出异常。
//如果不设置固定字符串的长度，就无法将固定字符串和序号分隔开
if (pattern.contains(FIX.getPlaceholder()) && (fixLength == null || fixLength == 0))
throw new NullPointerException("请设置固定字符串的长度，该长度需要大于0，否则无法区分固定字符串和序号。");
//年、月、日、序号分隔特殊符号正则规则 //年、月、日、序号分隔特殊符号正则规则
String splitRegString = "(" + YEAR.getPlaceholder() + "|" + MONTH.getPlaceholder() + "|" + DAY.getPlaceholder() + "|" + SEQ.getPlaceholder() + ")"; String splitRegString = "(" + YEAR.getPlaceholder() + "|" + MONTH.getPlaceholder() + "|" + DAY.getPlaceholder() + "|" + FIX.getPlaceholder() + "|" + SEQ.getPlaceholder() + ")";
//根据年、月、日、序号的特殊符号，对格式进行分隔，得到排除特殊符号后的字符串数组 //根据年、月、日、序号的特殊符号，对格式进行分隔，得到排除特殊符号后的字符串数组
String[] split = pattern.split(splitRegString); String[] split = pattern.split(splitRegString);
@@ -211,23 +221,25 @@ public class SequencesGenerator implements Generator {
formatted = formatted.replace(splitString, ""); formatted = formatted.replace(splitString, "");
} }
//年、月、日的数字匹配正则规则 //年、月、日、固定字符串 匹配正则规则
String yearRegStr = "\\d{4}"; String yearRegStr = "\\d{4}";
String monthRegStr = "\\d{2}"; String monthRegStr = "\\d{2}";
String dayRegStr = "\\d{2}"; String dayRegStr = "\\d{2}";
String fixRegStr = (fixLength == null || fixLength == 0) ? null : ".{" + fixLength + "}";
//将序号格式分隔特殊符号字符串转为正则匹配规则 //将序号格式分隔特殊符号字符串转为正则匹配规则
Pattern seqPattern = Pattern.compile(splitRegString); Pattern seqPattern = Pattern.compile(splitRegString);
//对序号格式进行匹配 //对序号格式进行匹配
Matcher matcher = seqPattern.matcher(pattern); Matcher matcher = seqPattern.matcher(pattern);
//将年、月、日匹配规则字符串转为正则匹配规则 //将年、月、日、固定字符串 匹配规则字符串转为正则匹配规则
Pattern yearPattern = Pattern.compile(yearRegStr); Pattern yearPattern = Pattern.compile(yearRegStr);
Pattern monthPattern = Pattern.compile(monthRegStr); Pattern monthPattern = Pattern.compile(monthRegStr);
Pattern dayPattern = Pattern.compile(dayRegStr); Pattern dayPattern = Pattern.compile(dayRegStr);
Pattern fixPattern = StringUtils.hasLength(fixRegStr) ? Pattern.compile(fixRegStr) : null;
//默认的年、月、日均为空字符串 //默认的年、月、日、固定字符串、序号均为空字符串
String year = "", month = "", day = "", seq = ""; String year = "", month = "", day = "", fix = "", seq = "";
//根据序号匹配规则字符串查找字符串分组 //根据序号匹配规则字符串查找字符串分组
while (matcher.find()) { while (matcher.find()) {
String group = matcher.group(); String group = matcher.group();
@@ -241,7 +253,7 @@ public class SequencesGenerator implements Generator {
if (yearMatcher.find()) { if (yearMatcher.find()) {
year = yearMatcher.group(); year = yearMatcher.group();
} }
formatted = formatted.replaceFirst(yearRegStr, ""); formatted = formatted.replaceFirst(yearPattern.pattern(), "");
break; break;
case MONTH: case MONTH:
//若分组为月份分组，则将月份正则匹配到的字符串赋值给month，同时把格式化后的序号字符串中，对应月的字符串替换为空字符串 //若分组为月份分组，则将月份正则匹配到的字符串赋值给month，同时把格式化后的序号字符串中，对应月的字符串替换为空字符串
@@ -249,7 +261,7 @@ public class SequencesGenerator implements Generator {
if (monthMatcher.find()) { if (monthMatcher.find()) {
month = monthMatcher.group(); month = monthMatcher.group();
} }
formatted = formatted.replaceFirst(monthRegStr, ""); formatted = formatted.replaceFirst(monthPattern.pattern(), "");
break; break;
case DAY: case DAY:
//若分组为日期分组，则将日期正则匹配到的字符串赋值给day，同时把格式化后的序号字符串中，对应日期的字符串替换为空字符串 //若分组为日期分组，则将日期正则匹配到的字符串赋值给day，同时把格式化后的序号字符串中，对应日期的字符串替换为空字符串
@@ -257,7 +269,17 @@ public class SequencesGenerator implements Generator {
if (dayMatcher.find()) { if (dayMatcher.find()) {
day = dayMatcher.group(); day = dayMatcher.group();
} }
formatted = formatted.replaceFirst(dayRegStr, ""); formatted = formatted.replaceFirst(dayPattern.pattern(), "");
break;
case FIX:
if (fixPattern == null)
break;
//若分组为固定字符串分组，则将固定字符串正则匹配到的字符串赋值给fix，同时把格式化后的序号字符串中，对应固定字符串的字符串替换为空字符串
Matcher fixMatcher = fixPattern.matcher(formatted);
if (fixMatcher.find()) {
fix = fixMatcher.group();
}
formatted = formatted.replaceFirst(fixPattern.pattern(), "");
break; break;
} }
} }
@@ -270,6 +292,7 @@ public class SequencesGenerator implements Generator {
sequences.setYear(StringUtils.hasLength(year) ? Integer.valueOf(year) : null); sequences.setYear(StringUtils.hasLength(year) ? Integer.valueOf(year) : null);
sequences.setMonth(StringUtils.hasLength(month) ? Integer.valueOf(month) : null); sequences.setMonth(StringUtils.hasLength(month) ? Integer.valueOf(month) : null);
sequences.setDay(StringUtils.hasLength(day) ? Integer.valueOf(day) : null); sequences.setDay(StringUtils.hasLength(day) ? Integer.valueOf(day) : null);
sequences.setFix(StringUtils.hasLength(fix) ? fix : null);
sequences.setSeq(StringUtils.hasLength(seq) ? Long.parseLong(seq) : 0L); sequences.setSeq(StringUtils.hasLength(seq) ? Long.parseLong(seq) : 0L);
sequences.setWithOutSeq(!StringUtils.hasLength(seq)); sequences.setWithOutSeq(!StringUtils.hasLength(seq));
sequences.setType(type); sequences.setType(type);

15
src/main/java/com/yanghuanglin/seq/po/Sequences.java
View File

@@ -42,6 +42,12 @@ public class Sequences {
*/ */
private transient Integer day; private transient Integer day;
/**
* 临时字段，序号对应的固定字符串（A1）。
* 该字段仅用于解析序号字符串时，解析出对应固定字符，用于合成key（如：序号对应的key为SNT+年份+月份+日期+固定字符串，返回的为其固定字符串）
*/
private transient String fix;
/** /**
* 临时字段，表示序号对象不包含序号 * 临时字段，表示序号对象不包含序号
*/ */
@@ -119,6 +125,14 @@ public class Sequences {
this.day = day; this.day = day;
} }
public String getFix() {
return fix;
}
public void setFix(String fix) {
this.fix = fix;
}
public Boolean getWithOutSeq() { public Boolean getWithOutSeq() {
return withOutSeq; return withOutSeq;
} }
@@ -169,6 +183,7 @@ public class Sequences {
", year=" + year + ", year=" + year +
", month=" + month + ", month=" + month +
", day=" + day + ", day=" + day +
", fix=" + fix +
", withOutSeq=" + withOutSeq + ", withOutSeq=" + withOutSeq +
'}'; '}';
} }

18
src/test/java/SeqTest.java
View File

@@ -1,14 +1,10 @@
import com.mysql.cj.jdbc.MysqlDataSource; import com.mysql.cj.jdbc.MysqlDataSource;
import com.yanghuanglin.seq.config.BaseConfig;
import com.yanghuanglin.seq.config.GeneratorConfig; import com.yanghuanglin.seq.config.GeneratorConfig;
import com.yanghuanglin.seq.config.TableConfig; import com.yanghuanglin.seq.config.TableConfig;
import com.yanghuanglin.seq.generator.Generator; import com.yanghuanglin.seq.generator.Generator;
import com.yanghuanglin.seq.generator.impl.SequencesGenerator; import com.yanghuanglin.seq.generator.impl.SequencesGenerator;
import com.yanghuanglin.seq.po.Sequences; import com.yanghuanglin.seq.po.Sequences;
import org.junit.Test; import org.junit.Test;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;
import java.util.HashSet; import java.util.HashSet;
import java.util.Set; import java.util.Set;
@@ -51,12 +47,17 @@ public class SeqTest {
Set<String> set = new HashSet<>(); Set<String> set = new HashSet<>();
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10, 1, TimeUnit.MINUTES, new ArrayBlockingQueue<>(100)); ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10, 1, TimeUnit.MINUTES, new ArrayBlockingQueue<>(100));
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
final int finalI = i;
threadPoolExecutor.execute(() -> { threadPoolExecutor.execute(() -> {
Sequences sequences = generator.generate("SNT", "MISSION"); Sequences sequences = generator.generate("SNT", "MISSION");
String formattedSeq = generator.format(sequences.getSeq(), "处〔#year#〕10801#seq#"); String pattern = "处〔#year#〕#fix##seq#";
String fix = "10801" + finalI;
String formattedSeq = generator.format(sequences.getSeq(), fix, pattern);
generator.lock(sequences); generator.lock(sequences);
set.add(formattedSeq); set.add(formattedSeq);
System.out.println(formattedSeq); System.out.println(formattedSeq);
Sequences parse = generator.parse(formattedSeq, pattern, fix.length());
System.out.println(parse);
}); });
} }
threadPoolExecutor.shutdown(); threadPoolExecutor.shutdown();
@@ -80,10 +81,11 @@ public class SeqTest {
@Test @Test
public void parseTest() { public void parseTest() {
String seqPattern = "ZZF#year##month##seq#"; String seqPattern = "ZZF#year##month##fix##seq#";
String formatted = "ZZF20220200008"; String formatted = "ZZF202202A18";
Sequences sequences = generator.parse(formatted, seqPattern); //A1视为固定字符串，其长度为2
Sequences sequences = generator.parse(formatted, seqPattern, 2);
String key = "zzfCode" + sequences.getYear(); String key = "zzfCode" + sequences.getYear();