死磕Java系列之Java数据库 Java程序对于单一数据库的增删改查

傷城~ 2022-03-17 08:14 79阅读 0赞

上一篇文章我们简单的了解了一下什么是数据，什么叫数据库，以及数据库的常见类型， 我们生活在一个信息化的时代，信息无处不在，数据是信息的载体，数据有其本身的结构特点，将其按照一定的特性划分为数据结构层次，面对广泛而复杂的数据；需要将数据存储起来，形成数据库，数据库的作用在于将信息分类存储，这样的话，面对数据库中的数据，可以实现增删改查等操作；常见的数据库有关系型和非关系型。 然而， 我们有了上面的基础，那么，将面对的问题是： 如何搭建数据库的操作环境呢？我们将数据存储到数据库中，如何通过Java程序来实现对于数据库的操作，对于数据库中的数据常见的操作有哪些？以及如何实现这些操作呢？对于大批次的数据应该如何操作实现。

### （一） 数据库的环境搭建 ###

*  下载mysql

[MySQL基础知识-安装MySQL][MySQL_-_MySQL]

![ac6eddc451da81cb037c289d5366d016082431c3.jpg][]

数据库（database）就是一个存储数据的仓库。为了方便数据的存储和管理，它将数据按照特定的规律存储在磁盘上。通过数据库管理系统，可以有效地组织和管理存储在数据库中的数据。MySQL数据库可以称得上是目前运行速度最快的SQL语言数据库,MySQL数据库可以称得上是目前运行速度最快的SQL语言数据库， MySQL是一种关系数据库管理系统，关系数据库将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，

*  下载navicat

[Navicat for MySQL下载、安装与破解][Navicat for MySQL]

![navicat premium 64位v12 特别版][navicat premium 64_v12]

mysql的操作环境是计算机的操作系统，而在日常工作中，我们不可能每次处理数据库都需要打开计算机的运行环境，故而需要轻量型数据库管理系统。Navicat  是一套快速、可靠并价格相宜的数据库管理工具，专为简化数据库的管理及降低系统管理成本而设。它的设计符合 数据库管理员，开发人员及中小企业的需要。Navicat 是以直觉化的图形界面而建的，让你可以以安全并且简单的方式创建、组织、访问并共用信息。

*  下载JDBC

下载好mysql和navicat，相当于在计算机上搭建好数据库运行环境，当我们准备用程序来在数据库中执行相关操作时，需要用JDBC来将程序和数据库mysql连接起来。

[JDBC全攻略（包括环境搭建、mysql连接、具体的使用）][JDBC_mysql]

[JDBC最全面的介绍][JDBC]

[JDBCj简介][JDBCj]

![这里写图片描述][SouthEast]

JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC为数据库开发人员提供了一个标准的API，据此可以构建更高级的工具和接口，使数据库开发人员能够用纯 Java API 编写数据库应用程序，并且可跨平台运行，并且不受数据库供应商的限制。JDBC的操作原理如下图：：

![这里写图片描述][20161015193227040]

### （二）  数据库基本操作------增删改查 ###

当我们搭建好数据库运行环境之后，Java程序通过JDBC控制数据库，其流程如下：

![这里写图片描述][SouthEast 1]

**1、搭建环境           **

**        **在开发环境中加载指定数据库的驱动程序，将JDBC导入到eclipse环境中，打开navicat，建立数据库。

**2，连接数据库；**

*  **       **在Java程序中加载驱动程序。在Java程序中，可以通过 **“Class.forName**(“指定数据库的驱动程序”)” 方式来加载添加到开发环境中的驱动程序，例如加载MySQL的数据驱动程序的代码为：  Class.forName(“com.mysql.jdbc.Driver”)
 *        创建数据连接对象：通过DriverManager类创建数据库连接对象Connection。DriverManager类作用于Java程序和JDBC驱动程序之间，用于检查所加载的驱动程序是否可以建立连接，然后通过它的getConnection方法，根据数据库的URL、用户名和密码，创建一个JDBC Connection 对象。

如：**Connection connection =  DriverManager.geiConnection(“连接数据库的URL", "用户名", "密码”)**。其中，URL=协议名                       +IP地址(域名)+端口+数据库名称；用户名和密码是指登录数据库时所使用的用户名和密码。具体示例创建MySQL的数据库连                      接代码如下

Connection connectMySQL  =  DriverManager.geiConnection(“jdbc:mysql://localhost:3306/myuser","root" ,"root" );

**3.使用语句操作数据库 **

*  **       **创建Statement对象：Statement 类的主要是用于执行静态 SQL 语句并返回它所生成结果的对象。通过Connection 对象的 createStatement()方法可以创建一个Statement对象。例如：Statement statament = connection.createStatement(); 具体示例创建Statement对象代码如下：

Statement statamentMySQL =connectMySQL.createStatement();

*  **      **调用Statement对象的相关方法执行相对应的 SQL 语句：通过execuUpdate()方法用来数据的更新，包括插入和删除等操作，例如向staff表中插入一条数据的代码：

statement.excuteUpdate( "INSERT INTO staff(name, age, sex,address, depart, worklen,wage)" + " VALUES ('Tom1', 321, 'M',                    'china','Personnel','3','3000' ) ") ;

*        通过调用Statement对象的executeQuery()方法进行数据的查询，而查询结果会得到 ResulSet对象，ResulSet表示执行查询数据库后返回的数据的集合，ResulSet对象具有可以指向当前数据行的指针。通过该对象的next()方法，使得指针指向下一行，然后将数据以列号或者字段名取出。如果当next()方法返回null，则表示下一行中没有数据存在。使用示例代码如下：

ResultSet resultSel = statement.executeQuery( "select \* from staff" );

**4.关闭数据库连接，释放资源**

关闭数据库连接：使用完数据库或者不需要访问数据库时，通过Connection的close() 方法及时关闭数据连接。

*（1）搭建环境并建立连接*

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
     
    public class JDBCtest {
        static final String DB_URL = "jdbc:mysql://localhost:3306/bxjt?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT";
        // MySQL的JDBC URL编写方式：jdbc:mysql://主机名称：连接端口/数据库的名称
        static final String USER = "root";//用户名
        static final String PASS = "lyp";//密码
        static final String SQL = "com.mysql.cj.jdbc.Driver";//加载注册
        Connection conn = null;
        Statement statement = null;
        ResultSet  res=null;
        public static void   main(String []args){
        	new  JDBCtest();
        }
        public  JDBCtest( ) {
           try {
        	  // 注册驱动
    		Class.forName( SQL);
    		//建立连接
    		conn =  DriverManager.getConnection(DB_URL,USER,PASS);	
    		System.out.print(conn);
    		statement=conn.createStatement();
    	 
           }catch(ClassNotFoundException e){
       		System.out.println("对不起，找不到这个Driver");
       		e.printStackTrace();
       	}catch(SQLException e){
       		e.printStackTrace();
       	}catch(Exception e){
       		e.printStackTrace();
       		}
        }
      }

运行结果：：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70][]

*（2）操作数据库----增删改查*

如图。我们在navicat中建立一个新的表，名字叫做testjdbc，接下来我们将对于这个表格中的数据进行增删改查

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 1][]

以下是Java代码：

import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
     
    public class JDBCtest {
        static final String DB_URL = "jdbc:mysql://localhost:3306/bxjt?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT";
        // MySQL的JDBC URL编写方式：jdbc:mysql://主机名称：连接端口/数据库的名称
        static final String USER = "root";//用户名
        static final String PASS = "lyp";//密码
        static final String SQL = "com.mysql.cj.jdbc.Driver";//加载注册
        Connection conn = null;
        Statement statement = null;
        PreparedStatement   pstmt=null;
        ResultSet  res=null;
        public static void   main(String []args){
        	new  JDBCtest();
        }
        public  JDBCtest( ) {
           try {
        	  // 注册驱动
    		Class.forName( SQL);
    		//建立连接
    		conn =  DriverManager.getConnection(DB_URL,USER,PASS);	
    		System.out.print(conn);
    		
    		//以上部分，我们完成了Java程序通过jdbc与数据库的连接工作，接下来将对数据库进行增删改查功能的实现。
    		//testinsert();//增加
    	 	// testDelete();//删除
    	    //testUpdate();//更新
    		 testSelect();//查找
    	 
           }catch(ClassNotFoundException e){
       		System.out.println("对不起，找不到这个Driver");
       		e.printStackTrace();
       	}catch(SQLException e){
       		e.printStackTrace();
       	}catch(Exception e){
       		e.printStackTrace();
       		}
             finally {
        	try {
    			res.close();
    		} catch (SQLException e) {
    			// TODO 自动生成的 catch 块
    			e.printStackTrace();
    		}
            	try {
    				statement.close();
    			} catch (SQLException e) {
    				// TODO 自动生成的 catch 块
    				e.printStackTrace();
    			} 
            	
            	try {
    				conn.close();
    			} catch (SQLException e) {
    				// TODO 自动生成的 catch 块
    				e.printStackTrace();
    			}
            	 
            	 
            	 
        }
        }
        public  void   testinsert() throws SQLException {
        	statement=conn.createStatement();
        	String sql="insert  into  testjdbc (id,name,password,sex) values (?,?,?,?)"; //定义插入语句，注意格式
        	//将数据保存到数据库
        	pstmt = conn.prepareStatement(sql);	
        	pstmt.setString(1,"11111");
        	pstmt.setString(2,  "22122");
        	pstmt.setString(3,"33313");
        	pstmt.setString(4, "44414");
        	//刷新结果集
        	pstmt.execute();
        	
        }
        private void testSelect() throws SQLException {
    		// TODO 自动生成的方法存根
        	statement=conn.createStatement();//容器
        	 
        	   int id=1;
             //	String sql="select name  from testjdbc  where  id=\""+id+"\"";  //查询某一行数据
        	    String sql="select * from testjdbc";           //sql语句，查询数据库中的所有语句，
        	    ResultSet rs=statement.executeQuery(sql);     //将sql语句传至数据库，返回的值为一个字符集用一个变量接收 
        	    /*
        	    while(rs.next()){    //next（）获取里面的内容
        	    System.out.println(rs.getString(1)+" "+rs.getString(2)+" "+rs.getString(3));
        	                         //getString（n）获取第n列的内容
        	                            //数据库中的列数是从1开始的
        	    }
        	    */
        	    //输出所有的数据
        	       int col = rs.getMetaData().getColumnCount();
                    System.out.println("============================");
                 while (rs.next()) {
                for (int i = 1; i <= col; i++) {
                    System.out.print(rs.getString(i) + "\t");
                    if ((i == 2) && (rs.getString(i).length() < 8)) {
                        System.out.print("\t");
                    }
                 }
                System.out.println("");
            }
                System.out.println("============================"); 
       	
    	}
    	private void testUpdate() throws SQLException {
    		// TODO 自动生成的方法存根
    		//更新某一行的某一个数据
    		statement=conn.createStatement();   //容器
            String sql="update testjdbc set  name='2333' where id='11' ";   //SQL语句
            statement.executeUpdate(sql);         //将sql语句上传至数据库执行
            
         /*
          //更新某一行的数据
     	   String sql="update testjdbc set  name=?,password=?,sex=? where id=?";
     		 
     			 pstmt = conn.prepareStatement(sql);
     			 
        	      pstmt.setString(1,"3");
        	     pstmt.setString(2,  "2");
        	      pstmt.setString(3,"3");
        	     pstmt.setString(4, "4");
        	
        	      pstmt.execute();
     			 
            */
            
    	}
    	private void testDelete() throws SQLException {
    		// TODO 自动生成的方法存根
    		 statement=conn.createStatement();   //容器
            String sql="delete from testjdbc where id='1'";   //SQL语句，删除某一行数据
            statement.executeUpdate(sql);         //将sql语句上传至数据库执行
     		
    	} 
      }

在上面的代码中，修改增加数据的部分，

public  void   testinsert() throws SQLException {
        	statement=conn.createStatement();
        	String sql="insert  into  testjdbc (id,name,password,sex) values (?,?,?,?)"; //定义插入语句，注意格式
        	//将数据保存到数据库
        	pstmt = conn.prepareStatement(sql);	
        	pstmt.setString(1,"11111");
        	pstmt.setString(2,  "22122");
        	pstmt.setString(3,"33313");
        	pstmt.setString(4, "44414");
        	//刷新结果集
        	pstmt.execute();
        	
        }

运行结果如下：：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 2][]

删除id=1的一行数据，

private void testDelete() throws SQLException {
    		// TODO 自动生成的方法存根
    		 statement=conn.createStatement();   //容器
            String sql="delete from testjdbc where id='1'";   //SQL语句，删除某一行数据
            statement.executeUpdate(sql);         //将sql语句上传至数据库执行
     		
    	}

运行结果如下：：

![20190223144707539.png][]

修改id=11的那一行数据，使得name=23333

private void testUpdate() throws SQLException {
    		// TODO 自动生成的方法存根
    		//更新某一行的某一个数据
    		statement=conn.createStatement();   //容器
            String sql="update testjdbc set  name='2333' where id='11' ";   //SQL语句
            statement.executeUpdate(sql);         //将sql语句上传至数据库执行
            
         /*
          //更新某一行的数据
     	   String sql="update testjdbc set  name=?,password=?,sex=? where id=?";
     		 
     			 pstmt = conn.prepareStatement(sql);
     			 
        	      pstmt.setString(1,"3");
        	     pstmt.setString(2,  "2");
        	      pstmt.setString(3,"3");
        	     pstmt.setString(4, "4");
        	
        	      pstmt.execute();
     			 
            */
            
    	}

![20190223144913863.png][]

查找表格中所有的数据

private void testSelect() throws SQLException {
    		// TODO 自动生成的方法存根
        	statement=conn.createStatement();//容器
        	 
        	   int id=1;
             //	String sql="select name  from testjdbc  where  id=\""+id+"\"";  //查询某一行数据
        	    String sql="select * from testjdbc";           //sql语句，查询数据库中的所有语句，
        	    ResultSet rs=statement.executeQuery(sql);     //将sql语句传至数据库，返回的值为一个字符集用一个变量接收 
        	    /*
        	    while(rs.next()){    //next（）获取里面的内容
        	    System.out.println(rs.getString(1)+" "+rs.getString(2)+" "+rs.getString(3));
        	                         //getString（n）获取第n列的内容
        	                            //数据库中的列数是从1开始的
        	    }
        	    */
        	    //输出所有的数据
        	       int col = rs.getMetaData().getColumnCount();
                    System.out.println("============================");
                 while (rs.next()) {
                for (int i = 1; i <= col; i++) {
                    System.out.print(rs.getString(i) + "\t");
                    if ((i == 2) && (rs.getString(i).length() < 8)) {
                        System.out.print("\t");
                    }
                 }
                System.out.println("");
            }
                System.out.println("============================"); 
       	
    	}

运行结果如下：：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 3][]

在以上的增删给查过程中需要注意的点在于：

*  Driver()接口：用于加载驱动。连接数据库
 *  Connection()接口，用与和指定的数据库连接DriverManager的getConnection()方法建立在JDBC  URL中定义的数据库Connection连接上。
 *  Statement()接口，用于执行静态的SQL语句，并返回生成结果的对象，通常使用PreparedStatement接口来实现，常用的Statement方法有，execute():执行语句，返回是否有结果集，executeQuery(),执行Select语句，返回ResultSet结果集。executeUptate()运行insert，update，delete和update操作，用于返回更新的行数。
 *  ResultSet接口,Statement执行SQL语句返回ResultSet结果集，getString()方法返回数据库中char类型的对象。
 *  关闭顺序：ResultSet---->Statement()----->Connection()

### **（三）数据库的批处理----事务** ###

数据库事务(Database Transaction) ，是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。这就意味着对于数据库中的数据进行批操作，相似或相同的数据进行事务的增删改查处理，能够提高在大数据库中的效率。

事务是必须满足4个条件（ACID）

**⑴ 原子性（Atomicity）**

原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，这和前面两篇博客介绍事务的功能是一样的概念，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。

**⑵ 一致性（Consistency）**

一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。

拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。

**⑶ 隔离性（Isolation）**

隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。

即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。

**⑷ 持久性（Durability）**

持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

例如我们在使用JDBC操作数据库时，在提交事务方法后，提示用户事务操作完成，当我们程序执行完成直到看到提示后，就可以认定事务以及正确提交，即使这时候数据库出现了问题，也必须要将我们的事务完全执行完成，否则就会造成我们看到提示事务处理完毕，但是数据库因为故障而没有执行事务的重大错误。

DBC事务是由Connection对象所控制的，它提供了两种事务模式：**自己主动提交和手动提交，默认是自己主动提交**。

**       自己主动提交就是**：在JDBC中。在一个连接对象Connection中。默认把每一个SQL语句的运行都当做是一个事务（即每次运行完SQL语句都会马上将操作更新到数据库）。

** 手动提交就是：**当须要一次性运行多个SQL语句，将多个SQL语句组成一个事务（即要么都成功，要么回滚全部的操作）时，就得手动提交

宏观来看须要例如以下四个步骤：

1、将事务模式设置为手动提交事务：

conn.setAutoCommit(false)；

2、设置事务的隔离级别：

conn.setTransactionIsolation(Connection.TRANSACTION\_READ\_COMMITTED);

3、提交事务：

conn.commit();

4、假设发生异常，回滚事务：

conn.rollback();

import java.sql.*;
    
    public class TransactionTest{
    
    public static void main(String[] args) throws SQLException {
    	try {
             Class.forName("oracle.jdbc.driver.OracleDriver");
                    Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:orcl","TransactionTest","123456");
    				
                    //将事务模式设置为手动提交事务：
                    conn.setAutoCommit(false);
    				
                    //设置事务的隔离级别。
                    conn.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
                    
    		//运行插入操作
                    String sqlInsert = "insert into testjdbc(id,password) values(?,?
    )";               
                    pstmt = conn.prepareStatement(sqlInsert);
                    pstmt.setString(1, "danny");
                    pstmt.setString(2, "123");
                    pstmt.executeUpdate();
    				
    		//运行改动操作
                    String sqlUpdate = "update t_user set userPassword=? where userName = ?";
                    pstmt = conn.prepareStatement(sqlUpdate);
                    pstmt.setString(1, "123456");
                    pstmt.setString(2, "danny");               
                    pstmt.executeUpdate();
    				
                    //提交事务
                    conn.commit();
    				
                } catch (Exception e) {                
                    // 若事务发生异常，回滚事务
                    conn.rollback();
                }finally{                
                    if (pstmt!=null) {
                        pstmt.close();
                    }
                    if (conn!=null) {
                        conn.close();
                    }
                }
    }
    }

[Java+Oracle实现事务——JDBC事务][Java_Oracle_JDBC]

[MySQL_-_MySQL]: https://www.cnblogs.com/ayyl/p/5978418.html
[ac6eddc451da81cb037c289d5366d016082431c3.jpg]: https://gss2.bdstatic.com/9fo3dSag_xI4khGkpoWK1HF6hhy/baike/w%3D268%3Bg%3D0/sign=e35e494a6159252da3171a020ca06406/ac6eddc451da81cb037c289d5366d016082431c3.jpg
[Navicat for MySQL]: https://blog.csdn.net/wjw_java_android/article/details/79002473
[navicat premium 64_v12]: /images/20220317/7acd64d9c9574bdbb07d69dc08971c99.png
[JDBC_mysql]: https://blog.csdn.net/yw987/article/details/75269094
[JDBC]: https://blog.csdn.net/xiaokuanblog/article/details/50708726
[JDBCj]: https://www.cnblogs.com/He-tao-yuan/p/6746954.html
[SouthEast]: /images/20220317/e34039466a4e4f8c9baf0ee04b01f68b.png
[20161015193227040]: /images/20220317/b8acf81bb14d4775b5163b0213ebaf62.png
[SouthEast 1]: /images/20220317/0748a3e1022846deafc56a42b49627c3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70]: /images/20220317/112b8a3847374f26bd526ff3c085b197.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 1]: /images/20220317/a4024b02a1464068b49c96a6527e43a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 2]: /images/20220317/1a0a4590eda042d5b15c636984b146b3.png
[20190223144707539.png]: /images/20220317/6f00bd70eabd4a73bbd1ac2388294aae.png
[20190223144913863.png]: /images/20220317/fb9c7d7ccad348ff82704759ad5c2dd0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 3]: /images/20220317/a782634ab42a482e8b37e2b6232c9a42.png
[Java_Oracle_JDBC]: https://www.cnblogs.com/claireyuancy/p/6699923.html