jdbc mysql应用

首先注册驱动，驱动注册一边即可，将代码封装在一个类里面

1. /*我们每次连接数据库都要注册驱动，并且注册驱动只要一次即可，如果用一次注册一次岂不是相当的麻烦，那 
2.  * 我们为何不把他写入一个类，只要程序一掉用此类，就自动注册驱动，static{}块是在程序中只要调用此类， 
3.  * static块就会自动执行的代码块， 
4. 并且只会执行一次*/  
5.   
6. import java.sql.Connection;  
7. import java.sql.DriverManager;  
8. import java.sql.ResultSet;  
9. import java.sql.SQLException;  
10. import java.sql.Statement;  
11.   
12.   
13. public class Util {  
14.   
15.     static String url="jdbc:mysql://127.0.0.1:3306/mydata";         //注册驱动  
16.     static String user="root";                                      //输入用户与密码  
17.     static String pass="1";  
18.       
19.       
20.     static{                                                     //一旦程序调用了此类，此段代码便会自动执行  
21.         try {  
22.             Class.forName("com.mysql.jdbc.Driver");  
23.         } catch (ClassNotFoundException e) {  
24.             // TODO Auto-generated catch block  
25.             e.printStackTrace();  
26.         }  
27.     }  
28.       
29.       
30.     public static Connection getConn() throws SQLException      //返回一个Connection对象，方便数据的插入  
31.     {  
32.         return DriverManager.getConnection(url, user, pass);    
33.     }  
34.       
35.       
36.     public static void free(Statement st,Connection conn)       //等sql语句执行完毕，关闭连接  
37.     {  
38.          if(st!=null)  
39.             try {  
40.                 st.close();  
41.             } catch (SQLException e) {  
42.                 // TODO Auto-generated catch block  
43.                 e.printStackTrace();  
44.             }  
45.            finally{                         //如果前面抛异常，conn照样可以关闭  
46.                if(conn!=null)  
47.                 try {  
48.                     conn.close();  
49.                 } catch (SQLException e) {  
50.                     // TODO Auto-generated catch block  
51.                     e.printStackTrace();  
52.                 }  
53.            }  
54.           
55.         /*st.close(); 
56.         conn.close();*/  
57.     }  
58.       
59.     public static void free(ResultSet rs,Statement st,Connection conn)  
60.     {  
61.         if(rs!=null)  
62.             try {  
63.                 rs.close();  
64.             } catch (SQLException e) {  
65.                 // TODO Auto-generated catch block  
66.                 e.printStackTrace();  
67.             }  
68.         free(st,conn);  
69.     }  
70. }  

将mysql里的student表封装成一个对象

Java代码  

1. //将要插入的数据封装成一个对象，并且生成每个属性的get和set方法  
2.   
3.   
4. public class Student {  
5.  private int id;  
6.  private String name;  
7.  private int age;  
8.    
9.  public Student(int id){  
10.      this.id=id;  
11.  }  
12.    
13.  public Student(int id,String name,int age)  
14.  {  
15.      this.id=id;  
16.      this.name=name;  
17.      this.age=age;  
18.  }  
19. public int getId() {  
20.     return id;  
21. }  
22. public void setId(int id) {  
23.     this.id = id;  
24. }  
25. public String getName() {  
26.     return name;  
27. }  
28. public void setName(String name) {  
29.     this.name = name;  
30. }  
31. public int getAge() {  
32.     return age;  
33. }  
34. public void setAge(int age) {  
35.     this.age = age;  
36. }  
37.    
38. }  

建立一个类用来写mysql的语句

Java代码  

1. /*此类里面写的是sql语句，当外部调用此类的方法的时候，不用再去写sql语句， 
2. 因为内部已经将sql语句写好，不需要知道内部的具体实现*/  
3.   
4.   
5. import java.sql.Connection;  
6. import java.sql.PreparedStatement;  
7. import java.sql.ResultSet;  
8. import java.sql.SQLException;  
9.   
10. import javax.naming.spi.DirStateFactory.Result;  
11.   
12.   
13. public class StuDao {  
14.   
15.     public void insert(Student s)           //插入语句  
16.     {  
17.         try {  
18.             Connection conn=Util.getConn();  
19.               
20.             /*在此用到了一个preparedStatement是Statement的一个子类，它比Statement更方便一些，在Statement的execteUpdate 
21.             方法中，传递的参数只能是sql语句，就算是一样的要修改数据不一样而其他一样的几句话也必须将代码全部写出 
22.             例如：String sql="insert into student(id,name,age)values(1,zhangsan,11)"; 
23.             String sql="insert into student(id,name,age)values(2,lisi,12)"; 
24.             String sql="insert into student(id,name,age)values(3,wangwu,13)"; 
25.             但是，PreparedStatement使用起来更加方便，它允许传递一个未知量————?,它的setInt等方法有两个参数 
26.             第一个是参数的意思是第几个?,第二个参数是修改的值*/  
27.               
28.             String sql="insert into student(id,name,age)values(?,?,?)";  
29.             PreparedStatement st=conn.prepareStatement(sql);  
30.             st.setInt(1, s.getId());  
31.             st.setString(2, s.getName());  
32.             st.setInt(3, s.getAge());  
33.             int i=st.executeUpdate();  
34.               
35.             Util.free(st, conn);  
36.               
37.               
38.         } catch (SQLException e) {  
39.             // TODO Auto-generated catch block  
40.             e.printStackTrace();  
41.         }  
42.           
43.     }  
44.       
45.     public void update(Student s)           //修改语句  
46.     {  
47.         try {  
48.             Connection conn=Util.getConn();  
49.               
50.             String sql="update student set name=?,age=? where id=?";  
51.             PreparedStatement st=conn.prepareStatement(sql);  
52.               
53.             st.setString(1, s.getName());  
54.             st.setInt(2, s.getAge());  
55.             st.setInt(3, s.getId());  
56.             int i=st.executeUpdate();  
57.               
58.             Util.free(st, conn);  
59.               
60.               
61.         } catch (SQLException e) {  
62.             // TODO Auto-generated catch block  
63.             e.printStackTrace();  
64.         }  
65.           
66.     }  
67.       
68.     public void delete(Student s){          //删除语句  
69.         try {  
70.             Connection conn = Util.getConn();  
71.               
72.             String sql="delete from student where id =?";  
73.             PreparedStatement st = conn.prepareStatement(sql);  
74.               
75.             st.setInt(1, s.getId());  
76.               
77.             int i=st.executeUpdate();  
78.               
79.             Util.free(st, conn);  
80.         } catch (SQLException e) {  
81.             // TODO Auto-generated catch block  
82.             e.printStackTrace();  
83.         }  
84.     }  
85.       
86.     public void select1(Student s){         //查询语句  
87.         try {  
88.             Connection conn = Util.getConn();  
89.               
90.             String sql = "select * from student where id=?";  
91.               
92.             PreparedStatement st = conn.prepareStatement(sql);  
93.             st.setInt(1, s.getId());  
94.               
95.             ResultSet rs = st.executeQuery();  
96.             while(rs.next()){  
97.                 System.out.println(rs.getInt(1)+" "+rs.getString(2)+" "+rs.getInt(3));  
98.             }  
99.             Util.free(st, conn);  
100.         } catch (SQLException e) {  
101.             // TODO Auto-generated catch block  
102.             e.printStackTrace();  
103.         }  
104.     }  
105.       
106. }  

测试类

Java代码  

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.sql.Statement;  
7.   
8.   
9. public class TestConnection {  
10.   
11.       
12.     public static void main(String[] args) {  
13.         // TODO Auto-generated method stub  
14.   
15.         Student s=new Student(4);  
16.         StuDao dao=new StuDao();  
17.         dao.select1(s);  
18.     }  
19.   
20. }