Spring Jdbc 泛型使用
Spring Jdbc 泛型使用
zhuyuping 发表于2年前
Spring Jdbc 泛型使用
  • 发表于 2年前
  • 阅读 201
  • 收藏 14
  • 点赞 1
  • 评论 1

新睿云服务器60天免费使用,快来体验!>>>   

摘要: 其实一直以来 我使用了 很多hibernate mybatis 都挺简单,但是性能 方面 一直感觉一般般,个人偏向使用原生的jdbc 其实写起来 也挺简单的,当能力跨越了这一个层次的时候 ,这些mybatis hibernate 其实并不那么重要了 我其实也不再户什么框架不框架了 ,这里分享一个我常用的jdbc的类 。这是我去年一直使用的类,最开始在一个博客上收集的一个,但是缺少了 很多类,于是我自己补全了 所有的类,使用jdbc 原生类 jdbcTemplate性能 速度 还是很好的。我不太喜欢 mybatis 虽然mybatis mybatis 当类太多 mapper.xml太多的时...

其实一直以来 我使用了 很多hibernate mybatis 都挺简单,但是性能 方面 一直感觉一般般,个人偏向使用原生的jdbc 其实写起来 也挺简单的,当能力跨越了这一个层次的时候 ,这些mybatis hibernate 其实并不那么重要了 我其实也不再户什么框架不框架了 ,这里分享一个我常用的jdbc的类 。这是我去年一直使用的类,最开始在一个博客上收集的一个,但是缺少了 很多类,于是我自己补全了 所有的类,使用jdbc 原生类 jdbcTemplate性能 速度 还是很好的。我不太喜欢 mybatis 虽然mybatis mybatis 当类太多 mapper.xml太多的时候阅读起来很烦的。




1.BASEDAO

/**
 * 
 * 
 * @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.NameHandler

/**
 * 把 驼峰法 改成 下划线 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。Jdbc

   

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

}

  

  • 打赏
  • 点赞
  • 收藏
  • 分享
共有 人打赏支持
粉丝 299
博文 34
码字总数 50705
评论 (1)
自由鱼
不错,收藏了
×
zhuyuping
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: