day5 - JDBC技术(一)
Java访问数据库技术概述
在JDBC出现之前,早期java需要访问数据库时,需要根据不同的数据库管理系统(DBMS)编写不同的数据源,使用一项称之为JDBC-ODBC桥链接模式。
通过以上访问方式,程序员会在访问数据方面花费大把精力,因此SUN在后来设计的JDBC接口,将访问数据库的具体实现交给不同的数据库厂商各自实现,从而减少java程序的压力。
JDBC入门
JDBC(Java Database Connectivity),java 链接数据库技术,是由java.sql包中提供的一系列接口构成,通过这些接口结合不同的数据库管理系统的驱动包,可以非常轻松的实现java访问数据库。
入门案例
//1.加载数据库驱动(注册驱动) JDBC4之后无需编写
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mydb2", "root", "123456");
//3.获取执行sql语句命令的对象
Statement stat = conn.createStatement();
//4.执行sql
boolean f = stat.execute("insert into tbuser(username,password) values('java-jdbc','112233')");
//5.处理结果
System.out.println("执行结果:"+f);
//6.关闭资源
stat.close();
conn.close();
JDBC相关接口介绍
jdbc中常用的类和接口:
- DriverManager
- Connection
- Statement/PreparedStatement
- ResultSet
DriverManager
驱动管家类,java.sql中提供的一个具体类,内部包含了一些用于加载数据库驱动的方法以及获取连接的操作:getConnection
使用DriverManager获取数据库连接的三种方式
// 方法一:
Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mydb2", "root", "123456");
//方法二:
// Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mydb2?user=root&password=123456");
//方法三:
// Properties info = new Properties();
// info.put("user", "root");
// info.put("password","123456");
// Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mydb2", info);
Connection
Connection用于表示从Java程序到数据库的连接通道,通过Connection可以向数据库传输sql命令,并且返回执行结果.另外Connection也可以用于对数据库事务管理,具体使用:
//获取执行sql的命令对象
Statement stat = connection.createStatement();
//获取sql语句的预处理对象(防止sql注入)
PreparedStatement ps = connection.parepareStatement();
//获取一个用于发送存储过程调用命令对象
CallableStatement pc = connection.prepareCall();
//设置禁止事务自动提交
connection.setAutoCommit(false);
//回滚事务
connection.rollback();
//事务提交
connection.commit();
Statement&PreparedStatement
是一个用于执行sql命令的对象,主要用于执行静态sql(事先准备好的,固定的);由于Statement的固有不安全性(很有可能导致sql注入的风险),因此还提供一个直接子接口:PreparedStatement(预处理命令对象),可以有效的防止sql注入的风险。
Statement中提供的常见方法:
- boolean execute(String sql)
- int executeUpdate(String sql)
- ResultSet executeQuery(String sql)
PreparedStatement提供的方法:
- int executeUpdate();
- ResultSet executeQuery();
//方式SQL注入,使用PreparedStatement
public static void login2(String username,String password) throws ClassNotFoundException, SQLException {
String sql = "select * from tbuser where username=? and password=?";
//1.加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
Connection conn = DriverManager.getConnection("jdbc:mysql:///mydb2", "root", "123456");
//3.获取预处理sql命令的对象(对传入的sql与进行预编译,防止出现sql注入问题)
PreparedStatement ps = conn.prepareStatement(sql);
//预处理
ps.setString(1, username);
ps.setString(2, password);
//4.执行
ResultSet rs = ps.executeQuery();
//5.处理结果
if(rs.next()) {
System.out.println("登录成功!");
}else {
System.out.println("请检查账号和密码!");
}
//6.关闭资源
rs.close();
ps.close();
conn.close();
}
//Statement可能导致sql注入
public static void login(String username,String password) throws ClassNotFoundException, SQLException {
String sql = "select * from tbuser where username='" + username + "' and password='" + password + "'";
System.out.println("执行sql语句:" + sql);
//1.加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
Connection conn = DriverManager.getConnection("jdbc:mysql:///mydb2", "root", "123456");
//3.获取处理sql命令的对象
Statement stat = conn.createStatement();
//4.执行sql
ResultSet rs = stat.executeQuery(sql);
//5.处理结果
if(rs.next()) {
System.out.println("登录成功!");
}else {
System.out.println("请检查账号和密码!");
}
//6.关闭资源
rs.close();
stat.close();
conn.close();
}
测试:
login2("sdrfsdf", "' or '1=1");
Statement和PreparedStatement的区别?
Statement是原始的执行sql命令的对象,不对sql语句做任何处理,可能会因为传入的参数问题导致sql注入,因此存在注入的风险;所以在实际开发中更加推荐使用PreparedStatement,该接口的实现针对sql语句进行了预编译,解决了可能出现的sql注入风险;另外PreparedStatement内部使用预编译机制,从运行效率来看,略高于Statement。
ResultSet
结果集对象,用于表示对于查询语句执行之后的结果,内部的数据可能是一条也可以是多条
CRUD操作
CRUD,增删改查,基于Java对数据库表中的数据进行增删改查操作(insert ,delete,update,select)
CRUD操作
package com.softeem.lesson48.crud;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.softeem.lesson48.utils.DBUtils;
public class UserCRUD {
private Connection conn;
/**
* 添加数据
* @param username
* @param password
* @return
* @throws ClassNotFoundException
* @throws SQLException
*/
public boolean insert(String username,String password) throws ClassNotFoundException, SQLException {
PreparedStatement ps = null;
try {
//DBUtil类参考JDBC基本封装
conn = DBUtils.getConn();
String sql = "insert into tbuser(username,password) values(?,?)";
//3.获取sql语句预处理对象
ps = conn.prepareStatement(sql);
ps.setString(1, username);
ps.setString(2, password);
//4.执行
int i = ps.executeUpdate();
//5.处理结果
return i > 0;
}finally {
DBUtils.close(null, ps, conn);
}
}
/**
* 修改数据
* @param id
* @param password
* @return
* @throws ClassNotFoundException
* @throws SQLException
*/
public boolean update(int id,String password) throws ClassNotFoundException, SQLException {
String sql = "update tbuser set password=? where id=?";
PreparedStatement ps = null;
try {
conn = DBUtils.getConn();
//3.获取sql语句预处理对象
ps = conn.prepareStatement(sql);
ps.setString(1, password);
ps.setInt(2, id);
//4.执行
int i = ps.executeUpdate();
return i > 0;
}finally {
DBUtils.close(null, ps, conn);
}
}
/**
* 删除数据
* @param id
* @return
* @throws ClassNotFoundException
* @throws SQLException
*/
public boolean delete(int id) throws ClassNotFoundException, SQLException {
String sql = "delete from tbuser where id=?";
PreparedStatement ps = null;
try {
conn = DBUtils.getConn();
//3.获取sql语句预处理对象
ps = conn.prepareStatement(sql);
ps.setInt(1, id);
//4.执行
int i = ps.executeUpdate();
return i > 0;
}finally {
DBUtils.close(null, ps, conn);
}
}
/**
* 查询一条数据
* @param username
* @return
* @throws SQLException
*/
public Map<String,Object> selectOne(String username) throws SQLException{
//声明map作为返回值
Map<String,Object> map = new HashMap<String, Object>();
String sql = "select * from tbuser where username=?";
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = DBUtils.getConn();
//3.获取预处理是sql命令的对象
ps = conn.prepareStatement(sql);
ps.setString(1, username);
//4.执行查询
rs = ps.executeQuery();
if(rs.next()) {
//根据列的标签(默认列名,如有设置别名,则标签为别名)获取列值
int id = rs.getInt("id");
String name = rs.getString("username");
String pwd = rs.getString("password");
//将获取的数据装入map集合
map.put("id", id);
map.put("username", name);
map.put("password", pwd);
}
} finally {
DBUtils.close(rs, ps, conn);
}
return map;
}
/**
* 查询所有
* @return
* @throws SQLException
*/
public List<Map<String,Object>> selectAll() throws SQLException{
List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
String sql = "select * from tbuser";
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = DBUtils.getConn();
//3.获取预处理是sql命令的对象
ps = conn.prepareStatement(sql);
//4.执行查询
rs = ps.executeQuery();
while(rs.next()) {
Map<String,Object> map = new HashMap<String, Object>();
//根据列的标签(默认列名,如有设置别名,则标签为别名)获取列值
int id = rs.getInt("id");
String name = rs.getString("username");
String pwd = rs.getString("password");
//将获取的数据装入map集合
map.put("id", id);
map.put("username", name);
map.put("password", pwd);
list.add(map);
}
} finally {
DBUtils.close(rs, ps, conn);
}
return list;
}
public static void main(String[] args) throws ClassNotFoundException, SQLException {
UserCRUD crud = new UserCRUD();
// boolean f = crud.insert("softeem123", "123softeem");
// boolean f = crud.update(2, "666666");
// boolean f = crud.delete(12);
// System.out.println("执行结果:"+f);
// Map<String,Object> map = crud.selectOne("softeem");
List<Map<String, Object>> list = crud.selectAll();
list.forEach(u->System.out.println(u));
}
}
JDBC基本封装
/**
* 数据库工具类V1.0
* 将访问数据库的公共代码抽取:
* 1.加载驱动
* 2.获取连接
* 6.关闭资源
* @author mrchai
*
*/
public class DBUtils {
/**驱动类路径*/
private static final String DRIVER_CLASS="com.mysql.jdbc.Driver";
/**url地址*/
private static final String URL = "jdbc:mysql://127.0.0.1:3306/mydb2";
/**数据库服务器登录用户名*/
private static final String USER = "root";
/**数据库服务器登录密码*/
private static final String PASSWORD = "123456";
static {
try {
//1.加载驱动
Class.forName(DRIVER_CLASS);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 2. 获取数据库连接对象
* @return
*/
public static synchronized Connection getConn() {
try {
return DriverManager.getConnection(URL, USER, PASSWORD);
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
/**
* 6.关闭资源
* @param rs
* @param stat
* @param conn
*/
public static void close(ResultSet rs,Statement stat,Connection conn) {
try {
if(rs != null)rs.close();
if(stat != null)stat.close();
if(conn != null)conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
day3 - JDBC(三)
ResultSetMetaData
public class ResultSetMetaDataDemo {
public static void main(String[] args) throws SQLException {
String sql = "select * from tblog";
Connection conn = DBUtils.getConn();
PreparedStatement ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
//获取结果集的元数据
ResultSetMetaData rsmd = rs.getMetaData();
//查询的列数
int count = rsmd.getColumnCount();
System.out.println("查询总列数:"+count);
while(rs.next()) {
//遍历所有的列
for (int i = 1; i <= count; i++) {
//获取列名称
String name = rsmd.getColumnName(i);
String label = rsmd.getColumnLabel(i);
int type = rsmd.getColumnType(i);
Object value = rs.getObject(label);
System.out.print(name+"--"+label+"--"+type+"==="+value);
}
System.out.println();
}
}
}
基于反射实现查询封装
/**
* 封装通用查询单条数据的方法
*
* JDBC,反射,集合框架,lambda表达式,新增Objects类
*
* @param <T>
* @param t
* @param sql
* @param params
* @return
*/
public static <T> T queryOne(Class<T> t, String sql, Object... params) {
// 获取查询到到数据集合
List<Map<String, Object>> list = queryMaps(sql, params);
if (list.size() > 0) {
// 获取一个Map对象
Map<String, Object> map = list.get(0);
// 将map集合转换为Javabean并返回
return mapToBean(map, t);
}
return null;
}
/**
* 封装通用查询多条数据的方法
*
* @param <T>
* @param t
* @param sql
* @param params
* @return
*/
public static <T> List<T> queryList(Class<T> t, String sql, Object... params) {
List<T> list = new ArrayList<T>();
// 获取所有查询的到的数据
List<Map<String, Object>> maps = queryMaps(sql, params);
// 遍历集合中每一条数据(map)
maps.forEach(m -> {
// 将map转换为Javabean
T obj = mapToBean(m, t);
// 将Javabean装入list
list.add(obj);
});
return list;
}
/**
* 将Map集合转换为一个确定的类型
*
* @param <T>
* @param map
* @param t
* @return
*/
private static <T> T mapToBean(Map<String, Object> map, Class<T> t) {
// T obj = null;
try {
// 根据提供的Class对象创建对应类型的Object
T obj = t.newInstance();
map.forEach((k, v) -> {
try {
// 根据Field名称获取字段对象
Field field = t.getDeclaredField(k);
// 设置字段的可访问性
field.setAccessible(true);
// 为字段设置值
field.set(obj, v);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
});
return obj;
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
// 返回对象
return null;
}
/**
* 执行相关查询并将结果返回为List<Map<String,Object>> 集合
*
* @param sql
* @param params
* @return
*/
public static List<Map<String, Object>> queryMaps(String sql, Object... params) {
// 声明动态数组用于存储每一个查询到的Map对象
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
// 获取连接
Connection conn = getConn();
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 获取预处理sql命令的对象
ps = conn.prepareStatement(sql);
if (params != null) {
for (int i = 0; i < params.length; i++) {
// 对指定位置的占位符填充值(预处理)
ps.setObject(i + 1, params[i]);
}
}
// 执行查询获取结果集
rs = ps.executeQuery();
// 获取结果集的元数据对象ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 获取总查询列数
int columnCount = rsmd.getColumnCount();
// 遍历结果集
while (rs.next()) {
// 声明map集合存储每一条数据(临时缓存)
Map<String, Object> map = new HashMap<String, Object>();
// 遍历获取每一列的信息
for (int i = 1; i <= columnCount; i++) {
// 获取列名称(作为map集合的键)
String key = rsmd.getColumnName(i);
// 获取列标签
String label = rsmd.getColumnLabel(i);
// 获取列值(作为map集合的值)
Object value = rs.getObject(label);
if (Objects.nonNull(value)) {
// 将取到的每一列的列名与列值存储到map
map.put(key, value);
}
}
// 将map集合装入list
list.add(map);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
close(rs, ps, conn);
}
return list;
}
/**
* 根据提供的查询语句以及查询参数,返回符合条件的数目
*
* @param sql
* @param params
* @return
*/
public static int queryCount(String sql, Object... params) {
Connection conn = getConn();
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = conn.prepareStatement(sql);
if (params != null) {
for (int i = 0; i < params.length; i++) {
ps.setObject(i + 1, params[i]);
}
}
rs = ps.executeQuery();
if(rs.next()) {
return rs.getInt(1);
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
close(rs, ps, conn);
}
return 0;
}
DBUtils完全版
package com.softeem.lesson50.utils;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Properties;
/**
* ORM框架(Mybatis,Hibernate,spring Data JPA)
* 数据库工具类V2.0 将访问数据库的公共代码抽取: 1.加载驱动 2.获取连接 6.关闭资源
* @author mrchai
*
*/
public class DBUtils {
/** 驱动类路径 */
private static String DRIVER_CLASS;
/** url地址 */
private static String URL;
/** 数据库服务器登录用户名 */
private static String USER;
/** 数据库服务器登录密码 */
private static String PASSWORD;
static {
try {
//读取属性文件获取连接数据库相关的字符串
InputStream is = DBUtils.class.getResourceAsStream("/jdbc.properties");
//创建属性对象
Properties p = new Properties();
//加载包含属性信息的输入流
p.load(is);
//根据属性名获取属性值
DRIVER_CLASS = p.getProperty("driver");
URL = p.getProperty("url");
USER = p.getProperty("user");
PASSWORD = p.getProperty("password");
// 1.加载驱动
Class.forName(DRIVER_CLASS);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 2. 获取数据库连接对象
*
* @return
*/
public static synchronized Connection getConn() {
try {
return DriverManager.getConnection(URL, USER, PASSWORD);
} catch (SQLException e) {
e.printStackTrace();
}![在这里插入图片描述](https://img-blog.csdnimg.cn/20200807160919204.png)
return null;
}
/**
* 6.关闭资源
*
* @param rs
* @param stat
* @param conn
*/
public static void close(ResultSet rs, Statement stat, Connection conn) {
try {
if (rs != null)
rs.close();
if (stat != null)
stat.close();
if (conn != null)
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 封装通用的更新操作:INSERT UPDATE DELETE
*
* @param sql
* @param params Object[] params
* @return
*/
public static boolean exeUpdate(String sql, Object... params) {
// 获取连接
Connection conn = getConn();
PreparedStatement ps = null;
try {
ps = conn.prepareStatement(sql);
if (params != null) {
for (int i = 0; i < params.length; i++) {
ps.setObject(i + 1, params[i]);
}
}
return ps.executeUpdate() > 0;
} catch (SQLException e) {
e.printStackTrace();
} finally {
close(null, ps, conn);
}
return false;
}
/**
* 封装通用查询单条数据的方法
*
* JDBC,反射,集合框架,lambda表达式,新增Objects类
*
* @param <T>
* @param t
* @param sql
* @param params
* @return
*/
public static <T> T queryOne(Class<T> t, String sql, Object... params) {
// 获取查询到到数据集合
List<Map<String, Object>> list = queryMaps(sql, params);
if (list.size() > 0) {
// 获取一个Map对象
Map<String, Object> map = list.get(0);
// 将map集合转换为Javabean并返回
return mapToBean(map, t);
}
return null;
}
/**
* 封装通用查询多条数据的方法
*
* @param <T>
* @param t
* @param sql
* @param params
* @return
*/
public static <T> List<T> queryList(Class<T> t, String sql, Object... params) {
List<T> list = new ArrayList<T>();
// 获取所有查询的到的数据
List<Map<String, Object>> maps = queryMaps(sql, params);
// 遍历集合中每一条数据(map)
maps.forEach(m -> {
// 将map转换为Javabean
T obj = mapToBean(m, t);
// 将Javabean装入list
list.add(obj);
});
return list;
}
/**
* 将Map集合转换为一个确定的类型
*
* @param <T>
* @param map
* @param t
* @return
*/
private static <T> T mapToBean(Map<String, Object> map, Class<T> t) {
// T obj = null;
try {
// 根据提供的Class对象创建对应类型的Object
T obj = t.newInstance();
// 获取Class中的所有Field
// Field[] fields = t.getDeclaredFields();
// //遍历获取每一个属性对象
// for (Field field : fields) {
// //获取属性名
// String fname = field.getName();
// //获取属性值
// Object value = map.get(fname);
// if(Objects.nonNull(value)) {
// //设置属性对象的可访问性
// field.setAccessible(true);
// //将从map中获取的值设置给属性 obj.name=XX
// field.set(obj, value);
// }
// }
map.forEach((k, v) -> {
try {
// 根据Field名称获取字段对象
Field field = t.getDeclaredField(k);
// 设置字段的可访问性
field.setAccessible(true);
// 为字段设置值
field.set(obj, v);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
});
return obj;
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
// 返回对象
return null;
}
/**
* 执行相关查询并将结果返回为List<Map<String,Object>> 集合
*
* @param sql
* @param params
* @return
*/
public static List<Map<String, Object>> queryMaps(String sql, Object... params) {
// 声明动态数组用于存储每一个查询到的Map对象
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
// 获取连接
Connection conn = getConn();
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 获取预处理sql命令的对象
ps = conn.prepareStatement(sql);
if (params != null) {
for (int i = 0; i < params.length; i++) {
// 对指定位置的占位符填充值(预处理)
ps.setObject(i + 1, params[i]);
}
}
// 执行查询获取结果集
rs = ps.executeQuery();
// 获取结果集的元数据对象ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 获取总查询列数
int columnCount = rsmd.getColumnCount();
// 遍历结果集
while (rs.next()) {
// 声明map集合存储每一条数据(临时缓存)
Map<String, Object> map = new HashMap<String, Object>();
// 遍历获取每一列的信息
for (int i = 1; i <= columnCount; i++) {
// 获取列名称(作为map集合的键)
String key = rsmd.getColumnName(i);
// 获取列标签
String label = rsmd.getColumnLabel(i);
// 获取列值(作为map集合的值)
Object value = rs.getObject(label);
if (Objects.nonNull(value)) {
// 将取到的每一列的列名与列值存储到map
map.put(key, value);
}
}
// 将map集合装入list
list.add(map);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
close(rs, ps, conn);
}
return list;
}
/**
* 根据提供的查询语句以及查询参数,返回符合条件的数目
*
* @param sql
* @param params
* @return
*/
public static int queryCount(String sql, Object... params) {
Connection conn = getConn();
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = conn.prepareStatement(sql);
if (params != null) {
for (int i = 0; i < params.length; i++) {
ps.setObject(i + 1, params[i]);
}
}
rs = ps.executeQuery();
if(rs.next()) {
return rs.getInt(1);
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
close(rs, ps, conn);
}
return 0;
}
}
连接池技术
由于数据库连接是一种资源,这种资源在使用前必须先创建,而这个创建过程是存在时间和空间的开销的,如果每次在执行数据库访问时都创建连接,并且使用完后要关闭连接,这个过程必然是效率低下的;因此,在实际开发中可以考虑在进行数据库操作前,先提前创建并维护一批数据库连接对象,当需要使用时,从这批对象中获取一个连接,用完之后再返还,从而避免了不必要的时间开销,提高程序的运行效率,这种技术在JDBC中称之为连接池技术(Connection Pool).
目前比较常用的连接池技术包含:apache-DBCP、C3P0(Spring/Hibernate框架在使用)、Proxool、阿里巴巴的Druid以及HikariCP(SpringBoot2.0默认连接池),这里我们分别使用Druid和HikariCP连接池:
Druid连接池使用
使用前先导入Druid的依赖:druid-1.1.9.jar
实现代码:
public class DruidDemo {
public static void main(String[] args) throws SQLException {
// 创建数据源
DruidDataSource dataSource = new DruidDataSource();
// dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/mydb2");
dataSource.setUsername("root");
dataSource.setPassword("123456");
// 设置最大链接数
dataSource.setMaxActive(5);
// 最小闲置链接数
dataSource.setMinIdle(1);
// 初始连接个数
dataSource.setInitialSize(2);
// 设置获取连接的最大等待时间
dataSource.setMaxWait(10000);
// 获取连接
Connection conn1 = dataSource.getConnection();
System.out.println("conn1:" + conn1);
Connection conn2 = dataSource.getConnection();
System.out.println("conn2:" + conn2);
Connection conn3 = dataSource.getConnection();
System.out.println("conn3:" + conn3);
Connection conn4 = dataSource.getConnection();
System.out.println("conn4:" + conn4);
new Thread() {
public void run() {
try {
sleep(15000);
//关闭第四个连接
conn4.close();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
};
}.start();
Connection conn5 = dataSource.getConnection();
System.out.println("conn5:" + conn5);
Connection conn6 = dataSource.getConnection();
System.out.println("conn6:" + conn6);
}
}
HikariCP使用
HikariCP使用需要以下几个依赖:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WlZ0GLXH-1596787504824)(assets\1596621762539.png)]
实现代码:
public class HikariCPDemo {
public static void main(String[] args) throws SQLException {
HikariDataSource ds = new HikariDataSource();
ds.setDriverClassName("com.mysql.jdbc.Driver");
ds.setJdbcUrl("jdbc:mysql://127.0.0.1:3306/mydb2");
ds.setUsername("root");
ds.setPassword("123456");
//设置最大链接数
ds.setMaximumPoolSize(10);
//设置最小闲置连接
ds.setMinimumIdle(1);
//设置最长等链接获取时间
ds.setConnectionTimeout(10000);
Connection conn = ds.getConnection();
System.out.println(conn);
}
}
通用工具类
/*
* # __----~~~~~~~~~~~------___
* # . . ~~//====...... __--~ ~~
* # -. \_|// |||\\ ~~~~~~::::... /~
* # ___-==_ _-~o~ \/ ||| \\ _/~~-
* # __---~~~.==~||\=_ -_--~/_-~|- |\\ \\ _/~
* # _-~~ .=~ | \\-_ '-~7 /- / || \ /
* # .~ .~ | \\ -_ / /- / || \ /
* # / ____ / | \\ ~-_/ /|- _/ .|| \ /
* # |~~ ~~|--~~~~--_ \ ~==-/ | \~--===~~ .\
* # ' ~-| /| |-~\~~ __--~~
* # |-~~-_/ | | ~\_ _-~ /\
* # / \ \__ \/~ \__
* # _--~ _/ | .-~~____--~-/ ~~==.
* # ((->/~ '.|||' -_| ~~-/ , . _||
* # -_ ~\ ~~---l__i__i__i--~~_/
* # _-~-__ ~) \--______________--~~
* # //.-~~~-~_--~- |-------~~~~~~~~
* # //.-~~~--\
*/
/*
* # __----~~~~~~~~~~~------___
* # . . ~~//====...... __--~ ~~
* # -. \_|// |||\\ ~~~~~~::::... /~
* # ___-==_ _-~o~ \/ ||| \\ _/~~-
* # __---~~~.==~||\=_ -_--~/_-~|- |\\ \\ _/~
* # _-~~ .=~ | \\-_ '-~7 /- / || \ /
* # .~ .~ | \\ -_ / /- / || \ /
* # / ____ / | \\ ~-_/ /|- _/ .|| \ /
* # |~~ ~~|--~~~~--_ \ ~==-/ | \~--===~~ .\
* # ' ~-| /| |-~\~~ __--~~
* # |-~~-_/ | | ~\_ _-~ /\
* # / \ \__ \/~ \__
* # _--~ _/ | .-~~____--~-/ ~~==.
* # ((->/~ '.|||' -_| ~~-/ , . _||
* # -_ ~\ ~~---l__i__i__i--~~_/
* # _-~-__ ~) \--______________--~~
* # //.-~~~-~_--~- |-------~~~~~~~~
* # //.-~~~--\
*/
/*
* # __----~~~~~~~~~~~------___
* # . . ~~//====...... __--~ ~~
* # -. \_|// |||\\ ~~~~~~::::... /~
* # ___-==_ _-~o~ \/ ||| \\ _/~~-
* # __---~~~.==~||\=_ -_--~/_-~|- |\\ \\ _/~
* # _-~~ .=~ | \\-_ '-~7 /- / || \ /
* # .~ .~ | \\ -_ / /- / || \ /
* # / ____ / | \\ ~-_/ /|- _/ .|| \ /
* # |~~ ~~|--~~~~--_ \ ~==-/ | \~--===~~ .\
* # ' ~-| /| |-~\~~ __--~~
* # |-~~-_/ | | ~\_ _-~ /\
* # / \ \__ \/~ \__
* # _--~ _/ | .-~~____--~-/ ~~==.
* # ((->/~ '.|||' -_| ~~-/ , . _||
* # -_ ~\ ~~---l__i__i__i--~~_/
* # _-~-__ ~) \--______________--~~
* # //.-~~~-~_--~- |-------~~~~~~~~
* # //.-~~~--\
*/
package lesson52.utils;
import com.alibaba.druid.pool.DruidDataSource;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;
/**
* ORM框架 (Mybatis )
* 数据库工具类v2.0
* 将访问的数据库的公共代码抽取
* 1.加载驱动
* 2.获取连接
* 6.关闭资源
*
* @author 法海打印
*/
public class DBUtils {
/**
* 驱动类路径
*/
private static String DRIVER_CLASS;
/**
* url地址
*/
private static String URL;
/**
* 数据库服务器登录用户名
*/
private static String USER;
/**
* 数据库服务器登录密码
*/
private static String PASSWORD;
/**
* 最大活动连接数
*/
private static int MAX_ACTIVE;
/**
* 最长等待连接获取的时间
*/
private static long MAX_WAIT;
/**
* 初始连接数
*/
private static int INIT_SIZE;
/**
* 声明连接池引用
*/
private static DruidDataSource ds;
static {
try {
//读取属性文件获取连接数据库的相关字符串
InputStream is = DBUtils.class.getResourceAsStream("/jdbc.properties");
//创建属性对象
Properties p = new Properties();
//加载包含属性信息的输入流
p.load(is);
//根据属性名获取属性值
DRIVER_CLASS = PASSWORD = p.getProperty("driver");
URL = p.getProperty("url");
USER = p.getProperty("user");
PASSWORD = p.getProperty("password");
//获取连接池相关配置
MAX_ACTIVE = Integer.parseInt(p.getProperty("pool.maxActive"));
INIT_SIZE = Integer.parseInt(p.getProperty("pool.initSize"));
MAX_WAIT = Long.parseLong(p.getProperty("pool.maxWait"));
//初始化连接池
init();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 初始化连接池
*/
public static void init() {
ds = new DruidDataSource();
ds.setDriverClassName(DRIVER_CLASS);
ds.setUrl(URL);
ds.setUsername(USER);
ds.setPassword(PASSWORD);
ds.setMaxActive(MAX_ACTIVE);
ds.setInitialSize(INIT_SIZE);
ds.setMaxWait(MAX_WAIT);
}
/**
* 2.获取数据库连接对象
* synchronized 线程私有
*
* @return
*/
public static synchronized Connection getConn() {
try {
//当连接池为null或者被关闭时,重新创建
if (ds == null || ds.isClosed()) {
init();
}
//从链接中获取一个连接并返回
return ds.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
/**
* 6.关闭资源
*
* @param rs
* @param stat
* @param conn
*/
public static void close(ResultSet rs, Statement stat, Connection conn) {
try {
if (rs != null) {
rs.close();
} ;
if (stat != null) {
stat.close();
} ;
if (conn != null) {
conn.close();
} ;
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 封装通用的更新操作: insert update delete
*
* @param sql
* @param params object[] params
* @return
*/
public static boolean exeUpdate(Connection conn,String sql, Object... params) {
PreparedStatement ps = null;
try {
ps = conn.prepareStatement(sql);
if (params != null) {
for (int i = 0; i < params.length; i++) {
ps.setObject(i + 1, params[i]);
}
}
return ps.executeUpdate() > 0;
} catch (SQLException e) {
e.printStackTrace();
}finally {
close(null,ps,null);
}
return false;
}
public static boolean exeUpdate(String sql, Object... params) {
Connection conn=getConn();
PreparedStatement ps = null;
try {
ps = conn.prepareStatement(sql);
if (params != null) {
for (int i = 0; i < params.length; i++) {
ps.setObject(i + 1, params[i]);
}
}
return ps.executeUpdate() > 0;
} catch (SQLException e) {
e.printStackTrace();
}finally {
close(null,ps,conn);
}
return false;
}
/**
* 封装通用查询单条数据的方法
*
* @param <T>
* @param t
* @param sql
* @param params
* @return
*/
public static <T> T queryOne(Class<T> t, String sql, Object... params) {
//获取查询到的数据集合
List<Map<String, Object>> list = queryMaps(sql, params);
if (list.size() > 0) {
//获取一个Map对象
Map<String, Object> map = list.get(0);
//将map集合转换为 javabean
return mapToBean(map, t);
}
return null;
}
/**
* 封装通用查询多条数据的方法
*
* @param <T>
* @param t
* @param sql
* @param params
* @return
*/
public static <T> List<T> queryList(Class<T> t, String sql, Object... params) {
List<T> list = new ArrayList<T>();
//获取所有查询到的数据
List<Map<String, Object>> maps = queryMaps(sql, params);
//遍历集合中每一条数据(map)
maps.forEach(m -> {
T obj = mapToBean(m, t);
//将javabean装入list
list.add(obj);
});
return list;
}
/**
* 将map集合转换为一个确定的类型
*
* @param <T>
* @param map
* @param t
* @return
*/
private static <T> T mapToBean(Map<String, Object> map, Class<T> t) {
T obj = null;
try {
//根据提供的Class对象创建对应类型的objct
obj = t.newInstance();
//获取Class中的所有的Filed
Field[] fields = t.getDeclaredFields();
//遍历获取每一个属性对象
for (Field field : fields) {
//获取属性名
String fname = field.getName();
//获取属性值
Object value = map.get(fname);
if (Objects.nonNull(value)) {
//设置属性对象的可访问性
field.setAccessible(true);
//将从map获取的属性值设置给属性 obj.XX=value
field.set(obj, value);
}
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
//返回对象
return obj;
}
/**
* 执行相关查询并将结果返回为List<Map<String, Object>>集合
*
* @param sql
* @param params
* @return
* @throws SQLException
*/
public static List<Map<String, Object>> queryMaps(String sql, Object... params) {
//声明动态数组用于存储每一个查询到的Map对象
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
//获取连接
Connection conn = getConn();
PreparedStatement ps = null;
ResultSet rs = null;
try {
//获取预处理sql命令的对象
ps = conn.prepareStatement(sql);
if (params != null) {
for (int i = 0; i < params.length; i++) {
//对指定位置的占位符填充(预处理)
ps.setObject(i + 1, params[i]);
}
}
//执行查询获取结果集
rs = ps.executeQuery();
//获取结果集元数据对象 ResultsetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
//获取总列数
int columnCount = rsmd.getColumnCount();
//遍历结果集
while (rs.next()) {
//声明map集合存储每一条数据(临时)
Map<String, Object> map = new HashMap<String, Object>();
//遍历获取每一列的数据
for (int i = 1; i <= columnCount; i++) {
//获取列名称(作为map集合的键)
String key = rsmd.getColumnName(i);
//获取列标签 (别名,没有的话就是列名)
String label = rsmd.getColumnLabel(i);
//获取列值(作为map集合的值)
Object value = rs.getObject(label);
if (Objects.nonNull(value)) {
//将取到的每一列的列名与列值存储到map
map.put(key, value);
}
}
//将map集合装入list
list.add(map);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
close(rs, ps, conn);
}
return list;
}
/**
* 根据提供的查询语句以及查询参数,返回符合条件的数目
*
* @param sql
* @param params
* @return
*/
public static int queryCount(String sql, Object... params) {
Connection conn = getConn();
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = conn.prepareCall(sql);
if (params != null) {
for (int i = 0; i < params.length; i++) {
ps.setObject(i + 1, params[i]);
}
}
rs = ps.executeQuery();
if (rs.next()) {
return rs.getInt(1);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
close(rs, ps, conn);
}
return 0;
}
public static void main(String[] args) {
}
}