JDBC技术

Java访问数据库技术概述

在JDBC出现之前，早期java需要访问数据库时，需要根据不同的数据库管理系统(DBMS)编写不同的数据源，使用一项称之为JDBC-ODBC桥链接模式。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G9IQuuRy-1596978444053)(D:\Java\图片\1596418546788.png)]

通过以上访问方式，程序员会在访问数据方面花费大把精力，因此SUN在后来设计的JDBC接口，将访问数据库的具体实现交给不同的数据库厂商各自实现，从而减少java程序的压力。

JDBC入门

JDBC(Java Database Connectivity),java 链接数据库技术，是由java.sql包中提供的一系列接口构成，通过这些接口结合不同的数据库管理系统的驱动包，可以非常轻松的实现java访问数据库。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MG6BklFt-1596978444058)(D:\Java\图片\1596418709023.png)]

入门案例

//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.执行sqlResultSet 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();}}
}

JDBC查询详解

分页查询

public static List<Emp> queryByPage(int start,int limit) {List<Emp> list = new ArrayList<Emp>();String sql = "select * from emp limit ?,?";Connection conn = DBUtils.getConn();ResultSet rs = null;PreparedStatement ps = null;try {ps = conn.prepareStatement(sql);ps.setInt(1,start);ps.setInt(2, limit);rs = ps.executeQuery();while(rs.next()) {int eno = rs.getInt("eno");String ename = rs.getString("ename");String job = rs.getString("job");Date hiredate = rs.getDate("hiredate");int age = rs.getInt("age");String sex = rs.getString("sex");double sal = rs.getDouble("sal");int dno = rs.getInt("dno");//将获取的员工信息存储到对象中Emp e = new Emp(eno, ename, job, hiredate, age, sex, sal, dno);//将对象装入集合list.add(e);}} catch (SQLException e) {e.printStackTrace();} finally {DBUtils.close(rs, ps, conn); }return list;
}

查询单行单列

/*** 	查询总记录数*/public static void queryCount() {String sql = "select count(*) from emp";Connection conn = DBUtils.getConn();PreparedStatement ps = null;ResultSet rs = null;try {ps = conn.prepareStatement(sql);rs = ps.executeQuery();if(rs.next()) {int count = rs.getInt(1);
//				int count = rs.getInt("count(*)");System.out.println("总数据行数:"+count);}} catch (SQLException e) {e.printStackTrace();}finally {DBUtils.close(rs, ps, conn); }}

执行关联查询

/*** 	多表联合查询*/
public static List<EmpInfo> queryMultipleTable() {List<EmpInfo> list = new ArrayList<EmpInfo>();String sql = "select e.ename ename,e.job job,e.hiredate hiredate,d.dname dname from emp e,dept d where e.dno=d.dno";Connection conn = DBUtils.getConn();ResultSet rs = null;PreparedStatement ps = null;try {ps = conn.prepareStatement(sql);rs = ps.executeQuery();while(rs.next()) {String ename = rs.getString("ename");String job = rs.getString("job");Date hiredate = rs.getDate("hiredate");String dname = rs.getString("dname");Emp e = new Emp();e.setEname(ename);e.setJob(job);e.setHiredate(hiredate);Dept d = new Dept();d.setDname(dname);EmpInfo info = new EmpInfo();info.setEmp(e);info.setDept(d);list.add(info);}} catch (SQLException e) {e.printStackTrace();} finally {DBUtils.close(rs, ps, conn); }return list;
}

JDBC执行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);}}

getGeneratedKeys获取自动生成键

public class JDBCGenKeys {public static int insert(String eventName) {int id = 0;String sql = "insert into tblog(event_name) values(?)";Connection conn = DBUtils.getConn();PreparedStatement ps = null;ResultSet rs = null;try {//获取预处理sql命令的对象，该对象允许返回自动生成的键ps = conn.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);ps.setString(1, eventName);int i = ps.executeUpdate();if(i > 0) {//返回包含自动生成的键的结果集rs = ps.getGeneratedKeys();id = rs.next() ? rs.getInt(1) : 0;}} catch (SQLException e) {e.printStackTrace();}finally {DBUtils.close(rs, ps, conn);}return id;}public static void main(String[] args) {int id = insert("修改数据了");System.out.println(id);}
}

SQL语句批处理

public class JDBCBatchDemo {public static void batchByPs() throws SQLException {String sql = "insert into tblog(event_name) values(?)";//eclipse：ctrl+1   idea：alt+enterConnection 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();}}

DAO与Entity(vo/dto/po/pojo)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u8xpZyjG-1596978444061)(D:\带班资料\2020\j2003\线下\part3-mysql&jdbc\20200804\笔记\assets\1596538588031.png)]

​ 以上时序图是常见的web项目架构模式，其中对于频繁的数据访问操作，实际开发中通常会抽取一层DAO(Data Access Object)层;DAO层主要负责访问数据库，对数据表进行CRUD操作，DAO层并不关注具体的业务逻辑，因此称之为数据访问层。

常见DAO层的定义语法:

public class EmpDAO{public boolean insert(Emp d) {// 执行添加操作return false;}public boolean delete(int id) {// 执行删除操作return false;}public boolean update(Emp d) {// 执行更新操作return false;}public Emp findById(int id) {// 根据id查询return null;}public Emp findById(int id) {// 查询所有return null;}
}

基于接口和泛型的IBaseDAO定义

由于大多数针对实体类的操作无外乎insert,update,delete,select操作，因此，可以将这些常见操作抽取出一个公共的接口，该接口只定义相关的标准，具体实现可以由对应的实现类完成：

public interface IBaseDAO<T> {/*** 	执行插入操作* @param d* @return*/boolean insert(T d);/*** 执行删除操作* @param id* @return*/boolean delete(int id);/*** 执行更新操作* @param d* @return*/boolean update(T d);/*** 根据id查询对象* @param id* @return*/T findById(int id);/*** 查询所有对象* @return*/List<T> findAll();}

实现

public class DeptDAO implements IBaseDAO<Dept> {@Overridepublic boolean insert(Dept d) {// TODO Auto-generated method stubreturn false;}@Overridepublic boolean delete(int id) {// TODO Auto-generated method stubreturn false; }@Overridepublic boolean update(Dept d) {// TODO Auto-generated method stubreturn false;}@Overridepublic Dept findById(int id) {// TODO Auto-generated method stubreturn null;}@Overridepublic List<Dept> findAll() {// TODO Auto-generated method stubreturn null;}public Dept findByDname(String dname) {// TODO Auto-generated method stubreturn null}
}

通用更新封装

观察所有的INSERT，DELETE,UPDATE操作，基本都会存在以下几个步骤：

• 准备sql语句
• 连接获取
• 获取预处理sql命令的对象
• 预处理
• 执行更新
• 关闭资源

而以上除了sql语句和预处理操作不一致以外，其他步骤几乎一致，因此可以通过以下封装来简化对于所有更新的操作：

/**
* 封装通用的更新操作：INSERT UPDATE DELETE
* 
* @param sql
* @param 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;
}

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转换为JavabeanT obj = mapToBean(m, t);// 将Javabean装入listlist.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对象创建对应类型的ObjectT 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();// 获取结果集的元数据对象ResultSetMetaDataResultSetMetaData 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)) {// 将取到的每一列的列名与列值存储到mapmap.put(key, value);}}// 将map集合装入listlist.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();}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转换为JavabeanT obj = mapToBean(m, t);// 将Javabean装入listlist.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对象创建对应类型的ObjectT 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();// 获取结果集的元数据对象ResultSetMetaDataResultSetMetaData 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)) {// 将取到的每一列的列名与列值存储到mapmap.put(key, value);}}// 将map集合装入listlist.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）.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QjV43j54-1596978444066)(D:/%E5%B8%A6%E7%8F%AD%E8%B5%84%E6%96%99/2019/j1909/%E8%AF%BE%E7%A8%8B%E8%B5%84%E6%96%99/%E8%AF%BE%E7%A8%8B%E5%86%85%E5%AE%B9/note/assets/1565689065391.png)]

​ 目前比较常用的连接池技术包含: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-9E5nZdAT-1596978444068)(D:\带班资料\2020\j2003\线下\part3-mysql&jdbc\20200805\笔记\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);}
}

day4 - idea使用 & JDBC(四)

InteillJ Idea使用入门

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jymHg9vx-1596978444069)(D:\Java\图片\1596642951480.png)]

项目创建

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pjxOEW2Q-1596978444070)(D:\Java\图片\1596675913610.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RCuQB6UO-1596978444071)(D:\Java\图片\1596676161363.png)]

基本设置

主题设置

字体设置

文件过滤

文件版权设置

类名注解配置

对象序列化UID自动生成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GifhF9e5-1596978444072)(D:\Java\图片\1596677861659.png)]

重复代码提示去除

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vBUSHdSN-1596978444074)(D:\Java\图片\1596678534646.png)]

去除参数提示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EnQg4eVS-1596978444075)(D:\Java\图片\1596679024818.png)]

忽略大小写提示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DdSr9cKh-1596978444076)(D:\Java\图片\1596679153420.png)]

新增自定义实时代码提示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mBoROyLl-1596978444077)(D:\Java\图片\1596679281646.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ViQta1mp-1596978444079)(D:\Java\图片\1596679663165.png)]

插件安装

• Alibaba Java Coding Guidelines 编码规约检测
• CodeGlance 代码缩略图
• GsonFormat 将json字符串转换为实体类

JDBC事务

/*** @Author mrchai 2020/8/6 15:35*/
public class AccountService {/*** 转账操作 从a账户转出money金额到b账户** @param a* @param b* @param money*/public void changeMoney(Account a, Account b, double money) {Connection conn = DBUtils.getConn();try {//1. 禁止事务自动提交conn.setAutoCommit(false);//创建dao对象，并且传入连接对象，保证所有的更新操作来自同一个连接AccountDAO dao = new AccountDAO(conn);//查询a账户a = dao.selectById(a.getId());//查询b账户b = dao.selectById(b.getId());if (a.getMoney() < money) {System.out.println("账户余额不足!");return;}//ctrl+alt+l 代码格式化    ctrl+d 代码复制    ctrl+y 删除代码   ctrl+shift+up/down 代码上下移动//减少a账户余额a.setMoney(a.getMoney() - money);//增加b账户余额b.setMoney(b.getMoney() + money);dao.update(a);System.out.println(10 / 0);dao.update(b);//逻辑正常执行时提交事务conn.commit();} catch (Exception e) {e.printStackTrace();try {//事务回滚conn.rollback();} catch (SQLException e1) {e1.printStackTrace();}} finally{DBUtils.close(null,null,conn);}}public static void main(String[] args) {Account a = new Account();a.setId(1);Account b = new Account();b.setId(2);AccountService service  = new AccountService();service.changeMoney(a,b,10000);}
}

• 组合
• 代理模式（动态代理）

存储过程调用

编写过程

-- 过程1，根据员工共工号查询员工
create procedure sp_emp(empno int)
beginselect * from emp where eno=empno;
end-- 分页查询（包含输出参数）
create procedure sp_emp_paging(pagenum int,pagesize int,out pagecount int,out totalnum int)
begindeclare startpage int;set startpage=(pagenum-1)*pagesize;-- 分页查询select * from emp limit startpage,pagesize;-- 将总数据行数查询到并设置给输出参数select count(*) into totalnum from emp;-- 计算获取总页码数set pagecount = CEILING(totalnum/pagesize);
end

JDBC代码

/*** @Author mrchai 2020/8/6 17:24*/
public class ProcedureDemo {/*** 调用普通存储过程* @throws SQLException*/public static void proc1() throws SQLException {Connection conn = DBUtils.getConn();CallableStatement cs = conn.prepareCall("{call sp_emp(?)}");cs.setInt(1,1);boolean f = cs.execute();ResultSet rs = cs.getResultSet();if(rs.next()){int eno = rs.getInt("eno");String ename = rs.getString("ename");String job = rs.getString("job");double sal = rs.getDouble("sal");Date hiredate = rs.getDate("hiredate");System.out.println(eno+"/"+ename+"/"+job+"/"+sal+"/"+hiredate);}rs.close();cs.close();conn.close();}/*** 调用包含输出参数的存储过程*/public static void proc2(int pagenum,int pagesize) throws SQLException {Connection conn = DBUtils.getConn();CallableStatement cs = conn.prepareCall("{call sp_emp_paging(?,?,?,?)}");cs.setInt(1,pagenum);cs.setInt(2,pagesize);//输出参数需要注册(注册输出参数)cs.registerOutParameter(3, Types.INTEGER);cs.registerOutParameter(4, Types.INTEGER);//执行cs.execute();//获取总页码数int totalPage = cs.getInt(3);//获取总数据行数int totalNum  = cs.getInt(4);System.out.println("totalNum-->"+totalNum);System.out.println("totalPager--->"+totalPage);//获取结果集ResultSet rs = cs.getResultSet();while(rs.next()){int eno = rs.getInt("eno");String ename = rs.getString("ename");String job = rs.getString("job");double sal = rs.getDouble("sal");Date hiredate = rs.getDate("hiredate");System.out.println(eno+"/"+ename+"/"+job+"/"+sal+"/"+hiredate);}rs.close();cs.close();conn.close();}public static void main(String[] args) throws SQLException {proc2(1,10);}}