Java生成流水号 -3 支持数据库查询，Spring注入(二)

第一篇文章/article/7497789.html介绍了，流水号的生成，可惜忘了加入循环操作，比如日循环，月循环，年循环，这次来补上。

注入方法已经在一写过了，就不写了。主要是代码部分。

直接上代码

Java代码


package com.wesley.framework.dao;

import java.text.ParseException;

import java.util.GregorianCalendar;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.lang.time.DateUtils;

/**

* 流水号参数封装类

*

* @author it.zl

*

*/

public class PrimaryBean {

// select 'SP-' as prefix,'yyyyMMdd' as dataString,'000000' startNumber

public final static String YEAR = "year";

public final static String MONTH = "month";

public final static String DAY = "day";

/**

* 表示流水号中的前缀，比如测试操作可以加'TETS-'那么流水号的前缀就会加上'TEST-201207250000001'

*/

private String prefix;

/**

* 表示日期的格式如'yyyyMMdd',那么会生产流水号中的日期为'20120725','yyyy-MM-dd'则会是'2012-07-25'

*/

private String dataString;

/**

* 开始第一个数是多少,定义长度和其实数值,如000000

*/

private String startNumber;

/**

* 表示流水号中的日期，如20120725

*/

private String dateTimeString;

/**

* 可以设置循环类型,如每日生成新的流水号从0开始,默认为日,循环 数值为year,month,day

*/

private String repeatCycle = DAY;

/**

* 是否每次都从数据库验证

*/

private Boolean isDataBase = false;

public String getPrefix() {

return prefix;

}

public void setPrefix(String prefix) {

this.prefix = prefix;

}

public String getDataString() {

return dataString;

}

public void setDataString(String dataString) {

this.dataString = dataString;

}

public String getStartNumber() {

return startNumber;

}

public void setStartNumber(String startNumber) {

this.startNumber = startNumber;

}

public Boolean getIsDataBase() {

return isDataBase;

}

public void setIsDataBase(Boolean isDataBase) {

this.isDataBase = isDataBase;

}

public String getRepeatCycle() {

return repeatCycle;

}

public void setRepeatCycle(String repeatCycle) {

this.repeatCycle = repeatCycle;

}

public String getDateTimeString() {

return dateTimeString;

}

public void setDateTimeString(String dateTimeString) {

this.dateTimeString = dateTimeString;

}

/**

* 把dateTimeString转换正GregorianCalendar

*

* @return DateTime

*/

public GregorianCalendar getDateTime() {

if (StringUtils.isEmpty(dateTimeString))

return new GregorianCalendar();

GregorianCalendar date = new GregorianCalendar();

try {

date.setTime(DateUtils.parseDate(this.getDateTimeString(),

new String[] { this.getDataString() }));

} catch (ParseException e) {

return new GregorianCalendar();

}

return date;

}

}

Java代码


package com.wesley.framework.dao;

import java.text.DecimalFormat;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.GregorianCalendar;

import java.util.HashMap;

import java.util.Map;

import org.apache.commons.dbcp.BasicDataSource;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.time.DateUtils;

import com.wesley.framework.dao.dbutils.DBHelper;

/**

* 流水号生成类

*

* @author it.zl

*

*/

public class PrimaryGenerater {

/**

* 单例

*/

private static PrimaryGenerater primaryGenerater = null;

/**

* 数据库访问类

*/

private DBHelper dbHelper;

/**

* 生成流水号的SQL,支持多种格式,如业务BIZ,非业务NOBIZ

*/

private Map<String, String> sqls = new HashMap<String, String>();

/**

* 对应不用的SQL生产的不同参数类

*/

private Map<String, PrimaryBean> primarBeans = new HashMap<String, PrimaryBean>();

private PrimaryGenerater() {

super();

}

public PrimaryGenerater(BasicDataSource database, Map<String, String> sqls) {

super();

this.dbHelper = new DBHelper(database);

this.sqls = sqls;

for (String key : sqls.keySet()) {

this.primarBeans.put(key, this.getPrimaryBeanByDatabase(key));

}

}

public static PrimaryGenerater newInstance(BasicDataSource database,

Map<String, String> sqls) {

synchronized (PrimaryGenerater.class) {

primaryGenerater = new PrimaryGenerater(database, sqls);

}

return primaryGenerater;

}

/**

*

* 取得PrimaryGenerater的单例实现

*

* @return

*/

public static PrimaryGenerater getInstance() {

if (primaryGenerater == null) {

synchronized (PrimaryGenerater.class) {

if (primaryGenerater == null) {

primaryGenerater = new PrimaryGenerater();

}

}

}

return primaryGenerater;

}

/**

* 通过 数据库查询键获得封装类

*

* @param key

* @return

*/

public synchronized PrimaryBean getPrimaryBeanByDatabase(String key) {

if (!this.sqls.containsKey(key))

return null;

PrimaryBean primaryBean = this.primarBeans.get(key);

if (primaryBean != null && !primaryBean.getIsDataBase())

return primaryBean;

primaryBean = dbHelper.findFirst(PrimaryBean.class, this.sqls.get(key));

return primaryBean;

}

/**

* 通过数据库查询键位生成流水号

*

* @param key

* @return

*/

public synchronized String geneterNextNumberByKey(String key) {

PrimaryBean primaryBean = this.getPrimaryBeanByDatabase(key);

return this.geneterNextNumber(primaryBean);

}

/**

* 通过封装类生成流水号

*

* @param primaryBean

* @return

*/

public synchronized String geneterNextNumber(PrimaryBean primaryBean) {

String nextNumber = this.geneterNextNumber(isRestart(primaryBean),

primaryBean.getStartNumber());

primaryBean.setStartNumber(nextNumber);

String dataString = this.geneterDataString(primaryBean.getDataString());

primaryBean.setDateTimeString(dataString);

String serialNumber = primaryBean.getPrefix() + dataString + nextNumber;

return serialNumber;

}

private synchronized Boolean isRestart(PrimaryBean primaryBean) {

GregorianCalendar gcNow = new GregorianCalendar();

GregorianCalendar date = primaryBean.getDateTime();

if (StringUtils.equalsIgnoreCase(PrimaryBean.YEAR,

primaryBean.getRepeatCycle())) {

if (gcNow.get(GregorianCalendar.YEAR) == date

.get(GregorianCalendar.YEAR))

return false;

}

if (StringUtils.equalsIgnoreCase(PrimaryBean.MONTH,

primaryBean.getRepeatCycle())) {

if (gcNow.get(GregorianCalendar.YEAR) == date

.get(GregorianCalendar.YEAR)

&& gcNow.get(GregorianCalendar.MONTH) == date

.get(GregorianCalendar.MONTH))

return false;

}

if (StringUtils.equalsIgnoreCase(PrimaryBean.DAY,

primaryBean.getRepeatCycle())) {

if (DateUtils.isSameDay(gcNow, date))

return false;

}

return true;

}

/**

* 通过开始数字字符串生成下一个流水号

*

* @param startNumber

* @return

*/

public synchronized String geneterNextNumber(Boolean isRestart,

String startNumber) {

Long temp = Long.valueOf(startNumber) + 1;

StringBuilder sb = new StringBuilder();

for (int i = 0; i < startNumber.length(); i++)

sb.append("0");

DecimalFormat df = new DecimalFormat(sb.toString());

return isRestart ? sb.toString() : df.format(temp);

}

/**

* 通过 格式生成日期格式

*

* @param dataformat

* @return

*/

private synchronized String geneterDataString(String dataformat) {

SimpleDateFormat formatter = new SimpleDateFormat(dataformat);

return formatter.format(new Date());

}

}

Java代码


package com.wesley.framework.dao.dbutils;

import java.math.BigDecimal;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import org.apache.commons.dbcp.BasicDataSource;

import org.apache.commons.dbutils.BasicRowProcessor;

import org.apache.commons.dbutils.QueryRunner;

import org.apache.commons.dbutils.handlers.BeanHandler;

import org.apache.commons.dbutils.handlers.BeanListHandler;

import org.apache.commons.dbutils.handlers.MapHandler;

import org.apache.commons.dbutils.handlers.MapListHandler;

import org.apache.commons.dbutils.handlers.ScalarHandler;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import com.wesley.framework.commen.StringFormat;

public class DBHelper {

private static final Log logger = LogFactory.getLog(DBHelper.class);

private BasicDataSource dataSource;

private QueryRunner queryRunner;

public DBHelper(BasicDataSource dataSource) {

super();

this.dataSource = dataSource;

}

public void setDataSource(BasicDataSource dataSource) {

this.dataSource = dataSource;

}

/**

* 执行sql语句

*

* @param sql

* sql语句

* @return 受影响的行数

*/

public int update(String sql) {

return update(sql, null);

}

/**

* 执行sql语句 <code>

* executeUpdate("update user set username = 'kitty' where username = ?", "hello kitty");

* </code>

*

* @param sql

* sql语句

* @param param

* 参数

* @return 受影响的行数

*/

public int update(String sql, Object param) {

return update(sql, new Object[] { param });

}

/**

* 执行sql语句

*

* @param sql

* sql语句

* @param params

* 参数数组

* @return 受影响的行数

*/

public int update(String sql, Object[] params) {

queryRunner = new QueryRunner(dataSource);

int affectedRows = 0;

try {

if (params == null) {

affectedRows = queryRunner.update(sql);

} else {

affectedRows = queryRunner.update(sql, params);

}

} catch (SQLException e) {

logger.error("Error occured while attempting to update data", e);

}

return affectedRows;

}

/**

* 执行批量sql语句

*

* @param sql

* sql语句

* @param params

* 二维参数数组

* @return 受影响的行数的数组

*/

public int[] batchUpdate(String sql, Object[][] params) {

queryRunner = new QueryRunner(dataSource);

int[] affectedRows = new int[0];

try {

affectedRows = queryRunner.batch(sql, params);

} catch (SQLException e) {

logger.error("Error occured while attempting to batch update data",

e);

}

return affectedRows;

}

/**

* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中

*

* @param sql

* sql语句

* @return 查询结果

*/

public List<Map<String, Object>> find(String sql) {

return find(sql, null);

}

/**

* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中

*

* @param sql

* sql语句

* @param param

* 参数

* @return 查询结果

*/

public List<Map<String, Object>> find(String sql, Object param) {

return find(sql, new Object[] { param });

}

/**

* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中

*

* @param sql

* sql语句

* @param params

* 参数数组

* @return 查询结果

*/

public List<Map<String, Object>> find(String sql, Object[] params) {

queryRunner = new QueryRunner(dataSource);

List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();

try {

if (params == null) {

list = (List<Map<String, Object>>) queryRunner.query(sql,

new MapListHandler());

} else {

list = (List<Map<String, Object>>) queryRunner.query(sql,

new MapListHandler(), params);

}

} catch (SQLException e) {

logger.error("Error occured while attempting to query data", e);

}

return list;

}

/**

* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中

*

* @param entityClass

* 类名

* @param sql

* sql语句

* @return 查询结果

*/

public <T> List<T> find(Class<T> entityClass, String sql) {

return find(entityClass, sql, null);

}

/**

* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中

*

* @param entityClass

* 类名

* @param sql

* sql语句

* @param param

* 参数

* @return 查询结果

*/

public <T> List<T> find(Class<T> entityClass, String sql, Object param) {

return find(entityClass, sql, new Object[] { param });

}

/**

* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中

*

* @param entityClass

* 类名

* @param sql

* sql语句

* @param params

* 参数数组

* @return 查询结果

*/

public <T> List<T> find(Class<T> entityClass, String sql, Object[] params) {

queryRunner = new QueryRunner(dataSource);

List<T> list = new ArrayList<T>();

try {

if (params == null) {

list = queryRunner.query(sql, new BeanListHandler<T>(

entityClass, new BasicRowProcessor(

new StrategyBeanProcessor(new HumpMatcher()))));

} else {

list = queryRunner.query(sql, new BeanListHandler<T>(

entityClass, new BasicRowProcessor(

new StrategyBeanProcessor(new HumpMatcher()))),

params);

}

} catch (SQLException e) {

logger.error("Error occured while attempting to query data", e);

}

return list;

}

/**

* 查询出结果集中的第一条记录，并封装成对象

*

* @param entityClass

* 类名

* @param sql

* sql语句

* @return 对象

*/

public <T> T findFirst(Class<T> entityClass, String sql) {

return findFirst(entityClass, sql, null);

}

/**

* 查询出结果集中的第一条记录，并封装成对象

*

* @param entityClass

* 类名

* @param sql

* sql语句

* @param param

* 参数

* @return 对象

*/

public <T> T findFirst(Class<T> entityClass, String sql, Object param) {

return findFirst(entityClass, sql, new Object[] { param });

}

/**

* 查询出结果集中的第一条记录，并封装成对象

*

* @param entityClass

* 类名

* @param sql

* sql语句

* @param params

* 参数数组

* @return 对象

*/

@SuppressWarnings({ "unchecked" })

public <T> T findFirst(Class<T> entityClass, String sql, Object[] params) {

queryRunner = new QueryRunner(dataSource);

Object object = null;

try {

if (params == null) {

object = queryRunner

.query(sql, new BeanHandler<T>(entityClass));

} else {

object = queryRunner.query(sql,

new BeanHandler<T>(entityClass), params);

}

} catch (SQLException e) {

logger.error("Error occured while attempting to query data", e);

}

return (T) object;

}

/**

* 查询出结果集中的第一条记录，并封装成Map对象

*

* @param sql

* sql语句

* @return 封装为Map的对象

*/

public Map<String, Object> findFirst(String sql) {

return findFirst(sql, null);

}

/**

* 查询出结果集中的第一条记录，并封装成Map对象

*

* @param sql

* sql语句

* @param param

* 参数

* @return 封装为Map的对象

*/

public Map<String, Object> findFirst(String sql, Object param) {

return findFirst(sql, new Object[] { param });

}

/**

* 查询出结果集中的第一条记录，并封装成Map对象

*

* @param sql

* sql语句

* @param params

* 参数数组

* @return 封装为Map的对象

*/

public Map<String, Object> findFirst(String sql, Object[] params) {

queryRunner = new QueryRunner(dataSource);

Map<String, Object> map = null;

try {

if (params == null) {

map = (Map<String, Object>) queryRunner.query(sql,

new MapHandler());

} else {

map = (Map<String, Object>) queryRunner.query(sql,

new MapHandler(), params);

}

} catch (SQLException e) {

logger.error("Error occured while attempting to query data", e);

}

return map;

}

/**

* 查询某一条记录，并将指定列的数据转换为Object

*

* @param sql

* sql语句

* @param columnName

* 列名

* @return 结果对象

*/

public Object findBy(String sql, String columnName) {

return findBy(sql, columnName, null);

}

/**

* 查询某一条记录，并将指定列的数据转换为Object

*

* @param sql

* sql语句

* @param columnName

* 列名

* @param param

* 参数

* @return 结果对象

*/

public Object findBy(String sql, String columnName, Object param) {

return findBy(sql, columnName, new Object[] { param });

}

/**

* 查询某一条记录，并将指定列的数据转换为Object

*

* @param sql

* sql语句

* @param columnName

* 列名

* @param params

* 参数数组

* @return 结果对象

*/

public Object findBy(String sql, String columnName, Object[] params) {

queryRunner = new QueryRunner(dataSource);

Object object = null;

try {

if (params == null) {

object = queryRunner.query(sql, new ScalarHandler(columnName));

} else {

object = queryRunner.query(sql, new ScalarHandler(columnName),

params);

}

} catch (SQLException e) {

logger.error("Error occured while attempting to query data", e);

}

return object;

}

/**

* 查询某一条记录，并将指定列的数据转换为Object

*

* @param sql

* sql语句

* @param columnIndex

* 列索引

* @return 结果对象

*/

public Object findBy(String sql, int columnIndex) {

return findBy(sql, columnIndex, null);

}

public boolean exist(String sql, Object... params) {

int x = this.findInteger(

StringFormat.format("SELECT COUNT(*) FROM ({0})", sql), params);

return x <= 0 ? false : true;

}

public int findInteger(String sql, Object... params) {

Object o = findBy(sql, null, params);

if (BigDecimal.class.equals(o.getClass()))

return ((BigDecimal) o).intValue();

return (Integer) o;

}

/**

* 查询某一条记录，并将指定列的数据转换为Object

*

* @param sql

* sql语句

* @param columnIndex

* 列索引

* @param param

* 参数

* @return 结果对象

*/

public Object findBy(String sql, int columnIndex, Object param) {

return findBy(sql, columnIndex, new Object[] { param });

}

/**

* 查询某一条记录，并将指定列的数据转换为Object

*

* @param sql

* sql语句

* @param columnIndex

* 列索引

* @param params

* 参数数组

* @return 结果对象

*/

public Object findBy(String sql, int columnIndex, Object[] params) {

queryRunner = new QueryRunner(dataSource);

Object object = null;

try {

if (params == null) {

object = queryRunner.query(sql, new ScalarHandler(columnIndex));

} else {

object = queryRunner.query(sql, new ScalarHandler(columnIndex),

params);

}

} catch (SQLException e) {

logger.error("Error occured while attempting to query data", e);

}

return object;

}

}