规则序号生成

最新推荐文章于 2023-05-06 00:22:04 发布
最新推荐文章于 2023-05-06 00:22:04 发布
阅读量664 收藏
点赞数
分类专栏： 应用 文章标签： Java正则表达式 自定义序号生成 规则序号 单据号生成 销售单号
需求说明：
[list]
[*]进销存销售产品时，需要系统按规则生成一个销售订单号
[*]订单号需要生成如"XS-日期-序号"的格式。其中“日期”为当天日期、“序号”为当天当前的销售单量并且不足四位时，以“0”填充在数量之前。如“XS-20100501-0050”
[*]可以系统中维护订单号生成规则，并且不影响之前生成的订单号
[/list]
解决办法：
一、分析需求，可确认销售订单序号的规则为“XS-日期-序号”，其中“序号”要以“日期”为因子进行归零递归。抽象出生成序号的规则“[b]XS-{DATE}-{S4[DATE]}[/b]”。
其他可能应用到规则如下： 
1. {Y} | {Y4} | {YYYY} / {Y2} | {YY} 表示获取年份值,四位数年份及二位数年份 
2. {MM} | {M} 表示月份值 
3. {DD} | {D}表示当前日期值 
4. {HH} 表示日期时间的小时值 
5. {MN} 表示日期时间的分钟值 
6. {SS} 表示日期时间的秒值 
7. {DATE} 表示当前日期同等于{YYYY}{MM}{DD}相连 
8. {NOW} 表示当前日期时间{YYYY}{MM}{DD}{HH}{MN}{SS} 
9. {@表单字段} 表示获取表单上某一控件的值为规则的一部分,如{@ORG}:获取表单上字段叫为"ORG"控件的值为规则一部分 
10. {@表单字段:replace(a,b)}/{@表单字段:replace(a)} 表示获取表单上某一控件的值,并替换值中的"a"为"b"字符,如{@createTime:replace(-)}:获取表单上字段叫为"createTime"控件的值并替换"-"为空字符。注意(支持函数):替换[replace(a,b)],截取字符[substring(开始位置,结束位置)],转小写(toLowerCase),转大写(toUpperCase),去除前后空格(trim) 
11.{W#*} 表示随机字符或数字,*号为长度,#为"D"时为随机数字(0-9);为"S"时为随机字符(A-Za-z);为空时为(0-9A-Za-z) 
12.{D*} 表示随机*位数字,*号为长度,如{D5}为随机5位数字,等同与{WD5} 
13.{C*} 表示随机*位字符,*号为长度,如{S5}为随机5位数字,等同与{WS5} 
14.{S*[#_#]}表示序号中流水号长度及增长因子(必须以S开始),其中*表示序号中流水号长度;[]之间的设置为增长因子设置,可使用上面(1-9项)的任意一种及组合,如多个组合需要使用"_"相隔。如:S5[Y_M_D]表示序号中的流水号长度为5,并且每天都会自动归1，然后重新递增

二、创建相关数据库表，规则定义表RuleDef，规则实例表RuleInst。定义表与实例表为一对多关系。
规则定义表RuleDef[table]
|字段描述 |字段名称 |字段类型
|id |definitionId |bigint
|规则序号名称 |definitionName |varchar(50)
|规则序号描述 |definitionComment|varchar(50)
|规则序号定义 |definitionRule|varchar(100)
[/table]
规则实例表RuleInst
[table]
|字段描述 |字段名称 |字段类型
|id |definitionId |bigint
|规则序号名称 |definitionName |varchar(50)
|序号增长因子 |iterateGene|varchar(50)
|当前最大值 |maxValue|int
[/table]
三、编写实现类（以正则表达式方式实现）
1、正则表达式properties配置设置 
##################################################
# custom Sequence pattern -- use SequenceRender
##################################################
sequence.utils.growthFactorPattern=\\{S{1}(\\d){1,2}(?\:\\[([\\w\\@]*)\\])*\\}
sequence.utils.commonRulePattern=\\{([\\w-\\@\\[\\]]+)(?\:\\\:([^\\{]*))*\\}
sequence.utils.commonRuleFnPattern=([\\w-\\[\\]]*)(?\:\\((.*?)?\\))*
sequence.utils.randomPattern=^W?(W|D|C){1}(\\d){1,2}
#值为yyyyMMddHHmmss格式的当前日期时间值
sequence.utils.oraDatePattern=(((\\d{2}(\\d{2}))(\\d{2}))(\\d{2}))(\\d{2})(\\d{2})(\\d{2})

##################################################
# custom Sequence date Rule values -- use SequenceRender
# 以下键值为sequence.utils.oraDatePattern正则值的索引号
##################################################
#yyyyMMddHHmmss=20110630115830
sequence.utils.YYYYMMDDHHMMSS=0
sequence.utils.NOW=${sequence.utils.YYYYMMDDHHMMSS}
sequence.utils.YYYYMMDD=1
sequence.utils.DATE=${sequence.utils.YYYYMMDD}
sequence.utils.YYYYMM=2
sequence.utils.YYYY=3
sequence.utils.Y4=${sequence.utils.YYYY}
sequence.utils.Y=${sequence.utils.YYYY}
sequence.utils.YY=4
sequence.utils.Y2=${sequence.utils.YY}
sequence.utils.MM=5
sequence.utils.M=${sequence.utils.MM}
sequence.utils.DD=6
sequence.utils.D=${sequence.utils.DD}
sequence.utils.HH=7
sequence.utils.MN=8
sequence.utils.SS=9

sequence.define.xiaoShouNo=XS-{DATE}-{S4[DATE]}


2、现实类SequenceUtils.java 
package test.inkcar.sequence.utils;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.beanutils.BeanUtils;

import test.inkcar.sequence.preferences.SystemGlobal;

public class SequenceUtils {
	// private static PtSequenceDefinitionBIZ ptSequenceDefinitionBIZ =
	// (PtSequenceDefinitionBIZ) BizFactory
	// .getBean("ptsequencedefinitionbiz");
	// private static PtSequenceInstanceBIZ ptSequenceInstanceBIZ =
	// (PtSequenceInstanceBIZ) BizFactory
	// .getBean("ptsequenceinstancebiz");
	/**
	 * 配置属性前缀名称
	 */
	private static final String PROPERTY_NAME = "sequence.utils.";
	/**
	 * 带时分秒的ORA标准时间格式 yyyyMMddHHmmss
	 */
	private static final SimpleDateFormat ORA_DATE_TIME_EXTENDED_FORMAT = new SimpleDateFormat(
			"yyyyMMddHHmmss");
	/**
	 * 带时分秒的ORA标准时间正则解析表达式
	 */
	private static final Pattern ORA_DATE_PATTERN = Pattern.compile(
			getPropertyName("oraDatePattern"), Pattern.CASE_INSENSITIVE);
	/**
	 * 增长因子正则解析表达式
	 */
	private static final Pattern GROWTH_FACTOR_PATTERN = Pattern.compile(
			getPropertyName("growthFactorPattern"), Pattern.CASE_INSENSITIVE);
	/**
	 * 随机字符正则解析表达式
	 */
	private static final Pattern RANDOM_PATTERN = Pattern.compile(
			getPropertyName("randomPattern"), Pattern.CASE_INSENSITIVE);
	/**
	 * 规则正则解析表达式 -- 表单值
	 */
	private static final Pattern COMMON_RULE_PATTERN = Pattern.compile(
			getPropertyName("commonRulePattern"), Pattern.CASE_INSENSITIVE);
	/**
	 * 规则正则解析表达式--表单值函数
	 */
	private static final Pattern COMMON_RULE_FN_PATTERN = Pattern.compile(
			getPropertyName("commonRuleFnPattern"), Pattern.CASE_INSENSITIVE);

	/**
	 * 带时分秒的ORA标准时间格式匹配
	 */
	private static Matcher ORA_DATE_MATCHER;

	/**
	 * 客户请求数据
	 */
	@SuppressWarnings("unchecked")
	private static ThreadLocal<Map> USERDATA = new ThreadLocal<Map>();

	/**
	 * 构造
	 */
	private SequenceUtils() {
	}

	/**
	 * 获取配置属性
	 * 
	 * @param name
	 *            属性名称
	 * @return 配置值
	 */
	private static final String getPropertyName(String name) {
		return SystemGlobal.get(PROPERTY_NAME + name);
	}

	/**
	 * 初始化当前日期时间字符串及客户端请求数据
	 */
	@SuppressWarnings("unchecked")
	private static final void reloadData(Object bean) {
		Map map = new HashMap();
		if (bean != null) {
			if ("HashMap".equals(bean.getClass().getSimpleName())) {
				map = (Map) bean;
			} else {
				try {
					map = BeanUtils.describe(bean);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		USERDATA.set(map);
		String dte = ORA_DATE_TIME_EXTENDED_FORMAT.format(Calendar
				.getInstance().getTime());
		ORA_DATE_MATCHER = ORA_DATE_PATTERN.matcher(dte);
		ORA_DATE_MATCHER.find();
	}

	/**
	 * 渲染序号
	 * 
	 * @param ruleDef
	 *            序号规则定义字符串
	 * @return 渲染后的序号值
	 */
	public static final String render(String defName) {
		return render(defName, null);
	}

	/**
	 * 渲染序号
	 * 
	 * @param ruleDef
	 *            序号规则定义字符串
	 * @param request
	 *            客户端请求数据
	 * @return 渲染后的序号值
	 */
	public static final String render(String defName, Object bean) {

		reloadData(bean);

		String ruleDef = getGrowthFactor(defName, true);
		if (StringUtils.isEmpty(ruleDef))
			return "";

		Matcher m = COMMON_RULE_PATTERN.matcher(ruleDef);
		StringBuffer sb = new StringBuffer("");
		String paramValue = null;
		while (m.find()) {
			String r = m.group(1);
			if (StringUtils.isEmpty(r))
				continue;
			// 检查是否需要进行字串变换操作
			paramValue = getFnParam(m.group(2), getMatcherValue(r));

			m.appendReplacement(sb, paramValue);
		}
		m.appendTail(sb);
		return sb.toString();
	}

	/**
	 * 根据规则序号定义获取预览序号值(表单没有进行保存前显示)
	 * 
	 * @param def
	 *            规则定义实体对象
	 * @return
	 * 
	 * @author Inkcar Nov 5, 2010 3:44:10 PM
	 */
	public static final String getPreviewSequence(String defName) {
		reloadData(null);

		// 获取已设置增长因子值的规则序号及定义
		String ruleDef = getGrowthFactor(defName, false);
		if (StringUtils.isEmpty(ruleDef)) {
			return "";
		}

		Matcher m = COMMON_RULE_PATTERN.matcher(ruleDef);
		StringBuffer sb = new StringBuffer("");
		while (m.find()) {
			String r = m.group(1);
			if (StringUtils.isEmpty(r) || r.charAt(0) == '@')
				continue;
			m.appendReplacement(sb, getMatcherValue(r));
		}
		m.appendTail(sb);
		return sb.toString();
	}

	/**
	 * 获取增长因子匹配
	 * 
	 * @param gene
	 *            规则定义字符
	 * @return 匹配增长因子之后的字符
	 */
	private static final String getGrowthFactor(String defName, boolean save) {
		if (StringUtils.isEmpty(defName)) {
			return "";
		}
		/*
		 * 从数据库获取规则序号定义
		 */
		// PtSequenceDefinition def = ptSequenceDefinitionBIZ
		// .getPtSequenceDefinitionByName(defName);
		// if (def == null) {
		// return "";
		// }
		// String ruleDef = def.getDefinitionRule();
		/*
		 * 从properties配置文件读取序号规则定义
		 */
		String defineName = "sequence.define." + defName;
		String ruleDef = SystemGlobal.get(defineName);
		if (StringUtils.isEmpty(ruleDef)) {
			return "";
		}

		Matcher g = GROWTH_FACTOR_PATTERN.matcher(ruleDef);
		StringBuffer sb = new StringBuffer("");
		Integer leng = 0, value = 0;
		String cacheFieldName;
		while (g.find()) {
			StringBuffer sbGene = new StringBuffer("");
			String strGene = g.group(2);
			if (!StringUtils.isEmpty(strGene)) {
				String[] arr = strGene.split("_");
				for (int i = 0; i < arr.length; i++) {
					String ch = arr[i];
					if (StringUtils.isEmpty(ch))
						continue;
					sbGene.append(getMatcherValue(ch));
				}

			}
			// 增长因子值最小位数
			leng = Integer.valueOf(g.group(1));

			// 从properties配置文件获取当前增长因子最大值
			cacheFieldName = defineName + "." + sbGene.toString();
			value = SystemGlobal.getInteger(cacheFieldName) + 1;

			// 从数据库获取增长因子最大值
			// value =
			// ptSequenceInstanceBIZ.getGrowthFactor(def,sbGene.toString());

			// 获取并更新当前因子最大值,对数据库进行操作
			if (save) {
				// 保存到properties配置文件
				SystemGlobal.set(cacheFieldName, value.toString());
				// 保存到数据库
				// ptSequenceInstanceBIZ.updateGrowthFactor(def,
				// value);
			}
			g.appendReplacement(sb, StringUtils.getFillDigits(value.toString(),
					leng));
		}
		g.appendTail(sb);
		return sb.toString();
	}

	/**
	 * 匹配随机字符
	 * 
	 * @param gene
	 *            随机匹配字符
	 * @return 匹配值
	 */
	private static final String getRandomCharacter(String gene) {
		Matcher m = RANDOM_PATTERN.matcher(gene);
		StringBuffer sb = new StringBuffer("");
		if (m.find()) {
			// 将随机值添加到序号值中
			m.appendReplacement(sb, StringUtils.getRands(Integer.valueOf(m
					.group(2)), m.group(1)));
			return sb.toString();
		}
		return gene;
	}

	/**
	 * 获取规则序号匹配值
	 * 
	 * @param val
	 *            匹配字符串
	 * @return 匹配值
	 */
	@SuppressWarnings("unchecked")
	private static final String getMatcherValue(String val) {
		// 获取传入参数值
		if (val.charAt(0) == '@') {
			String field = val.replace("@", "");
			// 获取参数键值对象
			Map bean = getRequestThread();
			if (!StringUtils.isEmpty(field)) {
				Object value = bean.get(field);
				if (value == null)
					return "";
				return value.toString();
			}
			return "";
		}
		Integer index = -1;
		// 从properties配置文件获取规则定义
		String value = getPropertyName(val);
		try {
			index = Integer.valueOf(value);
		} catch (Exception e) {
		}

		if (index != -1) {
			// 获取当前操作时间指定位置值
			return ORA_DATE_MATCHER.group(index);
		}
		return getRandomCharacter(val);
	}

	/**
	 * 对指定值进行预定义的变换操作
	 * 
	 * @param fnName
	 *            操作类型,如replace、substring、toLowerCase、toUpperCase、trim
	 * @param paramValue
	 *            操作字符值
	 * @return
	 */
	private static String getFnParam(String fnName, String paramValue) {
		if (!StringUtils.isEmpty(fnName)) {
			Matcher fnMatcher = COMMON_RULE_FN_PATTERN.matcher(fnName);
			String fn, fnParams, reValue;
			String[] arrParams;
			while (fnMatcher.find()) {
				if (!StringUtils.isEmpty(fnMatcher.group())) {
					try {
						fn = fnMatcher.group(1);
						fnParams = fnMatcher.group(2);
						arrParams = fnParams != null ? fnParams.split(",")
								: new String[] {};
						reValue = arrParams.length > 1 ? arrParams[1] : "";
						if ("replace".equals(fn)) {
							paramValue = paramValue.replaceAll(arrParams[0],
									reValue);
						} else if ("substring".equals(fn)) {
							Integer start = arrParams.length > 0 ? Integer
									.valueOf(arrParams[0]) : 0;
							Integer end = arrParams.length > 1 ? Integer
									.valueOf(arrParams[1]) : 0;
							if (end > 0) {
								paramValue = paramValue.substring(start, end);
							} else {
								paramValue = paramValue.substring(start);
							}
						} else if ("toLowerCase".equals(fn)) {
							paramValue = paramValue.toLowerCase();
						} else if ("toUpperCase".equals(fn)) {
							paramValue = paramValue.toUpperCase();
						} else if ("trim".equals(fn)) {
							paramValue = paramValue.trim();
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
		}
		return paramValue;
	}

	/**
	 * 获取当前请求线程
	 * 
	 * @return
	 */
	@SuppressWarnings("unchecked")
	private static final Map getRequestThread() {
		return USERDATA.get();
	}
}

3、测试类 
package test.inkcar.sequence;

import test.inkcar.sequence.preferences.SystemGlobal;
import test.inkcar.sequence.utils.SequenceUtils;
import junit.framework.TestCase;

public class SequenceTest extends TestCase {

	public void testSystemGlobal() {
		System.out.println("读取配置：");
		System.out
				.println(SystemGlobal.get("sequence.define.xiaoShouNo.20110701"));
	}

	public void testSequence() {
		System.out.println("生成序号");
		System.out.println(SequenceUtils.render("xiaoShouNo"));
	}
}
iteye_6694
关注
专栏目录
php 序列号生成规则,php如何生成不重复的序列号
weixin_26712065的博客
03-09 684
php生成不重复的序列号的方法：可以利用内置函数mt_rand()来实现。mt_rand()函数用于生成随机整数，例如要生成一个介于10和100之间的随机整数，具体代码为：【mt_rand(10, 100)】。php为我们提供了专门用于生成随机数的函数mt_rand()，该函数用 Mersenne Twister 算法生成随机整数。提示：该函数是产生随机值的更好选择，返回结果的速度是 rand()...
序列生成_常用的特殊序列号生成公式大全
weixin_34981697的博客
01-12 2312
在excel函数中，有时候我们需要生成特殊的序列号。如果用人工一个个设置太繁琐，且容易出错，我们可以运用excel行、列函数，再搭配相应的函数就能生成特殊的序列号。今天让我们一起来学习如何生成特殊的序列号。首先让我们先学习序列号常用的相关六大函数：一、Row函数ROW函数是函数中的一种，作用是返回一个引用的行号。如果省略 reference，则假定是对函数 ROW 单元格的引用。函数语法为：ROW...
序号的结构层次顺序
热门推荐
羞羞滴小朋友
01-30 8万+
数字序号的级别顺序为： 第一层为汉字数字加顿号，例如：“一、”“二、”“三、”； 第二层为括号中包含汉字数字，例如：“（一）”“（二）”“（三）”； 第三层为阿拉伯数字加下脚点，例如：“1. ”“2.”“3.”； 第四层为括号中包含阿拉伯数字，例如：“（1）”“（2）”“（3）”； 第五层为带圈的阿拉伯数字，例如：“①”“②”“③”或者“1）”“2）”“3）”；
c# 自动序号生成
11-09
针对硬件绑定 软件序列号生成 , 序列号检测, 相当的好用,都加了注释
序号自动生成器.zip
12-18
在这个“序号自动生成器.zip”压缩包中，包含了一个基于C#的源码项目，用户可以根据自己的需求进行定制，以满足特定的序号生成规则。 序号自动生成器的核心功能通常包括以下几点： 1. **序列生成策略**：序号可以...
el-table树形表格表单验证(列表生成序号)
11-20
1. **树形列表序号生成**：通过广度优先遍历，为每个节点分配层次结构的唯一序号。 2. **表单结构**：使用`el-form`和嵌套的`el-form-item`包裹表格，确保每个表单字段都能进行独立验证。 3. **验证规则**：定义`...
php生成excel列序号代码实例
12-19
这个循环会生成从1到150的列序号，覆盖了从"A"到"PQ"的所有列。如果需要生成更多的列序号，可以调整循环条件。 在实际应用中，生成Excel文件通常会使用专门的库，如PHPExcel或PHPSpreadsheet，它们提供了更丰富的...
序号生成一例
weixin_30291791的博客
01-28 178
Create VIEW [dbo].[v_GetDate]ASSELECT dt=CONVERT(VARCHAR(6),GETDATE(),12)CreateFUNCTION [dbo].[f_er_NextBH]() RETURNS char(7)ASBEGIN DECLARE @dt CHAR(6) DECLARE @d CHAR(2) SELECT ...
订单号生成规则
weixin_30764771的博客
10-28 1563
前阵子，公司有个电子商务项目，需要生成订单号。当时的考虑很简单，取系统时间加上随机数，或者使用 uniqid() 方法。我们都知道，订单号最基本的要求就是唯一，这个条件必须满足。仔细考虑下上述方法，在顾客购买量少的情况下，订单重复的可能性为零，但是在购买高蜂期生成的订单号重复是很有可能发生的。所以上述方法不可靠，有待强化。在网上找了一番，发现这位同学的想法挺不错的，redtamo，具体的请稳步过去...
序列号及序列号生成器（号段模式，数据库模式）详细介绍（建议收藏）
G探险者的博客
05-06 2498
现如今，数据的唯一性和可追溯性变得越来越重要。从简单的数据库主键到复杂的分布式系统，唯一标识符在各种场景中都发挥着关键作用。序列号，作为一种广泛应用的唯一标识符，为我们提供了确保数据完整性和一致性的基础。在这个背景下，高效、可靠的序列号生成器对于各种应用系统的顺利运行至关重要。本文将深入探讨序列号的概念、应用场景以及序列号生成器的设计和实现。我们将讨论在不同场景下如何选择合适的序列号生成策略，以满足性能、可扩展性和安全性等方面的需求。
使用java 正则表达式处理字符串 处理编号
qq_41103091的博客
09-19 526
java
利用ir.sequence自动生成序列号
weixin_30667301的博客
04-28 306
利用ir.sequence自动生成序列号 什么是序列号 可以这么理解，我有一个产品序号，编码的前缀是SOP,后缀是0001~9999的序号，没生成一个产品就自动流水加一，序列号不会重复，odoo中的ir.sequence这个模型提供了这个方法。 建立序号规则对象 建立一个XML,并记得在__mainfest__.py中导入 <?xml version="1.0" encoding="ut...
EBS 发运管理操作实例5——自定义发放规则（Release Rules）
congque9143的博客
11-25 674
“发放规则” 定义了“挑库发放” 时使用的标准。只有符合该标准和一定条件的订单才能够进行发放。如果订单行已完成必需的工作流活动（如“计划- 行” 或“创建供应”），则认为它符合条件。注意，切勿与挑库规则混淆。挑库规则是一种物料属...
T-SQL 单表查询解析
weixin_34220623的博客
04-12 97
本篇将聊聊 T-SQL中的SELECT 单表查询，SELECT语句的目的是对表进行查询、应用一定的逻辑处理，并返回结果。为了描述逻辑查询处理和各种SELECT查询子句，使用如下代码做为例子。 SELECT empid, YEAR(orderdate) AS orderyear, COUNT(*) AS numorders FROM sales.Orders WHERE custid =...
微软序列号生成和验证的技术原理!
Kalong Room
08-21 4216
1.产品ID(ProductID) 　　产品ID是由五组十进制数组成，如下： AAAAA        BBB        CCCCCCC        DD        EEE 52273        005        6861993        09
正则表达式
bjgaocp的博客
12-03 645
正则表达式 \ 转义符,将特殊字符进行转移,忽略其特殊含义 ^ 匹配字符串的开始 $ 匹配字符串的结尾 ^$ 匹配空行 . 匹配除换行符(\n)外的任意字符 .*
XWPFTemplate怎么生成序号
最新发布
09-12
4. **应用序号规则**: 对于表格或有序列表，可以创建`NumberingRule`，告诉Apache POI如何生成和更新序列。例如，如果你希望从1开始递增，可以设置`startAt`: `rule.setStartAt(1)`。 5. **设置当前行的序号**: ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值