一. 引言

1.1 如何操作数据库

  • 使用客户端工具访问数据库, 需要手工建立连接, 输入用户名和密码登陆, 编写SQL语句, 点击执行, 查看操作结果(结果集或受行数影响)

1.2 实际开发中, 会采用客户端操作数据库吗?

  • 在实际开发中, 当用户的数据发生改变时, 不可能通过客户端操作执行SQL语句, 因为操作量过大, 无法保证效率和正确性

二. JDBC

2.1 什么是JDBC?

  • JDBC(Java Database Connectivity) Java连接数据库, 可以使用Java语言连接数据库完成CRUD操作

2.2 JDBC核心思想

  • Java中定义了访问数据库的接口, 可以为多种关系型数据库提供统一的访问方式. 由数据库厂商提供驱动实现类(Driver数据库驱动)
2.2.1 MySQL数据库驱动
  • mysql-connector-java-5.1.X-bin.jar: 适用于5.X版本
  • mysql-connector-java-8.0.X-bin.jar: 适用于8.X版本
  • 下载链接:
2.2.2 JDBC API
  • JDBC是由多个接口和类进行功能实现
类型 权限定名 简介
class java.sql.DriverManager 管理多个数据库驱动类, 提供了获取数据库连接的方法
interface java.sql.Connection 代表一个数据库连接(当Connection不是null时, 表示已连接数据库)
interface java.sql.Statement 发送SQL语句到数据库工具
interface java.sql.ResultSet 保存SQL查询语句的结果数据(结果集)
class java.sql.SQLException 处理数据库应用程序时所发生的异常

2.3 环境搭建

  1. 在项目下新建lib文件夹,用于存放jar文件
  2. 将mysql驱动mysql-connector-java-5.1.X-bin.jar复制到项目中的lib文件夹中
  3. 选中lib文件夹右键Add as Library, 点击OK

三. JDBC开发步骤[重点]

3.1 注册驱动

  • 使用class.forName("com.mysql.jdbc.Driver");手动加载字节码文件到 JVM 中
  1. Class.forName("com.mysql.jdbc.Driver");//加载驱动

3.2 连接数据库

  • 通过DriverManager.getConection(url, user, password)获取数据库连接对象

    • URL: jdbc: msql: //localhost: 3306/database
    • username: root
    • password: root
  1. Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/database?useUnicode=true&characterEncoding=utf8", "root", "root");
  • URL(Union Resource Location) 统一资源定位符: 由协议, IP, 端口, SID(程序实例名称)组成

3.3 获取发送SQL的对象

  • 通过Connection对象获得Statement对象, 用于对数据库进行通用访问
  1. Statement statement = conn.createStatement();

3.4 执行SQL语句

  • 执行SQL语句并接收执行结果
  1. String sql = "insert into t_jobs(job_id,job_title,min_salary,max_salary) values('JAVA_Mgr','JAVA_Manager',4000,10000)";
  3. int result = statement.executeUpdate(sql);//执行SQL语句并接收结果
  • 注意: 在编写DML语句时, 一定要注意字符串参数的符号是单引号'值'
  • DML语句: 增删改时, 返回受影响的行数(int 类型)
  • DQL语句: 查询时, 返回结果数据(ResultSet结果集)

3.5 处理结果

  • 接收处理操作结果
  1. if(result == 1) {
  2.     System.out.println("Success");
  3. }
  • 受影响行数: 逻辑判断, 方法返回
  • 查询结果集: 迭代, 依次获取

3.6 释放资源

  • 遵循先开后关原则,释放所使用到的资源对象
  1. statement.close();
  2. conn.close();

3.7 综合案例

  • 整合以上核心六步, 实现在数据库表删除一条数据
  1. public class DeleteJDBC {
  3.     public static void main(String[] args) throws Exception{
  5.         //1. 加载驱动
  6.         Class.forName("com.mysql.jdbc.Driver");
  7.         //2. 获得连接对象
  8.         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/companydb", "root", "root");
  9.         //3. 获得执行SQL的对象
  10.         Statement statement = conn.createStatement();
  11.         //4. 执行SQL语句, 并接收结果
  12.         int result = statement.executeUpdate("delete from t_jobs where job_id = 'JAVA_Mgr'");
  13.         //5. 处理结果
  14.         if (result == 1) {
  15.             System.out.println("删除成功!");
  16.         }else{
  17.             System.out.println("删除失败!");
  18.         }
  19.         //6. 释放资源
  20.         statement.close();
  21.         conn.close();
  22.     }
  23. }

四. ResultSet(结果集)

  • 在执行查询SQL后,存放查询到的结果数据集

4.1 接收结果集

  • ResultSet rs = statement.executeQuery(sql);
  1. ResultSet rs = statement.executeQuery("select * from t_employees");

4.2 遍历ResultSet中的数据

  • ResultSet以表(table)结构进行临时结果的存储, 需要通过JDBC API将其中数据进行依次获取

    • 数据行指针: 初始位置在第一行数据前, 每调用一次boolean next()方法ResultSet的指针向下移动一行, 结果为true, 表示当前行有数据
    • rs.getXxx(整数);代表根据列的编号顺序获得, 从1开始
    • rs.getXxx("列名");代表根据列名获得
  1. boolean next() throws SQLException //判断 rs 的结果集中 下一行是否存在数据
4.2.1 遍历方法
  1. int getInt(int columnIndex) throws SQLException //获得当前行第N列的int值
  2. int getInt(String columnLabel) throws SQLException //获得当前行columnLabel列的int值
  4. double getDouble(int columnIndex) throws SQLException //获得当前行第N列的double值
  5. double getDouble(String columnLabel) throws SQLException //获得当前行columnLabel列的double值
  7. String getString(int columnIndex) throws SQLException //获得当前行第N列的String值
  8. String getString(String columnLabel) throws SQLException //获得当前行columnLabel列的String值
  • 注意: 列的编号从1开始

4.3 综合案例

4.3.1 根据列的名称获取
  1. public class QueryJdbc {
  3.     public static void main(String[] args) throws Exception{
  5.         //1. 注册驱动
  6.         Class.forName("com.mysql.jdbc.Driver");
  7.         //2. 获取连接对象
  8.         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/companydb", "root","root");
  9.         //3. 获取执行SQL的对象
  10.         Statement statement = conn.createStatement();
  11.         //4. 执行SQL语句,接收结果
  12.         ResultSet resultSet = statement.executeQuery("select * from t_jobs");
  13.         //5. 处理结果
  14.         while (resultSet.next()) {
  15.             //对当前行每列数据进行获取, 根据列的编号
  16.             String job_id = resultSet.getString("job_id");
  17.             String job_title = resultSet.getString("job_title");
  18.             String min_salary = resultSet.getString("min_salary");
  19.             String max_salary = resultSet.getString("max_salary");
  20.             System.out.println(job_id+"\t"+job_title+"\t"+min_salary+"\t"+max_salary);
  21.         }
  22.         //6. 释放资源
  23.         resultSet.close();
  24.         statement.close();
  25.         conn.close();
  26.     }
  27. }
4.3.2根据列的编号获取
  1. public class QueryJdbc2 {
  3.     public static void main(String[] args) throws Exception{
  5.         //1. 注册驱动
  6.         Class.forName("com.mysql.jdbc.Driver");
  7.         //2. 获取连接对象
  8.         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/companydb", "root","root");
  9.         //3. 获取执行SQL的对象
  10.         Statement statement = conn.createStatement();
  11.         //4. 执行SQL语句,接收结果
  12.         ResultSet resultSet = statement.executeQuery("select * from t_jobs");
  13.         //5. 处理结果
  14.         while (resultSet.next()) { //判断下一行是否有数据
  15.             //对当前行每列数据进行获取, 根据列的编号
  16.             String job_id = resultSet.getString(1);
  17.             String job_title = resultSet.getString(2);
  18.             String min_salary = resultSet.getString(3);
  19.             String max_salary = resultSet.getString(3);
  20.             System.out.println(job_id+"\t"+job_title+"\t"+min_salary+"\t"+max_salary);
  21.         }
  22.         //6. 释放资源
  23.         resultSet.close();
  24.         statement.close();
  25.         conn.close();
  26.     }
  27. }

五. 常见错误

  • java.lang.ClassNotFoundException:

    • 找不到类(类名书写错误, 没有导入jar包)
  • java.sql.SQLException:
    • 与sql语句相关的错误(约束错误, 表名列名书写错误) 建议: 在客户端工具中测试SQL语句之后再粘贴到代码中
  • com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Unknown column :
    • 列值String类型没有加单引号
  • Duplicate entry '1' for key 'PRIMARY' :
    • 主键值已存在或混乱, 更改主键值或清空表
  • com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Unknown column 'password' in:
    • 可能输入的值的类型不对, 确定在插入元素时, 其值所对应的类型是否正确

六. 综合案例[登陆]

6.1 创建表

  • 创建一张用户表user

    • id, 主键, 自动增长
    • 用户名, 字符串类型, 唯一, 非空
    • 密码, 字符串类型, 非空
    • 手机号码. 字符串类型
  • 插入;两条测试语句
  1. CREATE TABLE users(
  2. 	id INT PRIMARY KEY AUTO_INCREMENT,
  3. 	username VARCHAR(18) UNIQUE NOT NULL,
  4. 	`password` VARCHAR(18) NOT NULL,
  5. 	phone VARCHAR(11)
  6. )CHARSET=utf8;
  8. INSERT INTO users(username,`password`,phone) VALUES('zhangsan','123','12345678901');
  9. INSERT INTO users(username,`password`,phone) VALUES('lisi','321','12345678902');

6.2 实现登录

  • 用户通过控制台输入用户名和密码
  • 将用户输入的用户名和密码作为条件, 编写查询SQL语句
  • 如果该用户存在, 提示登录成功, 反之提示失败
  1. public class LoginJdbc {
  2.     public static void main(String[] args) throws Exception{
  3.         Scanner input = new Scanner(System.in);
  4.         System.out.println("请输入用户名: ");
  5.         String username = input.next();
  6.         System.out.println("请输入密码: ");
  7.         String password = input.next();
  9.         Class.forName("com.mysql.jdbc.Driver");
  11.         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/companydb","root","root");
  13.         Statement statement = conn.createStatement();
  15.         ResultSet resultSet = statement.executeQuery("select username,password from users where username = '"+username+"' and password = '"+password+"'");
  17.         if (resultSet.next()) { //查询到了数据
  18.             System.out.println("登陆成功!");
  19.         }else{
  20.             System.out.println("登陆失败!");
  21.         }
  23.         resultSet.close();
  24.         statement.close();
  25.         conn.close();
  26.     }
  27. }

七. SQL注入问题

7.1 什么是SQL注入

  • 用户输入的数据中有SQL关键字或语法并且参与了SQL语句的编译, 导致SQL语句编译后的条件含义为true, 一直得到正确的结果, 这种现象称为SQL注入

7.2 如何避免SQL注入

  • 由于编写的SQL语句是在用户输入数据, 整合后再进行编译, 所以为了避免SQL注入的问题, 我们要使SQL语句在用户输入数据前就已进行编译成完整的SQL语句, 再进行填充数据

八. PreparedStatement[重点]

  • PreparedStatement继承了Statement接口, 所以执行SQL语句的方法无异

8.1 PreparedStatement的应用

  • 作用:

    1. 预编译SQL语句, 效率高
    2. 安全, 避免SQL注入
    3. 可以动态的填充数据, 执行多个同构的SQL语句
8.1.1 参数标记
  1. //1. 预编译 SQL 语句
  2. PreparedStatement ps = conn.preparedStatement("select * from users where username=? and password=?");
  • 注意: JDBC中的所有参数都由?符号占位, 这被称为参数标记, 在执行SQL语句之前, 必须为每个参数提供值
8.1.2 动态参数绑定
  • ps.setXxx(下标,值) 参数下标从1开始, 为指定参数下标绑定值
  1. //2. 为参数下标赋值
  2. ps.setString(1,username);
  3. ps.setString(2,password);
  • 完整代码
  1. public class LoginJdbc2 {
  2.     public static void main(String[] args) throws Exception{
  3.         Scanner input = new Scanner(System.in);
  4.         System.out.println("请输入用户名: ");
  5.         String username = input.nextLine();
  6.         System.out.println("请输入密码: ");
  7.         String password = input.nextLine();
  9.         Class.forName("com.mysql.jdbc.Driver");
  11.         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/companydb", "root", "root");
  13.         //获得PreparedStatement对象,预编译SQL语句
  14.         PreparedStatement ps = conn.prepareStatement("select * from users where username = ? and password = ?");
  15.         //为?占位符赋值
  16.         ps.setString(1,username);
  17.         ps.setString(2,password);
  18.         ResultSet resultSet = ps.executeQuery();
  20.         if (resultSet.next()) {
  21.             System.out.println("登陆成功!");
  22.         }else{
  23.             System.out.println("登陆失败");
  24.         }
  26.         resultSet.close();
  27.         ps.close();
  28.         conn.close();
  29.     }
  30. }

九. 封装工具类

  • 在实际JDBC的使用中, 存在着大量的重复代码, 例如连接数据库, 关闭数据库等这些操作
  • 我们需要把传统的JDBC代码进行重构, 抽取出通用的JDBC工具类! 以后连接任何数据库, 释放资源都可以使用这个工具类

9.1 重用性方案

  • 封装获取连接, 释放资源两个方法

    • 提供public static Connection getConnection(){}方法
    • 提供public static void closeAll(Connection coon, Statement st, ResultSet rs){}方法
9.1.1 重用工具类实现
  1. public class JdbcUtils {
  3.     static{//类加载,只执行一次
  4.         try {
  5.             Class.forName("com.mysql.jdbc.Driver");
  6.         } catch (ClassNotFoundException e) {
  7.             e.printStackTrace();
  8.         }
  9.     }
  10.     //1. 获取连接
  11.     public static Connection getConnection(){
  12.         Connection conn = null;
  13.         try {
  14.             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/companydb","root","root");
  15.         } catch (SQLException throwables) {
  16.             throwables.printStackTrace();
  17.         }
  18.         return conn;
  19.     }
  20.     //2. 释放资源
  21.     public static void closeAll(Connection conn, Statement statement, ResultSet resultSet){
  22.         try {
  23.             if (resultSet != null){
  24.                 resultSet.close();
  25.             }
  26.             if (statement != null){
  27.                 statement.close();
  28.             }
  29.             if (conn != null){
  30.                 conn.close();
  31.             }
  32.         } catch (SQLException throwables) {
  33.             throwables.printStackTrace();
  34.         }
  35.     }
  37. }

9.2 跨平台方案

  • 定义public static final Properties prop = new Properties();//读取配置文件的Map

  • 定义static{

    • //首次使用工具类时, 加载驱动

      InputStream is = JdbcUtils.class.getResourceAsStream("路径");//通过复用本类自带流, 读取jdbc.properties配置文件. classpath = bin

    • prop.load(is);//通过prop对象将流中的配置信息分割成键值对

    • String driverName = prop.getProperty("driver");//通过driverName的键获取对应的值(com.mysql.jdbc.Driver)

    • Class.forName(driverName);//加载驱动

  • }

9.2.1 跨平台工具类实现

(1) 在src目录下新建jdbc.properties配置文件

  1. driver=com.mysql.jdbc.Driver
  2. url=jdbc:mysql://localhost:3306/companydb?useUnicode=true&characterEncoding=utf8
  3. username=root
  4. password=root

(2) 工具类的封装

  1. public class JdbcUtils2 {
  2.     private static final Properties PROPERTIES = new Properties();//存储配置文件的map
  3.     static {
  4.         InputStream is = JdbcUtils2.class.getResourceAsStream("/jdbc.properties");//通过复用本类自带流, 读取jdbc.properties配置文件
  5.         try {
  6.             PROPERTIES.load(is);//通过流,将配置文件内容加载到properties集合
  7.             Class.forName(PROPERTIES.getProperty("driver"));//通过键"driver"得到值"com.mysql.jdbc.Driver"
  8.         } catch (IOException e) {
  9.             e.printStackTrace();
  10.         } catch (ClassNotFoundException e) {
  11.             e.printStackTrace();
  12.         }
  13.     }
  15.     public static Connection getConnection() {
  16.         Connection conn = null;
  17.         try {
  18.             conn = DriverManager.getConnection(PROPERTIES.getProperty("url"), PROPERTIES.getProperty("username"), PROPERTIES.getProperty("password"));//通过键"url"得到值"jdbc:mysql://localhost:3306/companydb",通过键"username"得到值"root",通过键"password"得到值"root"
  19.         } catch (SQLException throwables) {
  20.             throwables.printStackTrace();
  21.         }
  22.         return conn;
  23.     }
  25.     public static void closeAll(Connection conn, Statement statement, ResultSet resultSet) {
  26.         try {
  27.             if (resultSet != null) {
  28.                 resultSet.close();
  29.             }
  30.             if (statement != null) {
  31.                 statement.close();
  32.             }
  33.             if (conn != null) {//先开后关
  34.                 conn.close();
  35.             }
  36.         } catch (SQLException throwables) {
  37.             throwables.printStackTrace();
  38.         }
  39.     }
  41. }

十. ORM 对象关系映射

  • ORM: (Object Relational Mapping)
  • 从数据库查询到的结果集(ResultSet)在进行遍历时, 逐行遍历, 取出的都是零散的数据, 在实际应用开发中, 我们需要将零散的数据进行封装整理

10.1 实体类(entity): 零散数据的载体

  • 一行数据中, 对多个零散的数据进行整理
  • 通过entity的规则对表中的数据进行对象的封装
  • 表名=类名; 列名=属性名; 提供各个属性的get,set方法
  • 提供无参构造方法(视情况添加有参构造)
10.1.1 ORM应用
  • entity实体类

    • 表名是t_jobs, 表有四列,分别是job_id, job_title, min_salary, max_salary所以我们创建一个T_Jobs类, 属性分别为四个列名
  1. public class T_Jobs {
  2.     private String job_id;
  3.     private String job_title;
  4.     private String min_salary;
  5.     private String max_salary;
  7.     public T_Jobs() {
  8.     }
  10.     public String getJob_id() {
  11.         return job_id;
  12.     }
  14.     public void setJob_id(String job_id) {
  15.         this.job_id = job_id;
  16.     }
  18.     public String getJob_title() {
  19.         return job_title;
  20.     }
  22.     public void setJob_title(String job_title) {
  23.         this.job_title = job_title;
  24.     }
  26.     public String getMin_salary() {
  27.         return min_salary;
  28.     }
  30.     public void setMin_salary(String min_salary) {
  31.         this.min_salary = min_salary;
  32.     }
  34.     public String getMax_salary() {
  35.         return max_salary;
  36.     }
  38.     public void setMax_salary(String max_salary) {
  39.         this.max_salary = max_salary;
  40.     }
  42.     @Override
  43.     public String toString() {
  44.         return "T_Jobs{" +
  45.                 "job_id='" + job_id + '\'' +
  46.                 ", job_title='" + job_title + '\'' +
  47.                 ", min_salary='" + min_salary + '\'' +
  48.                 ", max_salary='" + max_salary + '\'' +
  49.                 '}';
  50.     }
  51. }
  • 将查询到的数据进行封装, 将所有对象存入集合中, 方便后续使用
  1. public class TestORM {
  2.     public static void main(String[] args) {
  3.         Connection conn = null;
  4.         PreparedStatement ps = null;
  5.         ResultSet resultSet = null;
  6.         List<T_Jobs> t_jobsList = new ArrayList<>();
  7.         try {
  8.             conn = JdbcUtils2.getConnection();
  9.             ps = conn.prepareStatement("select * from t_jobs");
  10.             resultSet = ps.executeQuery();
  11.             while (resultSet.next()) {
  12.                 String job_id = resultSet.getString("job_id");
  13.                 String job_title = resultSet.getString("job_title");
  14.                 String min_salary = resultSet.getString("min_salary");
  15.                 String max_salary = resultSet.getString("max_salary");
  17.                 //创建对象, 封装查询到的零散数据
  18.                 T_Jobs t_jobs = new T_Jobs();
  20.                 t_jobs.setJob_id(job_id);
  21.                 t_jobs.setJob_title(job_title);
  22.                 t_jobs.setMin_salary(min_salary);
  23.                 t_jobs.setMax_salary(max_salary);
  24.                 //每遍历一次得到一个对象, 把对象存到集合里, 方便后续的使用
  25.                 t_jobsList.add(t_jobs);
  26.             }
  27.             //集合遍历
  28.             for (T_Jobs t_jobs : t_jobsList) {
  29.                 System.out.println(t_jobs);
  30.             }
  31.         } catch (SQLException throwables) {
  32.             throwables.printStackTrace();
  33.         }finally {
  34.             JdbcUtils2.closeAll(conn,ps,resultSet);
  35.         }
  36.     }
  37. }

十一. DAO 数据访问对象

  • DAO: (Data Access Object)
  • DAO实现了业务逻辑与数据库访问相分离
    • 对同一张表的所有操作封装在XxxDaoImpl对象中
    • 根据增删改查的不同功能实现具体的方法(insert, update, delete, select, selectAll)

11.1 创建数据库

  • 创建一张person表, 有以下列:

    • id: int, 主键 自动增长
    • name: varchar(20) 非空
    • age: int 非空
    • birthday: date
    • email: 字符串
    • address: 字符串
  1. CREATE TABLE person(
  2. 	id INT PRIMARY KEY AUTO_INCREMENT,
  3. 	`name` VARCHAR(20) NOT NULL,
  4. 	age INT NOT NULL,
  5. 	birthday DATE,
  6. 	email VARCHAR(20),
  7. 	address VARCHAR(20)
  8. )CHARSET=utf8;

11.2 封装实体类

  • 创建entity实体类Person,编写属性私有化, 构造方法, get/set 方法
  1. public class Person {//根据表名person, 创建Person类
  2.     private int id;//根据表的列名编写类的各个属性(私有)
  3.     private String name;
  4.     private int age;
  5.     private Date birthday;
  6.     private String email;
  7.     private String address;
  9.     public Person() {
  10.     }
  12.     public Person(String name, int age, Date birthday, String email, String address) {
  13.         this.name = name;
  14.         this.age = age;
  15.         this.birthday = birthday;
  16.         this.email = email;
  17.         this.address = address;
  18.     }
  20.     public Person(int id, String name, int age, Date birthday, String email, String address) {
  21.         this.id = id;
  22.         this.name = name;
  23.         this.age = age;
  24.         this.birthday = birthday;
  25.         this.email = email;
  26.         this.address = address;
  27.     }
  29.     public int getId() {
  30.         return id;
  31.     }
  33.     public void setId(int id) {
  34.         this.id = id;
  35.     }
  37.     public String getName() {
  38.         return name;
  39.     }
  41.     public void setName(String name) {
  42.         this.name = name;
  43.     }
  45.     public int getAge() {
  46.         return age;
  47.     }
  49.     public void setAge(int age) {
  50.         this.age = age;
  51.     }
  53.     public Date getBirthday() {
  54.         return birthday;
  55.     }
  57.     public void setBirthday(Date birthday) {
  58.         this.birthday = birthday;
  59.     }
  61.     public String getEmail() {
  62.         return email;
  63.     }
  65.     public void setEmail(String email) {
  66.         this.email = email;
  67.     }
  69.     public String getAddress() {
  70.         return address;
  71.     }
  73.     public void setAddress(String address) {
  74.         this.address = address;
  75.     }
  77.     @Override
  78.     public String toString() {
  79.         return "Person{" +
  80.                 "id=" + id +
  81.                 ", name='" + name + '\'' +
  82.                 ", age=" + age +
  83.                 ", birthday=" + birthday +
  84.                 ", email='" + email + '\'' +
  85.                 ", address='" + address + '\'' +
  86.                 '}';
  87.     }
  88. }

11.3 编写DaoImpl类

  • 编写DaoImpl类, 提供增删改查方法. 使用JDBC开发步骤, 完成功能
  1. public class PersonDaoImpl {
  2.     //1. 新增
  3.     public int insert(Person person) {
  4.         Connection conn = null;
  5.         PreparedStatement ps = null;
  6.         String sql = "insert into person(name,age,birthday,email,address) values(?,?,?,?,?)";//往person表里新增一条数据
  7.         try {
  8.             conn = DBUtils.getConnection();//调用跨平台工具类获取数据库连接对象
  9.             ps = conn.prepareStatement(sql);//获取执行SQL语句的对象
  10.             //为指定的参数下标赋值
  11.             ps.setString(1,person.getName());
  12.             ps.setInt(2,person.getAge());
  13.             ps.setDate(3,null);
  14.             ps.setString(4,person.getEmail());
  15.             ps.setString(5,person.getAddress());
  16.             int result = ps.executeUpdate();
  17.             return result;//返回执行结果,result为1则成功,0则失败
  18.         } catch (SQLException throwables) {
  19.             throwables.printStackTrace();
  20.         } finally {
  21.             DBUtils.closeAll(conn,ps,null);//最后调用跨平台工具类释放资源
  22.         }
  24.         return 0;
  25.     }
  26.     //2. 修改
  27.     public int update(Person person) {
  28.         Connection conn = null;
  29.         PreparedStatement ps = null;
  30.         String sql = "update person set name=?,age=?,birthday=?,email=?,address=? where id = ?";
  31.         try {
  32.             conn = DBUtils.getConnection();
  33.             ps = conn.prepareStatement(sql);
  34.             ps.setString(1,person.getName());
  35.             ps.setInt(2,person.getAge());
  36.             ps.setDate(3,null);
  37.             ps.setString(4,person.getEmail());
  38.             ps.setString(5,person.getAddress());
  39.             ps.setInt(6,person.getId());
  40.             int result = ps.executeUpdate();
  41.             return result;
  42.         } catch (SQLException throwables) {
  43.             throwables.printStackTrace();
  44.         } finally {
  45.             DBUtils.closeAll(conn,ps,null);
  46.         }
  47.         return 0;
  48.     }
  49.     //3. 删除
  50.     public int delete(int id) {
  51.         Connection conn = null;
  52.         PreparedStatement ps = null;
  53.         String sql = "delete from person where id = ?";
  54.         try {
  55.             conn = DBUtils.getConnection();
  56.             ps = conn.prepareStatement(sql);
  57.             ps.setInt(1,id);
  58.             int result = ps.executeUpdate();
  59.             return result;
  60.         } catch (SQLException throwables) {
  61.             throwables.printStackTrace();
  62.         } finally {
  63.             DBUtils.closeAll(conn,ps,null);
  64.         }
  65.         return 0;
  66.     }
  67.     //4. 查单条数据
  68.     public Person select(int id) {
  69.         Connection conn = null;
  70.         PreparedStatement ps = null;
  71.         ResultSet resultSet = null;
  72.         String sql = "select * from person where id = ?";
  73.         Person person = null;
  74.         try {
  75.             conn = DBUtils.getConnection();
  76.             ps = conn.prepareStatement(sql);
  77.             ps.setInt(1,id);
  78.             resultSet = ps.executeQuery();
  79.             if (resultSet.next()) {//如果查到数据
  80.                 person = new Person();//则创建一个对象
  81.                 int pid = resultSet.getInt("id");
  82.                 String name = resultSet.getString("name");
  83.                 int age = resultSet.getInt("age");
  84.                 Date birthday = resultSet.getDate("birthday");
  85.                 String email = resultSet.getString("email");
  86.                 String address = resultSet.getString("address");
  87.                 //通过set方法为属性赋值
  88.                 person.setId(pid);
  89.                 person.setName(name);
  90.                 person.setAge(age);
  91.                 person.setBirthday(birthday);
  92.                 person.setEmail(email);
  93.                 person.setAddress(address);
  94.             }
  95.             return person;
  97.         } catch (SQLException throwables) {
  98.             throwables.printStackTrace();
  99.         } finally {
  100.             DBUtils.closeAll(conn,ps,resultSet);
  101.         }
  102.         return null;
  103.     }
  104.     //5. 查所有数据
  105.     public List<Person> selectAll() {
  106.         Connection conn = null;
  107.         PreparedStatement ps = null;
  108.         ResultSet resultSet = null;
  109.         String sql = "select * from person";
  110.         Person person = null;
  111.         List<Person> personList = new ArrayList<>();//创建一个集合,用来存放Person对象
  112.         try {
  113.             conn = DBUtils.getConnection();
  114.             ps = conn.prepareStatement(sql);
  115.             resultSet = ps.executeQuery();
  116.             while (resultSet.next()) {
  117.                 int id = resultSet.getInt("id");
  118.                 String name = resultSet.getString("name");
  119.                 int age = resultSet.getInt("age");
  120.                 Date birthday = resultSet.getDate("birthday");
  121.                 String email = resultSet.getString("email");
  122.                 String address = resultSet.getString("address");
  123.                 person = new Person(id,name,age,birthday,email,address);//通过构造方法为属性赋值
  124.                 personList.add(person);
  125.             }
  126.             return personList;
  128.         } catch (SQLException throwables) {
  129.             throwables.printStackTrace();
  130.         } finally {
  131.             DBUtils.closeAll(conn,ps,resultSet);
  132.         }
  133.         return null;
  134.     }
  135. }

十二. Date工具类

  • 现有问题: 数据库存储的数据类型为java.sql.Date. 而我们Java应用层存储日期类型为java.util.Date. 当我们用Java应用程序插入带有日期的数据到数据库中时, 需要进行转换

12.1 java.util.Date

  • Java语言常规应用层面的日期类型, 可以通过字符串创建对应的时间对象
  • 无法直接通过JDBC插入到数据库

12.2 java.sql.Date

  • 不可以通过字符串创建对应的时间对象, 只能通过毫秒值创建对象(1970年至今的毫秒值)
  • 可以直接通过JDBC插入到数据库

12.3 SimpleDateFormat

  • 格式化和解析日期的具体类. 允许进行格式化(日期-->文本), 解析(文本-->日期) 和规范化
12.3.1 SimpleDateFormat应用
  1. public class TestTimes {
  2.     public static void main(String[] args) throws Exception{
  3.         //格式化
  4.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  5.         //将字符串转日期 parse
  6.         Date date = sdf.parse("2021-03-22");
  7.         System.out.println(date);
  8.         //将日期转字符串 format
  9.         String str = sdf.format(date);
  10.         System.out.println(str);
  12.         //sql.Date 不支持字符串转换, 只支持毫秒值创建
  13.         //通过util.Date拿到指定日期的毫秒值, 转换为sql.Date
  14.         java.sql.Date sqlDate = new java.sql.Date(date.getTime());
  15.         System.out.println(sqlDate);
  17.     }
  18. }

12.4 封装DateUtils工具类

  1. public class DateUtils {
  3.     private static final SimpleDateFormat sdf = new SimpleDateFormat("yy-MM-dd");
  4.     //1. 字符串转为util.Date
  5.     public static java.util.Date strToUtil(String str) {
  6.         try {
  7.             return sdf.parse(str);
  8.         } catch (ParseException e) {
  9.             e.printStackTrace();
  10.         }
  11.         return null;
  12.     }
  14.     //2. util.Date转sql.Date
  15.     public static java.sql.Date utilToSql(java.util.Date date) {
  16.         return new java.sql.Date(date.getTime());
  17.     }
  19.     //3. util.Date转字符串
  20.     public static String utilToString(java.util.Date date) {
  21.         return sdf.format(date);
  22.     }
  23. }

十三. Service业务逻辑

13.1 什么是业务?

(软件所提供的一个功能就叫业务)

service层核心思想

站在用户角度, 一个功能即是一个业务,可能需要多个DAO组成

  • 转账(业务): A账户存款, B账户取款

    • Service业务逻辑层业务功能对应Service中一个方法

AccountServiceImpl{

transfer(){

saveMoney();

takeMoney();

}

}

AccountDaoImpl{

saveMoney();

takeMoney();

}

  • 查看电商所有商品(业务): 销量最高的, 优惠打折的, 最新上架的

ProductServiceImpl{

showProduct(){

hostProduct();

salesProduct();

newProduct();

}

}

ProductDaoImpl{

hostProduct();

salesProduct();

newProduct();

}

13.2 Service开发流程

client

int result = AccountServiceImpl.transfer();

if (result > 0) {

//成功

}else {

//失败

}

AccountServiceImpl {

public int transfer(){

//1.验证卡号密码

//2.验证金额是否充足

//3.验证对方卡号

//4.A账户扣钱

//5.B账户加钱

return 0/1;

}

}

AccountDaoImpl{

//1.验证卡号密码

//2.验证金额是否充足

//3.验证对方卡号

//4.A账户扣钱

//5.B账户加钱

}

13.2.1 编写service实现转账功能
  1. /**
  2.  * @description: 转账业务
  3.  * @param: fromNo 转账卡号
  4.  * @param: pwd    转账卡的密码
  5.  * @param: toNo   收钱卡号
  6.  * @param: money  转账金额
  7.  */
  9. public class AccountsServiceImpl {
  11.     public String transfer(String fromNo,String pwd,String toNo,double money) {//1. 收参
  12.         String result = "转账失败!"
  13.         //2. 组织完善业务功能
  14.         AccountsDaoImpl accountsDao = new AccountsDaoImpl();
  15.         try {
  16.             //2.1 验证fromNo是否存在
  17.             Accounts account = accountsDao.select(fromNo);
  18.             if (account == null) {
  19.                 throw new RuntimeException("您的卡号不存在!");
  20.             }
  22.             //2.2 验证fromNo的密码是否正确
  23.             if (!account.getPassword().equals(pwd)) {
  24.                 throw new RuntimeException("您的密码错误!");
  25.             }
  27.             //2.3 验证fromNo的余额是否充足
  28.             if (account.getBalance() < money) {
  29.                 throw new RuntimeException("您的余额不足!");
  30.             }
  32.             //2.4 验证toNo的卡号是否存在
  33.             Accounts toAccount = accountsDao.select(toNo);
  34.             if (toAccount == null) {
  35.                 throw new RuntimeException("抱歉,对方卡号不存在!");
  36.             }
  38.             //2.5 减少fromNo的余额
  39.             //修改自己的金额,将余额减去转账金额 替换原有的属性
  40.             account.setBalance(account.getBalance() - money);
  41.             accountsDao.update(account);
  43.             //2.6 增加toNo的余额
  44.             toAccount.setBalance(toAccount.getBalance() + money);
  45.             accountsDao.update(toAccount);
  47.             result = "转账成功!";
  49.         } catch (Exception e) {
  50.             e.printStackTrace();
  51.         } finally {
  52.             DBUtils.closeAll(conn,null,null);
  53.         }
  54.         return result;
  55.     }
  56. }

十四. 事务

  • 在JDBC中, 获得Connection对象开始事务---提交或回滚---关闭连接. 其事务策略是

    • conn.setAutoCommit(false);//true等价于1, false等价于0
    • conn.commit();//手动提交事务
    • conn.rollback();//手动回滚事务

14.1 service层控制事务

  1. public class AccountsServiceImpl {
  3.     public String transfer(String fromNo,String pwd,String toNo,double money) {//1. 收参
  4.         String result = "转账失败!";
  5.         //2. 组织完善业务功能
  6.         AccountsDaoImpl accountsDao = new AccountsDaoImpl();
  8.         //拿一个连接
  9.         Connection conn = null;
  11.         try {
  12.             //建立了一个数据库连接
  13.             conn = DBUtils.getConnection();
  14.             System.out.println("service: "+conn);
  15.             //开启事务,并关闭事务的自动提交
  16.             conn.setAutoCommit(false);
  18.             //2.1 验证fromNo是否存在
  19.             Accounts account = accountsDao.select(fromNo);
  20.             if (account == null) {
  21.                 throw new RuntimeException("您的卡号不存在!");
  22.             }
  24.             //2.2 验证fromNo的密码是否正确
  25.             if (!account.getPassword().equals(pwd)) {
  26.                 throw new RuntimeException("您的密码错误!");
  27.             }
  29.             //2.3 验证fromNo的余额是否充足
  30.             if (account.getBalance() < money) {
  31.                 throw new RuntimeException("您的余额不足!");
  32.             }
  34.             //2.4 验证toNo的卡号是否存在
  35.             Accounts toAccount = accountsDao.select(toNo);
  36.             if (toAccount == null) {
  37.                 throw new RuntimeException("抱歉,对方卡号不存在!");
  38.             }
  40.             //2.5 减少fromNo的余额
  41.             //修改自己的金额,将余额减去转账金额 替换原有的属性
  42.             account.setBalance(account.getBalance() - money);
  43.             accountsDao.update(account);
  45.             //2.6 增加toNo的余额
  46.             toAccount.setBalance(toAccount.getBalance() + money);
  47.             accountsDao.update(toAccount);
  49.             result = "转账成功!";
  50.             //执行到这里,没有异常,则提交事务
  51.             conn.commit();
  52.         } catch (RuntimeException | SQLException e) {
  53.             e.printStackTrace();
  54.             //转账失败,则整个事务回滚
  55.             try {
  56.                 //出现异常,回滚
  57.                 System.out.println("出现了异常,回滚整个事务!");
  58.                 conn.rollback();
  59.             } catch (SQLException throwables) {
  60.                 throwables.printStackTrace();
  61.             }
  63.         } finally {
  64.             DBUtils.closeAll(conn,null,null);
  65.         }
  66.         return result;
  67.     }
  68. }
  • 问题: 当转账程序出现异常,事务控制成功了吗?

14.2 解决方案1: 传递Connection

  • 为解决线程中Connection对象不同步的问题,可以将Connection对象通过service传递给各个DAO方法吗?
14.2.1 传递的问题
  • 如果使用传递Connection, 容易造成接口污染(BadSmell)
  • 定义接口是为了更容易更换实现, 而将Connection定义在接口中, 会造成污染当前接口

14.3 解决方案2: ThreadLocal

  • 可以将整个线程中(单线程), 存储一个共享值
  • 线程拥有一个类似Map的属性, 键值对结构<ThreadLocal对象, 值>

14.4 ThreadLocal应用

  • 一个线程共享同一个ThreadLocal, 在整个流程中任一环节可以存值或取值
14.4.1 参数绑定
  • 在DBUtils中, 将当前Connection对象添加到ThreadLocal中
  1. public class DBUtils {
  3.     private static final Properties PROPERTIES = new Properties();
  5.     private static ThreadLocal<Connection> threadLocal = new ThreadLocal<>();
  6.     static {
  7.         InputStream is = DBUtils.class.getResourceAsStream("/jdbc.properties");
  9.         try {
  10.             PROPERTIES.load(is);
  11.             Class.forName(PROPERTIES.getProperty("driver"));
  12.         } catch (IOException e) {
  13.             e.printStackTrace();
  14.         } catch (ClassNotFoundException e) {
  15.             e.printStackTrace();
  16.         }
  17.     }
  19.     public static Connection getConnection() {
  20.         Connection conn = threadLocal.get();//获取当前线程中存储的Connection对象,赋值给conn
  22.         try {
  23.             if (conn == null) {
  24.                 conn = DriverManager.getConnection(PROPERTIES.getProperty("url"), PROPERTIES.getProperty("username"), PROPERTIES.getProperty("password"));
  25.                 threadLocal.set(conn);//把连接存储到当前线程共享中
  26.             }
  27.         } catch (SQLException throwables) {
  28.             throwables.printStackTrace();
  29.         }
  31.         return conn;
  32.     }
  34.     //关闭所有连接 增加 threadLocal.remove(); 移除
  35.     public static void closeAll(Connection conn, Statement statement, ResultSet resultSet) {
  36.         try {
  37.             if (resultSet != null) {
  38.                 resultSet.close();
  39.             }
  40.             if (statement != null) {
  41.                 statement.close();
  42.             }
  43.             if (conn != null) {
  44.                 conn.close();
  45.                 threadLocal.remove();//将conn移除
  46.             }
  47.         } catch (SQLException throwables) {
  48.             throwables.printStackTrace();
  49.         }
  50.     }
  51. }

十五. 事务的封装

  • 将事务的开启, 提交, 回滚都封装在工具类中, 业务层调用即可

15.1 完善工具类

  1. //开启事务
  2.     public static void begin() {
  3.         try {
  4.             Connection conn = getConnection();
  5.             conn.setAutoCommit(false);//开启事务,关闭自动提交
  6.         } catch (SQLException throwables) {
  7.             throwables.printStackTrace();
  8.         }
  9.     }
  11.     //提交事务
  12.     public static void commit() {
  13.         Connection conn = null;
  14.         try {
  15.             conn = getConnection();
  16.             conn.commit();
  17.         } catch (SQLException throwables) {
  18.             throwables.printStackTrace();
  19.         } finally {
  20.             closeAll(conn,null,null);
  21.         }
  22.     }
  23.     //回滚事务
  24.     public static void rollback() {
  25.         Connection conn = null;
  26.         try {
  27.             conn = getConnection();
  28.             conn.rollback();
  29.         } catch (SQLException throwables) {
  30.             throwables.printStackTrace();
  31.         } finally {
  32.             closeAll(conn,null,null);
  33.         }
  34.     }

十六. 三层架构

16.1 什么是三层

  • 表示层(UI, Main)

    • 命名: XXXView
    • 职责:
      1. 收集用户输入数据
      2. 调用业务逻辑层, 完成业务方法
      3. 展示数据或展示操作结果
  • 业务逻辑层(service)
    • 命名: XXXServiceImpl
    • 职责:
      1. 开启事务
      2. 调用DAO层
      3. 处理数据
      4. 提交或回滚
  • 数据访问层(DAO)
    • 命名: XXXDaoImpl
    • 职责:
      1. 查询相关业务逻辑的数据
      2. 根据相关业务逻辑修改的数据

16.2 三层架构项目搭建(按开发步骤)

  • utils 存放工具类 (DBUtils)
  • entity 存放实体类 (Person)
  • dao 存放 DAO 接口 (PersonDao)
    • impl存放 DAO 接口实现类 (PersonDaoImpl)
  • service 存放 service 接口 (PersonServiceImpl)
    • impl存放 service 接口实现类 (PersonServiceImpl)
  • view 存放程序启动类 (main)
  • 程序设计时, 考虑易修改, 易扩展, 为service层和DAO层设计接口, 便于未来更换实现类
  1. //1. 更自然的使用多态(父类接口引用指向子类对象)
  2. //2. 更容易更换具体实现
  4. public interface AccountsDao {
  6.     int insert(Accounts accounts);
  7.     int delete(String cardNo);
  8.     int update(Accounts accounts);
  9.     Accounts select(String cardNo);
  10.     List<Accounts> selectAll();
  12. }
  13. public interface AccountsService {
  14.     String transfer(String fromNo,String pwd,String toNo,double money);
  15. }

十七. DaoUtils

  • 在DAO层中, 对数据库表的增, 删, 改, 查操作存在代码冗余, 可对其进行抽取封装DaoUtils工具类实现复用

17.1 commonUpdate

  1. /*
  2. * 公共处理增, 删, 改的方法
  3. *
  4. * @param sql 执行的sql语句
  5. * @param args 参数列表,为占位符赋值
  6. * @return  受影响的行数
  7. */
  8. public class DaoUtils {
  10.     public int commonUpdate(String sql,Object... args) {
  11.         Connection conn = null;
  12.         PreparedStatement ps = null;
  14.         conn = DbUtils.getConnection();
  15.         try {
  16.             ps = conn.prepareStatement(sql);
  18.             for (int i = 0; i < args.length; i++) {
  19.                 ps.setObject(i+1,args[i]);
  20.             }
  21.             return ps.executeUpdate();
  22.         } catch (SQLException throwables) {
  23.             throwables.printStackTrace();
  24.         } finally {
  25.             DbUtils.closeAll(null,ps,null);
  26.         }
  27.         return 0;
  28.     }
  29. }

17.2 commonselect

  1. /*
  2. * 公共查询方法 (可查询单个对象, 也可以查询多个对象,可以查任何一张表)
  3. *
  4. * @param sql
  5. * @param args
  6. * @return 集合
  7. */
  8. //	select * from t_account;
  9. //	select * from t_student;
  10. //  select * from person;
  11. //	工具不知道查的是什么 调用者知道
  12. //	封装对象,对象赋值 调用者清除
  13. public List<T> commonSelect(String sql, RowMapper<T> rowMapper, Object... args) {
  14.         Connection conn = null;
  15.         PreparedStatement ps = null;
  16.         ResultSet resultSet = null;
  17.         List<T> list = new ArrayList<>();
  19.         conn = DbUtils.getConnection();
  20.         try {
  21.             ps = conn.prepareStatement(sql);
  22.             if (args != null) {
  23.                 for (int i = 0; i < args.length; i++) {
  24.                     ps.setObject(i+1,args[i]);//为占位符赋值
  25.                 }
  26.             }
  27.             resultSet = ps.executeQuery();
  28.             while (resultSet.next()) {
  29.                 // id.name,age,birthday,email,address
  30.                 // 如何根据查询结果完成ORM,如何进行对象的创建及赋值
  31.                 T t = rowMapper.getRow(resultSet);//回调--->调用者提供一个封装方法ORM
  32.                 list.add(t);
  33.             }
  34.             return list;
  35.         } catch (SQLException throwables) {
  36.             throwables.printStackTrace();
  37.         }
  38.         return null;
  39.     }

RowMapper接口

  1. public interface RowMapper<T> {
  2.     T getRow(ResultSet resultSet);
  3. }

PersonRowMapper实现类

  1. public class PersonRowMapper implements RowMapper<Person> {
  2.     @Override
  3.     public Person getRow(ResultSet resultSet) {
  4.         Person person = null;
  5.         try {
  6.             int pid = resultSet.getInt("id");
  7.             String name = resultSet.getString("name");
  8.             int age = resultSet.getInt("age");
  9.             Date birthday = resultSet.getDate("birthday");
  10.             String email = resultSet.getString("email");
  11.             String address = resultSet.getString("address");
  13.             person = new Person(pid,name,age,birthday,email,address);
  14.             return person;
  15.         } catch (SQLException throwables) {
  16.             throwables.printStackTrace();
  17.         }
  18.         return null;
  19.     }
  20. }

十八. Druid连接池

  • 在程序初始化时, 预先创建指定数量的数据库连接对象存储在池中, 当需要连接数据库时, 从连接池中取出现有连接, 使用完毕后, 也不会进行关闭, 而是放回池中, 实现复用, 节省资源

18.1 Druid连接池使用步骤

  • 创建 database properties配置文件
  • 引入 druid.1.1.5.jar文件
18.1.1 database.properties配置文件
  1. #<!-- 连接设置 -->
  2. driverClassName=com.mysql.jdbc.Driver
  3. url=jdbc:mysql://localhost:3306/companydb?useUnicode=true&characterEncoding=utf8
  4. username=root
  5. password=root
  6. #<!-- 初始化连接 -->
  7. initialSize=10
  8. #<!-- 最大连接数量 -->
  9. maxActive=30
  10. #<!-- 最小空闲连接 -->
  11. minIdle=5
  12. #<!-- 超时等待时间以毫秒为单位 60000毫秒/1000等于60秒 -->
  13. maxWait=5000
18.1.2 连接池工具类
  1. public class DbUtils {
  2.     //声明连接池对象
  3.     private static DruidDataSource ds;
  4.     static {
  5.         Properties properties = new Properties();
  6.         InputStream is = DbUtils.class.getResourceAsStream("/database.properties");
  7.         try {
  8.             properties.load(is);
  9.             //创建连接池
  10.             ds = (DruidDataSource)DruidDataSourceFactory.createDataSource(properties);
  11.         } catch (IOException e) {
  12.             e.printStackTrace();
  13.         } catch (Exception e) {
  14.             e.printStackTrace();
  15.         }
  16.     }
  17.     public static Connection getConnection() {
  18.         try {
  19.             return ds.getConnection();
  20.         } catch (SQLException throwables) {
  21.             throwables.printStackTrace();
  22.         }
  23.         return null;
  24.     }
  25. }

十九. Apache的DbUtils的使用

  • Commons DbUtils 是Apache组织提供的一个对JDBC进行简单封装的开源工具类库, 使用它能够简化JDBC应用程序的开发! 同时, 不会影响程序的性能

19.1 DbUtils简介

  • DbUtils是java编程中数据库操作实用小工具, 小巧, 简单, 实用

    • 对于数据库表的查询操作, 可以把结果转换为List, Array, Set等集合, 便于操作
    • 对于数据库表的DML操作, 也变得很简单(只需要写SQL语句)
19.1.1 DbUtils主要包含
  • ResultSetHandler接口: 转换类型接口

    • BeanHandler类: 实现类, 把一条记录转换成对象
    • BeanListHandler类: 实现类, 把多条数据转换成List集合
    • ScalarHandler类: 实现类, 适合获取一行一列的数据
  • QueryRunner: 执行sql语句的类
    • 增, 删, 改: update();
    • 查询: query();

19.2 DbUtils的使用步骤

  • 导入jar 包

    • mysql连接驱动jar包: mysql-connector-java-5.1.25-bin.jar
    • Druid连接池jar包: druid-1.1.5.jar
    • database.properties配置文件
    • DbUtils工具jar包: commons-dbutils-1.7.jar
19.2.1 DbUtils工具类
  1. public class DbUtils {
  2.     //声明连接池对象
  3.     private static DruidDataSource ds;
  5.     static {
  6.         //实例化配置对象
  7.         Properties properties = new Properties();
  8.         InputStream is = DbUtils.class.getResourceAsStream("/database.properties");
  9.         try {
  10.             //加载配置文件内容
  11.             properties.load(is);
  12.             //创建连接池
  13.             ds = (DruidDataSource)DruidDataSourceFactory.createDataSource(properties);
  14.         } catch (IOException e) {
  15.             e.printStackTrace();
  16.         } catch (Exception e) {
  17.             e.printStackTrace();
  18.         }
  19.     }
  20.     //获取连接对象
  21.     public static Connection getConnection() {
  22.         try {
  23.             return ds.getConnection();
  24.         } catch (SQLException throwables) {
  25.             throwables.printStackTrace();
  26.         }
  27.         return null;
  28.     }
  29.     //返回一个数据源ds
  30.     public static DataSource getDataSource() {
  31.         return ds;
  32.     }
  33.     //释放资源
  34.     //调用close()方法,实际调用的是DruidPooledConnection实现类里的close()
  35. }
19.2.2 UserDaoImpl数据访问对象
  1. public class UserDaoImpl implements UserDao {
  2.     //创建QueryRunner对象,并传递一个数据源对象
  3.     private QueryRunner queryRunner = new QueryRunner(DbUtils.getDataSource());
  4.     @Override
  5.     //1. 新增
  6.     public int insert(User user) {
  7.         Object[] params = {user.getUserId(),user.getUsername(),user.getPassword(),user.getAddress(),user.getPhone()};
  8.         try {
  9.             int result = queryRunner.update("insert into user(userId,username,password,address,phone) values(?,?,?,?,?)", params);
  10.             return result;
  11.         } catch (SQLException throwables) {
  12.             throwables.printStackTrace();
  13.         }
  14.         return 0;
  15.     }
  17.     @Override
  18.     //2. 删除
  19.     public int delete(int userId) {
  20.         try {
  21.             int result = queryRunner.update("delete from user where userId=?", userId);
  22.             return result;
  23.         } catch (SQLException throwables) {
  24.             throwables.printStackTrace();
  25.         }
  26.         return 0;
  27.     }
  29.     @Override
  30.     //3. 修改
  31.     public int update(User user) {
  32.         Object[] params = {user.getUsername(),user.getPassword(),user.getAddress(),user.getPhone(),user.getUserId()};
  33.         try {
  34.             int result = queryRunner.update("update user set username=?,password=?,address=?,phone=? where userId=?", params);
  35.             return result;
  36.         } catch (SQLException throwables) {
  37.             throwables.printStackTrace();
  38.         }
  39.         return 0;
  40.     }
  42.     @Override
  43.     //4. 查单个
  44.     public User select(int userId) {
  45.         try {
  46.             //把查询到的记录封装成 指定对象
  47.             User user = queryRunner.query("select * from user where userId=?", new BeanHandler<User>(User.class), userId);
  48.             return user;
  49.         } catch (SQLException throwables) {
  50.             throwables.printStackTrace();
  51.         }
  52.         return null;
  53.     }
  55.     @Override
  56.     //5. 查所有
  57.     public List<User> selectAll() {
  58.         try {
  59.             List<User> userList = queryRunner.query("select * from user", new BeanListHandler<User>(User.class));
  60.             return userList;
  61.         } catch (SQLException throwables) {
  62.             throwables.printStackTrace();
  63.         }
  64.         return null;
  65.     }
  67.     @Override
  68.     //6. 查数量(单行单列)
  69.     public long selectUserNums() {
  70.         try {
  71.             long count = queryRunner.query("select count(*) from user", new ScalarHandler<>());
  72.             return count;
  73.         } catch (SQLException throwables) {
  74.             throwables.printStackTrace();
  75.         }
  76.         return 0;
  77.     }
  78. }

2_JDBC的更多相关文章

随机推荐

  1. 使用Java客户端发送消息和消费的应用

    体验链接:https://developer.aliyun.com/adc/scenario/fb1b72ee956a4068a95228066c3a40d6 实验简介 本教程将Demo演示使用jav ...

  2. Linux 任务计划管理

    在某个时间点执行一次任务 at工具 作用:用于执行一次性任务,需要指定执行的时间. at工具来源于at软件包. 依赖与atd服务,需要启动才能实现at任务.#通过这个守护进程见监控at的相关内容 #选 ...

  3. 字节输出流的续写和换行和字节输入流InputStream类&FileInputStream类介绍

    数据追加续写 每次程序运行,创建输出流对象,都会清空目标文件中的数据.如何保目标文件中的数据,还能继续添加新数据呢? public FileOutputStream(File file,boolean ...

  4. 从零开始Blazor Server(4)--登录系统

    说明 上一篇文章中我们添加了Cookie授权,可以跳转到登录页了.但是并没有完成登录,今天我们来完成它. 我们添加Cookie授权的时候也说了,这套跟MVC一模一样,所以我们登录也是跟MVC一模一样. ...

  5. Python算法之动态规划(Dynamic Programming)解析:二维矩阵中的醉汉(魔改版leetcode出界的路径数)

    原文转载自「刘悦的技术博客」https://v3u.cn/a_id_168 现在很多互联网企业学聪明了,知道应聘者有目的性的刷Leetcode原题,用来应付算法题面试,所以开始对这些题进行" ...

  6. Hive存储格式之RCFile详解，RCFile的过去现在和未来

    我在整理Hive的存储格式和压缩格式,本来打算一篇发出来,结果其中一小节就有很多内容,于是打算写成Hive存储格式和压缩格式系列. 本节主要讲一下Hive存储格式最早的典型的列式存储格式RCFile. ...

  7. 如何保证遍历parent的时候的task的存在性

    在一次crash的排查过程中,有这么一个内核模块,他需要往上遍历父进程, 但是在拿父进程task_struct中的一个成员的时候,发现为NULL了, 具体查看父进程,原来它收到信号退出中. 那么怎么保 ...

  8. Python入门系列（一）安装环境

    python是什么 python是一门很受欢迎的语言,除了不能生孩子以外,其它都可以做. 它擅长的领域是脚本工具和科学数据这一块,比如大数据,数据分析什么的. python安装 为了演示和验证教程可用 ...

  9. dotnet 设计规范 · 抽象类

    X 不要定义 public 或 protected internal 访问的构造函数.默认 C# 语言不提供抽象类的公开构造函数方法. 如果一个构造函数定义为公开,只有在开发者需要创建这个类的实例的时 ...

  10. Codeforces Round #604 (Div. 2) -D

    Problem - D - Codeforces 题意 : 有 a 个0,b个1,c个2,d个3,构成一个序列,使得每两个数字之间的差值为1 题解: 就是以四种数字分别为起点,暴力模拟 #includ ...