package com.jdbctemplate;
import java.util.List;
import java.util.Map;
public interface JdbcTemplateDao {
/**
* 原生插入
*/
public int insert(String sql);
/**
* 原生插入+参数，采用问号占位符
*/
public int insert(String sql, final Object... args);
/**
* 批量插入，参数为一个LIST包含了多个数组
*/
public int[] batchInsert(String sql, final List<Object[]> args);
/**
* 批量更新或删除，参数为一个LIST包含了多个数组
*/
public int[] batchUpdateOrDelete(String sql, final List<Object[]> args);
/**
* 原生更新或删除
*/
public int updateOrDelete(String sql);
/**
* 原生更新或删除+参数，采用问号占位符
*/
public int updateOrDelete(String sql, final Object... args);
/**
* 原生查询，返回LIST包含了多个MAP
*/
public List<Map<String, Object>> execute(String sql);
/**
* 原生查询+参数，返回LIST包含了多个MAP
*/
public List<Map<String, Object>> execute(String sql, Object... args);
// public Object executeForObject(String sql);
// public Object executeForObject(String sql, Object... args);
/**
* 原生查询单个实例，返回一个MAP，采用key+value方式
*/
public Map<String, Object> executeForMap(String sql);
/**
* 原生查询单个实例+参数，返回一个MAP，采用key+value方式
*/
public Map<String, Object> executeForMap(String sql, Object... args);
/**
* 原生分页查询
*/
public Map<String, Object> executeForPageList(String sql, int curNum, int pageSize, boolean count);
/**
* 原生分页查询+参数
*/
public Map<String, Object> executeForPageList(String sql, int curNum, int pageSize, Object[] params, boolean count);
/**
* 原生查总数，返回一个Long型
*/
public Long getCount(String sql);
/**
* 原生查总数+参数，返回一个Long型
*/
public Long getCount(String sql, Object... args);
}
package com.jdbctemplate.impl;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.util.ByteSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementSetter;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.stereotype.Repository;
import com.hesc.urp.Constants;
import com.jdbctemplate.JdbcTemplateDao;
/**
*
* @Title JdbcTemplateDaoImpl.java
* @Description TODO(JdbcTemplate操作，替代mybaits，使用无pojo类的方式)
*/
@Repository
public class JdbcTemplateDaoImpl implements JdbcTemplateDao {
private static final Logger logger = Logger.getLogger(JdbcTemplateDaoImpl.class);
@Autowired
private JdbcTemplate jdbcTemplate;
/**
*
* @Description （insert+sql）
* @param sql
* @return
* @date 2017年11月28日
*/
public int insert(String sql) {
return insert(sql, new Object[] {});
}
/**
*
* @Description （insert+sql+args，避免sql注入）
* @param sql
* @param args
* @return
* @date 2017年11月28日
*/
public int insert(final String sql, final Object... args) {
logger.info("***sql=[" + sql + "]");
// return updateOrDelete(sql, new Object[] {});
long starttime = System.currentTimeMillis();
int affectedLine = 0;
affectedLine = jdbcTemplate.update(sql, new PreparedStatementSetter() {
public void setValues(PreparedStatement ps) throws SQLException {
if (args != null && args.length > 0) {
for (int i = 0, len = args.length; i < len; i++) {
ps.setObject(i + 1, args[i]);
}
}
}
});
long endtime = System.currentTimeMillis();
logger.info("insert耗时：" + (endtime - starttime) + "ms");
return affectedLine;
}
/**
*
* @Description （updateOrDelete+sql）
* @param sql
* @return
* @date 2017年11月28日
*/
public int updateOrDelete(String sql) {
return updateOrDelete(sql, new Object[] {});
}
/**
*
* @Description （updateOrDelete+sql+args，避免sql注入）
* @param sql
* @param args
* @return
* @date 2017年11月28日
*/
public int updateOrDelete(String sql, final Object... args) {
logger.info("***sql=[" + sql + "]");
long starttime = System.currentTimeMillis();
int affectedLine = 0;
// if (args.length > 0) {
// affectedLine = jdbcTemplate.update(sql, args);
// } else {
// affectedLine = jdbcTemplate.update(sql);
// }
affectedLine = jdbcTemplate.update(sql, new PreparedStatementSetter() {
public void setValues(PreparedStatement ps) throws SQLException {
if (args != null && args.length > 0) {
for (int i = 0, len = args.length; i < len; i++) {
ps.setObject(i + 1, args[i]);
}
}
}
});
long endtime = System.currentTimeMillis();
logger.info("updateOrDelete耗时：" + (endtime - starttime) + "ms");
return affectedLine;
}
/**
*
* @Description （batchInsert+sql+args）
* @param sql
* @param args
* @return
* @date 2017年11月29日
*/
public int[] batchInsert(String sql, final List<Object[]> args) {
logger.info("***sql=[" + sql + "]");
if (args != null && args.size() > 0) {
long starttime = System.currentTimeMillis();
int[] affectline = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
@Override
public void setValues(PreparedStatement ps, int i) throws SQLException {
Object[] objs = args.get(i);
if (args != null && objs.length > 0) {
for (int j = 0, len = objs.length; j < len; j++) {
ps.setObject(j + 1, objs[j]);
}
}
}
@Override
public int getBatchSize() {
return args.size();
}
});
long endtime = System.currentTimeMillis();
logger.info("batchInsert耗时：" + (endtime - starttime) + " ms");
return affectline;
} else {
logger.info("args数组不可为空！");
return new int[] {};
}
}
/**
*
* @Description （batchUpdateOrDelete+sql+args）
* @param sql
* @param args
* @return
* @date 2017年11月29日
*/
public int[] batchUpdateOrDelete(String sql, final List<Object[]> args) {
logger.info("***sql=[" + sql + "]");
if (args != null && args.size() > 0) {
long starttime = System.currentTimeMillis();
int[] affectline = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
@Override
public void setValues(PreparedStatement ps, int i) throws SQLException {
Object[] objs = args.get(i);
if (args != null && objs.length > 0) {
for (int j = 0, len = objs.length; j < len; j++) {
ps.setObject(j + 1, objs[j]);
}
}
}
@Override
public int getBatchSize() {
return args.size();
}
});
long endtime = System.currentTimeMillis();
logger.info("batchUpdateOrDelete耗时：" + (endtime - starttime) + " ms");
return affectline;
} else {
logger.info("args数组不可为空！");
return new int[] {};
}
}
/**
*
* @Description （execute+sql）
* @param sql
* @return
* @date 2017年11月28日
*/
public List<Map<String, Object>> execute(String sql) {
return execute(sql, new Object[] {});
}
/**
*
* @Description （execute+sql+args）
* @param sql
* @param args
* @return
* @date 2017年11月28日
*/
public List<Map<String, Object>> execute(String sql, Object... args) {
logger.info("***sql=[" + sql + "]");
long starttime = System.currentTimeMillis();
List<Map<String, Object>> map = null;
if (args.length > 0) {
map = jdbcTemplate.queryForList(sql, args);
} else {
map = jdbcTemplate.queryForList(sql);
}
long endtime = System.currentTimeMillis();
logger.info("execute耗时：" + (endtime - starttime) + "ms");
return map;
}
/**
*
* @Description （executeForObject+sql）
* @param sql
* @return
* @date 2017年11月29日
*/
public Object executeForObject(String sql) {
return executeForObject(sql, new Object[] {});
}
/**
*
* @Description （executeForObject+sql+args）
* @param sql
* @param args
* @return
* @date 2017年11月29日
*/
public Object executeForObject(String sql, Object... args) {
logger.info("***sql=[" + sql + "]");
long starttime = System.currentTimeMillis();
Object obj = null;
if (args.length > 0) {
obj = jdbcTemplate.queryForObject(sql, args, Object.class);
} else {
obj = jdbcTemplate.queryForObject(sql, Object.class);
}
long endtime = System.currentTimeMillis();
logger.info("executeForObject耗时：" + (endtime - starttime) + "ms");
return obj;
}
/**
*
* @Description （executeForMap+sql）
* @param sql
* @return
* @date 2017年11月29日
*/
public Map<String, Object> executeForMap(String sql) {
return executeForMap(sql, new Object[] {});
}
/**
*
* @Description （executeForMap+sql+args）
* @param sql
* @param args
* @return
* @date 2017年11月29日
*/
public Map<String, Object> executeForMap(String sql, Object... args) {
logger.info("***sql=[" + sql + "]");
long starttime = System.currentTimeMillis();
Map<String, Object> map = null;
if (args.length > 0) {
map = jdbcTemplate.queryForMap(sql, args);
} else {
map = jdbcTemplate.queryForMap(sql);
}
long endtime = System.currentTimeMillis();
logger.info("executeForMap耗时：" + (endtime - starttime) + "ms");
return map;
}
/**
*
* @Description （executeForPageList+sql+curNum+pageSize）
* @param sql
* @param curNum
* @param pageSize
* @return
* @date 2017年11月29日
*/
public Map<String, Object> executeForPageList(String sql, int curNum, int pageSize, boolean count) {
return executeForPageList(sql, curNum, pageSize, new Object[] {}, count);
}
/**
*
* @Description （executeForPageList+sql+curNum+pageSize+args）
* @param sql
* @param curNum
* @param pageSize
* @param args
* @return
* @date 2017年11月30日
*/
public Map<String, Object> executeForPageList(String sql, int curNum, int pageSize, Object[] args, boolean count) {
logger.info("***sql=[" + sql + "]");
long starttime = System.currentTimeMillis();
Map<String, Object> map = new HashMap<String, Object>();
long totalrecord = 0;
if (count) { // 是否count查询，默认false
// 记录统计
totalrecord = getCount(sql, args).longValue();
}
// 2. sql封装
int start = pageSize * (curNum - 1);
// int end = pageSize * curNum;
String searchsql = sql + " limit " + start + " , " + pageSize;
List<Map<String, Object>> mapList = null;
if (args.length > 0) {
mapList = jdbcTemplate.queryForList(searchsql, args);
} else {
mapList = jdbcTemplate.queryForList(searchsql);
}
// 5.统一返回map封装数据
map.put("totalrecord", totalrecord);
map.put("list", mapList);
// 计时
long endtime = System.currentTimeMillis();
logger.info("executeForPageList耗时：" + (endtime - starttime) + "ms");
return map;
}
/**
*
* @Description （getCount+sql）
* @param sql
* @return
* @date 2017年11月28日
*/
public Long getCount(String sql) {
return getCount(sql, new Object[] {});
}
/**
*
* @Description （getCount+sql+args）
* @param sql
* @param args
* @return
* @date 2017年11月28日
*/
public Long getCount(String sql, Object... args) {
logger.info("***sql=[" + sql + "]");
long starttime = System.currentTimeMillis();
// sql = sql.toLowerCase();
// int whereIndex = sql.indexOf("from");
// String whereSql = sql.substring(whereIndex);
// int orderIndex = whereSql.indexOf("order by");
// if (orderIndex > 0) {
// whereSql = whereSql.substring(0, orderIndex - 1);
// }
String countSQL = "select count(*) count from (" + sql + ") a";
long countSum = 0;
if (args != null && args.length > 0) {
countSum = jdbcTemplate.queryForObject(countSQL, args, Long.class);
} else {
countSum = jdbcTemplate.queryForObject(countSQL, Long.class);
}
long endtime = System.currentTimeMillis();
logger.info("getCount耗时：" + (endtime - starttime) + "ms");
return countSum;
}
public static void main(String[] args) {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl(
"jdbc:mysql://127.0.0.1:3306/db?rewriteBatchedStatements=true&useUnicode=true&characterEncoding=utf-8");
dataSource.setUsername("root");
dataSource.setPassword("123456");
// 创建jdbcTemplate对象
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "SELECT id, username FROM `urp_user` where createtime= 1540000000000";
List<Map<String, Object>> mapList = jdbcTemplate.queryForList(sql);
for (Map<String, Object> map : mapList) {
// 处理
String updateSql = "update `urp_user` set `password` = ? where id = ? ";
String username = map.get("username").toString();
System.out.println(username+"="+username.substring(username.length()-4));
String password = new Md5Hash("rmtj"+username.substring(username.length()-4), ByteSource.Util.bytes(Constants.HESCSALT), 2).toHex();
jdbcTemplate.update(updateSql, new Object[] { password, map.get("id") });
}
}
}
相关推荐
原生jdbc
JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问解决部分mybatis或者hibernate不支持的数据库，例informix。通过pool连接池提高性能，并将...
本教程将详细讲解如何使用JSP、Servlet和JDBC（Java Database Connectivity）原生实现对数据库的增删改查操作，无需依赖任何框架。这个项目适合Java Web开发初学者，通过学习，你可以了解到基础的数据库交互逻辑。 ...
这个小项目是以前学习servlet的时候写的，前端用的是bootstrap框架，脚本都是用的JQuery，后台用的是原生的servlet和JDBC，只对JDBC做了初步的封装,对想要了解servlet与后台交互基层只是和JDBC原生样式有一些帮助，...
本篇将详细介绍如何基于原生的MySQL JDBC实现一个简单的分页组件，这对于初学者理解数据库操作和分页原理非常有帮助。 1. **JDBC基础**： JDBC是Java访问数据库的标准接口，它提供了连接数据库、执行SQL语句、处理...
Java Database Connectivity（JDBC）是Java编程语言中用于与关系数据库交互的一组接口和类。它是Java标准API的一部分，由Sun ...在实际开发中，根据项目需求选择合适的数据访问策略，如使用JDBC原生方式或结合ORM框架。
Java原生JDBC（Java Database Connectivity）是Java语言与数据库交互的标准接口，它允许开发者编写数据库无关性的代码，实现对各种数据库的操作。本教程将详细讲解如何使用Java原生JDBC进行数据的增删改查操作。 ...
原包存在一个bug，请下载该版本 boolean delete(java.lang.String sql) 删除单条记录的方法，适用于简单的sql语句 boolean delete(java.lang.String sql, java.util.Map,java.lang.Object> elements) ...
此外，由于这个框架是基于 JDBC 原生写的，因此它可以充分利用 JDBC API 提供的所有功能，包括执行 SQL 语句、事务管理、结果集处理等。同时，JDBC API 的灵活性也意味着开发者可以根据需求自定义数据访问层，实现更...
JDBC原生方法操作mysql（封装了公共的增删改查方法，参看src.model.access.Connect.java） MVC作为整体架构 密码加密使用MD5 操作 普通用户账号：20170755101 密码：123456 管理员默认账号：123123 密码：123123 ...
例如说jdbc，dbutil+C3p0，hibernate,jdbcTemplate等等【这五个都会总结】，到后面的话使用一些高级的框架去操作数据库，比如hibernate。但是底层操作数据库是重要的，高级框架也是也底层为基础搭建的，所以这里还是...
这个工具类通常封装了JDBC（Java Database Connectivity）API，隐藏了繁琐的数据库连接管理和资源释放过程，使得开发者可以更专注于业务逻辑。 首先，DBHelper需要包含数据库连接的配置信息，如数据库URL、用户名和...
原生JDBC（Java Database Connectivity）是Java编程语言中用于与关系数据库进行交互的一种标准接口。在"原生jdbc超市订单管理系统"项目中，开发者直接使用JDBC API进行数据库操作，而不是依赖于任何ORM（对象关系...
宠物管理系统基于jdbc最基层原生框架系列是一个适合初学者或对源码不太熟悉的开发者学习的项目。这个系统可能涵盖了数据库操作、用户身份验证以及会话管理等基础IT知识点。让我们详细了解一下这些关键概念。 首先，...
本文将详细介绍使用Java调用存储过程的三种方法：通过Hibernate框架、使用JDBC原生方式以及结合Hibernate的SQLQuery接口。 #### 一、通过Hibernate框架调用存储过程 Hibernate是一个非常流行的Java持久化框架，它...
## jdbc操作mysql数据库基础编程## 作者：空哥### 代码说明：* 主要的编码在单元测试模块JdbcTests，通过jdbc原生代码编写mysql数据库的增删改查操作* 无复杂配置* 支持Spring管理* 对于初学者，刚接触数据库存储，...
现在的数据层的开发，大多会使用...但是在一些极端的场景下往往原生的jdbc方式操作数据库更灵活，性能更高。由于部分场景下MyBatis或JPA之类无法满足我的需求，所以我打算自己封装一套查数据库的工具类。 文章地址： ...
Java Database Connectivity (JDBC) 是Java编程语言中用于与各种类型数据库交互的一组标准API。JDBC Jar包是实现这一连接功能的核心库，它包含了所有必要的类和接口，使得Java开发者能够编写程序来访问和操作数据库...
这个驱动扩展了sqljdbc41.jar的功能，包括对Java 8日期和时间类型的原生支持，增强的SSL加密选项，以及更全面的JMX（Java Management Extensions）监控支持。这使得开发者可以更好地利用Java 8的新特性来管理数据库...
基于jsp+js+servlet+jdbc+mysql开发产品后台管理系统，实现用户增删改查、分页，登录，注册，图片上传等功能。 包括以下5个功能： 1、登录 用户默认主页index.jsp,可选择【登录】功能，若登录成功，则进入产品管理中...