一、JDBC操作步骤

1.加载数据库驱动程序：各个数据库都会提供JDBC的驱动程序开发包，直接把JDBC操作所需要的开发包（一般为*.jar或*.zip）直接配置到classpath路径即可。

2.连接数据库：根据各个数据库的不同连接的地址也不同，此连接地址将由数据库厂商提供，一般在使用JDBC连接数据库的时候都要求用户输入数据库连接的用户名和密码，用户在取得连接之后才可以对数据库进行查询或更新的操作。

3.使用语句进行数据库操作：数据库操作分为更新和查询两种操作，除了可以使用标准的SQL语句之外，对于各个数据库也可以使用其自己提供的各种命令。

4.关闭数据库连接：数据库操作完毕之后需要关闭连接以释放资源。

二、配置数据库的驱动程序

1.下载驱动：http://www.mysql.com/downloads/connector/j/

2.配置环境变量：在classpath中添加驱动路径（例如我的路径是D:\mysql-connector-java-5.1.21-bin.jar;);

三、加载驱动

[java] view plain copy

1. public class connector {
2. public static final String DBDRIVER = "org.gjt.mm.mysql.Driver";   //定义MySQL数据库驱动程序
3. public static void main(String[] args) {
4. try {
5. Class.forName(DBDRIVER); //加载驱动程序
6. } catch (ClassNotFoundException e) {
7. e.printStackTrace();
8. }
9. }
10. }

四、连接及关闭数据库

1.使用DriverManager类进行连接操作，DriverManager类的常用方法：

(1)通过连接地址连接数据库

public static Connection getConnection(String url) throws SQLException

(2)通过连接地址连接数据库同时输入用户名和密码

public static Connection getConnection(String url, String user, String password) throws SQLException

2.DriverManager说明：

(1)在DriverManager中，提供的主要操作是得到一个数据库的连接，getConnection()方法就是取得连接对象，此方法返回的类型是Connection对象，不管使用那种方式连接，都必须提供一个数据库的连接地址，如果在连接数据库的时候需要用户名和密码，则还需要将用户名和密码设置上。MySQL数据库的连接地址格式如下：jdbc:mysql://IP地址:端口号/数据库名称

(2)数据库连接地址的形式由三部分组成：

a.jdbc协议：JDBC URL中的协议总是jdbc；

b.子协议：驱动程序名和数据库连接机制（这种机制可由一个或多个驱动程序支持）的名称，例如:mysql;

c.子名称：一种标识数据库的方法。必须遵循"/主机名:端口/子协议"的标准URL命名约定，例如：//localhost:3306/Joywy.

3.Connection

通过DriverManager取得Connection对象之后，实际上就表示数据库连接上了，连接上数据库之后就可以进行数据库的更新及查询操作，但是操作的最后数据库的连接必须关闭。

连接数据库代码如下：

[java] view plain copy

1. import java.sql.Connection;
2. import java.sql.DriverManager;
3. import java.sql.SQLException;
4. public class ConnectionDemo{
5. //定义MySQL驱动程序
6. public static final String DBDRIVER = "org.gjt.mm.mysql.Driver";
7. //定义MySQL数据库的连接地址
8. public static final String DBURL = "jdbc:mysql://localhost:3306/xiaowei";
9. //MySQL数据库的连接用户名
10. public static final String DBUSER = "root";
11. //MySQL数据库的连接密码
12. public static final String DBPASS = "android";
13. public static void main(String[] args){
14. //数据库连接
15. Connection con = null;
16. try{
17. //加载驱动
18. Class.forName(DBDRIVER);
19. }catch(ClassNotFoundException e){
20. e.printStackTrace();
21. }
22. try{
23. con = DriverManager.getConnection(DBURL, DBUSER, DBPASS);
24. }catch(SQLException e){
25. e.printStackTrace();
26. }
27. System.out.println(con);
28. try{
29. //数据库关闭
30. con.close();
31. }catch(SQLException e){
32. e.printStackTrace();
33. }
34. }
35. }

五、数据库操作

1.Statement接口

此接口通过使用Connection接口中的createStatement()方法实例化，此接口定义了一下方法：

2.ResultSet接口

使用SQL中的SELECT语句可以将数据库的全部结果查询出来，在JDBC的操作中数据库的所有查询记录将使用ResultSet进行接收，并使用ResultSet显示内容。

3.PreparedStatement接口

PreparedStatement接口是Statement的子接口，属于预处理操作，与直接使用Statement不同的是，PreparedStatement在操作时，是先在数据表之中准备好一条SQL语句，但是此SQL语句的具体内容暂时不设置，而是之后再进行设置，以插入数据为例，使用PreparedStatement插入数据时，数据表中的指针首先指向最后一条数据之后，但是里面的内容是不知道的，而是等待用户分别设置的。

注意：设置日期格式的问题，在PreparedStatement中定义了setData(),此方法可以设置日期内容，但是此方法使用时，后面的Data类型变量是java.sql.Data,而不是java.util.Data,所以如果要想将一个java.util.Data类型的内容变为java.sql.Date类型的内容应该使用如下的语句形式：

[java] view plain copy

1. String birthday = "2007-08-27"        //生日
2. java.util.Date temp = null;         //声明一个Date对象
3. //通过SimpleDataFormat类将一个字符串变为java.util.Date类型
4. temp = new SimpleDataFormat("yyyy-MM-dd").parse(birthday);
5. //通过java.util.Data取出具体的日期数，并将其变为java.sql.Data类型
6. java.sql.Data bir = new java.sql.Data(temp.getTime());

代码如下：

DBHelper.java

[java] view plain copy

1. import java.sql.Connection;
2. import java.sql.DriverManager;
3. import java.sql.PreparedStatement;
4. import java.sql.ResultSet;
5. import java.sql.SQLException;
6. import java.util.ArrayList;
7. import java.util.List;
8. public class DBHelper {
9. public static final String DBDRIVER = "com.mysql.jdbc.Driver";
10. public static final String DBURL = "jdbc:mysql://localhost:3306/test";
11. public static final String DBUSER = "root";
12. public static final String DBPASS = "1111";
13. public static Connection getConnection(){
14. Connection conn = null;
15. try {
16. Class.forName(DBDRIVER);
17. conn = DriverManager.getConnection(DBURL, DBUSER, DBPASS);
18. } catch (Exception e) {
19. e.printStackTrace();
20. }
21. return conn;
22. }
23. public static void save(){
24. Connection con = getConnection();
25. String sql = "insert into Info values(?, ?, ?)";
26. PreparedStatement psmt = null;
27. try {
28. psmt = con.prepareStatement(sql);
29. psmt.setString(1, "123");
30. psmt.setString(2, "12");
31. psmt.setInt(3, 3);
32. int count = psmt.executeUpdate();
33. } catch (Exception e) {
34. e.printStackTrace();
35. }finally{
36. if(psmt != null){
37. try {
38. psmt.close();
39. } catch (SQLException e) {
40. e.printStackTrace();
41. }
42. }
43. if(con != null){
44. try {
45. con.close();
46. } catch (SQLException e) {
47. e.printStackTrace();
48. }
49. }
50. }
51. }
52. public static void delete(){
53. Connection con = getConnection();
54. String sql = "delete from Info where id=?";
55. PreparedStatement psmt = null;
56. try {
57. psmt = con.prepareStatement(sql);
58. psmt.setString(1, "10330070");
59. int count = psmt.executeUpdate();
60. } catch (Exception e) {
61. e.printStackTrace();
62. }finally{
63. if(psmt != null){
64. try {
65. psmt.close();
66. } catch (SQLException e) {
67. // TODO Auto-generated catch block
68. e.printStackTrace();
69. }
70. }
71. if(con != null){
72. try {
73. con.close();
74. } catch (SQLException e) {
75. // TODO Auto-generated catch block
76. e.printStackTrace();
77. }
78. }
79. }
80. }
81. public static void update(){
82. Connection con = getConnection();
83. String sql = "update Info set age = ? where id = ?";
84. PreparedStatement psmt = null;
85. try {
86. psmt = con.prepareStatement(sql);
87. psmt.setInt(1, 22);
88. psmt.setString(2, "111313");
89. int count = psmt.executeUpdate();
90. } catch (Exception e) {
91. e.printStackTrace();
92. }finally{
93. if(psmt != null){
94. try {
95. psmt.close();
96. } catch (SQLException e) {
97. e.printStackTrace();
98. }
99. }
100. if(con != null){
101. try {
102. con.close();
103. } catch (SQLException e) {
104. e.printStackTrace();
105. }
106. }
107. }
108. }
109. public static List<Info> query(){
110. List<Info> list = new ArrayList<Info>();
111. Connection con = getConnection();
112. String sql = "select * from Info";
113. PreparedStatement psmt = null;
114. ResultSet rs = null;
115. try {
116. psmt = con.prepareStatement(sql);
117. rs = psmt.executeQuery();
118. while(rs.next()){    //依次取出数据
119. Info info = new Info();
120. info.setId(rs.getString("id"));
121. info.setPass(rs.getString("pass"));
122. info.setAge(rs.getInt("age"));
123. System.out.println(info.getId() +"\t" + info.getPass() + "\t" + info.getAge());
124. list.add(info);
125. }
126. } catch (Exception e) {
127. e.printStackTrace();
128. }finally{
129. if(rs != null){
130. try {
131. rs.close();
132. } catch (SQLException e) {
133. e.printStackTrace();
134. }
135. }
136. if(psmt != null){
137. try {
138. psmt.close();
139. } catch (SQLException e) {
140. e.printStackTrace();
141. }
142. }
143. if(con != null){
144. try {
145. con.close();
146. } catch (SQLException e) {
147. e.printStackTrace();
148. }
149. }
150. }
151. return list;
152. }
153. public static void main(String[] args){
154. System.out.println(query().get(0).getAge());
155. }
156. }

Info.java

[java] view plain copy

1. public class Info {
2. private String id;
3. private String pass;
4. private int age;
5. public String getId() {
6. return id;
7. }
8. public void setId(String id) {
9. this.id = id;
10. }
11. public String getPass() {
12. return pass;
13. }
14. public void setPass(String pass) {
15. this.pass = pass;
16. }
17. public int getAge() {
18. return age;
19. }
20. public void setAge(int age) {
21. this.age = age;
22. }
23. }

注：

(1)一般来说，我会习惯使用PreparedStatement对数据库进行操作。PreparedStatement是预编译方式的，在执行SQL语句的时候效率就要高一些，还有就是PreparedStatement可以更好地避免SQL注入问题；在拼接sql语句时，采用PreparedStatement可以有效地减少出错的几率；PreparedStatement是Statement的一个子类，理所当然地PreparedStatement对Statement有一定的扩展，在性能方面有一定的提高。

(2)在开发中是不能直接使用"SELECT * FROM user",因为这样在查询的时候并不能明确的表示要取的内容是什么，所以开发中查询时肯定要明确地写出需要查找的列。