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

最新推荐文章于 2023-02-08 16:04:24 发布

SQZHAO

最新推荐文章于 2023-02-08 16:04:24 发布

阅读量1k

点赞数

分类专栏： Java 流水号

Java 同时被 2 个专栏收录

97 篇文章 0 订阅

订阅专栏

流水号

3 篇文章 0 订阅

订阅专栏

第一篇文章 http://numen06.iteye.com/blog/1420694 介绍了，流水号的生成，可惜忘了加入循环操作，比如日循环，月循环，年循环，这次来补上。

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

    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;  
     }  
   
 }

SQZHAO

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java生成流水号 -3 支持数据库查询，Spring注入(二)

第一篇文章http://numen06.iteye.com/blog/1420694介绍了，流水号的生成，可惜忘了加入循环操作，比如日循环，月循环，年循环，这次来补上。注入方法已经在一写过了，就不写了。主要是代码部分。直接上代码 Java代码 package com.wesley.framework.dao; import java.te
复制链接

扫一扫