devbox
代码世界探险家
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

MySQL入门教程：JDBC事务&API阅读&DAO模式_mysql preparedstatement addbatch 返回 -2

作者：代码世界探险家 | 2024-02-05 22:17:37

赞

踩

mysql preparedstatement addbatch 返回 -2

1、事务及回滚点

JDBC中使用事务

    事务回顾:

     事务概念:在逻辑上一组不可分割的操作,由多个sql语句组成,多个sql语句要么全都执行成功,要么都不执行.  原子性 一致性  隔离性 持久性

     JDBC控制事物主要就是在学习如何让多个数据库操作成为一个整体,实现要么全都执行成功,要么全都不执行

     在JDBC中，事务操作是自动提交。一条对数据库的DML(insert、update、delete)代表一项事务操作,操作成功后，系统将自动调用commit()提交，否则自动调用rollback()回滚,在JDBC中，事务操作方法都位于接口java.sql.Connection中,可以通过调用setAutoCommit(false)来禁止自动提交。之后就可以把多个数据库操作的表达式作为一个事务，在操作完成后调用commit()来进行整体提交，倘若其中一个表达式操作失败，都不会执行到commit()，并且将产生响应的异常；此时就可以在异常捕获时调用rollback()进行回滚,回复至数据初始状态.事务开始的边界则不是那么明显了，它会开始于组成当前事务的所有statement中的第一个被执行的时候。事务结束的边界是commit或者rollback方法的调用

  使用事务保证转账安全性 

  1.  
  2. import java.sql.Connection;
  3. import java.sql.DriverManager;
  4. import java.sql.PreparedStatement;
  5. import java.sql.SQLException;
  6.  
  7. public class TestTransaction {
  8.  
  9.     private static String driver ="com.mysql.cj.jdbc.Driver";
  10.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useServerPrepStmts=true&cachePrepStmts=true&&rewriteBatchedStatements=true";
  11.     private static String user="root";
  12.     private static String password="root";
  13.     public static void main(String[] args) {
  14.         testTransaction();
  15.     }
  16.     // 定义一个方法,向部门表增加1000条数据
  17.     public static void testTransaction(){
  18.         Connection connection = null;
  19.         PreparedStatement preparedStatement=null;
  20.  
  21.  
  22.         /*
  23.         * JDBC 默认是自动提交事务
  24.         * 每条DML都是默认提交事务的,多个preparedStatement.executeUpdate();都会提交一次事务
  25.         * 如果想手动控制事务,那么就不能让事务自动提交
  26.         * 通过Connection对象控制connection.setAutoCommit(false);
  27.         * 如果不设置 默认值为true,自动提交,设置为false之后就是手动提交了
  28.         * 无论是否发生回滚,事务最终会一定要提交的 提交我们建议放在finally之中进行提交
  29.         * 如果是转账的过程中出现异常了,那么我们就要执行回滚,回滚操作应该方法catch语句块中
  30.         *
  31.         * */
  32.         try{
  33.             Class.forName(driver);
  34.             connection = DriverManager.getConnection(url, user,password);
  35.             // 设置事务手动提交
  36.             connection.setAutoCommit(false);
  37.             String sql="update account set money =money- ? where aid = ?";
  38.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  39.             // 转出
  40.             preparedStatement.setDouble(1, 100);
  41.             preparedStatement.setInt(2, 1);
  42.             preparedStatement.executeUpdate();
  43.             // 产生异常
  44.             //int i =1/0;
  45.  
  46.             // 转入
  47.             preparedStatement.setDouble(1, -100);
  48.             preparedStatement.setInt(2, 2);
  49.             preparedStatement.executeUpdate();
  50.  
  51.         }catch (Exception e){
  52.             if(null != connection){
  53.                 try {
  54.                     connection.rollback();// 回滚事务
  55.                 } catch (SQLException ex) {
  56.                     ex.printStackTrace();
  57.                 }
  58.             }
  59.             e.printStackTrace();
  60.         }finally {
  61.             // 提交事务
  62.             if(null != connection){
  63.                 try {
  64.                     connection.commit();
  65.                 } catch (SQLException e) {
  66.                     e.printStackTrace();
  67.                 }
  68.             }
  69.  
  70.             if(null != preparedStatement){
  71.                 try {
  72.                     preparedStatement.close();
  73.                 } catch (SQLException e) {
  74.                     e.printStackTrace();
  75.                 }
  76.             }
  77.  
  78.             if(null != connection){
  79.                 try {
  80.                     connection.close();
  81.                 } catch (SQLException e) {
  82.                     e.printStackTrace();
  83.                 }
  84.             }
  85.         }
  86.     }
  87.  
  88. }

 设置回滚点

  1. import java.sql.*;
  2. import java.util.LinkedList;
  3.  
  4.  
  5. public class TestTransaction2 {
  6.     private static String driver ="com.mysql.cj.jdbc.Driver";
  7.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useServerPrepStmts=true&cachePrepStmts=true&&rewriteBatchedStatements=true";
  8.     private static String user="root";
  9.     private static String password="root";
  10.     public static void main(String[] args) {
  11.         testAddBatch();
  12.     }
  13.     // 定义一个方法,向部门表增加1000条数据
  14.     public static void testAddBatch(){
  15.         Connection connection = null;
  16.         PreparedStatement preparedStatement=null;
  17.  
  18.         LinkedList<Savepoint> savepoints =new LinkedList<Savepoint>();
  19.         try{
  20.             Class.forName(driver);
  21.             connection = DriverManager.getConnection(url, user,password);
  22.             connection.setAutoCommit(false);
  23.             String sql="insert into dept values (DEFAULT ,?,?)";
  24.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  25.  
  26.             //设置参数
  27.             for (int i = 1; i <= 10663; i++) {
  28.                 preparedStatement.setString(1, "name");
  29.                 preparedStatement.setString(2, "loc");
  30.                 preparedStatement.addBatch();// 将修改放入一个批次中
  31.                 if(i%1000==0){
  32.                     preparedStatement.executeBatch();
  33.                    preparedStatement.clearBatch();// 清除批处理中的数据
  34.                     // 设置回滚点
  35.                     Savepoint savepoint = connection.setSavepoint();
  36.                     savepoints.addLast(savepoint);
  37.                 }
  38.                 // 数据在 100001条插入的时候出现异常
  39.                 if(i ==10001){
  40.                     int x =1/0;
  41.                 }
  42.             }
  43.  
  44.             /*
  45.             * 整数数组中的元素代表执行的结果代号
  46.             * SUCCESS_NO_INFO -2
  47.             * EXECUTE_FAILED  -3
  48.             * */
  49.             /*int[] ints = */
  50.             preparedStatement.executeBatch();
  51.             preparedStatement.clearBatch();
  52.  
  53.         }catch (Exception e){
  54.             if(null != connection){
  55.                 try {
  56.                     //Savepoint sp = savepoints.getLast();
  57.                     Savepoint sp = savepoints.get(4);
  58.                     if(null != sp){
  59.                         // 选择回滚点
  60.                         connection.rollback(sp);// 回滚
  61.                     }
  62.  
  63.                 } catch (SQLException e2) {
  64.                     e2.printStackTrace();
  65.                 }
  66.             }
  67.             e.printStackTrace();
  68.         }finally {
  69.             if(null != connection){
  70.                 try {
  71.                     connection.commit();// 提交
  72.                 } catch (SQLException e) {
  73.                     e.printStackTrace();
  74.                 }
  75.             }
  76.  
  77.             if(null != preparedStatement){
  78.                 try {
  79.                     preparedStatement.close();
  80.                 } catch (SQLException e) {
  81.                     e.printStackTrace();
  82.                 }
  83.             }
  84.  
  85.             if(null != connection){
  86.                 try {
  87.                     connection.close();
  88.                 } catch (SQLException e) {
  89.                     e.printStackTrace();
  90.                 }
  91.             }
  92.         }
  93.     }
  94. }
  95.

2、JDBCAPI总结_阅读

JDBC API总结

Connection接口

•作用：代表数据库连接

 

方法摘要

 

 

 void

 

 

close () 
   立即释放此   Connection  对象的数据库和 JDBC 资源，而不是等待它们被自动释放。

 

 

 void

 

 

commit () 
            使所有上一次提交/回滚后进行的更改成为持久更改，并释放此 Connection  对象当前持有的所有数据库锁。

 

 

 Statement

 

 

createStatement () 
            创建一个   Statement  对象来将 SQL 语句发送到数据库。

 

 

 CallableStatement

 

 

prepareCall (String  sql) 
            创建一个   CallableStatement  对象来调用数据库存储过程。

 

 

 PreparedStatement

 

 

prepareStatement (String  sql) 
            创建一个   PreparedStatement  对象来将参数化的 SQL 语句发送到数据库。

 

 

 PreparedStatement

 

 

prepareStatement (String  sql, int autoGeneratedKeys)
            创建一个默认   PreparedStatement  对象，该对象能获取自动生成的键。

 

 

 void

 

 

rollback () 
            取消在当前事务中进行的所有更改，并释放此   Connection  对象当前持有的所有数据库锁。

 

 

 void

 

 

setAutoCommit (boolean autoCommit) 
            将此连接的自动提交模式设置为给定状态。

 

  DriverManager类

 作用：管理一组 JDBC 驱动程序的基本服务

应用程序不再需要使用 Class.forName() 显式地加载 JDBC 驱动程序。在调用 getConnection 方法时，DriverManager 会试着从初始化时加载的那些驱动程序以及使用与当前 applet 或应用程序相同的类加载器显式加载的那些驱动程序中查找合适的驱动程序。

 

方法摘要

 

 

static Connection

 

 

getConnection (String  url) 
            试图建立到给定数据库 URL 的连接。

 

 

static Connection

 

 

getConnection (String  url, Properties  info) 
            试图建立到给定数据库 URL 的连接。

 

 

static Connection

 

 

getConnection (String  url, String  user, String  password)
            试图建立到给定数据库 URL 的连接。

 

Statement接口

作用：用于将 SQL 语句发送到数据库中，或理解为执行sql语句

有三种 Statement对象：

Statement：用于执行不带参数的简单SQL语句；

PreparedStatement（从 Statement 继承）：用于执行带或不带参数的预编译SQL语句；

CallableStatement（从PreparedStatement 继承）：用于执行数据库存储过程的调用。

 

方法

 

 

作用

 

 

ResultSet   executeQuery(String   sql)

 

 

执行SQL查询并获取到ResultSet对象

 

 

int   executeUpdate(String   sql)

 

 

可以执行插入、删除、更新等操作，返回值是执行该操作所影响的行数

 

  PreparedStatement接口

关系：public interface PreparedStatement extends Statement

区别

PreparedStatment安全性高，可以避免SQL注入

PreparedStatment简单不繁琐，不用进行字符串拼接

PreparedStatment性能高，用在执行多个相同数据库DML操作时

ResultSet接口

     ResultSet对象是executeQuery()方法的返回值，它被称为结果集，它代表符合SQL语句条件的所有行，并且它通过一套getXXX方法（这些get方法可以访问当前行中的不同列）提供了对这些行中数据的访问。

     ResultSet里的数据一行一行排列，每行有多个字段，且有一个记录指针，指针所指的数据行叫做当前数据行，我们只能来操作当前的数据行。我们如果想要取得某一条记录，就要使用ResultSet的next()方法 ,如果我们想要得到ResultSet里的所有记录，就应该使用while循环。

    ResultSet对象自动维护指向当前数据行的游标。每调用一次next()方法，游标向下移动一行。

     初始状态下记录指针指向第一条记录的前面，通过next()方法指向第一条记录。循环完毕后指向最后一条记录的后面。

 

方法名

 

 

说    明

 

 

boolean   next()

 

 

将光标从当前位置向下移动一行

 

 

boolean   previous()

 

  游标从当前位置向上移动一行

 

 

void   close()

 

 

关闭ResultSet 对象

 

 

int   getInt(int colIndex)

 

 

以int形式获取结果集当前行指定列号值

 

 

int   getInt(String colLabel)

 

 

以int形式获取结果集当前行指定列名值

 

 

float   getFloat(int colIndex)

 

 

以float形式获取结果集当前行指定列号值

 

 

Float   getFloat(String colLabel)

 

 

以float形式获取结果集当前行指定列名值

 

 

String   getString(int colIndex)

 

 

以String 形式获取结果集当前行指定列号值

 

 

StringgetString(String   colLabel)

 

 

以String形式获取结果集当前行指定列名值

 

 

3、DAO模式

DAO(Data Access Object)是一个数据访问接口，数据访问：顾名思义就是与数据库打交道。夹在业务逻辑与数据库资源中间。

在核心J2EE模式中是这样介绍DAO模式的：为了建立一个健壮的J2EE应用，应该将所有对数据源的访问操作抽象封装在一个公共API中。用程序设计的语言来说，就是建立一个接口，接口中定义了此应用程序中将会用到的所有事务方法。在这个应用程序中，当需要和数据源进行交互的时候则使用这个接口，并且编写一个单独的类来实现这个接口在逻辑上对应这个特定的数据存储.

简单来说,就是定义一个接口,规定一些增删改查的方法,然后交给实现类去实现, 它介于数据库和业务逻辑代码之间,这样当我们需要操作数据库是,根据接口定义的API去操作数据库就可以了,每个方法都是一个原子性的操作,例如：增加、修改、删除等

Dao模式要求项目必须具备这样几个结构

1、实体类:和数据库表格一一对应的类,单独放入一个包中,包名往往是 pojo/entity/bean,要操作的每个表格都应该有对应的实体类

emp > class Emp  

dept > class Dept  

account > class Account 

2、DAO 层:定义了对数据要执行那些操作的接口和实现类,包名往往是 dao/mapper,要操作的每个表格都应该有对应的接口和实现类

emp > interface EmpDao >EmpDaoImpl

dept > interface DeptDao> DeptDaoImpl

3、Mybatis/Spring JDBCTemplate 中,对DAO层代码进行了封装,代码编写方式会有其他变化   

项目的搭建

1.创建项目

2.添加jar包

3.创建包

4.创建实体类Emp

5.创建后台的接口EmpDao和实现类EmpDaoImpl

导入各个层级的接口和页面之后的项目

项目结构截图如下

实体类代码 

  1. public class Emp implements Serializable {
  2.     private Integer empno;
  3.     private String ename;
  4.     private String job;
  5.     private Integer mgr;
  6.     private Date hiredate;
  7.     private Double sal;
  8.     private Double comm;
  9.     private Integer deptno;
  10. }
  11.  
  12.  
  13. public class Dept implements Serializable {
  14.     private Integer deptno;
  15.     private String dname;
  16.     private String loc;
  17. }
  18.  
  19. //DAO接口代码
  20.  
  21.  
  22. public interface EmpDao {
  23.     /**
  24.      * 向数据库Emp表中增加一条数据的方法
  25.      * @param emp 要增加的数据封装成的Emp类的对象
  26.      * @return 增加成功返回大于0 的整数,增加失败返回0
  27.      */
  28.     int addEmp(Emp emp);
  29.  
  30.     /**
  31.      * 根据员工编号删除员工信息的方法
  32.      * @param empno 要删除的员工编号
  33.      * @return 删除成功返回大于0的整数,失败返回0
  34.      */
  35.     int deleteByEmpno(int empno);
  36.  
  37. }
  38.  
  39. //DAO实现类代码
  40.  
  41. import java.sql.*;
  42.  
  43. public class EmpDaoImpl implements EmpDao {
  44.     private static String driver ="com.mysql.cj.jdbc.Driver";
  45.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
  46.     private static String user="root";
  47.     private static String password="root";
  48.  
  49.     @Override
  50.     public int addEmp(Emp emp) {
  51.         // 向 Emp表中增加一条数据
  52.         Connection connection = null;
  53.         PreparedStatement preparedStatement=null;
  54.         int rows=0;
  55.  
  56.  
  57.         try{
  58.             Class.forName(driver);
  59.             connection = DriverManager.getConnection(url, user,password);
  60.             String sql="insert into emp values(DEFAULT ,?,?,?,?,?,?,?)";
  61.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  62.             //设置参数
  63.             preparedStatement.setObject(1,emp.getEname());
  64.             preparedStatement.setObject(2,emp.getJob() );
  65.             preparedStatement.setObject(3,emp.getMgr());
  66.             preparedStatement.setObject(4,emp.getHiredate());
  67.             preparedStatement.setObject(5,emp.getSal());
  68.             preparedStatement.setObject(6,emp.getComm());
  69.             preparedStatement.setObject(7,emp.getDeptno());
  70.  
  71.             //执行CURD
  72.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
  73.         }catch (Exception e){
  74.             e.printStackTrace();
  75.         }finally {
  76.  
  77.             if(null != preparedStatement){
  78.                 try {
  79.                     preparedStatement.close();
  80.                 } catch (SQLException e) {
  81.                     e.printStackTrace();
  82.                 }
  83.             }
  84.  
  85.             if(null != connection){
  86.                 try {
  87.                     connection.close();
  88.                 } catch (SQLException e) {
  89.                     e.printStackTrace();
  90.                 }
  91.             }
  92.         }
  93.  
  94.         return rows;
  95.     }
  96.  
  97.     @Override
  98.     public int deleteByEmpno(int empno) {
  99.         // 向 Emp表中增加一条数据
  100.         Connection connection = null;
  101.         PreparedStatement preparedStatement=null;
  102.         int rows=0;
  103.  
  104.  
  105.         try{
  106.             Class.forName(driver);
  107.             connection = DriverManager.getConnection(url, user,password);
  108.             String sql="delete from emp where empno =?";
  109.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  110.             //设置参数
  111.             preparedStatement.setObject(1,empno);
  112.  
  113.  
  114.             //执行CURD
  115.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
  116.  
  117.         }catch (Exception e){
  118.             e.printStackTrace();
  119.         }finally {
  120.  
  121.             if(null != preparedStatement){
  122.                 try {
  123.                     preparedStatement.close();
  124.                 } catch (SQLException e) {
  125.                     e.printStackTrace();
  126.                 }
  127.             }
  128.  
  129.             if(null != connection){
  130.                 try {
  131.                     connection.close();
  132.                 } catch (SQLException e) {
  133.                     e.printStackTrace();
  134.                 }
  135.             }
  136.         }
  137.  
  138.         return rows;
  139.     }
  140. }
  141.

4、员工管理系统开发

DAO接口

  1.  
  2. import java.util.List;
  3.  
  4. public interface EmpDao {
  5.     /**
  6.      * 向数据库Emp表中增加一条数据的方法
  7.      * @param emp 要增加的数据封装成的Emp类的对象
  8.      * @return 增加成功返回大于0 的整数,增加失败返回0
  9.      */
  10.     int addEmp(Emp emp);
  11.  
  12.     /**
  13.      * 根据员工编号删除员工信息的方法
  14.      * @param empno 要删除的员工编号
  15.      * @return 删除成功返回大于0的整数,失败返回0
  16.      */
  17.     int deleteByEmpno(int empno);
  18.  
  19.     /**
  20.      * 查看数据库表格中所有的员工信息
  21.      * @return 所有员工信息封装的一个List<Emp>集合
  22.      */
  23.     List<Emp> findAll();
  24.  
  25.     /**
  26.      * 根据员工编号修改员工其他所有字段的方法
  27.      * @param emp 员工编号和其他7个字段封装的一个Emp类对象
  28.      * @return 修改成功返回大于0的整数,失败返回0
  29.      */
  30.     int updateEmp(Emp emp);
  31.  
  32. }
  33.  
  34.  
  35.  
  36. import java.util.List;
  37. public interface DeptDao {
  38.     /**
  39.      * 查询全部门的方法
  40.      * @return Dept对象封装的List集合
  41.      */
  42.     List<Dept> findAll();
  43.  
  44.     int addDept(Dept dept);
  45. }
  46.  
  47.  
  48.  
  49. //DAO实现类
  50.  
  51. public class EmpDaoImpl implements EmpDao {
  52.     private static String driver ="com.mysql.cj.jdbc.Driver";
  53.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
  54.     private static String user="root";
  55.     private static String password="root";
  56.  
  57.     @Override
  58.     public int addEmp(Emp emp) {
  59.         // 向 Emp表中增加一条数据
  60.         Connection connection = null;
  61.         PreparedStatement preparedStatement=null;
  62.         int rows=0;
  63.  
  64.  
  65.         try{
  66.             Class.forName(driver);
  67.             connection = DriverManager.getConnection(url, user,password);
  68.             String sql="insert into emp values(DEFAULT ,?,?,?,?,?,?,?)";
  69.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  70.             //设置参数
  71.             preparedStatement.setObject(1,emp.getEname());
  72.             preparedStatement.setObject(2,emp.getJob() );
  73.             preparedStatement.setObject(3,emp.getMgr());
  74.             preparedStatement.setObject(4,emp.getHiredate());
  75.             preparedStatement.setObject(5,emp.getSal());
  76.             preparedStatement.setObject(6,emp.getComm());
  77.             preparedStatement.setObject(7,emp.getDeptno());
  78.  
  79.             //执行CURD
  80.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
  81.         }catch (Exception e){
  82.             e.printStackTrace();
  83.         }finally {
  84.  
  85.             if(null != preparedStatement){
  86.                 try {
  87.                     preparedStatement.close();
  88.                 } catch (SQLException e) {
  89.                     e.printStackTrace();
  90.                 }
  91.             }
  92.  
  93.             if(null != connection){
  94.                 try {
  95.                     connection.close();
  96.                 } catch (SQLException e) {
  97.                     e.printStackTrace();
  98.                 }
  99.             }
  100.         }
  101.  
  102.         return rows;
  103.     }
  104.  
  105.     @Override
  106.     public int deleteByEmpno(int empno) {
  107.         // 向 Emp表中增加一条数据
  108.         Connection connection = null;
  109.         PreparedStatement preparedStatement=null;
  110.         int rows=0;
  111.  
  112.  
  113.         try{
  114.             Class.forName(driver);
  115.             connection = DriverManager.getConnection(url, user,password);
  116.             String sql="delete from emp where empno =?";
  117.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  118.             //设置参数
  119.             preparedStatement.setObject(1,empno);
  120.  
  121.  
  122.             //执行CURD
  123.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
  124.  
  125.         }catch (Exception e){
  126.             e.printStackTrace();
  127.         }finally {
  128.  
  129.             if(null != preparedStatement){
  130.                 try {
  131.                     preparedStatement.close();
  132.                 } catch (SQLException e) {
  133.                     e.printStackTrace();
  134.                 }
  135.             }
  136.  
  137.             if(null != connection){
  138.                 try {
  139.                     connection.close();
  140.                 } catch (SQLException e) {
  141.                     e.printStackTrace();
  142.                 }
  143.             }
  144.         }
  145.  
  146.         return rows;
  147.     }
  148.  
  149.     @Override
  150.     public List<Emp> findAll() {
  151.         // 查询名字中包含字母A的员工信息
  152.         Connection connection = null;
  153.         PreparedStatement preparedStatement=null;
  154.         ResultSet resultSet=null;
  155.  
  156.         List<Emp> list =null;
  157.         try{
  158.             Class.forName(driver);
  159.             connection = DriverManager.getConnection(url, user,password);
  160.  
  161.             String sql="select * from emp";
  162.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  163.             //执行CURD
  164.             resultSet = preparedStatement.executeQuery();// 这里不需要再传入SQL语句
  165.             list=new ArrayList<Emp>() ;
  166.             while(resultSet.next()){
  167.                 int empno = resultSet.getInt("empno");
  168.                 String ename = resultSet.getString("ename");
  169.                 String job = resultSet.getString("job");
  170.                 int mgr = resultSet.getInt("mgr");
  171.                 Date hiredate = resultSet.getDate("hiredate");
  172.                 double sal= resultSet.getDouble("sal");
  173.                 double comm= resultSet.getDouble("comm");
  174.                 int deptno= resultSet.getInt("deptno");
  175.                 Emp emp =new Emp(empno, ename, job, mgr, hiredate, sal, comm, deptno);
  176.                 list.add(emp);
  177.             }
  178.  
  179.         }catch (Exception e){
  180.             e.printStackTrace();
  181.         }finally {
  182.             if(null != resultSet){
  183.                 try {
  184.                     resultSet.close();
  185.                 } catch (SQLException e) {
  186.                     e.printStackTrace();
  187.  
  188.                 }
  189.  
  190.             }
  191.             if(null != preparedStatement){
  192.                 try {
  193.                     preparedStatement.close();
  194.                 } catch (SQLException e) {
  195.                     e.printStackTrace();
  196.                 }
  197.             }
  198.  
  199.             if(null != connection){
  200.                 try {
  201.                     connection.close();
  202.                 } catch (SQLException e) {
  203.                     e.printStackTrace();
  204.                 }
  205.             }
  206.         }
  207.         return list;
  208.     }
  209.  
  210.     @Override
  211.     public int updateEmp(Emp emp) {
  212.         // 向 Emp表中增加一条数据
  213.         Connection connection = null;
  214.         PreparedStatement preparedStatement=null;
  215.         int rows=0;
  216.  
  217.  
  218.         try{
  219.             Class.forName(driver);
  220.             connection = DriverManager.getConnection(url, user,password);
  221.             String sql="update emp set ename =? ,job=?, mgr =?,hiredate =?,sal=?,comm=?,deptno=? where empno =?";
  222.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  223.             //设置参数
  224.             preparedStatement.setObject(1,emp.getEname());
  225.             preparedStatement.setObject(2,emp.getJob() );
  226.             preparedStatement.setObject(3,emp.getMgr());
  227.             preparedStatement.setObject(4,emp.getHiredate());
  228.             preparedStatement.setObject(5,emp.getSal());
  229.             preparedStatement.setObject(6,emp.getComm());
  230.             preparedStatement.setObject(7,emp.getDeptno());
  231.             preparedStatement.setObject(8,emp.getEmpno());
  232.  
  233.             //执行CURD
  234.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
  235.         }catch (Exception e){
  236.             e.printStackTrace();
  237.         }finally {
  238.  
  239.             if(null != preparedStatement){
  240.                 try {
  241.                     preparedStatement.close();
  242.                 } catch (SQLException e) {
  243.                     e.printStackTrace();
  244.                 }
  245.             }
  246.  
  247.             if(null != connection){
  248.                 try {
  249.                     connection.close();
  250.                 } catch (SQLException e) {
  251.                     e.printStackTrace();
  252.                 }
  253.             }
  254.         }
  255.  
  256.         return rows;
  257.     }
  258. }
  259.  
  260.  
  261. public class DeptDaoImpl implements DeptDao {
  262.     private static String driver ="com.mysql.cj.jdbc.Driver";
  263.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
  264.     private static String user="root";
  265.     private static String password="root";
  266.     @Override
  267.     public List<Dept> findAll() {
  268.         // 查询名字中包含字母A的员工信息
  269.         Connection connection = null;
  270.         PreparedStatement preparedStatement=null;
  271.         ResultSet resultSet=null;
  272.  
  273.         List<Dept> list =null;
  274.         try{
  275.             Class.forName(driver);
  276.             connection = DriverManager.getConnection(url, user,password);
  277.  
  278.             String sql="select * from dept";
  279.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  280.             //执行CURD
  281.             resultSet = preparedStatement.executeQuery();// 这里不需要再传入SQL语句
  282.             list=new ArrayList<Dept>() ;
  283.             while(resultSet.next()){
  284.                 int deptno = resultSet.getInt("deptno");
  285.                 String dname = resultSet.getString("dname");
  286.                 String loc = resultSet.getString("loc");
  287.                 Dept dept =new Dept(deptno,dname,loc);
  288.                 list.add(dept);
  289.             }
  290.  
  291.         }catch (Exception e){
  292.             e.printStackTrace();
  293.         }finally {
  294.             if(null != resultSet){
  295.                 try {
  296.                     resultSet.close();
  297.                 } catch (SQLException e) {
  298.                     e.printStackTrace();
  299.  
  300.                 }
  301.  
  302.             }
  303.             if(null != preparedStatement){
  304.                 try {
  305.                     preparedStatement.close();
  306.                 } catch (SQLException e) {
  307.                     e.printStackTrace();
  308.                 }
  309.             }
  310.  
  311.             if(null != connection){
  312.                 try {
  313.                     connection.close();
  314.                 } catch (SQLException e) {
  315.                     e.printStackTrace();
  316.                 }
  317.             }
  318.         }
  319.         return list;
  320.     }
  321.  
  322.     @Override
  323.     public int addDept(Dept dept) {
  324.         // 向 Emp表中增加一条数据
  325.         Connection connection = null;
  326.         PreparedStatement preparedStatement=null;
  327.         int rows=0;
  328.  
  329.  
  330.         try{
  331.             Class.forName(driver);
  332.             connection = DriverManager.getConnection(url, user,password);
  333.             String sql="insert into dept values(?,?,?)";
  334.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  335.             //设置参数
  336.             preparedStatement.setObject(1,dept.getDeptno());
  337.             preparedStatement.setObject(2,dept.getDname());
  338.             preparedStatement.setObject(3,dept.getLoc() );
  339.  
  340.  
  341.             //执行CURD
  342.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
  343.         }catch (Exception e){
  344.             e.printStackTrace();
  345.         }finally {
  346.  
  347.             if(null != preparedStatement){
  348.                 try {
  349.                     preparedStatement.close();
  350.                 } catch (SQLException e) {
  351.                     e.printStackTrace();
  352.                 }
  353.             }
  354.  
  355.             if(null != connection){
  356.                 try {
  357.                     connection.close();
  358.                 } catch (SQLException e) {
  359.                     e.printStackTrace();
  360.                 }
  361.             }
  362.         }
  363.  
  364.         return rows;
  365.     }
  366. }
  367.  
  368.  
  369.  
  370. //EmpManageSystem类
  371.  
  372. public class EmpManageSystem {
  373.     private static Scanner sc =new Scanner(System.in);
  374.     private static EmpDao empDao =new EmpDaoImpl();
  375.     private static DeptDao deptDao=new DeptDaoImpl();
  376.     private static SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");;
  377.  
  378.     public static void main(String[] args) {
  379.         while(true){
  380.             showMenu();
  381.             System.out.println("请录入选项");
  382.             int option  =sc.nextInt();
  383.             switch (option){
  384.                 case 1:
  385.                     case1();
  386.                     break;
  387.                 case 2:
  388.                     case2();
  389.                     break;
  390.                 case 3:
  391.                     case3();
  392.                     break;
  393.                 case 4:
  394.                     case4();
  395.                     break;
  396.                 case 5:
  397.                     case5();
  398.                     break;
  399.                 case 6:
  400.                     case6();
  401.                     break;
  402.                 case 7: 
  403.                                               sc.close();
  404.                                                 System.exit(0);
  405.                     break;
  406.                 default:
  407.                    System.out.println("请正确输入选项");
  408.             }
  409.         }
  410.     }
  411.     private static void case1(){
  412.         List<Emp> emps = empDao.findAll();
  413.         emps.forEach(System.out::println);
  414.     }
  415.     private static void case2(){
  416.         List<Dept> depts = deptDao.findAll();
  417.         depts.forEach(System.out::println);
  418.     }
  419.     private static void case3(){
  420.         System.out.println("请输入要删除的员工编号");
  421.         int empno=sc.nextInt();
  422.         empDao.deleteByEmpno(empno);
  423.     }
  424.     private static void case4(){
  425.         System.out.println("请输入员工编号");
  426.         int empno =sc.nextInt();
  427.         System.out.println("请输入员工姓名");
  428.         String ename =sc.next();
  429.         System.out.println("请输入员工职位");
  430.         String job =sc.next();
  431.         System.out.println("请输入员工上级");
  432.         int mgr =sc.nextInt();
  433.         System.out.println("请输入员工入职日期,格式为yyyy-MM-dd");
  434.         Date hiredate =null;
  435.         try {
  436.             hiredate = simpleDateFormat.parse(sc.next());
  437.         } catch (ParseException e) {
  438.             e.printStackTrace();
  439.         }
  440.         System.out.println("请输入员工工资");
  441.         double sal =sc.nextDouble();
  442.         System.out.println("请输入员工补助");
  443.         double comm=sc.nextDouble();
  444.         System.out.println("请输入员工部门号");
  445.         int deptno =sc.nextInt();
  446.         Emp emp=new Emp(empno, ename, job, mgr, hiredate, sal, comm,deptno);
  447.         empDao.updateEmp(emp);
  448.     }
  449.     private static void case5(){
  450.  
  451.         System.out.println("请输入员工姓名");
  452.         String ename =sc.next();
  453.         System.out.println("请输入员工职位");
  454.         String job =sc.next();
  455.         System.out.println("请输入员工上级");
  456.         int mgr =sc.nextInt();
  457.         System.out.println("请输入员工入职日期,格式为yyyy-MM-dd");
  458.         Date hiredate =null;
  459.         try {
  460.             hiredate = simpleDateFormat.parse(sc.next());
  461.         } catch (ParseException e) {
  462.             e.printStackTrace();
  463.         }
  464.         System.out.println("请输入员工工资");
  465.         double sal =sc.nextDouble();
  466.         System.out.println("请输入员工补助");
  467.         double comm=sc.nextDouble();
  468.         System.out.println("请输入员工部门号");
  469.         int deptno =sc.nextInt();
  470.         Emp emp=new Emp(null, ename, job, mgr, hiredate, sal, comm,deptno);
  471.         empDao.addEmp(emp);
  472.     }
  473.     private static void case6(){
  474.         System.out.println("请录入部门号");
  475.         int deptno =sc.nextInt();
  476.         System.out.println("请录入部门名称");
  477.         String dname =sc.next();
  478.         System.out.println("请录入部门位置");
  479.         String loc =sc.next();
  480.         Dept dept =new Dept(deptno,dname,loc);
  481.         deptDao.addDept(dept);
  482.     }
  483.  
  484.     public static void showMenu(){
  485.         System.out.println("************************************");
  486.         System.out.println("* 1 查看所有员工信息");
  487.         System.out.println("* 2 查看所有部门信息");
  488.         System.out.println("* 3 根据工号删除员工信息");
  489.         System.out.println("* 4 根据工号修改员工信息");
  490.         System.out.println("* 5 增加员工信息");
  491.         System.out.println("* 6 增加部门信息");
  492.         System.out.println("* 7 退出");
  493.         System.out.println("************************************");
  494.     }
  495. }

DAO抽取

  1. //BaseDAO代码
  2.  
  3. public abstract class BaseDao {
  4.     private static String driver ="com.mysql.cj.jdbc.Driver";
  5.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
  6.     private static String user="root";
  7.     private static String password="root";
  8.  
  9.     public int baseUpdate(String sql,Object ... args){
  10.         // 向 Emp表中增加一条数据
  11.         Connection connection = null;
  12.         PreparedStatement preparedStatement=null;
  13.         int rows=0;
  14.  
  15.  
  16.         try{
  17.             Class.forName(driver);
  18.             connection = DriverManager.getConnection(url, user,password);
  19.  
  20.             preparedStatement = connection.prepareStatement(sql);
  21.             //设置参数
  22.             for (int i = 0; i <args.length ; i++) {
  23.                 preparedStatement.setObject(i+1, args[i]);
  24.             }
  25.  
  26.             //执行CURD
  27.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
  28.         }catch (Exception e){
  29.             e.printStackTrace();
  30.         }finally {
  31.  
  32.             if(null != preparedStatement){
  33.                 try {
  34.                     preparedStatement.close();
  35.                 } catch (SQLException e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }
  39.  
  40.             if(null != connection){
  41.                 try {
  42.                     connection.close();
  43.                 } catch (SQLException e) {
  44.                     e.printStackTrace();
  45.                 }
  46.             }
  47.         }
  48.  
  49.         return rows;
  50.     }
  51.  
  52.  
  53.     public List baseQuery(Class clazz,String sql,Object ... args) {
  54.         // 查询名字中包含字母A的员工信息
  55.         Connection connection = null;
  56.         PreparedStatement preparedStatement=null;
  57.         ResultSet resultSet=null;
  58.  
  59.         List list =null;
  60.         try{
  61.             Class.forName(driver);
  62.             connection = DriverManager.getConnection(url, user,password);
  63.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  64.             //设置参数
  65.             for (int i = 0; i <args.length ; i++) {
  66.                 preparedStatement.setObject(i+1, args[i]);
  67.             }
  68.  
  69.  
  70.             //执行CURD
  71.             resultSet = preparedStatement.executeQuery();// 这里不需要再传入SQL语句
  72.             list=new ArrayList() ;
  73.             // 根据字节码获取所有 的属性
  74.             Field[] fields = clazz.getDeclaredFields();
  75.             for (Field field : fields) {
  76.                 field.setAccessible(true);// 设置属性可以 访问
  77.             }
  78.  
  79.             while(resultSet.next()){
  80.                 // 通过反射创建对象
  81.                 Object obj = clazz.newInstance();//默认在通过反射调用对象的空参构造方法
  82.                 for (Field field : fields) {// 临时用Field设置属性
  83.                     String fieldName = field.getName();// empno  ename job .... ...
  84.                     Object data = resultSet.getObject(fieldName);
  85.                     field.set(obj,data);
  86.                 }
  87.                 list.add(obj);
  88.  
  89.             }
  90.  
  91.         }catch (Exception e){
  92.             e.printStackTrace();
  93.         }finally {
  94.             if(null != resultSet){
  95.                 try {
  96.                     resultSet.close();
  97.                 } catch (SQLException e) {
  98.                     e.printStackTrace();
  99.  
  100.                 }
  101.  
  102.             }
  103.             if(null != preparedStatement){
  104.                 try {
  105.                     preparedStatement.close();
  106.                 } catch (SQLException e) {
  107.                     e.printStackTrace();
  108.                 }
  109.             }
  110.  
  111.             if(null != connection){
  112.                 try {
  113.                     connection.close();
  114.                 } catch (SQLException e) {
  115.                     e.printStackTrace();
  116.                 }
  117.             }
  118.         }
  119.         return list;
  120.     }
  121.  
  122. }
  123.  
  124. //实现类代码
  125. public class EmpDaoImpl extends BaseDao implements EmpDao {
  126.  
  127.     @Override
  128.     public int addEmp(Emp emp) {
  129.         String sql="insert into emp values(DEFAULT ,?,?,?,?,?,?,?)";
  130.         return baseUpdate(sql, emp.getEname(),emp.getJob(),emp.getMgr(),emp.getHiredate(),emp.getSal(),emp.getComm(),emp.getDeptno());
  131.     }
  132.  
  133.     @Override
  134.     public int deleteByEmpno(int empno) {
  135.         String sql="delete from emp where empno =?";
  136.         return baseUpdate(sql, empno);
  137.     }
  138.  
  139.     @Override
  140.     public List<Emp> findAll() {
  141.         String sql ="select * from emp";
  142.         return baseQuery(Emp.class, sql );
  143.     }
  144.  
  145.     @Override
  146.     public int updateEmp(Emp emp) {
  147.         String sql="update emp set ename =? ,job=?, mgr =?,hiredate =?,sal=?,comm=?,deptno=? where empno =?";
  148.         return baseUpdate(sql, emp.getEname(),emp.getJob(),emp.getMgr(),emp.getHiredate(),emp.getSal(),emp.getComm(),emp.getDeptno(),emp.getEmpno());
  149.  
  150.     }
  151.  
  152.  
  153. }
  154.  
  155. public class DeptDaoImpl extends BaseDao implements DeptDao {
  156.  
  157.     @Override
  158.     public List<Dept> findAll() {
  159.         String sql="select * from dept";
  160.         return  baseQuery(Dept.class, sql);
  161.     }
  162.  
  163.     @Override
  164.     public int addDept(Dept dept) {
  165.         String sql="insert into dept values(?,?,?)";
  166.         return baseUpdate(sql, dept.getDeptno(),dept.getDname(),dept.getLoc());
  167.     }
  168. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/代码世界探险家/article/detail/61869
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号