zoukankan html css js c++ java

JDBC学习小结

一、JDBC基础

连接数据的步骤：

1.注册驱动：Class.forName(“com.mysql.jdbc.Driver”) 推荐这种方式，不会对具体的驱动类产生依赖；DriverManager.registerDriver(com.mysql.jdbc.Driver)
会造成DriverManager中产生两个一样的驱动，并会对具体的驱动类产生依赖；System.setProperty(“jdbc.drivers”, “driver1:driver2”) 虽然不会对具体的驱动类产生依赖；但注册不太方便，所以很少使用。
2.建立连接(Connection) ：Connection conn = DriverManager.getConnection(url, user, password);url格式： JDBC:子协议:子名称//主机名:端口/数据库名？属性名=属性值&...;User,password可以用“属性名=属性值”方式告诉数据库；其他参数如：useUnicode=true&characterEncoding=GBK。
3.创建执行SQL的语句(Statement):
4.执行语句
5.处理执行结果(ResultSet)
6.释放资源

1、注册数据库驱动的方式：

1）加载 JDBC 驱动需调用 Class 类的静态方法 forName()，向其传递要加载的 JDBC 驱动的类名；

 1 @Test
 2 public void testDriverManager() throws Exception{
 3     //1. 准备连接数据库的 4 个字符串. 
 4     //驱动的全类名.
 5     String driverClass = "com.mysql.jdbc.Driver";
 6     //JDBC URL
 7     String jdbcUrl = "jdbc:mysql://localhost:3306/test";
 8     //user
 9     String user = "root";
10     //password
11     String password = "123456";
12         
13     //2. 加载数据库驱动程序(对应的 Driver 实现类中有注册驱动的静态代码块.)
14     Class.forName(driverClass);
15         
16     //3. 通过 DriverManager 的 getConnection() 方法获取数据库连接. 
17     Connection connection = 
18             DriverManager.getConnection(jdbcUrl, user, password);
19     System.out.println(connection); 
20         
21 }

View Code

2）Driver 是一个接口: 数据库厂商必须提供实现的接口. 能从其中获取数据库连接.可以通过 Driver 的实现类对象获取数据库连接.

 1 @Test
 2 public void testDriver() throws SQLException {
 3     //1. 创建一个 Driver 实现类的对象
 4     Driver driver = new com.mysql.jdbc.Driver();
 5 
 6     //2. 准备连接数据库的基本信息: url, user, password
 7     String url = "jdbc:mysql://localhost:3306/test";
 8     Properties info = new Properties();
 9     info.put("user", "root");
10     info.put("password", "123456");
11         
12     //3. 调用 Driver 接口的　connect(url, info) 获取数据库连接
13     Connection connection = driver.connect(url, info);
14     System.out.println(connection);
15 }

View Code

2、获取数据库连接的方式：
1）DriverManager 是驱动的管理类：1). 可以通过重载的 getConnection() 方法获取数据库连接. 较为方便，2). 可以同时管理多个驱动程序: 若注册了多个数据库连接, 则调用 getConnection()，3）方法时传入的参数不同, 即返回不同的数据库连接。

例：Connection connection = DriverManager.getConnection(jdbcUrl, user, password);

2）Driver 是一个接口: 数据库厂商必须提供实现的接口. 能从其中获取数据库连接.可以通过 Driver 的实现类对象获取数据库连接.

例：Connection connection = driver.connect(url, info);

3.创建执行SQL的语句（statement、preparedstatement）：

通过 JDBC 向指定的数据表中插入一条记录.
a. Statement: 用于执行 SQL 语句的对象
1). 通过 Connection 的 createStatement() 方法来获取
2). 通过 executeUpdate(sql) 可以执行 SQL 语句.
3). 传入的 SQL 可以是 INSRET, UPDATE 或 DELETE. 但不能是 SELECT

b. Connection、Statement 都是应用程序和数据库服务器的连接资源. 使用后一定要关闭.
需要在 finally 中关闭 Connection 和 Statement 对象.

c. 关闭的顺序是: 先关闭后获取的. 即先关闭 Statement 后关闭 Connection

示例代码如下：

 1 @Test
 2 public void testStatement() throws Exception{
 3     //1. 获取数据库连接
 4     Connection conn = null;
 5     Statement statement = null;
 6         
 7     try {
 8         conn = JDBCTools.getConnection();
 9         
10         //3. 准备插入的 SQL 语句
11         String sql = null;
12         
13                //sql = "INSERT INTO customers (NAME, EMAIL, BIRTH) " +
14                    //"VALUES('XYZ', 'xyz@atguigu.com', '1990-12-12')";
15               //sql = "DELETE FROM customers WHERE id = 1";
16         sql = "UPDATE customers SET name = 'TOM' " +
17                 "WHERE id = 4";
18         System.out.println(sql);
19             
20           //4. 执行插入. 
21           //1). 获取操作 SQL 语句的 Statement 对象: 
22          //调用 Connection 的 createStatement() 方法来获取
23           statement = conn.createStatement();
24             
25          //2). 调用 Statement 对象的 executeUpdate(sql) 执行 SQL 语句进行插入
26           statement.executeUpdate(sql);
27     } catch (Exception e) {
28         e.printStackTrace();
29     } finally{
30         JDBCTools.release(statement,conn);
31     }

View Code

4.处理执行结果(ResultSet):
ResultSet: 结果集. 封装了使用 JDBC 进行查询的结果.
   a. 调用 Statement 对象的 executeQuery(sql) 可以得到结果集.
   b. ResultSet 返回的实际上就是一张数据表. 有一个指针指向数据表的第一样的前面.可以调用 next() 方法检测下一行是否有效. 若有效该方法返回 true, 且指针下移. 相当于Iterator 对象的 hasNext() 和 next() 方法的结合体
   c. 当指针对位到一行时, 可以通过调用 getXxx(index) 或 getXxx(columnName),获取每一列的值. 例如: getInt(1), getString("name")
   d. ResultSet 当然也需要进行关闭.

示例代码如下：

 1 @Test
 2 public void testResultSet(){
 3     //获取 id=4 的 customers 数据表的记录, 并打印
 4         
 5     Connection conn = null;
 6     Statement statement = null;
 7     ResultSet rs = null;
 8         
 9     try {
10         //1. 获取 Connection
11         conn = JDBCTools.getConnection();
12         System.out.println(conn);
13             
14         //2. 获取 Statement
15         statement = conn.createStatement();
16         System.out.println(statement);
17             
18         //3. 准备 SQL
19         String sql = "SELECT id, name, email, birth " +
20                     "FROM customers";
21             
22         //4. 执行查询, 得到 ResultSet
23         rs = statement.executeQuery(sql);
24         System.out.println(rs);
25             
26         //5. 处理 ResultSet
27         while(rs.next()){
28             int id = rs.getInt(1);
29             String name = rs.getString("name");
30             String email = rs.getString(3);
31             Date birth = rs.getDate(4);
32                 
33             System.out.println(id);
34             System.out.println(name);
35             System.out.println(email);
36             System.out.println(birth);
37         }
38             
39     } catch (Exception e) {
40         e.printStackTrace();
41     } finally{
42         //6. 关闭数据库资源. 
43         JDBCTools.release(rs, statement, conn);
44     }
45         
46 }

View Code

JDBC工具模板（JDBCTools）配置如下：

 1 import java.io.InputStream;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.ResultSet;
 5 import java.sql.SQLException;
 6 import java.sql.Statement;
 7 import java.util.Properties;
 8 
 9 /**
10  * 操作 JDBC 的工具类. 其中封装了一些工具方法 Version 1
11  */
12 public class JDBCTools {
13 
14     public static void release(ResultSet rs, 
15             Statement statement, Connection conn) {
16         if(rs != null){
17             try {
18                 rs.close();
19             } catch (SQLException e) {
20                 e.printStackTrace();
21             }
22         }
23         
24         
25         if (statement != null) {
26             try {
27                 statement.close();
28             } catch (Exception e2) {
29                 e2.printStackTrace();
30             }
31         }
32 
33         if (conn != null) {
34             try {
35                 conn.close();
36             } catch (Exception e2) {
37                 e2.printStackTrace();
38             }
39         }
40     }
41     
42     /**
43      * 关闭 Statement 和 Connection
44      * @param statement
45      * @param conn
46      */
47     public static void release(Statement statement, Connection conn) {
48         if (statement != null) {
49             try {
50                 statement.close();
51             } catch (Exception e2) {
52                 e2.printStackTrace();
53             }
54         }
55 
56         if (conn != null) {
57             try {
58                 conn.close();
59             } catch (Exception e2) {
60                 e2.printStackTrace();
61             }
62         }
63     }
64 
65     /**
66      * 1. 获取连接的方法. 通过读取配置文件从数据库服务器获取一个连接.
67      * 
68      * @return
69      * @throws Exception
70      */
71     public static Connection getConnection() throws Exception {
72         // 1. 准备连接数据库的 4 个字符串.
73         // 1). 创建 Properties 对象
74         Properties properties = new Properties();
75 
76         // 2). 获取 jdbc.properties 对应的输入流
77         InputStream in = JDBCTools.class.getClassLoader().getResourceAsStream(
78                 "jdbc.properties");
79 
80         // 3). 加载 2） 对应的输入流
81         properties.load(in);
82 
83         // 4). 具体决定 user, password 等4 个字符串.
84         String user = properties.getProperty("user");
85         String password = properties.getProperty("password");
86         String jdbcUrl = properties.getProperty("jdbcUrl");
87         String driver = properties.getProperty("driver");
88 
89         // 2. 加载数据库驱动程序(对应的 Driver 实现类中有注册驱动的静态代码块.)
90         Class.forName(driver);
91 
92         // 3. 通过 DriverManager 的 getConnection() 方法获取数据库连接.
93         return DriverManager.getConnection(jdbcUrl, user, password);
94     }
95 
96 }

View Code

1 driver=com.mysql.jdbc.Driver
2 jdbcUrl=jdbc:mysql://localhost:3306/test
3 user=root
4 password=123456

View Code

二、实现数据库增删改查

1.创立数据库表 examstudent；

 1 /*
 2 Navicat MySQL Data Transfer
 3 
 4 Source Server         : localhost
 5 Source Server Version : 50524
 6 Source Host           : localhost:3306
 7 Source Database       : examstudent
 8 
 9 Target Server Type    : MYSQL
10 Target Server Version : 50524
11 File Encoding         : 65001
12 
13 Date: 2015-06-27 15:49:22
14 */
15 
16 SET FOREIGN_KEY_CHECKS=0;
17 
18 -- ----------------------------
19 -- Table structure for examstudent
20 -- ----------------------------
21 DROP TABLE IF EXISTS `examstudent`;
22 CREATE TABLE `examstudent` (
23   `flowid` int(11) NOT NULL,
24   `type` int(11) DEFAULT NULL,
25   `idcard` varchar(18) DEFAULT NULL,
26   `examcard` varchar(15) DEFAULT NULL,
27   `studentname` varchar(20) DEFAULT NULL,
28   `location` varchar(20) DEFAULT NULL,
29   `grade` int(11) DEFAULT NULL,
30   PRIMARY KEY (`flowid`)
31 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

View Code

2.向数据库中添加如下数据

3. 在 eclipse 中建立 java 程序：输入身份证号或准考证号可以查询到学生的基本信息。

4.完成学生信息的删除功能

示例代码如下：

jdbc.properties

1 user=root
2 password=123456
3 driverClass=com.mysql.jdbc.Driver
4 url=jdbc:mysql://localhost:3306/examstudent

View Code

student.java

  1 package com.atguigu.jdbc;
  2 
  3 public class Student {
  4 
  5     // 流水号
  6     private int flowId;
  7     // 考试的类型
  8     private int type;
  9     // 身份证号
 10     private String idCard;
 11     // 准考证号
 12     private String examCard;
 13     // 学生名
 14     private String studentName;
 15     // 学生地址
 16     private String location;
 17     // 考试分数.
 18     private int grade;
 19 
 20     public int getFlowId() {
 21         return flowId;
 22     }
 23 
 24     public void setFlowId(int flowId) {
 25         this.flowId = flowId;
 26     }
 27 
 28     public int getType() {
 29         return type;
 30     }
 31 
 32     public void setType(int type) {
 33         this.type = type;
 34     }
 35 
 36     public String getIdCard() {
 37         return idCard;
 38     }
 39 
 40     public void setIdCard(String idCard) {
 41         this.idCard = idCard;
 42     }
 43 
 44     public String getExamCard() {
 45         return examCard;
 46     }
 47 
 48     public void setExamCard(String examCard) {
 49         this.examCard = examCard;
 50     }
 51 
 52     public String getStudentName() {
 53         return studentName;
 54     }
 55 
 56     public void setStudentName(String studentName) {
 57         this.studentName = studentName;
 58     }
 59 
 60     public String getLocation() {
 61         return location;
 62     }
 63 
 64     public void setLocation(String location) {
 65         this.location = location;
 66     }
 67 
 68     public int getGrade() {
 69         return grade;
 70     }
 71 
 72     public void setGrade(int grade) {
 73         this.grade = grade;
 74     }
 75 
 76     public Student(int flowId, int type, String idCard, String examCard,
 77             String studentName, String location, int grade) {
 78         super();
 79         this.flowId = flowId;
 80         this.type = type;
 81         this.idCard = idCard;
 82         this.examCard = examCard;
 83         this.studentName = studentName;
 84         this.location = location;
 85         this.grade = grade;
 86     }
 87 
 88     public Student() {
 89         // TODO Auto-generated constructor stub
 90     }
 91 
 92     @Override
 93     public String toString() {
 94         return "Student [flowId=" + flowId + ", type=" + type + ", idCard="
 95                 + idCard + ", examCard=" + examCard + ", studentName="
 96                 + studentName + ", location=" + location + ", grade=" + grade
 97                 + "]";
 98     }
 99 
100 }

View Code

JDBCTools.java

  1 package cky.test;
  2 
  3 import java.io.IOException;
  4 import java.io.InputStream;
  5 import java.sql.Connection;
  6 import java.sql.DriverManager;
  7 import java.sql.PreparedStatement;
  8 import java.sql.ResultSet;
  9 import java.sql.SQLException;
 10 import java.sql.Statement;
 11 import java.util.Properties;
 12 
 13 public class JDBCTools {
 14 
 15     /**
 16      * 执行 SQL 语句, 使用 PreparedStatement
 17      * @param sql
 18      * @param args: 填写 SQL 占位符的可变参数
 19      */
 20     public static void update(String sql, Object ... args){
 21         Connection connection = null;
 22         PreparedStatement preparedStatement = null;
 23         
 24         try {
 25             connection = JDBCTools.getConnection();
 26             preparedStatement = connection.prepareStatement(sql);
 27             
 28             for(int i = 0; i < args.length; i++){
 29                 preparedStatement.setObject(i + 1, args[i]);
 30             }
 31             
 32             preparedStatement.executeUpdate();
 33             
 34         } catch (Exception e) {
 35             e.printStackTrace();
 36         } finally{
 37             JDBCTools.releaseDB(null, preparedStatement, connection);
 38         }
 39     }
 40     
 41     /**
 42      * 执行 SQL 的方法
 43      * 
 44      * @param sql: insert, update 或 delete。 而不包含 select
 45      */
 46     public static void update(String sql) {
 47         Connection connection = null;
 48         Statement statement = null;
 49 
 50         try {
 51             // 1. 获取数据库连接
 52             connection = getConnection();
 53 
 54             // 2. 调用 Connection 对象的 createStatement() 方法获取 Statement 对象
 55             statement = connection.createStatement();
 56 
 57             // 4. 发送 SQL 语句: 调用 Statement 对象的 executeUpdate(sql) 方法
 58             statement.executeUpdate(sql);
 59 
 60         } catch (Exception e) {
 61             e.printStackTrace();
 62         } finally {
 63             // 5. 关闭数据库资源: 由里向外关闭.
 64             releaseDB(null, statement, connection);
 65         }
 66     }
 67 
 68     /**
 69      * 释放数据库资源的方法
 70      * 
 71      * @param resultSet
 72      * @param statement
 73      * @param connection
 74      */
 75     public static void releaseDB(ResultSet resultSet, Statement statement,
 76             Connection connection) {
 77 
 78         if (resultSet != null) {
 79             try {
 80                 resultSet.close();
 81             } catch (SQLException e) {
 82                 e.printStackTrace();
 83             }
 84         }
 85 
 86         if (statement != null) {
 87             try {
 88                 statement.close();
 89             } catch (SQLException e) {
 90                 e.printStackTrace();
 91             }
 92         }
 93 
 94         if (connection != null) {
 95             try {
 96                 connection.close();
 97             } catch (SQLException e) {
 98                 e.printStackTrace();
 99             }
100         }
101 
102     }
103 
104     /**
105      * 获取数据库连接的方法
106      */
107     public static Connection getConnection() throws IOException,
108             ClassNotFoundException, SQLException {
109         // 0. 读取 jdbc.properties
110         /**
111          * 1). 属性文件对应 Java 中的 Properties 类 2). 可以使用类加载器加载 bin 目录(类路径下)的文件
112          */
113         Properties properties = new Properties();
114         InputStream inStream = JDBCTools.class.getClassLoader()
115                 .getResourceAsStream("jdbc.properties");
116         properties.load(inStream);
117 
118         // 1. 准备获取连接的 4 个字符串: user, password, jdbcUrl, driverClass
119         String user = properties.getProperty("user");
120         String password = properties.getProperty("password");
121         String jdbcUrl = properties.getProperty("url");
122         String driverClass = properties.getProperty("driverClass");
123 
124         // 2. 加载驱动: Class.forName(driverClass)
125         Class.forName(driverClass);
126 
127         // 3. 调用
128         // DriverManager.getConnection(jdbcUrl, user, password)
129         // 获取数据库连接
130         Connection connection = DriverManager.getConnection(jdbcUrl, user,
131                 password);
132         return connection;
133     }
134 
135 }

View Code

JDBCTest.java

  1 package cky.test;
  2 
  3 import java.sql.Connection;
  4 
  5 import java.sql.PreparedStatement;
  6 import java.sql.ResultSet;
  7 
  8 import java.util.Scanner;
  9 
 10 import org.junit.Test;
 11 
 12 public class JDBCTest {
 13 
 14     //得到学生的信息集
 15     public Student getStudent(String sql, Object... args) {
 16         Student stu = null;
 17 
 18         Connection connection = null;
 19         PreparedStatement preparedStatement = null;
 20         ResultSet resultSet = null;
 21 
 22         try {
 23             connection = JDBCTools.getConnection();
 24             preparedStatement = connection.prepareStatement(sql);
 25             for (int i = 0; i < args.length; i++) {
 26                 preparedStatement.setObject(i + 1, args[i]);
 27             }
 28             resultSet = preparedStatement.executeQuery();
 29 
 30             if (resultSet.next()) {
 31                 stu = new Student();
 32                 stu.setFlowId(resultSet.getInt(1));
 33                 stu.setType(resultSet.getInt(2));
 34                 stu.setIdCard(resultSet.getString(3));
 35                 
 36             }
 37 
 38         } catch (Exception e) {
 39             e.printStackTrace();
 40         } finally {
 41             JDBCTools.releaseDB(resultSet, preparedStatement, connection);
 42         }
 43 
 44         return stu;
 45     }
 46 
 47 
 48     /*
 49     private Student getStudent(String sql) {
 50 
 51         Student stu = null;
 52 
 53         Connection connection = null;
 54         Statement statement = null;
 55         ResultSet resultSet = null;
 56 
 57         try {
 58             connection = JDBCTools.getConnection();
 59             statement = connection.createStatement();
 60             resultSet = statement.executeQuery(sql);
 61 
 62             if (resultSet.next()) {
 63                 stu = new Student(resultSet.getInt(1), resultSet.getInt(2),
 64                         resultSet.getString(3), resultSet.getString(4),
 65                         resultSet.getString(5), resultSet.getString(6),
 66                         resultSet.getInt(7));
 67             }
 68 
 69         } catch (Exception e) {
 70             e.printStackTrace();
 71         } finally {
 72             JDBCTools.releaseDB(resultSet, statement, connection);
 73         }
 74 
 75         return stu;
 76     }
 77     */
 78     
 79     //打印学生信息: 若学生存在则打印其具体信息. 若不存在: 打印查无此人
 80     private void printStudent(Student student) {
 81         if (student != null) {
 82             System.out.println(student);
 83         } else {
 84             System.out.println("查无此人!");
 85         }
 86     }
 87     
 88     // 从控制台读入一个整数, 确定要查询的类型; @return: 1. 用身份证查询. 2. 用准考证号查询 其他的无效. 并提示请用户重新输入.
 89     private int getSearchTypeFromConsole() {
 90 
 91         System.out.print("请输入查询类型: 1. 用身份证查询. 2. 用准考证号查询 ");
 92 
 93         Scanner scanner = new Scanner(System.in);
 94         int type = scanner.nextInt();
 95 
 96         if (type != 1 && type != 2) {
 97             System.out.println("输入有误请重新输入!");
 98             throw new RuntimeException();
 99         }
100 
101         return type;
102     }
103 
104     //从控制台输入学生的信息
105     private Student getStudentFromConsole() {
106 
107         Scanner scanner = new Scanner(System.in);
108 
109         Student student = new Student();
110 
111         System.out.print("FlowId:");
112         student.setFlowId(scanner.nextInt());
113 
114         System.out.print("Type: ");
115         student.setType(scanner.nextInt());
116 
117         System.out.print("IdCard:");
118         student.setIdCard(scanner.next());
119 
120         System.out.print("ExamCard:");
121         student.setExamCard(scanner.next());
122 
123         System.out.print("StudentName:");
124         student.setStudentName(scanner.next());
125 
126         System.out.print("Location:");
127         student.setLocation(scanner.next());
128 
129         System.out.print("Grade:");
130         student.setGrade(scanner.nextInt());
131 
132         return student;
133     }
134     
135     public void addNewStudent2(Student student) {
136         String sql = "INSERT INTO examstudent(flowid, type, idcard, "
137                 + "examcard, studentname, location, grade) "
138                 + "VALUES(?,?,?,?,?,?,?)";
139 
140         JDBCTools.update(sql, student.getFlowId(), student.getType(),
141                 student.getIdCard(), student.getExamCard(),
142                 student.getStudentName(), student.getLocation(),
143                 student.getGrade());
144     }
145 
146     /*
147     public void addNewStudent(Student student) {
148         // 1. 准备一条 SQL 语句:
149         String sql = "INSERT INTO examstudent VALUES(" + student.getFlowId()
150                 + "," + student.getType() + ",'" + student.getIdCard() + "','"
151                 + student.getExamCard() + "','" + student.getStudentName()
152                 + "','" + student.getLocation() + "'," + student.getGrade()
153                 + ")";
154 
155         System.out.println(sql);
156 
157         // 2. 调用 JDBCTools 类的 update(sql) 方法执行插入操作.
158         JDBCTools.update(sql);
159     }
160     */
161     
162     //具体查询学生信息的. 返回一个 Student 对象. 若不存在, 则返回 null
163     private Student searchStudent(int searchType) {
164         
165         String sql = "SELECT flowid, type, idcard, examcard,"
166                 + "studentname, location, grade " + "FROM examstudent "
167                 + "WHERE ";
168 
169         Scanner scanner = new Scanner(System.in);
170 
171         // 1. 根据输入的 searchType, 提示用户输入信息:
172         // 1.1 若 searchType 为 1, 提示: 请输入身份证号. 若为 2 提示: 请输入准考证号
173         // 2. 根据 searchType 确定 SQL
174         if (searchType == 1) {
175             System.out.print("请输入准考证号:");
176             String examCard = scanner.next();
177             sql = sql + "examcard = '" + examCard + "'";
178         } else {
179             System.out.print("请输入身份证号:");
180             String examCard = scanner.next();
181             sql = sql + "idcard = '" + examCard + "'";
182         }
183 
184         // 3. 执行查询
185         Student student = getStudent(sql);
186 
187         // 4. 若存在查询结果, 把查询结果封装为一个 Student 对象
188 
189         return student;
190     }
191 
192     
193     //测试打印查询到的学生信息
194     @Test
195     public void testGetStudent() {
196         // 1. 得到查询的类型
197         int searchType = getSearchTypeFromConsole();
198 
199         // 2. 具体查询学生信息
200         Student student = searchStudent(searchType);
201 
202         // 3. 打印学生信息
203         printStudent(student);
204     }
205     
206     
207     @Test
208     public void testAddNewStudent() {
209         Student student = getStudentFromConsole();
210         addNewStudent2(student);
211     }
212 
213 }

View Code

三、Statement 与 ResultSet
1.通过调用 Connection 对象的 createStatement 方法创建该对象
 Statement st = conn.createStatement();
2.该对象用于执行静态的 SQL 语句，并且返回执行结果
3.Statement 接口中定义了下列方法用于执行 SQL 语句：
 ResultSet excuteQuery(String sql)
 int excuteUpdate(String sql)

通用的INSERT、UPDATA、DELETE方法

 1 //通用的 INSSERT UPDATE DELETE 方法(version 1.0)
 2 public void update(String sql){
 3     //1.获取数据库的连接
 4     Connection conn = null;
 5     Statement st = null;
 6     try{
 7         conn = JDBCUtils.getConnection();
 8         //2.提供一个 Statement 对象，将 sql 传递给数据库中执行
 9         st = conn.createStatement();
10         st.execute(sql);
11     }catch(Exception e){
12         e.printStackTrace();
13     }finally{
14         //3.关闭 Statement 对象及连接
15         JDBCUtils.close(null, st, conn);
16     } 
17 }

View Code

通用的查询方法,返回一个对象

 1 public <T> T get(String sql, Class<T> clazz) {
 2     Connection conn = null;
 3     Statement st = null;
 4     ResultSet rs = null;
 5     T t = null;
 6     try {
 7         t = clazz.newInstance();
 8         conn = JDBCUtils.getConnection();
 9         st = conn.createStatement();
10         rs = st.executeQuery(sql);
11         /*
12         * 通过 ResultSet 调用 getMetaData()返回一个结果集的元数据：ResultSetMetaData
13         *
14         * 1.getColumnCount():返回结果集的列数
15         * 2.getColumnLabel():返回列的别名
16         */
17         ResultSetMetaData rsmd = rs.getMetaData();
18         int columnCount = rsmd.getColumnCount();
19         if (rs.next()) {
20             for (int i = 0; i < columnCount; i++) {
21                 Object columnVal = rs.getObject(i + 1);// 相应列的值
22                 //String columnName = rsmd.getColumnName(i + 1);
23                 String columnName = rsmd.getColumnLabel(i + 1);
24                 //使用 PropertyUtils 将指定对象 t 的指定属性 columnName 设置为指定的值 columnVal
25                 PropertyUtils.setProperty(t, columnName, columnVal);
26             } 
27         }
28     } catch (Exception e) {
29         e.printStackTrace();
30     } finally {
31         JDBCUtils.close(rs, st, conn);
32     }
33     return t;
34 }

View Code

//通用的返回多个对象的查询操作

 1 public <T> List<T> getInstances(String sql,Class<T> clazz){
 2     Connection conn = null;
 3     Statement st = null;
 4     ResultSet rs = null;
 5     List<T> list = new ArrayList<T>();
 6     try {
 7         conn = JDBCUtils.getConnection();
 8         st = conn.createStatement();
 9         rs = st.executeQuery(sql);
10         /*
11         * 通过 ResultSet 调用 getMetaData()返回一个结果集的元数据：ResultSetMetaData
12         *
13         * 1.getColumnCount():返回结果集的列数
14         * 2.getColumnLabel():返回列的别名
15         */
16         ResultSetMetaData rsmd = rs.getMetaData();
17         int columnCount = rsmd.getColumnCount();
18         while (rs.next()) {
19             T t = clazz.newInstance();
20             for (int i = 0; i < columnCount; i++) {
21                 Object columnVal = rs.getObject(i + 1);// 相应列的值
22                 //String columnName = rsmd.getColumnName(i + 1);
23                 String columnName = rsmd.getColumnLabel(i + 1);
24                 //使用 PropertyUtils 将指定对象 t 的指定属性 columnName 设置为指定的值 columnVal
25                 PropertyUtils.setProperty(t, columnName, columnVal);
26             }
27             list.add(t);
28         }
29     } catch (Exception e) {
30         e.printStackTrace();
31     } finally {
32         JDBCUtils.close(rs, st, conn);
33     }
34     return list;
35 }

View Code

或者采用这个方法（个人比较喜欢）

 1 public List<Map<String, Object>> read(String sql) throws SQLException {
 2         Connection conn = null;
 3         PreparedStatement ps = null;
 4         ResultSet rs = null;
 5         try {
 6             conn = JdbcUtils.getConnection();
 7             ps = conn.prepareStatement(sql);
 8             rs = ps.executeQuery();
 9             ResultSetMetaData rsmd = rs.getMetaData();
10             int count = rsmd.getColumnCount();
11             String[] colNames = new String[count];
12             System.out.println(count);
13             for (int i = 1; i <= count; i++) {
14                 //Object val = rs.getObject(i);
15                 //System.out.println(val);
16                 //System.out.print(rsmd.getColumnClassName(i) + "	");
17                 //System.out.print(rsmd.getColumnName(i) + "	");
18                 //System.out.println(rsmd.getColumnLabel(i));
19                 colNames[i - 1] = rsmd.getColumnLabel(i);
20             }
21             List<Map<String, Object>> datas = new ArrayList<Map<String, Object>>();
22 
23             while (rs.next()) {
24                 Map<String, Object> data = new HashMap<String, Object>();
25                 for (int i = 0; i < colNames.length; i++) {
26                     data.put(colNames[i], rs.getObject(colNames[i]));
27                 }
28                 datas.add(data);
29             }
30             return datas;
31         } finally {
32             JdbcUtils.free(rs, ps, conn);
33         }
34     }

View Code

两种思想：
1.面向接口编程的思想；
2.ORM 思想：ORM:Object Relational Mapping
数据库中的表与 java 中的一个类对应（如： customers 表与 Customer 类对应）；数据库中表的一个列与 java 类的一个属性对应（如：表中的 id 列与 Customer类的 id 属性对应）；数据库中表的一行（一条数据）与 java 类的一个对象对应

  1 package cn.itcast.jdbc;
  2 
  3 import java.lang.reflect.InvocationTargetException;
  4 import java.lang.reflect.Method;
  5 import java.sql.Connection;
  6 import java.sql.PreparedStatement;
  7 import java.sql.ResultSet;
  8 import java.sql.ResultSetMetaData;
  9 import java.sql.SQLException;
 10 import java.util.ArrayList;
 11 import java.util.HashMap;
 12 import java.util.List;
 13 import java.util.Map;
 14 
 15 import cn.itcast.jdbc.domain.User;
 16 
 17 /**
 18  * 
 19  * 2008-12-7
 20  * 
 21  * @author <a href="mailto:liyongibm@gmail.com">liyong</a>
 22  * 
 23  */
 24 public class ORMTest {
 25 
 26     /**
 27      * @param args
 28      * @throws Exception
 29      * @throws InvocationTargetException
 30      * @throws IllegalAccessException
 31      * @throws SQLException
 32      */
 33     public static void main(String[] args) throws SQLException,
 34             IllegalAccessException, InvocationTargetException, Exception {
 35         User user = (User) getObject(
 36                 "select id as Id, name as Name, birthday as Birthday, money as Money  from user where id=1",
 37                 User.class);
 38         System.out.println(user);
 39 
 40         Bean b = (Bean) getObject(
 41                 "select id as Id, name as Name, birthday as Birthday, money as Money from user where id=1",
 42                 Bean.class);
 43         System.out.println(b);
 44     }
 45 
 46     static List<Object> getObjects(String sql, Class clazz)
 47             throws SQLException, Exception, IllegalAccessException,
 48             InvocationTargetException {
 49         Connection conn = null;
 50         PreparedStatement ps = null;
 51         ResultSet rs = null;
 52         try {
 53             conn = JdbcUtils.getConnection();
 54             ps = conn.prepareStatement(sql);
 55             rs = ps.executeQuery();
 56             String[] colNames = getColNames(rs);
 57 
 58             List<Object> objects = new ArrayList<Object>();
 59             Method[] ms = clazz.getMethods();
 60             while (rs.next()) {
 61                 Object object = clazz.newInstance();
 62                 for (int i = 0; i < colNames.length; i++) {
 63                     String colName = colNames[i];
 64                     String methodName = "set" + colName;
 65                     // Object value = rs.getObject(colName);
 66                     // try {
 67                     // Method m = clazz
 68                     // .getMethod(methodName, value.getClass());
 69                     // if (m != null)
 70                     // m.invoke(object, value);
 71                     // } catch (NoSuchMethodException e) {
 72                     // e.printStackTrace();
 73                     // //
 74                     // }
 75                     for (Method m : ms) {
 76                         if (methodName.equals(m.getName())) {
 77                             m.invoke(object, rs.getObject(colName));
 78                             break;
 79                         }
 80                     }
 81                     objects.add(object);
 82                 }
 83             }
 84             return objects;
 85         } finally {
 86             JdbcUtils.free(rs, ps, conn);
 87         }
 88     }
 89 
 90     private static String[] getColNames(ResultSet rs) throws SQLException {
 91         ResultSetMetaData rsmd = rs.getMetaData();
 92         int count = rsmd.getColumnCount();
 93         String[] colNames = new String[count];
 94         for (int i = 1; i <= count; i++) {
 95             colNames[i - 1] = rsmd.getColumnLabel(i);
 96         }
 97         return colNames;
 98     }
 99 
100     static Object getObject(String sql, Class clazz) throws SQLException,
101             Exception, IllegalAccessException, InvocationTargetException {
102         Connection conn = null;
103         PreparedStatement ps = null;
104         ResultSet rs = null;
105         try {
106             conn = JdbcUtils.getConnection();
107             ps = conn.prepareStatement(sql);
108             rs = ps.executeQuery();
109             String[] colNames = getColNames(rs);
110 
111             Object object = null;
112             Method[] ms = clazz.getMethods();
113             if (rs.next()) {
114                 object = clazz.newInstance();
115                 for (int i = 0; i < colNames.length; i++) {
116                     String colName = colNames[i];
117                     String methodName = "set" + colName;
118                     // Object value = rs.getObject(colName);
119                     // try {
120                     // Method m = clazz
121                     // .getMethod(methodName, value.getClass());
122                     // if (m != null)
123                     // m.invoke(object, value);
124                     // } catch (NoSuchMethodException e) {
125                     // e.printStackTrace();
126                     // //
127                     // }
128                     for (Method m : ms) {
129                         if (methodName.equals(m.getName())) {
130                             m.invoke(object, rs.getObject(colName));
131                             break;
132                         }
133                     }
134                 }
135             }
136             return object;
137         } finally {
138             JdbcUtils.free(rs, ps, conn);
139         }
140     }
141 }

View Code

两个技术：
1.结果集的元数据： ResultSetMetaData；

可用于获取关于 ResultSet 对象中列的类型和属性信息的对象：
　　—getColumnName(int column)：获取指定列的名称
　　—getColumnCount()：返回当前 ResultSet 对象中的列数。
　　—getColumnTypeName(int column)：检索指定列的数据库特定的类型名称。
　　—getColumnDisplaySize(int column)：指示指定列的最大标准宽度，以字符为单位。　　
　　—isNullable(int column)：指示指定列中的值是否可以为 null。
　　—isAutoIncrement(int column)：指示是否自动为指定列进行编号，这样这些列仍然是只读的。

 1 public void testResultSetMetaData(){
 2     Connection conn = null;
 3     Statement st = null;
 4     ResultSet rs = null;
 5     String sql = "select order_id id,order_name name,order_date date from `order`";
 6     try{
 7         conn = JDBCUtils.getConnection();
 8         st = conn.createStatement();
 9         rs = st.executeQuery(sql);
10         ResultSetMetaData rsmd = rs.getMetaData();
11         int columnCount = rsmd.getColumnCount();
12         System.out.println(columnCount);
13         while(rs.next()){
14             for(int i = 0;i < columnCount;i++){
15                 System.out.print(rsmd.getColumnName(i + 1) + " ");
16                 System.out.print(rsmd.getColumnLabel(i + 1) + " ");
17                 System.out.println(rs.getObject(i + 1));
18             }
19             System.out.println();
20         }
21     }catch(Exception e){
22         e.printStackTrace();
23     }finally{
24         JDBCUtils.close(rs, st, conn);
25     } 
26 }

View Code

2.PropertyUtils：使用它的 setProperty(Object obj,String FieldName,Object FieldValue)

1 public void testPropertyUtils() throws Exception{
2     Order order = new Order();
3     System.out.println(order);
4     PropertyUtils.setProperty(order, "id", 1001);
5     PropertyUtils.setProperty(order, "name", "AA");
6     PropertyUtils.setProperty(order, "date", new Date(new java.util.Date().getTime()));
7     System.out.println(order);
8 }

View Code

四、PreparedStatement

PreparedStatement 是 Statement 的子接口

a.需要预编译 SQL 语句： PreparedStatement ps = conn.preparedStatement(sql);
b.填充占位符： setObject(int index);//index 从 1 开始
c.execute() / executeUpdate() ; executeQuery(); 返回一个 ResultSet

1.替换原来的 Statement，实现增删改和查的操作
-->Statement 的问题：①拼串不方便，容易出错 ②存在 sql 注入的问题，可以对数据库进行恶意攻击。

// 实现一个通用的 UPDATE INSERT DELETE 的操作的方法

 1 public void update(String sql, Object... args) {
 2     Connection conn = null;
 3     PreparedStatement ps = null;
 4     try {
 5         // 1.获取连接
 6         conn = JDBCUtils.getConnection();
 7         // 2.返回 PreparedSt 对象，预编译 sql 语句
 8         ps = conn.prepareStatement(sql);
 9         // 3.填充占位符
10         for (int i = 0; i < args.length; i++) {
11             ps.setObject(i + 1, args[i]);
12         }
13         ps.execute();
14     } catch (Exception e) {
15         e.printStackTrace();
16     } finally {
17         JDBCUtils.close(null, ps, conn);
18     } 
19 }

View Code

// 实现一个通用的查询操作,返回一个对象

 1 public <T> T getInstance(String sql, Class<T> clazz, Object... args) {
 2     Connection conn = null;
 3     PreparedStatement ps = null;
 4     ResultSet rs = null;
 5     try {
 6         // 1.获取连接
 7         conn = JDBCUtils.getConnection();
 8         // 2.预编译 sql 语句，返回 PreparedStatement 对象
 9         ps = conn.prepareStatement(sql);
10         // 3.填充占位符
11         for (int i = 0; i < args.length; i++) {
12             ps.setObject(i + 1, args[i]);
13         }
14         // 4.执行并返回 ResultSet 的对象
15         rs = ps.executeQuery();
16         if (rs.next()) {
17             // 5.创建 T 的对象
18             T t = clazz.newInstance();
19             // 6.将结果集中的列值作为 T 的对象的属性，给予赋值
20             ResultSetMetaData rsmd = rs.getMetaData();
21             int columnCount = rsmd.getColumnCount();
22             for (int i = 0; i < columnCount; i++) {
23                 Object columnVal = rs.getObject(i + 1);
24                 String columnLabel = rsmd.getColumnLabel(i + 1);
25                 PropertyUtils.setProperty(t, columnLabel, columnVal);
26             }
27             return t;
28         }
29     } catch (Exception e) {
30         e.printStackTrace();
31     } finally {
32         // 7.关闭相应的操作
33         JDBCUtils.close(rs, ps, conn);
34     }
35     return null;
36 }

View Code

// 实现一个通用的查询操作,返回一个对象的集合

 1 public <T> List<T> getForList(String sql,Class<T> clazz,Object ... args){
 2     Connection conn = null;
 3     PreparedStatement ps = null;
 4     ResultSet rs = null;
 5     List<T> list = new ArrayList<T>();
 6     try{
 7         conn = JDBCUtils.getConnection();
 8         ps = conn.prepareStatement(sql);
 9         for(int i = 0;i < args.length;i++){
10             ps.setObject(i + 1, args[i]);
11         }
12         rs = ps.executeQuery();
13         ResultSetMetaData rsmd = rs.getMetaData();
14         int columnCount = rsmd.getColumnCount();
15         while(rs.next()){
16             T t = clazz.newInstance();
17             for(int i = 0;i < columnCount;i++){
18                 Object columnVal = rs.getObject(i + 1);
19                 String columnLabel = rsmd.getColumnLabel(i + 1);
20                 PropertyUtils.setProperty(t, columnLabel, columnVal);
21             }
22             list.add(t);
23         }
24     }catch(Exception e){
25         e.printStackTrace();
26     }finally{
27         JDBCUtils.close(rs, ps, conn);
28     }
29     return list;
30 }

View Code

2.使用 PreparedStatement 的其他优点
-->1.实现大数据类型的数据的插入、修改、查询的操作.
setBlob() getBlob();

// 从数据表中将大数据类型的数据取出

 1 @Test
 2 public void testBlob3(){
 3     Connection conn = null;
 4     PreparedStatement ps = null;
 5     String sql = "select id,name,email,birth,photo from customers where id = ?";
 6     ResultSet rs = null;
 7     InputStream is = null;
 8     FileOutputStream fos = null;
 9     try{
10         conn = JDBCUtils.getConnection();
11         ps = conn.prepareStatement(sql);
12         fos = new FileOutputStream("ym1.jpg");
13         ps.setInt(1, 21);
14         rs = ps.executeQuery();
15         if(rs.next()){
16             int id = rs.getInt("id");
17             String name = rs.getString("name");
18             Date birth = rs.getDate("birth");
19             String email = rs.getString("email");
20             Customer cust = new Customer(id,name,email,birth);
21             System.out.println(cust);
22         }
23         Blob photo = rs.getBlob(5);//获取此 ResultSet 对象的当前行中指定列的值
24         is = photo.getBinaryStream();//获取用于写入此 Blob 对象表示的 BLOB 值的流,输入流
25 
26         byte[] b = new byte[1024];
27         int len;
28         while((len = is.read(b)) != -1){
29             fos.write(b, 0, len);//文件输出流，保存大数据文件到ym1.jpg中。
30         }
31     }catch (Exception e) {
32         e.printStackTrace();
33     } finally {
34         JDBCUtils.close(rs, ps, conn);
35         if(fos != null){
36             try {
37                 fos.close();
38             } catch (IOException e) {
39                 // TODO Auto-generated catch block
40                 e.printStackTrace();
41             }
42         }
43         if(is != null){
44             try {
45                 is.close();
46             } catch (IOException e) {
47                 // TODO Auto-generated catch block
48                 e.printStackTrace();
49             } 
50         }
51     } 
52 }

View Code

// 向数据表中修改现有的大数据类型的数据

 1 @Test
 2 public void testBlob2() {
 3     Connection conn = null;
 4     PreparedStatement ps = null;
 5     String sql = "update customers set photo = ? where id = ?";
 6     try {
 7         conn = JDBCUtils.getConnection();
 8         ps = conn.prepareStatement(sql);
 9         ps.setBlob(1, new FileInputStream("ym.jpg"));
10         ps.setInt(2, 21);
11         ps.execute();
12     } catch (Exception e) {
13         e.printStackTrace();
14     } finally {
15         JDBCUtils.close(null, ps, conn);
16     } 
17 }

View Code

// 向数据库的表中写入大数据类型的数据

 1 @Test
 2 public void testBlob1() {
 3     Connection conn = null;
 4     PreparedStatement ps = null;
 5     String sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
 6     try {
 7         conn = JDBCUtils.getConnection();
 8         ps = conn.prepareStatement(sql);
 9         ps.setString(1, "杨幂 1");
10         ps.setString(2, "yang@126.com");
11         ps.setDate(3, new Date(new java.util.Date().getTime()));
12         ps.setBlob(4, new FileInputStream("1.jpg"));
13         ps.execute();
14     } catch (Exception e) {
15         e.printStackTrace();
16     } finally {
17         JDBCUtils.close(null, ps, conn);
18     }
19 }

View Code

-->2.使用 PreparedStatement 进行批量操作时，效率优于 Statement.
oracle 是支持批量插入的。
如何实现最优？ ①使用 PreparedStatement ②addBatch() executeBatch() clearBatch()
//批量操作，主要指的是批量插入

 1 public void test4() {
 2     Connection conn = null;
 3     PreparedStatement ps = null;
 4     long start = System.currentTimeMillis();
 5     String sql = "insert into dept values(?,?)";
 6     try {
 7         conn = JDBCUtils.getConnection();
 8         ps = conn.prepareStatement(sql);
 9         for (int i = 0; i < 100000; i++) {
10             ps.setInt(1, i + 1);
11             ps.setString(2, "dept_" + (i + 1) + "_name");
12             //1.“攒” SQL
13             ps.addBatch();
14             if( (i + 1) % 250 == 0){
15                 //2.执行 sql
16                 ps.executeBatch();
17                 //3.清空 sql
18                 ps.clearBatch();
19             }     
20         }
21     } catch (Exception e) {
22         e.printStackTrace();
23     } finally {
24         JDBCUtils.close(null, ps, conn);
25     }
26     long end = System.currentTimeMillis();
27     System.out.println("花费时间： " + (end - start));//2427
28 }

View Code

五、数据库的元数据： DataBaseMetaData(了解)
“元”数据： String name = "AA";
ResutSet :结果集
ResultSetMetaData：结果集的元数据

DatabaseMetaData:数据库的元数据

public class TestDataBaseMetaData {
    public static void main(String[] args) {
        Connection conn = null;
        DatabaseMetaData dbmd = null;
        ResultSet rs = null;
        try{
            conn = JDBCUtils.getConnection();
            //获取数据库的元数据
            dbmd = conn.getMetaData();
            //以字符串的形式返回数据库的名字
            System.out.println(dbmd.getDatabaseProductName());
            //返回数据库的版本号
            System.out.println(dbmd.getDatabaseProductVersion());
            rs = dbmd.getCatalogs();
            //返回含有的各个数据库的名字
            while(rs.next()){
                String databaseName = rs.getString(1);
                System.out.println(databaseName);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.close(rs, null, conn);
        }
    }
}

View Code

六、数据库事务（重点）
1.事务：指构成单个逻辑工作单元的操作集合
2.事务处理：保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，要么整个事务回滚(rollback)到最初状态
2当一个连接对象被创建时，默认情况下是自动提交事务：每次执行一个 SQL 语句时，如果执行成功，就会向数据库自动提交，而不能回滚，为了让多个 SQL 语句作为一个事务执行：
a.调用 Connection 对象的 setAutoCommit(false); 以取消自动提交事务
b.在所有的 SQL 语句都成功执行后，调用 commit(); 方法提交事务
c.在出现异常时，调用 rollback(); 方法回滚事务
d.若此时 Connection 没有被关闭, 则需要恢复其自动提交状态

// 以下的两个操作共同构成一个数据库事务。但是在两个操作之间可能出现异常问题。
// 原则上，一旦出现问题，就需要将之前的操作“回滚”！需要对如下的操作进行完善。

1 @Test
2 public void testUpdate() {
3     String sql1 = "update user_table set balance = balance - 100 where user = ?";
4     update(sql1, "AA");
5     System.out.println(10 / 0);
6     String sql2 = "update user_table set balance = balance + 100 where user = ?";
7     update(sql2, "BB");
8 }

View Code

3.考虑到数据库事务的话，我们又将原来使用 PreparedStatement 重构的
Statement 的增删改和查的操作，再升级。

// 实现一个通用的 UPDATE INSERT DELETE 的操作的方法(version 3.0)

 1 public void update(Connection conn,String sql, Object... args) {
 2     PreparedStatement ps = null;
 3     try {
 4         ps = conn.prepareStatement(sql);
 5         for (int i = 0; i < args.length; i++) {
 6             ps.setObject(i + 1, args[i]);
 7         }
 8         ps.execute();
 9     } catch (Exception e) {
10         e.printStackTrace();
11     } finally {
12         JDBCUtils.close(null, ps, null);
13     }
14 }

View Code

// 实现一个通用的查询操作,返回一个对象(version 3.0)

 1 public <T> T getInstance(Connection conn,String sql, Class<T> clazz, Object... args) {
 2     PreparedStatement ps = null;
 3     ResultSet rs = null;
 4     try {
 5         ps = conn.prepareStatement(sql);
 6         // 填充占位符
 7         for (int i = 0; i < args.length; i++) {
 8             ps.setObject(i + 1, args[i]);
 9         }
10         // 4.执行并返回 ResultSet 的对象
11         rs = ps.executeQuery();
12         if (rs.next()) {
13             // 5.创建 T 的对象
14             T t = clazz.newInstance();
15             // 6.将结果集中的列值作为 T 的对象的属性，给予赋值
16             ResultSetMetaData rsmd = rs.getMetaData();
17             int columnCount = rsmd.getColumnCount();
18             for (int i = 0; i < columnCount; i++) {
19                 Object columnVal = rs.getObject(i + 1);
20                 String columnLabel = rsmd.getColumnLabel(i + 1);
21                 PropertyUtils.setProperty(t, columnLabel, columnVal);
22             }
23             return t;
24         }
25     } catch (Exception e) {
26         e.printStackTrace();
27     } finally {
28         // 7.关闭相应的操作
29         JDBCUtils.close(rs, ps, null);
30     }
31     return null;
32 }

View Code

// 实现一个通用的查询操作,返回一个对象的集合(version 3.0)

 1 public <T> List<T> getForList(Connection conn,String sql,Class<T> clazz,Object ...args){
 2     PreparedStatement ps = null;
 3     ResultSet rs = null;
 4     List<T> list = new ArrayList<T>();
 5     try{
 6         ps = conn.prepareStatement(sql);
 7         for(int i = 0;i < args.length;i++){
 8             ps.setObject(i + 1, args[i]);
 9         }
10         rs = ps.executeQuery();
11         ResultSetMetaData rsmd = rs.getMetaData();
12         int columnCount = rsmd.getColumnCount();
13         while(rs.next()){
14             T t = clazz.newInstance();
15             for(int i = 0;i < columnCount;i++){
16                 Object columnVal = rs.getObject(i + 1);
17                 String columnLabel = rsmd.getColumnLabel(i + 1);
18                 PropertyUtils.setProperty(t, columnLabel, columnVal);
19             }
20             list.add(t);
21         }
22     }catch(Exception e){
23         e.printStackTrace();
24     }finally{
25         JDBCUtils.close(rs, ps, null);
26     }
27     return list;
28 }

View Code

//考虑到数据库事务，通过 java 程序对数据库中表的操作的模板（掌握）

 1 public void method(){
 2     Connection conn = null;
 3     try{
 4         //1.获取数据库的连接（①conn = JDBCUtils.getConnection(); ②数据库连接池（开发者选择此））
 5         //2.开启事务
 6         conn.setAutoCommit(false);
 7         //3.对数据库中表进行相应的操作(增、删、改、查)（①version 3.0 ②DBUtils 工具类： update() 和 query()方法）
 8         //4.提交事务
 9         conn.commit();
10     }catch(Exception e){
11         e.printStackTrace();
12         try{
13             //5.回滚事务
14             conn.rollback();
15         }catch(Exception e1){
16             e1.printStackTrace();
17         }
18     }finally{
19         //6.关闭数据库的连接（①自己实现数据库相应资源的关闭JDBCUtils.close(null,null,conn); ②使用 DBUtils 工具类的 close()方法）
20     }
21 }

View Code

事务的ACID(acid)属性：

1. 原子性（Atomicity）原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
2. 一致性（Consistency）事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
3. 隔离性（Isolation）事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
4. 持久性（Durability）持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响

数据库的隔离级别:

1.对于同时运行的多个事务, 当这些事务访问数据库中相同的数据时, 如果没有采取必要的隔离机制, 就会导致各种并发问题:
a.脏读: 对于两个事物 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段. 之后, 若 T2 回滚, T1读取的内容就是临时且无效的.
b.不可重复读: 对于两个事物 T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段. 之后, T1再次读取同一个字段, 值就不同了.
c.幻读: 对于两个事物 T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行. 之后, 如果 T1 再次读取同一个表, 就会多出几行.
2.数据库事务的隔离性: 数据库系统必须具有隔离并发运行各个事务的能力, 使它们不会相互影响, 避免各种并发问题.
3.一个事务与其他事务隔离的程度称为隔离级别. 数据库规定了多种事务隔离级别, 不同隔离级别对应不同的干扰程度, 隔离级别越高, 数据一致性就越好, 但并发性越弱

七、实现 DAO 及其实现类 CustomerDAO 的代码

DAO.java

  1 //DAO： database access object
  2 class ReflectionUtils{
  3     //获取 clazz 对象对应的运行时类的父类的泛型
  4     public static Class getSuperGeneric(Class clazz){
  5         Type type = clazz.getGenericSuperclass();
  6         ParameterizedType p = (ParameterizedType)type;
  7         Type[] ts = p.getActualTypeArguments();
  8         return (Class)ts[0];
  9     }
 10 }
 11 
 12 public class DAO<T> {
 13     private Class<T> clazz = null;
 14     //this.getClass()在这个问题中，就是 CustomerDAO
 15     public DAO(){
 16     clazz = ReflectionUtils.getSuperGeneric(this.getClass());
 17     }
 18 
 19     //获取数据库的标准的特定含义的值
 20     public <E> E getValue(Connection conn,String sql,Object...args){
 21         PreparedStatement ps = null;
 22         ResultSet rs = null;
 23         try{
 24             ps = conn.prepareStatement(sql);
 25             for(int i = 0;i < args.length;i++){
 26                 ps.setObject(i + 1, args[i]);
 27             }
 28             rs = ps.executeQuery();
 29             if(rs.next()){
 30             return (E)rs.getObject(1);
 31             }
 32         }catch(Exception e){
 33             e.printStackTrace();
 34         }finally{
 35             JDBCUtils.close(rs, ps, null);
 36         }
 37         return null;
 38     }
 39 
 40     //返回多个对象，以集合的形式返回
 41     public List<T> getForList(Connection conn,String sql,Object ...args){
 42         PreparedStatement ps = null;
 43         ResultSet rs = null;
 44         List<T> list = new ArrayList<>();
 45         try{
 46             //1.预编译 sql 语句，获取 PreparedStatement 对象
 47             ps = conn.prepareStatement(sql);
 48             //2.填充占位符
 49             for(int i = 0;i < args.length;i++){
 50                 ps.setObject(i + 1, args[i]);
 51             }
 52             //3.返回一个结果集
 53             rs = ps.executeQuery();
 54             ResultSetMetaData rsmd = rs.getMetaData();
 55             int columnCount = rsmd.getColumnCount();
 56             while(rs.next()){
 57                 T t = clazz.newInstance();
 58                 //给 t 对象的相应属性赋值
 59                 for(int i = 0;i < columnCount;i++){
 60                     Object columnVal = rs.getObject(i + 1);
 61                     String columnLabel = rsmd.getColumnLabel(i + 1);
 62                     PropertyUtils.setProperty(t, columnLabel, columnVal);
 63                 }
 64                 list.add(t);
 65             }
 66         }catch(Exception e){
 67             e.printStackTrace();
 68         }finally{
 69             JDBCUtils.close(rs, ps, null);
 70         }
 71         //System.out.println(clazz);
 72         return list;
 73     }
 74 
 75     //返回一个对象
 76     public T get(Connection conn,String sql,Object ...args){
 77         PreparedStatement ps = null;
 78         ResultSet rs = null;
 79         try{
 80             //1.预编译 sql 语句，获取 PreparedStatement 对象
 81             ps = conn.prepareStatement(sql);
 82             //2.填充占位符
 83             for(int i = 0;i < args.length;i++){
 84                 ps.setObject(i + 1, args[i]);
 85             }
 86             //3.返回一个结果集
 87             rs = ps.executeQuery();
 88             ResultSetMetaData rsmd = rs.getMetaData();
 89             int columnCount = rsmd.getColumnCount();
 90             if(rs.next()){
 91                 T t = clazz.newInstance();
 92                 //给 t 对象的相应属性赋值
 93                 for(int i = 0;i < columnCount;i++){
 94                     Object columnVal = rs.getObject(i + 1);
 95                     String columnLabel = rsmd.getColumnLabel(i + 1);
 96                     PropertyUtils.setProperty(t, columnLabel, columnVal);
 97                 }
 98                 return t;
 99             }
100         }catch(Exception e){
101             e.printStackTrace();
102         }finally{
103             JDBCUtils.close(rs, ps, null);
104         }
105         //System.out.println(clazz);
106         return null;
107     }
108 
109     //通用的增删改的操作
110     public void update(Connection conn,String sql,Object ... args){
111         PreparedStatement ps = null;
112         try{
113             ps = conn.prepareStatement(sql);
114             for(int i = 0;i < args.length;i++){
115                 ps.setObject(i + 1, args[i]);
116             }
117             ps.executeUpdate();
118         }catch(Exception e){
119             e.printStackTrace();
120         }finally{
121             JDBCUtils.close(null, ps, null);
122         }
123     }
124 }

View Code

Customer.java

 1 //CustomerDAO 类是用来操作 Customer 类的
 2 public class CustomerDAO extends DAO<Customer>{
 3 
 4     // @Test
 5     // public void testGeneric(){
 6         // Class clazz = CustomerDAO.class;
 7         // Type type = clazz.getGenericSuperclass();
 8         // ParameterizedType p = (ParameterizedType)type;
 9         // Type[] ts = p.getActualTypeArguments();
10         // System.out.println(ts[0]);
11     // }
12 
13     /**
14     * 获取对应的表中的记录的个数
15     */
16     public long getCount(Connection conn){
17         String sql = "select count(*) from customers";
18         return (long)getValue(conn, sql);
19     }
20 
21     /**
22     * 返回 customers 表中的所有数据
23     * @param conn
24     * @return
25     */
26     public List<Customer> getAll(Connection conn){
27         String sql = "select id,name,email,birth from customers";
28         return getForList(conn, sql);
29     }
30 
31     /**
32     * 根据指定的 id 返回相应的对象
33     * @param conn
34     * @param customerId
35     */
36     public Customer getInstance(Connection conn,int customerId){
37         String sql = "select id,name,email,birth from customers where id = ?";
38         return get(conn, sql, customerId);
39     }
40 
41     /**
42     * 删除指定 customerId 的数据表中的记录
43     * @param conn
44     * @param customerId
45     */
46     public void delete(Connection conn,int customerId){
47         String sql = "delete from customers where id = ?";
48         update(conn, sql, customerId);
49     }
50 
51     /**
52     * 向数据表中修改指定 id 的信息为 Customer 对象的信息
53     * @param conn
54     * @param cust
55     */
56     public void update(Connection conn,Customer cust){
57         String sql = "update customers set name = ?,email = ?,birth = ? where id = ?";
58         update(conn, sql,cust.getName(),cust.getEmail(),cust.getBirth(),cust.getId());
59     }
60 
61     /**
62     * 向数据表中插入一条数据
63     * @param conn 数据库的连接
64     * @param cust 要插入的 Customer 对象
65     */
66     public void insert(Connection conn,Customer cust){
67         String sql = "insert into customers(name,email,birth)values(?,?,?)";
68         update(conn, sql, cust.getName(),cust.getEmail(),cust.getBirth());
69     }
70 }

View Code

TestCustomer.java

 1 public class TestCustomerDAO {
 2     CustomerDAO customerDAO = new CustomerDAO();
 3 
 4     @Test
 5     public void testGetCount(){
 6         Connection conn = null;
 7         try{
 8             conn = JDBCUtils.getConnection();
 9             long count = customerDAO.getCount(conn);
10             System.out.println(count);
11         }catch(Exception e){
12             e.printStackTrace();
13         }finally{
14             JDBCUtils.close(null, null, conn);
15         }
16     }
17 
18     @Test
19     public void testGetAll(){
20         Connection conn = null;
21         try{
22             conn = JDBCUtils.getConnection();
23             List<Customer> list = customerDAO.getAll(conn);
24             //System.out.println(list);
25             Iterator<Customer> iterator = list.iterator();
26             while(iterator.hasNext()){
27                 System.out.println(iterator.next());
28             }
29         }catch(Exception e){
30             e.printStackTrace();
31         }finally{
32             JDBCUtils.close(null, null, conn);
33         }
34     }
35 
36     @Test
37     public void testQuery(){
38         Connection conn = null;
39         try{
40             conn = JDBCUtils.getConnection();
41             Customer cust = customerDAO.getInstance(conn, 13);
42             System.out.println(cust);
43         }catch(Exception e){
44             e.printStackTrace();
45         }finally{
46             JDBCUtils.close(null, null, conn);
47         }
48     }
49 
50     @Test
51     public void testDelete(){
52         Connection conn = null;
53         try{
54             conn = JDBCUtils.getConnection();
55             customerDAO.delete(conn, 10);
56         }catch(Exception e){
57             e.printStackTrace();
58         }finally{
59             JDBCUtils.close(null, null, conn);
60         }
61     }
62 
63     @Test
64     public void testUpdate(){
65         Connection conn = null;
66         try{
67             conn = JDBCUtils.getConnection();
68             Customer cust = new Customer(10, "张卫健", "zwj@gmail.com",new
69             Date(new java.util.Date().getTime()));
70             customerDAO.update(conn, cust);
71         }catch(Exception e){
72             e.printStackTrace();
73         }finally{
74             JDBCUtils.close(null, null, conn);
75         }
76     }
77 
78     @Test
79     public void testInsert(){
80         Connection conn = null;
81         try{
82             conn = JDBCUtils.getConnection();
83             Customer cust = new Customer(10, "张卫健", "zwj@gmail.com",new
84             Date(new java.util.Date().getTime()));
85             customerDAO.insert(conn, cust);
86         }catch(Exception e){
87             e.printStackTrace();
88         }finally{
89             JDBCUtils.close(null, null, conn);
90         }
91     }
92 }

View Code

八、数据库连接池

C3P0 数据库连接池

 1 // 保证在所有的通过 C3P0 获取的连接中，只有一个 DataSource 的对象。（推荐）
 2 private static DataSource source = null;
 3 
 4 static {
 5     source = new ComboPooledDataSource("helloc3p0");
 6 }
 7 // 获取数据库的连接方式 3:使用 c3p0 数据库连接池获取数据库的连接,使用配置文件
 8 public static Connection getConnection3() throws Exception {
 9     return source.getConnection();
10 }

View Code

对应的配置文件： c3p0-config.xml

 1 <c3p0-config>
 2 <named-config name="helloc3p0">
 3 <!-- 提供数据库连接的 4 个基本信息 -->
 4 <property name="jdbcUrl">jdbc:mysql:///test</property>
 5 <property name="driverClass">com.mysql.jdbc.Driver</property>
 6 <property name="user">root</property>
 7 <property name="password">123456</property>
 8 <!-- 当连接池中的数量不足时， c3p0 连接一次性向数据库服务器申请的
 9 连接数 -->
10 <property name="acquireIncrement">5</property>
11 <!-- 初始化数据库连接池时，池中存在的连接数 -->
12 <property name="initialPoolSize">10</property>
13 <!-- 数据库连接池中最少容纳的连接数 -->
14 <property name="minPoolSize">5</property>
15 <!-- 数据库连接池中最大容纳的连接数 -->
16 <property name="maxPoolSize">100</property>
17 <!-- 连接池中，最多允许存在的 Statement 的数量 -->
18 <property name="maxStatements">10</property>
19 <!-- 一次连接中，最多容纳的 Statement 的个数 -->
20 <property name="maxStatementsPerConnection">5</property>
21 </named-config>
22 </c3p0-config>

View Code

DBCP 数据库连接池

 1 //随着类的加载，使用 BasicDataSourceFactory 的静态方法 createDataSource()返回一个
 2 //DataSource 的对象
 3 private static DataSource source1 = null;
 4 static {
 5     Properties info = new Properties();
 6     // info.load(new FileInputStream("dbcp.properties"));
 7     InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream(
 8     "com/atguigu/java/dbcp.properties");
 9     try {
10         info.load(is);
11         source1 = BasicDataSourceFactory.createDataSource(info);
12     } catch (Exception e) {
13         e.printStackTrace();
14     }
15 }
16 // 获取数据库的连接方式 4:使用 DBCP 数据库连接池获取数据库的连接（推荐）
17 public static Connection getConnection5() throws Exception {
18     return source1.getConnection();
19 }

View Code

配置文件 dbcp.properties：

1 username=root
2 password=123456
3 url=jdbc:mysql://127.0.0.1:3306/test
4 driverClassName=com.mysql.jdbc.Driver
5 initialSize=10
6 maxActive=100

View Code

九、 DBUtils
提供了 QueryRunner 类，类中有诸多重载 update() 和 query()方法，供使用，用于堆数据库实现操作：增删改查

一些细节问题：

1.设计数据库时候，要考虑编码问题，要主要，创建数据库编码方式和创建表的方式以及java程序运行的编码方式一致，不然会报错，或者导致数据存入到数据库中出现乱码。

2.关于JDBC实现数据库连接时，对日期对象的处理方式：

 1 public class DateTest {
 2 
 3     /**
 4      * @param args
 5      * @throws SQLException
 6      */
 7     public static void main(String[] args) throws SQLException {
 8         // create("name2", new Date(), 500.0f);
 9         Date d = read(7);
10         System.out.println(d);
11     }
12 
13     static Date read(int id) throws SQLException {
14         Connection conn = null;
15         Statement st = null;
16         ResultSet rs = null;
17         Date birthday = null;
18         try {
19             // 2.建立连接
20             conn = JdbcUtils.getConnection();
21             // conn = JdbcUtilsSing.getInstance().getConnection();
22             // 3.创建语句
23             st = conn.createStatement();
24 
25             // 4.执行语句
26             rs = st.executeQuery("select birthday  from user where id=" + id);
27 
28             // 5.处理结果
29             while (rs.next()) {
30                 //birthday = new Date(rs.getDate("birthday").getTime());
31                 birthday = rs.getDate("birthday");
32             }
33         } finally {
34             JdbcUtils.free(rs, st, conn);
35         }
36         return birthday;
37     }
38 
39     static void create(String name, Date birthday, float money)
40             throws SQLException {
41         Connection conn = null;
42         PreparedStatement ps = null;
43         ResultSet rs = null;
44         try {
45             // 2.建立连接
46             conn = JdbcUtils.getConnection();
47             // conn = JdbcUtilsSing.getInstance().getConnection();
48             // 3.创建语句
49             String sql = "insert into user(name,birthday, money) values (?, ?, ?) ";
50             ps = conn.prepareStatement(sql);
51             ps.setString(1, name);
52             ps.setDate(2, new java.sql.Date(birthday.getTime()));
53             ps.setFloat(3, money);
54 
55             // 4.执行语句
56             int i = ps.executeUpdate();
57 
58             System.out.println("i=" + i);
59         } finally {
60             JdbcUtils.free(rs, ps, conn);
61         }
62     }
63 }

View Code

查看全文

相关阅读:
驱动
 设备编号
 makefile 中的赋值
 UART
c 语言的复杂声明
 linux下arm汇编的常用指令解析
 linux下的arm汇编程序
 ok6410下的uboot分析与实现
 层级选择器的理解
 css外部样式的理解

原文地址：https://www.cnblogs.com/ckysea/p/4603753.html