【JavaWeb】一篇文章复习JDBC、DAO及相关实现类
一篇文章复习JDBC、DAO及相关实现类
- 一、JDBC实现数据库的连接
- 1、IEDA引入JDBC.jar包
- 2、连接方式
- 3、JDBCUtils工具类封装数据库连接和关闭操作
- 二、使用PreparedStatement实现CRUD操作
- 1、PreparedStatement实现增、删、改操作
- 2、PreparedStatement实现查询操作
- 3、ResultSet与ResultSetMetaData
- ResultSet
- ResultSetMetaData
- 4、ORM思想(object relational mapping)
- 5、资源的释放
- 6、PsUtils封装PrepareStatement操作
- 三、DAO及相关实现类
- DAO
- pojo.User.java
- BaseDao.java
- UserDao.java
- UserDaoImpl.java
本篇主要讲述了JDBC、DAO及相关实现类的知识,帮助大家快速掌握使用JDBC以及DAO设计。
JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接 口(一组API),定义了用来访问数据库的标准Java类库,(java.sql,javax.sql)使用这些类库可以以一种标 准的方法、方便地访问数据库资源。
一、JDBC实现数据库的连接
1、IEDA引入JDBC.jar包
在工程目录下,创建一个lib文件夹,将jar包复制到该文件夹下,然后如图进行引入。
2、连接方式
首先我们先写一个配置文件jdbc.properties
使用配置文件的好处:
- 实现了代码和数据的分离,如果需要修改配置信息,直接在配置文件中修改,不需要深入代码
- 如果修改了 配置信息,省去重新编译的过程。
user=root
password=sm1208
url=jdbc:mysql://localhost:3306/javaweb?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true
driverClass=com.mysql.cj.jdbc.Driver
package com.sun.jdbc;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
/**
* @author JumperSun
* @date 2022-09-08-19:57
*/
public class ConnectionTest {
// 非读取配置文件方式
@Test
public void testConnection1(){
try {
// 1.数据库连接的4个基本要素
String url = "jdbc:mysql://localhost:3306/javaweb?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true";
String driverName = "com.mysql.cj.jdbc.Driver";
String user = "root";
String password = "sm1208";
// 2.加载驱动(实例化Driver 注册驱动)
Class.forName(driverName);
// 3.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
System.out.println(conn);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
// 读取配置文件方式
@Test
public void testConnection2() throws Exception {
// 1.加载配置文件
InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
Properties pros = new Properties();
pros.load(is);
// 2.读取配置信息
String user = pros.getProperty("user");
String password = pros.getProperty("password");
String url = pros.getProperty("url");
String driverClass = pros.getProperty("driverClass");
// 3.加载驱动
Class.forName(driverClass);
// 4.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
System.out.println(conn);
}
}
3、JDBCUtils工具类封装数据库连接和关闭操作
package com.sun.jdbc;
import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
/**
* @author JumperSun
* @date 2022-09-08-20:53
* 封装的JDBC工具类
*/
public class JDBCUtils {
public static Connection getConnection() throws Exception {
// 1.读取配置文件的信息
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
Properties pros = new Properties();
pros.load(is);
String user = pros.getProperty("user");
String password = pros.getProperty("password");
String url = pros.getProperty("url");
String driverClass = pros.getProperty("driverClass");
// 2.加载驱动
Class.forName(driverClass);
// 3.返回获取连接
return DriverManager.getConnection(url, user, password);
}
public static void closeResources(Connection conn, PreparedStatement ps) {
try {
if (ps != null) {
ps.close();
}
if (conn != null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
public static void closeResources(Connection conn, PreparedStatement ps, ResultSet rs) {
try {
if (rs != null) {
rs.close();
}
if (ps != null) {
ps.close();
}
if (conn != null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
二、使用PreparedStatement实现CRUD操作
PreparedStatement是什么?
- PreparedStatement用来执行SQL查询语句的API之一,数据库连接被用于向数据库服务器发送命令和 SQL 语句,并接受数据库服务器返回的结果。
数据库操作对象都有哪些?
- Statement:用于执行静态 SQL 语句并返回它所生成结果的对象。
- PrepatedStatement:SQL 语句被预编译并存储在此对象中,可以使用此对象多次高效地执行该语句。
- CallableStatement:用于执行 SQL 存储过程
为什么使用PreparedStatement?
- 使用Statement操作数据表存在弊端
- 存在拼串操作、繁琐
- 存在SQL注入问题
- PreparedStatement表示一条预编译过的 SQL 语句
- 能最大可能提高性能
- 能最大可能提高性能:
综上:
1、PreparedStatement实现增、删、改操作
// 通用的增、删、改操作(体现一:增、删、改 体现二:针对不同的表)
public boolean update(String sql,Object ...args) {
Connection conn = null;
PreparedStatement ps = null;
boolean flag = false;
try {
// 1.获取数据库的连接
conn = com.sun.jdbc.JDBCUtils.getConnection();
// 2.获取PreparedStatement实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i+1,args[i]);
}
// 4.执行sql语句
flag = ps.execute();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.关闭资源
JDBCUtils.closeResources(conn,ps);
return flag;
}
}
2、PreparedStatement实现查询操作
// 通用的针对于不同表的查询:返回一个对象
public <T> T getBean(Class<T> clazz,String sql,Object ...args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.获取数据库连接
conn = JDBCUtils.getConnection();
// 2.预编译sql语句,得到PrepareStatement对象
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i+1,args[i]);
}
// 4.执行executeQuery(),得到结果:ResultSet
rs = ps.executeQuery();
// 5.得到结果集的元数据:ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 6.通过ResultSetMetaData得到columnCount,columLable;通过ResultSet得到列值
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
// 通过反射,创建指定类的对象,获取指定的属性并赋值
T t = clazz.newInstance();
for (int i = 0; i < columnCount; i++) { // 遍历每一个列
// 获取列值
Object columnval = rs.getObject(i + 1);
// 获取列的别名:列的别名,使用类的属性名充当
String columnLabel = rsmd.getColumnLabel((Integer) columnval);
// 使用反射,给对象的相应属性赋值
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t,columnval);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.关闭资源
JDBCUtils.closeResources(conn,ps,rs);
}
return null;
}
// 通用的针对于不同表的查询:返回对象集合
public <T> List<T> getBeanList(Class<T> clazz, String sql, Object ...args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.获取数据库连接
conn = com.sun.jdbc.JDBCUtils.getConnection();
// 2.预编译sql语句,得到PrepareStatement对象
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i+1,args[i]);
}
// 4.执行executeQuery(),得到结果:ResultSet
rs = ps.executeQuery();
// 5.得到结果集的元数据:ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 6.通过ResultSetMetaData得到columnCount,columLable;通过ResultSet得到列值
int columnCount = rsmd.getColumnCount();
// 创建集合对象
ArrayList<T> list = new ArrayList<>();
while (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一列:给
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columnval = rs.getObject(i + 1);
// 获取列的别名:列的别名,使用类的属性名充当
String columnLabel = rsmd.getColumnLabel((Integer) columnval);
// 使用反射,给对象的相应属性赋值
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t,columnval);
}
list.add(t);
}
return list;
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.关闭资源
JDBCUtils.closeResources(conn,ps,rs);
}
return null;
}
3、ResultSet与ResultSetMetaData
我们进行查询操作需要调用PreparedStatement 的 executeQuery() 方法,查询结果是一个ResultSet 对象。
ResultSet
- ResultSet 对象以逻辑表格的形式封装了执行数据库操作的结果集,ResultSet 接口由数据库厂商提供实现
- ResultSet 返回的实际上就是一张数据表。有一个指针指向数据表的第一条记录的前面。
- ResultSet 对象维护了一个指向当前数据行的游标,初始的时候,游标在第一行之前,可以通过 ResultSet 对象 的 next() 方法移动到下一行。调用 next()方法检测下一行是否有效。若有效,该方法返回 true,且指针下移。 相当于Iterator对象的 hasNext() 和 next() 方法的结合体。
- 当指针指向一行时, 可以通过调用 getXxx(int index) 或 getXxx(int columnName) 获取每一列的值。
- 例如: getInt(1), getString(“name”)
- 注意:Java与数据库交互涉及到的相关Java API中的索引都从1开始。
- ResultSet 接口的常用方法: boolean next()、getString()
ResultSetMetaData
-
可用于获取关于 ResultSet 对象中列的类型和属性信息的对象
-
ResultSetMetaData meta = rs.getMetaData();
-
getColumnName(int column):获取指定列的名称
-
getColumnLabel(int column):获取指定列的别名
-
getColumnCount():返回当前 ResultSet 对象中的列数。
-
getColumnTypeName(int column):检索指定列的数据库特定的类型名称。
-
getColumnDisplaySize(int column):指示指定列的最大标准宽度,以字符为单位。
-
isNullable(int column):指示指定列中的值是否可以为 null。
-
isAutoIncrement(int column):指示是否自动为指定列进行编号,这样这些列仍然是只读的。
-
-
如何获取 ResultSetMetaData: 调用 ResultSet 的 getMetaData() 方法即可
-
获取 ResultSet 中有多少列:调用 ResultSetMetaData 的 getColumnCount() 方法
-
获取 ResultSet 每一列的列的别名是什么:调用 ResultSetMetaData 的getColumnLabel() 方法
4、ORM思想(object relational mapping)
- 一个数据表对应一个java类
- 表中的一条记录对应java类的一个对象
- 表中的一个字段对应java类的一个属性
5、资源的释放
- 释放ResultSet, Statement,Connection。
- 数据库连接(Connection)是非常稀有的资源,用完后必须马上释放,如果Connection不能及时正确的关闭将 导致系统宕机。Connection的使用原则是尽量晚创建,尽量早的释放。
- 可以在finally中关闭,保证及时其他代码出现异常,资源也一定能被关闭。
6、PsUtils封装PrepareStatement操作
package com.sun.util;
import com.sun.util.JDBCUtils;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;
/**
* @author JumperSun
* @date 2022-09-08-20:29
*/
public class PsUtils {
// 通用的增、删、改操作(体现一:增、删、改 体现二:针对不同的表)
public boolean update(String sql,Object ...args) {
Connection conn = null;
PreparedStatement ps = null;
boolean flag = false;
try {
// 1.获取数据库的连接
conn = com.sun.jdbc.JDBCUtils.getConnection();
// 2.获取PreparedStatement实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i+1,args[i]);
}
// 4.执行sql语句
flag = ps.execute();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.关闭资源
JDBCUtils.closeResources(conn,ps);
return flag;
}
}
// 通用的针对于不同表的查询:返回一个对象
public <T> T getBean(Class<T> clazz,String sql,Object ...args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.获取数据库连接
conn = com.sun.jdbc.JDBCUtils.getConnection();
// 2.预编译sql语句,得到PrepareStatement对象
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i+1,args[i]);
}
// 4.执行executeQuery(),得到结果:ResultSet
rs = ps.executeQuery();
// 5.得到结果集的元数据:ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 6.通过ResultSetMetaData得到columnCount,columLable;通过ResultSet得到列值
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
T t = clazz.newInstance();
for (int i = 0; i < columnCount; i++) { // 遍历每一个列
// 获取列值
Object columnval = rs.getObject(i + 1);
// 获取列的别名:列的别名,使用类的属性名充当
String columnLabel = rsmd.getColumnLabel((Integer) columnval);
// 使用反射,给对象的相应属性赋值
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t,columnval);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.关闭资源
JDBCUtils.closeResources(conn,ps,rs);
}
return null;
}
// 通用的针对于不同表的查询:返回对象集合
public <T> List<T> getBeanList(Class<T> clazz, String sql, Object ...args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 1.获取数据库连接
conn = com.sun.jdbc.JDBCUtils.getConnection();
// 2.预编译sql语句,得到PrepareStatement对象
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i+1,args[i]);
}
// 4.执行executeQuery(),得到结果:ResultSet
rs = ps.executeQuery();
// 5.得到结果集的元数据:ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 6.通过ResultSetMetaData得到columnCount,columLable;通过ResultSet得到列值
int columnCount = rsmd.getColumnCount();
// 创建集合对象
ArrayList<T> list = new ArrayList<>();
while (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一列:给
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columnval = rs.getObject(i + 1);
// 获取列的别名:列的别名,使用类的属性名充当
String columnLabel = rsmd.getColumnLabel((Integer) columnval);
// 使用反射,给对象的相应属性赋值
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t,columnval);
}
list.add(t);
}
return list;
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.关闭资源
JDBCUtils.closeResources(conn,ps,rs);
}
return null;
}
}
三、DAO及相关实现类
DAO
(Data Access Object)访问数据信息的类和接口,包括了对数据的CRUD(Create、Retrival、Update、 Delete),而不包含任何业务相关的信息。
**DAO作用:**为了实现功能的模块化,更有利于代码的维护和升级。
层次结构:
代码如下:
pojo.User.java
package com.sun.pojo;
/**
* @author JumperSun
* @date 2022-09-09-12:51
*/
public class User {
int id;
String name;
String password;
public User(int id, String name, String password) {
super();
this.id = id;
this.name = name;
this.password = password;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", password='" + password + '\'' +
'}';
}
}
BaseDao.java
package com.sun.dao;
import com.sun.util.JDBCUtils;
import com.sun.util.PsUtils;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
/**
* @author JumperSun
* @date 2022-09-09-12:53
* 定义一个用来被继承的对数据库进行基本操作的Dao
*/
public abstract class BaseDao<T> {
private PsUtils PsUtils = new PsUtils();
// 定义一个变量来接收泛型的类型
private Class<T> type;
// 获取T的Class对象,获取泛型的类型,泛型是在被子类继承时才确定
public BaseDao() {
// 获取子类的类型
Class clazz = this.getClass();
// 获取父类的类型
// getGenericSuperclass()用来获取当前类的父类的类型
// ParameterizedType表示的是带泛型的类型
ParameterizedType parameterizedType = (ParameterizedType) clazz.getGenericSuperclass();
// 获取具体的泛型类型 getActualTypeArguments获取具体的泛型的类型
// 这个方法会返回一个Type的数组
Type[] types = parameterizedType.getActualTypeArguments();
// 获取具体的泛型的类型·
this.type = (Class<T>) types[0];
}
/**
* 通用的增删改操作
* @param sql
* @param params
* @return
*/
public boolean update(String sql, Object... params) {
boolean flag = false;
try {
flag = PsUtils.update(sql, params);
} catch (Exception e) {
e.printStackTrace();
}
return flag;
}
/**
* 获取一个对象
*
* @param sql
* @param params
* @return
*/
public T getBean(String sql, Object... params) {
T t = null;
try {
t = PsUtils.getBean(type,sql, params);
} catch (Exception e) {
e.printStackTrace();
}
return t;
}
/**
* 获取所有对象
* @param sql
* @param params
* @return
*/
public List<T> getBeanList(String sql, Object... params) {
List<T> list = null;
try {
list = PsUtils.getBeanList(type, sql, params);
} catch (Exception e) {
e.printStackTrace();
}
return list;
}
}
UserDao.java
package com.sun.dao;
import com.sun.pojo.User;
import java.util.List;
/**
* @author JumperSun
* @date 2022-09-09-13:52
*/
public interface UserDao {
/**
* 查询所有用户
* @return
*/
List<User> getUsers();
/**
* 根据用户名查询用户
* @param name
* @return
*/
User getUserByName(String name);
/**
* 添加用户
* @param user
* @return
*/
boolean addUser(User user);
/**
* 删除用户
* @param user
* @return
*/
boolean deleteUser(User user);
/**
* 修改用户
* @param user
* @return
*/
boolean updateUser(User user);
}
UserDaoImpl.java
package com.sun.dao.impl;
import com.sun.dao.BaseDao;
import com.sun.dao.UserDao;
import com.sun.pojo.User;
import java.util.List;
/**
* @author JumperSun
* @date 2022-09-09-13:53
*/
public class UserDaoImpl extends BaseDao implements UserDao {
@Override
public List<User> getUsers() {
String sql = "select * from user";
List UserList = getBeanList(sql);
return UserList;
}
@Override
public User getUserByName(String name) {
String sql = "select * from user where name = ?";
User user = (User) getBean(sql, name);
return user;
}
@Override
public boolean addUser(User user) {
String sql = "insert into user values(?,?,?)";
boolean flag = update(sql, user.getId(), user.getName(), user.getPassword());
return flag;
}
@Override
public boolean deleteUser(User user) {
String sql = "delete from user where name = ? and password = ?";
boolean flag = update(sql, user.getName(), user.getPassword());
return flag;
}
@Override
public boolean updateUser(User user) {
String sql = "update user set name = ? ,password = ? where id = ?";
boolean flag = update(sql, user.getName(), user.getPassword(),user.getId());
return flag;
}
}