MySQL之JDBC插入、修改、删除封装集于一个方法

1、先建四个包

　　① com.tz.entity 实体包

　　② com.tz.dao 数据访问层包

　　　　-> com.tz.dao.impl 实现包

　　③ com.tz.util 工具类包

　　④ com.tz.test 测试包

com.tz.entity 实体包

　　新建 Student 实体类

 1 package com.tz.entity;
 2 
 3 
 4 public class Student{
 5     private int id;
 6     private String name;
 7     private String sex;
 8     private String pwd;
 9     private String address;
10     public Student() {
11     }
12     public Student(int id, String name, String sex, String pwd, String address) {
13         this.id = id;
14         this.name = name;
15         this.sex = sex;
16         this.pwd = pwd;
17         this.address = address;
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 String getSex() {
32         return sex;
33     }
34     public void setSex(String sex) {
35         this.sex = sex;
36     }
37     public String getPwd() {
38         return pwd;
39     }
40     public void setPwd(String pwd) {
41         this.pwd = pwd;
42     }
43     public String getAddress() {
44         return address;
45     }
46     public void setAddress(String address) {
47         this.address = address;
48     }
//
49     public String toString() {
50         return "Student [id=" + id + ", name=" + name + ", sex=" + sex
51                 + ", pwd=" + pwd + ", address=" + address + "]";
52     }
53     
54 }

com.tz.dao 数据访问层包

　　新建StudentDao 接口

 1 package com.tz.dao;
 2 
 3 import com.tz.entity.Student;
 4 
 5 /**
 6  * 规范 方法名 
 7  * 方法有几个，要做哪些方法
 8  */
 9 public interface StudentDao {
10     // 增加一个学生
11     void addStudent(Student s);
12     // 删除一个学生
13     int deleteStudent(int id);
14     // 修改一个学生
15     Student updateStudent(Student s);
16     // 查询学生
17     Student findById(int id);
18 }

　　新建BaseDao 类

 1 package com.tz.dao;
 2 
 3 import java.sql.Connection;
 4 import java.sql.PreparedStatement;
 5 import java.sql.ResultSet;
 6 
 7 import com.tz.util.DBUtil;
 8 
 9 /**
10  * 做所有dao的父类，封装他们基本的增删改操作，
11  * 因为所有的Dao的增删改操作都一样。
12  * 只是换了 不同的 sql语句和传入的参数。
13  */
14 public class BaseDao {
15     private Connection conn;
16     private PreparedStatement ps;
17     private ResultSet rs;
18     /**
19      * 封装 任何增删改
20      * sql 传入方法的Sql语句
21      * Object[] Sql语句里面的参数，因为参数的类型不同 所以Object
22      */
23     public int toUpdate(String sql,Object[] obs){
24         int a=0;
25         try {
26             conn=DBUtil.getConn();
27             ps=conn.prepareStatement(sql);
28             // 循环 赋值参数
29             if(obs!=null&&obs.length>0){
30                 for(int i=0;i<obs.length;i++){
31                     ps.setObject(i+1, obs[i]);
32                 }
33             }
34             a=ps.executeUpdate();
35             return a;
36         } catch (Exception e) {
37             e.printStackTrace();
38         }finally{
39             DBUtil.closeConn(conn, ps, rs);
40         }
41         return a;
42     }
43 }

com.tz.dao 数据访问层

　　　　-> com.tz.dao.impl 实现包

　　　　新建StudentDaoImpl 类

 1 package com.tz.dao.impl;
 2 
 3 import java.sql.Connection;
 4 import java.sql.PreparedStatement;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7 
 8 
 9 
10 import com.tz.dao.BaseDao;
11 import com.tz.dao.StudentDao;
12 import com.tz.entity.Student;
13 import com.tz.util.DBUtil;
14 /**
15  * StudentDao的实现
16  * Java是单继承的  只能继承一个父类
17  * 但是可以实现多个接口
18  * 写 先继承后实现
19  */
20 public class StudentDaoImpl extends BaseDao  implements StudentDao{
21     // 连接组件
22     private Connection conn;
23     // 得到预编译的发送Sql语句的组件
24     private PreparedStatement ps;
25     // 处理结果集的组件
26     private ResultSet rs;
27     public void addStudent(Student s) {
28          String sql="insert into student(sid,sname,pwd,sex,address) values(?,?,?,?,?)";
29          Object[] obs={s.getId(),s.getName(),s.getPwd(),s.getSex(),s.getAddress()};
30          toUpdate(sql, obs);
31     }
32 
33     public int deleteStudent(int id) {
34         String sql="delete from student where sid=?";
35         Object[] obs={id};
36         int a=toUpdate(sql, obs);
37         return a;
38     }
39 
40     public Student updateStudent(Student s) {
41         String sql="update student set sname=?,pwd=?,sex=?,address=? where sid=?";
42         Object[] obs={s.getName(),s.getPwd(),s.getSex(),s.getAddress(),s.getId()};
43         toUpdate(sql, obs);
44         Student student=findById(s.getId());
45         return student;
46     }
47 
48     public Student findById(int id) {
49         Student s=new Student();
50         try {
51             conn=DBUtil.getConn();
52             String sql="select * from student where sid=?";
53             ps=conn.prepareStatement(sql);
54             ps.setObject(1, id);
55             // 会返回一个int值 表示 你影响了 几行数据
56             rs=ps.executeQuery();
57             while(rs.next()){
58                 s.setId(rs.getInt("sid"));
59                 s.setName(rs.getString("sname"));
60                 s.setPwd(rs.getString("pwd"));
61                 s.setAddress(rs.getString("address"));
62                 s.setSex(rs.getString("sex"));
63             }
64             return s;
65         } catch (SQLException e) {
66             e.printStackTrace();
67         }finally{
68             DBUtil.closeConn(conn, ps, rs);
69         }
70         return s;
71     }
72 
73 }

com.tz.util 工具类包

　　新建 db.properties 配置文件

1 #Mysql JDBC的连接配置
2 driver=com.mysql.jdbc.Driver
3 url=jdbc:mysql://localhost:3306/tz
4 username=root
5 pwd=root123

　　新建 DBUtil.java 类

 1 package com.tz.util;
 2 
 3 import java.io.InputStream;
 4 import java.sql.Connection;
 5 import java.sql.DriverManager;
 6 import java.sql.PreparedStatement;
 7 import java.sql.ResultSet;
 8 import java.sql.SQLException;
 9 import java.util.Properties;
10 
11 
12 /**
13  * DBUtil负责得到数据库的连接
14  * 做成一个工具类(如果是工具类 一般不会实例化new)
15  * 工具方法 一般会做成静态方法
16  */
17 public class DBUtil {
18     private static String driver;
19     private static String url;
20     private static String username;
21     private static String pwd;
22     // static可以写静态的代码块
23     static{
24         // 实例化 属性集
25         Properties p=new Properties();
26         // 从本类的字节码文件中根据路径得到一个输入流
27         InputStream is=DBUtil.class.getClassLoader()
28                 .getResourceAsStream("com/tz/util/db.properties");
29         try {
30             // 属性集 去加载输入流
31             p.load(is);
32             driver=p.getProperty("driver");
33             url=p.getProperty("url");
34             username=p.getProperty("username");
35             pwd=p.getProperty("pwd");
36             // 记载驱动
37             Class.forName(driver);
38         } catch (Exception e) {
39             e.printStackTrace();
40         }
41     }
42     
43     // 封装一个得到 Connection的方法
44     public static Connection getConn() throws SQLException{
45         return DriverManager.getConnection(url, username, pwd);
46     }
47     // 封装一个关闭连接的方法
48     public static void closeConn(Connection conn,PreparedStatement ps,ResultSet rs){
49         if(conn!=null){
50             try {
51                 conn.close();
52             } catch (SQLException e) {
53                 e.printStackTrace();
54             }
55         }
56         if(ps!=null){
57             try {
58                 ps.close();
59             } catch (SQLException e) {
60                 e.printStackTrace();
61             }
62         }
63         if(rs!=null){
64             try {
65                 rs.close();
66             } catch (SQLException e) {
67                 e.printStackTrace();
68             }
69         }
70     }
71 }

com.tz.test 测试包

 1 package com.tz.test;
 2 
 3 import org.junit.Test;
 4 
 5 import com.tz.dao.StudentDao;
 6 import com.tz.dao.impl.StudentDaoImpl;
 7 import com.tz.entity.Student;
 8 
 9 public class TestStudentDao {
10     @Test
11     public void testadd(){
12         // 向上造型 
13         StudentDao dao=new StudentDaoImpl();
14         Student s=new Student(1010,"刘能","男","123","铁岭象牙山");
15         dao.addStudent(s);
16     }
17     @Test
18     public void testdelete(){
19         StudentDao dao=new StudentDaoImpl();
20         int a=dao.deleteStudent(1010);
21         System.out.println(a);
22     }
23     @Test
24     public void testupdate(){
25         StudentDao dao=new StudentDaoImpl();
26         Student s=new Student(1010,"刘德华","男","123","中国香港");
27         Student st=dao.updateStudent(s);
28         System.out.println(st);
29     }
30     @Test
31     public void testfindByid(){
32         StudentDao dao=new StudentDaoImpl();
33         Student st=dao.findById(1010);
34         System.out.println(st);
35     }
36     
37     
38 }