Spring Jdbc 泛型使用
其实一直以来 我使用了 不少hibernate mybatis 都挺简单，可是性能 方面 一直感受通常般，我的偏向使用原生的jdbc 其实写起来 也挺简单的，当能力跨越了这一个层次的时候 ，这些mybatis hibernate 其实并不那么重要了 我其实也再也不户什么框架不框架了 ，这里分享一个我经常使用的jdbc的类 。这是我去年一直使用的类，最开始在一个博客上收集的一个，可是缺乏了 不少类，因而我本身补全了 全部的类，使用jdbc 原生类 jdbcTemplate性能 速度 仍是很好的。我不太喜欢 mybatis 虽然mybatis mybatis 当类太多 mapper.xml太多的时候阅读起来很烦的。java
1.BASEDAO
spring
/**
*
*
* @zhuyuping
* @2014-3-30
* @doc:
*/
public abstract class BaseDao<T> {
/** 具体操做的实体类对象 */
private Class<T> entityClass;
/** 名称加工处理器 */
private NameHandler nameHandler;
/**
* jdbcTemplate
*/
@Resource
protected JdbcTemplate jdbcTemplate;
/**
* nameJdbcTemplate
*/
@Resource
protected NamedParameterJdbcTemplate namedParameterJdbcTemplate;
/**
* 构造方法，获取运行时的具体实体对象
*/
public BaseDao() {
Type superclass = getClass().getGenericSuperclass();
ParameterizedType type = (ParameterizedType) superclass;
entityClass = (Class<T>) type.getActualTypeArguments()[0];
}
/**
* 获取实际运行时的名称处理器
*
* @return
*/
private NameHandler getActualNameHandler() {
if (nameHandler == null) {
synchronized (this) {
if (nameHandler == null) {
nameHandler = this.getNameHandler();
}
}
}
return nameHandler;
}
/**
* 获得名称处理器，子类覆盖此方法实现本身的名称转换处理器
*
* @return
*/
protected NameHandler getNameHandler() {
return new DefaultNameHandler();
}
/**
* 插入一条记录
*
* @param entity
*/
public Long insert(T entity) {
final SqlContext sqlContext = SqlUtils.buildInsertSql(entity, this.getActualNameHandler());
KeyHolder keyHolder = new GeneratedKeyHolder();
jdbcTemplate.update(new PreparedStatementCreator() {
public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
PreparedStatement ps = con.prepareStatement(sqlContext.getSql().toString(),
new String[] { sqlContext.getPrimaryKey() });
int index = 0;
for (Object param : sqlContext.getParams()) {
index++;
ps.setObject(index, param);
}
return ps;
}
}, keyHolder);
return keyHolder.getKey().longValue();
}
/**
* 更新记录
*
* @param entity
*/
public void update(T entity) {
SqlContext sqlContext = SqlUtils.buildUpdateSql(entity, this.getActualNameHandler());
jdbcTemplate.update(sqlContext.getSql().toString(), sqlContext.getParams().toArray());
}
/**
* 删除记录
*
* @param id
*/
public void delete(Serializable id) {
String tableName = this.getActualNameHandler().getTableName(entityClass.getSimpleName());
String primaryName = this.getNameHandler().getPrimaryName(entityClass.getSimpleName());
String sql = "DELETE FROM " + tableName + " WHERE " + primaryName + " = ?";
jdbcTemplate.update(sql, id);
}
/**
* 删除全部记录
*/
public void deleteAll() {
String tableName = this.getActualNameHandler().getTableName(entityClass.getSimpleName());
String sql = " TRUNCATE TABLE " + tableName;
jdbcTemplate.execute(sql);
}
/**
* 获得记录
*
* @param id
* @return
*/
public T getById(Serializable id) {
String tableName = this.getNameHandler().getTableName(entityClass.getSimpleName());
String primaryName = this.getNameHandler().getPrimaryName(entityClass.getSimpleName());
String sql = "SELECT * FROM " + tableName + " WHERE " + primaryName + " = ?";
return (T) jdbcTemplate.query(sql,
new DefaultRowMapper(entityClass, this.getActualNameHandler()), id).get(0);
}
/**
* 查询全部记录
*
* @return
*/
public List<T> findAll() {
String sql = "SELECT * FROM "
+ this.getActualNameHandler().getTableName(entityClass.getSimpleName());
return (List<T>) jdbcTemplate.query(sql,
new DefaultRowMapper(entityClass, this.getActualNameHandler()));
}
/**
* 查询记录数
*
* @param entity
* @return
*/
public int queryCount(T entity) {
String tableName = this.getActualNameHandler().getTableName(entityClass.getSimpleName());
StringBuilder countSql = new StringBuilder("select count(*) from ");
countSql.append(tableName);
SqlContext sqlContext = SqlUtils.buildQueryCondition(entity, this.getActualNameHandler());
if (sqlContext.getSql().length() > 0) {
countSql.append(" where ");
countSql.append(sqlContext.getSql());
}
return jdbcTemplate.queryForObject(countSql.toString(), sqlContext.getParams().toArray(),Integer.class);
}
/* *//**
* 查询分页列表
*
* @param entity
* @return
*//*
public Pager queryPageList(T entity) {
Pager pager = new Pager();
PagingOrder pagingOrder = (PagingOrder) entity;
pager.setCurPage(pagingOrder.getCurPage());
pager.setItemsPerPage(pagingOrder.getItemsPerPage());
String tableName = this.getActualNameHandler().getTableName(entityClass.getSimpleName());
String primaryName = this.getActualNameHandler()
.getPrimaryName(entityClass.getSimpleName());
StringBuilder querySql = new StringBuilder("select * from ");
StringBuilder countSql = new StringBuilder("select count(*) from ");
querySql.append(tableName);
countSql.append(tableName);
//不调用queryCount方法，条件共同组装一次，减小反射获取的次数
SqlContext sqlContext = SqlUtils.buildQueryCondition(entity, this.getActualNameHandler());
if (sqlContext.getSql().length() > 0) {
querySql.append(" where ");
countSql.append(" where ");
querySql.append(sqlContext.getSql());
countSql.append(sqlContext.getSql());
}
querySql.append(" order by ");
querySql.append(primaryName);
querySql.append(" desc ");
querySql.append("limit ?,?");
List<Object> queryParams = new ArrayList<Object>(sqlContext.getParams());
queryParams.add(pager.getBeginIndex());
queryParams.add(pager.getItemsPerPage());
List<T> list = (List<T>) jdbcTemplate.query(querySql.toString(), queryParams.toArray(),
new DefaultRowMapper(entityClass, this.getActualNameHandler()));
int totalCount = jdbcTemplate.queryForInt(countSql.toString(), sqlContext.getParams()
.toArray());
pager.setList(list);
pager.setItems(totalCount);
return pager;
}*/
}
2.NameHandlersql
/**
* 把 驼峰法 改为 下划线 model userName -----> db user_name
*
* @zhuyuping
* @2015-3-30
* @doc:
*/
public class DefaultNameHandler implements NameHandler {
/**
* 根据实体名获取表名
*
* @param entityName
* @return
*/
@Override
public String getTableName(String entityName) {
//Java属性的骆驼命名法转换回数据库下划线“_”分隔的格式
return ColumnFormatUtil.underLineName(entityName);
}
/**
* 根据表名获取主键名
*
* @param entityName
* @return
*/
@Override
public String getPrimaryName(String entityName) {
// String underlineName = ColumnFormatUtil.underLineName(entityName);
// //正如前面说到的，数据库列名统一以“_”开始，主键以表名加上“_id” 如user表主键即“_user_id”
// return underlineName + PRI_SUFFIX;
return "id";
}
/**
* 根据属性名获取列名
*
* @param fieldName
* @return
*/
@Override
public String getColumnName(String fieldName) {
String underlineName = ColumnFormatUtil.underLineName(fieldName);
return underlineName;
}
public static void main(String[] args) {
System.out.println("DefaultNameHandler.main()"+new DefaultNameHandler().getColumnName("userName"));
System.out.println("DefaultNameHandler.main()"+new DefaultNameHandler().getTableName("userName"));
}
}
3.Mapper数据库
import java.beans.BeanInfo;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
import com.zsuper.base.utils.ClassUtils;
/**
*
*
* @zhuyuping
* @2014-3-30
* @doc:通用映射器
*/
public class DefaultRowMapper implements RowMapper<Object> {
/** 转换的目标对象 */
private Class<?> clazz;
/** 名称处理器 */
private NameHandler nameHandler;
public DefaultRowMapper(Class<?> clazz, NameHandler nameHandler) {
this.clazz = clazz;
this.nameHandler = nameHandler;
}
@Override
public Object mapRow(ResultSet resultSet, int i) throws SQLException {
Object entity = ClassUtils.newInstance(this.clazz);
BeanInfo beanInfo = ClassUtils.getSelfBeanInfo(this.clazz);
PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor pd : pds) {
String column = nameHandler.getColumnName(pd.getName());
Method writeMethod = pd.getWriteMethod();
if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
writeMethod.setAccessible(true);
}
try {
writeMethod.invoke(entity, resultSet.getObject(column));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
return entity;
}
}
4。Jdbcmybatis
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import com.zsuper.base.utils.SqlUtils;
public class JdbcExector {
/** 具体操做的实体类对象 */
/** 名称加工处理器 */
private NameHandler nameHandler;
/** spring jdbcTemplate 对象 */
@Autowired
protected JdbcTemplate jdbcTemplate;
/**
* 构造方法，获取运行时的具体实体对象
*/
public JdbcExector() {
}
/**
* 获取实际运行时的名称处理器
*
* @return
*/
private NameHandler getActualNameHandler() {
if (nameHandler == null) {
synchronized (this) {
if (nameHandler == null) {
nameHandler = this.getNameHandler();
}
}
}
return nameHandler;
}
/**
* 获得名称处理器，子类覆盖此方法实现本身的名称转换处理器
*
* @return
*/
protected NameHandler getNameHandler() {
return new DefaultNameHandler();
}
/**
* 插入一条记录
*
* @param entity
* @throws Exception
* @throws IllegalArgumentException
*/
public <T> Long insert(T entity) throws Exception {
final SqlContext sqlContext = SqlUtils.buildInsertSql(entity, this.getActualNameHandler());
System.out.println(entity+"==="+sqlContext.getSql());
/*KeyHolder keyHolder = new GeneratedKeyHolder();
jdbcTemplate.update(new PreparedStatementCreator() {
public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
PreparedStatement ps = con.prepareStatement(sqlContext.getSql().toString(),
new String[] { sqlContext.getPrimaryKey() });
int index = 0;
for (Object param : sqlContext.getParams()) {
index++;
ps.setObject(index, param);
}
return ps;
}
}, keyHolder);
return keyHolder.getKey().longValue();*/
return null;
}
public static void main(String[] args) throws Exception {
//new JdbcExector().insert(TestUser.class);
TestUser testUser=new TestUser();
testUser.setAge(22);
testUser.setCnName("xxx");
testUser.setTestUserId(1);
SqlContext context=SqlUtils.buildUpdateSql(testUser, new DefaultNameHandler());
System.out.println("JdbcExector.main() "+context.getSql());
}
}
5.SqlContext
/**
*
*
* @zhuyuping
* @2014-3-30
* @doc:sql 上下文
*/
public class SqlContext {
public StringBuilder getSql() {
return sql;
}
public void setSql(StringBuilder sql) {
this.sql = sql;
}
public String getPrimaryKey() {
return primaryKey;
}
public void setPrimaryKey(String primaryKey) {
this.primaryKey = primaryKey;
}
public List<Object> getParams() {
return params;
}
public void setParams(List<Object> params) {
this.params = params;
}
/** 执行的sql */
private StringBuilder sql;
/** 主键名称 */
private String primaryKey;
/** 参数，对应sql中的?号 */
private List<Object> params;
public SqlContext(StringBuilder sql, String primaryKey, List<Object> params) {
this.sql = sql;
this.primaryKey = primaryKey;
this.params = params;
}
}
相关文章
- 1. 泛型使用
- 2. 泛型简介，泛型类及使用
- 3. HashMap泛型使用
- 4. 泛型的使用
- 5. 泛型概念_自定义泛型、容器中使用泛型
- 6. Spring JDBC 的使用
- 7. 使用泛型和反射技术简化Spring jdbcTemplate的使用
- 8. c#泛型使用详解：泛型特色、泛型继承、泛型接口、泛型委托
- 9. Java泛型详解：Java泛型集合、泛型类、泛型方法、泛型的使用
- 10. Leopard Jdbc:简化Spring Jdbc使用
- 更多相关文章...
- • C# 泛型（Generic） - C#教程
- • Swift 泛型 - Swift 教程
- • Composer 安装与使用
- • 使用Rxjava计算圆周率
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
欢迎关注本站公众号,获取更多信息
