Java访问数据库技术
JDBC(Java Database Connectivity),java 链接数据库技术，是由java.sql包中提供的一系列接口构成，通过这些接口结合不同的数据库管理系统的驱动包，可以非常轻松的实现java访问数据库
JDBC连接数据库的几个步骤：
- 加载数据库驱动(注册驱动) JDBC4之后无需编写；
- 获取连接对象
- 获取执行sql语句命令的对象
- 执行sql命令
- 返回处理结果
- 关闭资源；
示例：
//1.加载数据库驱动(注册驱动) JDBC4之后无需编写
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test", "root", "root");
//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中的常用接口
- DriverManager
- Connection
- Statement/PreparedStatement
- ResultSet
DriverManager
驱动管家类，java.sql中提供的一个具体类，内部包含了一些用于加载数据库驱动的方法以及获取连接的操作:getConnection
使用DriverManager获取数据库连接的三种方式：
// 方法一:
Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test", "root", "root");
//方法二：
Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test?user=root&password=root");
//方法三:
Properties info = new Properties();
info.put("user", "root");
info.put("password","root");
Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test", 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();
Statement和PreparedStatement的区别？
Statement是原始的执行sql命令的对象，不对sql语句做任何处理，可能会因为传入的参数问题导致sql注入，因此存在注入的风险；所以在实际开发中更加推荐使用PreparedStatement,该接口的实现针对sql语句进行了预编译，解决了可能出现的sql注入风险；另外PreparedStatement内部使用预编译机制，从运行效率来看，略高于Statement。
ResultSet
结果集对象，用于表示对于查询语句执行之后的结果，内部的数据可能是一条也可以是多条
CRUD操作
CRUD,增删改查，基于Java对数据库表中的数据进行增删改查操作(insert ,delete,update,select)
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));
}
}
DDL操作
示例：
public class DDLDemo {
public static void main(String[] args) throws SQLException {
String sql = "create table tblog("
+ "id int primary key auto_increment,"
+ "event_name varchar(30),"
+ "event_time timestamp default CURRENT_TIMESTAMP)";
Connection conn = DBUtils.getConn();
PreparedStatement ps = conn.prepareStatement(sql);
boolean f = ps.execute();
System.out.println(f);
DBUtils.close(null, ps, conn);
}
}
SQL语句批处理
public class JDBCBatchDemo {
public static void batchByPs() throws SQLException {
String sql = "insert into tblog(event_name) values(?)";
//eclipse：ctrl+1 idea：alt+enter
Connection conn = DBUtils.getConn();
PreparedStatement ps = conn.prepareStatement(sql);
for (int i = 0; i < 100000; i++) {
ps.setString(1, "数据添加"+i);
//批处理
ps.addBatch();
}
//执行
int[] results = ps.executeBatch();
for (int i : results) {
System.out.println("受影响数据行:"+i);
}
DBUtils.close(null, ps, conn);
}
public static void batchByStatement() throws SQLException {
String sql1 = "insert into tblog(event_name) values('查询100条数据')";
String sql2 = "delete from tblog where id>100";
String sql3 = "update tblog set event_name='修改前5条数据' where id<=5";
Connection conn = DBUtils.getConn();
Statement state = conn.createStatement();
state.addBatch(sql1);
state.addBatch(sql2);
state.addBatch(sql3);
int[] results = state.executeBatch();
for (int i : results) {
System.out.println("受影响数据行:"+i);
}
DBUtils.close(null, state, conn);
}
public static void main(String[] args) throws SQLException {
batchByStatement();
}
}
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();
}
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）.
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使用
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);
}
}
扫一扫
2875
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
