package com.wesley.framework.dao;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.dbcp.BasicDataSource;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import com.wesley.framework.dao.dbutils.DBHelper;
public class PrimaryGenerater {
private static PrimaryGenerater primaryGenerater = null;
private DBHelper<PrimaryBean> dbHelper;
private Map<String, String> sqls = new HashMap<String, String>();
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<PrimaryBean>(database, PrimaryBean.class);
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.query(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(primaryBean.getStartNumber());
primaryBean.setStartNumber(nextNumber);
String dataString = this.geneterDataString(primaryBean.getDataString());
String serialNumber = primaryBean.getPrefix() + dataString + nextNumber;
return serialNumber;
}
/**
* 通过开始数字字符串生成下一个流水号
*
* @param startNumber
* @return
*/
public synchronized String geneterNextNumber(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 df.format(temp);
}
/**
* 通过 格式生成日期格式
*
* @param dataformat
* @return
*/
private synchronized String geneterDataString(String dataformat) {
SimpleDateFormat formatter = new SimpleDateFormat(dataformat);
return formatter.format(new Date());
}
public static void main(String[] args) throws Exception {
XmlBeanFactory context = new XmlBeanFactory(new ClassPathResource(
"applicationContext.xml"));
BasicDataSource dataSource = (BasicDataSource) context
.getBean("dataSource");
Map<String, String> map = new HashMap<String, String>();
map.put("new",
"select 'SP-' as prefix,'yyyyMMdd' as dataString,'000000' as startNumber from business union select 'SP-' as prefix,'yyyyMMdd' as dataString,'000000' as startNumber");
PrimaryGenerater.newInstance(dataSource, map);
for (int i = 0; i < 100; i++) {
System.out.println(PrimaryGenerater.getInstance()
.geneterNextNumberByKey("new"));
}
}
}
package com.wesley.framework.dao;
public class PrimaryBean {
// select 'SP-' as prefix,'yyyyMMdd' as dataString,'000000' startNumber
private String prefix;
private String dataString;
private String startNumber;
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;
}
}
package com.wesley.framework.dao.dbutils;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.dbutils.BasicRowProcessor;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.unitils.thirdparty.org.apache.commons.dbutils.DbUtils;
public class DBHelper<T> {
private static final Logger logger = LoggerFactory
.getLogger(DBHelper.class);
private BasicDataSource pool;
private Class<T> beanClass = null;
public DBHelper(BasicDataSource pool) {
super();
this.pool = pool;
}
public DBHelper(BasicDataSource pool, Class<T> beanClass) {
super();
this.pool = pool;
this.beanClass = beanClass;
}
/**
* 根据无参sql语句进行查询，并返回一个对象，用于单条记录的查询
*
* @param sql
* @return Object
*/
public T query(String sql) {
Connection conn = this.getPoolConnection();
if (conn == null || beanClass == null)
return null;
QueryRunner run = new QueryRunner();
ResultSetHandler<T> h = new BeanHandler<T>(beanClass);
T result = null;
try {
result = run.query(conn, sql, h);
} catch (SQLException e) {
logger.info("SQLException in [" + sql + "]");
logger.error(e.getMessage());
} finally {
DbUtils.closeQuietly(conn);
}
return result;
}
/**
* 根据有参sql语句进行查询，并返回一个对象，用于单条记录的查询
*
* @param sql
* @param args
* @return Object
*/
public T query(String sql, Object... args) {
Connection conn = this.getPoolConnection();
if (conn == null || beanClass == null)
return null;
QueryRunner run = new QueryRunner();
ResultSetHandler<T> h = new BeanHandler<T>(beanClass);
T result = null;
try {
result = (T) run.query(conn, sql, h, args);
} catch (SQLException e) {
logger.info("SQLException in [" + sql + "]");
logger.error(e.getMessage());
} finally {
DbUtils.closeQuietly(conn);
}
return result;
}
/**
* 根据无参sql语句进行查询，并返回一个数据集，用于多条记录的查询
*
* @param sql
* @return ArrayList
*/
public List<T> queryRecords(String sql) {
Connection conn = this.getPoolConnection();
if (conn == null || beanClass == null)
return null;
// ResultSetHandler<?> h = new BeanListHandler(beanClass);
ResultSetHandler<List<T>> h = new BeanListHandler<T>(beanClass,
new BasicRowProcessor(new StrategyBeanProcessor(
new HumpMatcher())));
QueryRunner run = new QueryRunner();
List<T> result = null;
try {
result = run.query(conn, sql, h);
} catch (SQLException e) {
logger.info("SQLException in [" + sql + "]");
logger.error(e.getMessage());
} finally {
DbUtils.closeQuietly(conn);
}
return result;
}
/**
* 根据有参sql语句进行查询，并返回一个数据集，用于多条记录的查询
*
* @param sql
* @param args
* @return
*/
public List<T> queryRecords(String sql, Object... args) {
Connection conn = this.getPoolConnection();
if (conn == null || beanClass == null)
return null;
QueryRunner run = new QueryRunner();
ResultSetHandler<List<T>> h = new BeanListHandler<T>(beanClass,
new BasicRowProcessor(new StrategyBeanProcessor(
new HumpMatcher())));
List<T> result = null;
try {
result = run.query(conn, sql, h, args);
System.out.println(result.size());
} catch (SQLException e) {
logger.info("SQLException in [" + sql + "]");
logger.error(e.getMessage());
} finally {
DbUtils.closeQuietly(conn);
}
return result;
}
/**
* 根据无参sql语句进行数据更新，并返回更新后影响的记录数
*
* @param sql
* @return int
*/
public int update(String sql) {
Connection conn = this.getPoolConnection();
if (conn == null)
return 0;
QueryRunner run = new QueryRunner();
int result = 0;
try {
result = run.update(conn, sql);
} catch (SQLException e) {
logger.info("SQLException in [" + sql + "]");
logger.error(e.getMessage());
} finally {
DbUtils.closeQuietly(conn);
}
return result;
}
/**
* 根据有参sql语句进行数据更新，并返回更新后影响的记录数
*
* @param sql
* @param args
* @return int
*/
public int update(String sql, Object... args) {
Connection conn = this.getPoolConnection();
if (conn == null)
return -1;
QueryRunner run = new QueryRunner();
int result = 0;
try {
result = run.update(conn, sql, args);
} catch (SQLException e) {
logger.info("SQLException in [" + sql + "]");
logger.error(e.getMessage());
} finally {
DbUtils.closeQuietly(conn);
}
return result;
}
/**
* 设置存放查询结果的Bean类，每个Bean类对象对应一条查询的结果记录
*
* @param beanClass
* ，如User.class
*/
public void setBeanClass(Class<T> beanClass) {
this.beanClass = beanClass;
}
public Connection getPoolConnection() {
int x = 3;
while (x > 0) {
try {
return pool.getConnection();
} catch (SQLException e) {
x--;
logger.error(e.getMessage());
}
}
return null;
}
public void dispose() {
try {
this.pool.close();
} catch (SQLException e) {
logger.error(e.getMessage());
}
}
}
<bean id="PrimaryGenerater" class="com.wesley.framework.dao.PrimaryGenerater"
factory-method="newInstance">
<constructor-arg index="0" ref="dataSource" />
<constructor-arg index="1" >
<map>
<entry key="bsno">
<value>select 'SP-' as prefix,'yyyyMMdd' as dataString,'000000' as
startNumber union select null as prefix,null as dataString,null as
startNumber from business
</value>
</entry>
</map>
</constructor-arg>
</bean>
分享到：
相关推荐
5. **Java技术栈**：在Java环境中，可能使用了Spring MVC框架来构建MVC结构，它提供了丰富的功能，如依赖注入、AOP（面向切面编程）以及Web开发所需的各种工具。此外，可能还使用了Servlet和JSP（JavaServer Pages）...
- **支付表**：存储支付相关数据，如支付方式、交易流水号、支付状态等。 5. **安全性考虑**： - **身份验证与授权**：确保只有合法用户能访问其个人信息和订单，防止未授权访问。 - **SQL注入防护**：使用预...
【JavaWeb超市进销存管理系统】是一个基于JavaWeb技术实现的、采用Oracle数据库存储数据、Struts2作为MVC框架的高效能管理平台。这个系统主要用于帮助超市进行商品的进货、销售、库存等日常运营活动的高效管理和监控...
例如，`getContriApplyNo()`方法使用了自定义的SQL语句来生成一个特定格式的序列号，`getInsnId()`方法则获取了一个6位数字的序列号，而`getRefNo()`方法则结合了日期和序列号生成了一个唯一的交易流水号。...
- **Spring框架**：作为核心容器，负责管理应用对象（Bean）的生命周期和依赖注入，使得组件间的耦合度降低。 - **SpringMVC**：处理HTTP请求，提供模型-视图-控制器（MVC）模式，分离业务逻辑与展示层，提高代码...
基于`aggregate-pay-master`这个文件名，我们可以推测项目可能使用了Git进行版本控制，可能使用了Java或Python作为后端语言，结合Spring Boot或Django等框架，数据库可能是MySQL或MongoDB，前端可能采用React或Vue....