JDBC操做步骤及数据库链接操做

1、JDBC操做步骤

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

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

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

4.关闭数据库链接：数据库操做完毕以后须要关闭链接以释放资源。

 

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

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

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

 

3、加载驱动

 

[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. }  

4、链接及关闭数据库

 

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

5、数据库操做

 

1.Statement接口

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

 

No.	方法	类型	描述
1	Int executeUpdate(String sql)throws SQLException	普通	执行数据库更新的SQL语句，例如：INSERT、UPDATE、DELETE等语句，返回更新的记录数
2	ResultSet executeQuery(String sql)throws SQLException	普通	执行数据库查询操做，返回一个结果集对象
3	void addBatch(String sql)throws SQLException	普通	增长一个待执行的SQL语句
4	int[] executeBatch()throws SQLException	普通	批量执行SQL语句
5	void close()throws SQLException	普通	关闭Statement操做
6	Boolean execute(String sql)throws SQLException	普通	执行SQL语句

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

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",由于这样在查询的时候并不能明确的表示要取的内容是什么，因此开发中查询时确定要明确地写出须要查找的列。