javaweb學習總結(三十三)——使用JDBC對數據庫進行CRUD

時間 2019-11-17

標籤 javaweb 學習總結三十三使用 jdbc 數據庫進行 crud 欄目 Java 简体版

原文原文鏈接

1、statement對象介紹　　

　　Jdbc中的statement對象用於向數據庫發送SQL語句，想完成對數據庫的增刪改查，只須要經過這個對象向數據庫發送增刪改查語句便可。
　　Statement對象的executeUpdate方法，用於向數據庫發送增、刪、改的sql語句，executeUpdate執行完後，將會返回一個整數(即增刪改語句致使了數據庫幾行數據發生了變化)。
　　Statement.executeQuery方法用於向數據庫發送查詢語句，executeQuery方法返回表明查詢結果的ResultSet對象。java

1.一、CRUD操做-create

　　使用executeUpdate(String sql)方法完成數據添加操做，示例操做：mysql

1 Statement st = conn.createStatement();
2 String sql = "insert into user(….) values(…..) "; 
3 int num = st.executeUpdate(sql);
4 if(num>0){
5     System.out.println("插入成功！！！");
6 }

1.二、CRUD操做-update

　　使用executeUpdate(String sql)方法完成數據修改操做，示例操做：sql

1 Statement st = conn.createStatement();
2 String sql = 「update user set name=‘’ where name=‘’"; 
3 int num = st.executeUpdate(sql);
4 if(num>0){
5     System.out.println(「修改爲功！！！");
6 }

1.三、CRUD操做-delete

　　使用executeUpdate(String sql)方法完成數據刪除操做，示例操做：數據庫

1 Statement st = conn.createStatement();
2 String sql = 「delete from user where id=1; 
3 int num = st.executeUpdate(sql);
4 if(num>0){
5     System.out.println(「刪除成功！！！");
6 }

1.四、CRUD操做-read

　　使用executeQuery(String sql)方法完成數據查詢操做，示例操做：工具

1 Statement st = conn.createStatement();
2 String sql = 「select * from user where id=1; 
3 ResultSet rs = st.executeUpdate(sql);
4 while(rs.next()){
5     //根據獲取列的數據類型，分別調用rs的相應方法映射到java對象中
6 }

2、使用jdbc對數據庫增刪改查

2.一、搭建實驗環境

　　一、在mysql中建立一個庫，並建立user表和插入表的數據。測試

　　SQL腳本以下：url

 1 create database jdbcStudy;
 2 
 3 use jdbcStudy;
 4 
 5 create table users(
 6     id int primary key,
 7     name varchar(40),
 8     password varchar(40),
 9     email varchar(60),
10     birthday date
11 );

　　二、新建一個JavaWeb工程，並導入MySQL數據庫驅動。spa

　　三、在src目錄下建立一個db.properties文件，以下圖所示：code

　　在db.properties中編寫MySQL數據庫的鏈接信息，代碼以下所示：對象

1 driver=com.mysql.jdbc.Driver
2 url=jdbc:mysql://localhost:3306/jdbcStudy
3 username=root
4 password=XDP

　　四、編寫一個JdbcUtils工具類，用於鏈接數據庫，獲取數據庫鏈接和釋放數據庫鏈接，代碼以下：

 1 package me.gacl.utils;
 2 
 3 import java.io.InputStream;
 4 import java.sql.Connection;
 5 import java.sql.DriverManager;
 6 import java.sql.ResultSet;
 7 import java.sql.SQLException;
 8 import java.sql.Statement;
 9 import java.util.Properties;
10 
11 public class JdbcUtils {
12 
13     private static String driver = null;
14     private static String url = null;
15     private static String username = null;
16     private static String password = null;
17     
18     static{
19         try{
20             //讀取db.properties文件中的數據庫鏈接信息
21             InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
22             Properties prop = new Properties();
23             prop.load(in);
24             
25             //獲取數據庫鏈接驅動
26             driver = prop.getProperty("driver");
27             //獲取數據庫鏈接URL地址
28             url = prop.getProperty("url");
29             //獲取數據庫鏈接用戶名
30             username = prop.getProperty("username");
31             //獲取數據庫鏈接密碼
32             password = prop.getProperty("password");
33             
34             //加載數據庫驅動
35             Class.forName(driver);
36             
37         }catch (Exception e) {
38             throw new ExceptionInInitializerError(e);
39         }
40     }
41     
42     /**
43     * @Method: getConnection
44     * @Description: 獲取數據庫鏈接對象
45     * @Anthor:孤傲蒼狼
46     *
47     * @return Connection數據庫鏈接對象
48     * @throws SQLException
49     */ 
50     public static Connection getConnection() throws SQLException{
51         return DriverManager.getConnection(url, username,password);
52     }
53     
54     /**
55     * @Method: release
56     * @Description: 釋放資源，
57     *     要釋放的資源包括Connection數據庫鏈接對象，負責執行SQL命令的Statement對象，存儲查詢結果的ResultSet對象
58     * @Anthor:孤傲蒼狼
59     *
60     * @param conn
61     * @param st
62     * @param rs
63     */ 
64     public static void release(Connection conn,Statement st,ResultSet rs){
65         if(rs!=null){
66             try{
67                 //關閉存儲查詢結果的ResultSet對象
68                 rs.close();
69             }catch (Exception e) {
70                 e.printStackTrace();
71             }
72             rs = null;
73         }
74         if(st!=null){
75             try{
76                 //關閉負責執行SQL命令的Statement對象
77                 st.close();
78             }catch (Exception e) {
79                 e.printStackTrace();
80             }
81         }
82         
83         if(conn!=null){
84             try{
85                 //關閉Connection數據庫鏈接對象
86                 conn.close();
87             }catch (Exception e) {
88                 e.printStackTrace();
89             }
90         }
91     }
92 }

2.二、使用statement對象完成對數據庫的CRUD操做

　　測試代碼以下：

  1 package me.gacl.demo;
  2 
  3 import java.sql.Connection;
  4 import java.sql.ResultSet;
  5 import java.sql.Statement;
  6 import me.gacl.utils.JdbcUtils;
  7 
  8 import org.junit.Test;
  9 
 10 /**
 11 * @ClassName: JdbcCRUDByStatement
 12 * @Description: 經過Statement對象完成對數據庫的CRUD操做
 13 * @author: 孤傲蒼狼
 14 * @date: 2014-9-15 下午11:22:12
 15 *
 16 */ 
 17 public class JdbcCRUDByStatement {
 18 
 19     @Test
 20     public void insert(){
 21         Connection conn = null;
 22         Statement st = null;
 23         ResultSet rs = null;
 24         try{
 25             //獲取一個數據庫鏈接
 26             conn = JdbcUtils.getConnection();
 27             //經過conn對象獲取負責執行SQL命令的Statement對象
 28             st = conn.createStatement();
 29             //要執行的SQL命令
 30             String sql = "insert into users(id,name,password,email,birthday) values(3,'白虎神皇','123','bhsh@sina.com','1980-09-09')";
 31             //執行插入操做，executeUpdate方法返回成功的條數
 32             int num = st.executeUpdate(sql);
 33             if(num>0){
 34                 System.out.println("插入成功！！");
 35             }
 36             
 37         }catch (Exception e) {
 38             e.printStackTrace();
 39         }finally{
 40             //SQL執行完成以後釋放相關資源
 41             JdbcUtils.release(conn, st, rs);
 42         }
 43     }
 44     
 45     @Test
 46     public void delete(){
 47         Connection conn = null;
 48         Statement st = null;
 49         ResultSet rs = null;
 50         try{
 51             conn = JdbcUtils.getConnection();
 52             String sql = "delete from users where id=3";
 53             st = conn.createStatement();
 54             int num = st.executeUpdate(sql);
 55             if(num>0){
 56                 System.out.println("刪除成功！！");
 57             }
 58         }catch (Exception e) {
 59             e.printStackTrace();
 60             
 61         }finally{
 62             JdbcUtils.release(conn, st, rs);
 63         }
 64     }
 65     
 66     @Test
 67     public void update(){
 68         Connection conn = null;
 69         Statement st = null;
 70         ResultSet rs = null;
 71         try{
 72             conn = JdbcUtils.getConnection();
 73             String sql = "update users set name='孤傲蒼狼',email='gacl@sina.com' where id=3";
 74             st = conn.createStatement();
 75             int num = st.executeUpdate(sql);
 76             if(num>0){
 77                 System.out.println("更新成功！！");
 78             }
 79         }catch (Exception e) {
 80             e.printStackTrace();
 81             
 82         }finally{
 83             JdbcUtils.release(conn, st, rs);
 84         }
 85     }
 86     
 87     @Test
 88     public void find(){
 89         Connection conn = null;
 90         Statement st = null;
 91         ResultSet rs = null;
 92         try{
 93             conn = JdbcUtils.getConnection();
 94             String sql = "select * from users where id=3";
 95             st = conn.createStatement();
 96             rs = st.executeQuery(sql);
 97             if(rs.next()){
 98                 System.out.println(rs.getString("name"));
 99             }
100         }catch (Exception e) {
101             e.printStackTrace();
102         }finally{
103             JdbcUtils.release(conn, st, rs);
104         }
105     }
106 }

3、PreparedStatement對象介紹

　　PreperedStatement是Statement的子類，它的實例對象能夠經過調用Connection.preparedStatement()方法得到，相對於Statement對象而言：PreperedStatement能夠避免SQL注入的問題。
　　Statement會使數據庫頻繁編譯SQL，可能形成數據庫緩衝區溢出。PreparedStatement可對SQL進行預編譯，從而提升數據庫的執行效率。而且PreperedStatement對於sql中的參數，容許使用佔位符的形式進行替換，簡化sql語句的編寫。

3.一、使用PreparedStatement對象完成對數據庫的CRUD操做

　　測試代碼以下：

  1 package me.gacl.demo;
  2 
  3 import java.sql.Connection;
  4 import java.sql.PreparedStatement;
  5 import java.sql.ResultSet;
  6 import java.util.Date;
  7 import me.gacl.utils.JdbcUtils;
  8 import org.junit.Test;
  9 
 10 /**
 11 * @ClassName: JdbcCRUDByPreparedStatement
 12 * @Description: 經過PreparedStatement對象完成對數據庫的CRUD操做
 13 * @author: 孤傲蒼狼
 14 * @date: 2014-9-15 下午11:21:42
 15 *
 16 */ 
 17 public class JdbcCRUDByPreparedStatement {
 18 
 19     @Test
 20     public void insert(){
 21         Connection conn = null;
 22         PreparedStatement st = null;
 23         ResultSet rs = null;
 24         try{
 25             //獲取一個數據庫鏈接
 26             conn = JdbcUtils.getConnection();
 27             //要執行的SQL命令，SQL中的參數使用?做爲佔位符
 28             String sql = "insert into users(id,name,password,email,birthday) values(?,?,?,?,?)";
 29             //經過conn對象獲取負責執行SQL命令的prepareStatement對象
 30             st = conn.prepareStatement(sql);
 31             //爲SQL語句中的參數賦值，注意，索引是從1開始的
 32             /**
 33              * SQL語句中各個字段的類型以下：
 34              *  +----------+-------------+
 35                 | Field    | Type        |
 36                 +----------+-------------+
 37                 | id       | int(11)     |
 38                 | name     | varchar(40) |
 39                 | password | varchar(40) |
 40                 | email    | varchar(60) |
 41                 | birthday | date        |
 42                 +----------+-------------+
 43              */
 44             st.setInt(1, 1);//id是int類型的
 45             st.setString(2, "白虎神皇");//name是varchar(字符串類型)
 46             st.setString(3, "123");//password是varchar(字符串類型)
 47             st.setString(4, "bhsh@sina.com");//email是varchar(字符串類型)
 48             st.setDate(5, new java.sql.Date(new Date().getTime()));//birthday是date類型
 49             //執行插入操做，executeUpdate方法返回成功的條數
 50             int num = st.executeUpdate();
 51             if(num>0){
 52                 System.out.println("插入成功！！");
 53             }
 54             
 55         }catch (Exception e) {
 56             e.printStackTrace();
 57         }finally{
 58             //SQL執行完成以後釋放相關資源
 59             JdbcUtils.release(conn, st, rs);
 60         }
 61     }
 62     
 63     @Test
 64     public void delete(){
 65         Connection conn = null;
 66         PreparedStatement st = null;
 67         ResultSet rs = null;
 68         try{
 69             conn = JdbcUtils.getConnection();
 70             String sql = "delete from users where id=?";
 71             st = conn.prepareStatement(sql);
 72             st.setInt(1, 1);
 73             int num = st.executeUpdate();
 74             if(num>0){
 75                 System.out.println("刪除成功！！");
 76             }
 77         }catch (Exception e) {
 78             e.printStackTrace();
 79         }finally{
 80             JdbcUtils.release(conn, st, rs);
 81         }
 82     }
 83     
 84     @Test
 85     public void update(){
 86         Connection conn = null;
 87         PreparedStatement st = null;
 88         ResultSet rs = null;
 89         try{
 90             conn = JdbcUtils.getConnection();
 91             String sql = "update users set name=?,email=? where id=?";
 92             st = conn.prepareStatement(sql);
 93             st.setString(1, "gacl");
 94             st.setString(2, "gacl@sina.com");
 95             st.setInt(3, 2);
 96             int num = st.executeUpdate();
 97             if(num>0){
 98                 System.out.println("更新成功！！");
 99             }
100         }catch (Exception e) {
101             e.printStackTrace();
102             
103         }finally{
104             JdbcUtils.release(conn, st, rs);
105         }
106     }
107     
108     @Test
109     public void find(){
110         Connection conn = null;
111         PreparedStatement st = null;
112         ResultSet rs = null;
113         try{
114             conn = JdbcUtils.getConnection();
115             String sql = "select * from users where id=?";
116             st = conn.prepareStatement(sql);
117             st.setInt(1, 1);
118             rs = st.executeQuery();
119             if(rs.next()){
120                 System.out.println(rs.getString("name"));
121             }
122         }catch (Exception e) {
123             
124         }finally{
125             JdbcUtils.release(conn, st, rs);
126         }
127     }
128 }