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

1、 先建四个包

　　① com.tz.entity 实体包

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

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

　　③ com.tz.util 工具类包

　　④ com.tz.test 测试包

com.tz.entity 实体包

　　新建 Student 实体类

 package com.tz.entity;

 public class Student{
     private int id;
     private String name;
     private String sex;
     private String pwd;
     private String address;
     public Student() {
     }
     public Student(int id, String name, String sex, String pwd, String address) {
         this.id = id;
         this.name = name;
         this.sex = sex;
         this.pwd = pwd;
         this.address = address;
     }
     public int getId() {
         return id;
     }
     public void setId(int id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getSex() {
         return sex;
     }
     public void setSex(String sex) {
         this.sex = sex;
     }
     public String getPwd() {
         return pwd;
     }
     public void setPwd(String pwd) {
         this.pwd = pwd;
     }
     public String getAddress() {
         return address;
     }
     public void setAddress(String address) {
         this.address = address;
     }
//
     public String toString() {
         return "Student [id=" + id + ", name=" + name + ", sex=" + sex
                 + ", pwd=" + pwd + ", address=" + address + "]";
     }

 }

com.tz.dao 数据访问层包

　　新建StudentDao 接口

 package com.tz.dao;

 import com.tz.entity.Student;

 /**
  * 规范 方法名
  * 方法有几个，要做哪些方法
  */
 public interface StudentDao {
     // 增加一个学生
     void addStudent(Student s);
     // 删除一个学生
     int deleteStudent(int id);
     // 修改一个学生
     Student updateStudent(Student s);
     // 查询学生
     Student findById(int id);
 }

　　 新建BaseDao 类

 package com.tz.dao;

 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;

 import com.tz.util.DBUtil;

 /**
  * 做所有dao的父类，封装他们基本的增删改操作，
  * 因为所有的Dao的增删改操作都一样。
  * 只是换了 不同的 sql语句和传入的参数。
  */
 public class BaseDao {
     private Connection conn;
     private PreparedStatement ps;
     private ResultSet rs;
     /**
      * 封装 任何增删改
      * sql 传入方法的Sql语句
      * Object[] Sql语句里面的参数，因为参数的类型不同 所以Object
      */
     public int toUpdate(String sql,Object[] obs){
         int a=0;
         try {
             conn=DBUtil.getConn();
             ps=conn.prepareStatement(sql);
             // 循环 赋值参数
             if(obs!=null&&obs.length>0){
                 for(int i=0;i<obs.length;i++){
                     ps.setObject(i+1, obs[i]);
                 }
             }
             a=ps.executeUpdate();
             return a;
         } catch (Exception e) {
             e.printStackTrace();
         }finally{
             DBUtil.closeConn(conn, ps, rs);
         }
         return a;
     }
 }

com.tz.dao 数据访问层

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

　　　　新建StudentDaoImpl 类

 package com.tz.dao.impl;

 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;

 import com.tz.dao.BaseDao;
 import com.tz.dao.StudentDao;
 import com.tz.entity.Student;
 import com.tz.util.DBUtil;
 /**
  * StudentDao的实现
  * Java是单继承的  只能继承一个父类
  * 但是可以实现多个接口
  * 写 先继承后实现
  */
 public class StudentDaoImpl extends BaseDao  implements StudentDao{
     // 连接组件
     private Connection conn;
     // 得到预编译的发送Sql语句的组件
     private PreparedStatement ps;
     // 处理结果集的组件
     private ResultSet rs;
     public void addStudent(Student s) {
          String sql="insert into student(sid,sname,pwd,sex,address) values(?,?,?,?,?)";
          Object[] obs={s.getId(),s.getName(),s.getPwd(),s.getSex(),s.getAddress()};
          toUpdate(sql, obs);
     }

     public int deleteStudent(int id) {
         String sql="delete from student where sid=?";
         Object[] obs={id};
         int a=toUpdate(sql, obs);
         return a;
     }

     public Student updateStudent(Student s) {
         String sql="update student set sname=?,pwd=?,sex=?,address=? where sid=?";
         Object[] obs={s.getName(),s.getPwd(),s.getSex(),s.getAddress(),s.getId()};
         toUpdate(sql, obs);
         Student student=findById(s.getId());
         return student;
     }

     public Student findById(int id) {
         Student s=new Student();
         try {
             conn=DBUtil.getConn();
             String sql="select * from student where sid=?";
             ps=conn.prepareStatement(sql);
             ps.setObject(1, id);
             // 会返回一个int值 表示 你影响了 几行数据
             rs=ps.executeQuery();
             while(rs.next()){
                 s.setId(rs.getInt("sid"));
                 s.setName(rs.getString("sname"));
                 s.setPwd(rs.getString("pwd"));
                 s.setAddress(rs.getString("address"));
                 s.setSex(rs.getString("sex"));
             }
             return s;
         } catch (SQLException e) {
             e.printStackTrace();
         }finally{
             DBUtil.closeConn(conn, ps, rs);
         }
         return s;
     }

 }

 com.tz.util 工具类包

　　新建 db.properties 配置文件

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

　　新建 DBUtil.java 类

 package com.tz.util;

 import java.io.InputStream;
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Properties;

 /**
  * DBUtil负责得到数据库的连接
  * 做成一个工具类(如果是工具类 一般不会实例化new)
  * 工具方法 一般会做成静态方法
  */
 public class DBUtil {
     private static String driver;
     private static String url;
     private static String username;
     private static String pwd;
     // static可以写静态的代码块
     static{
         // 实例化 属性集
         Properties p=new Properties();
         // 从本类的字节码文件中根据路径得到一个输入流
         InputStream is=DBUtil.class.getClassLoader()
                 .getResourceAsStream("com/tz/util/db.properties");
         try {
             // 属性集 去加载输入流
             p.load(is);
             driver=p.getProperty("driver");
             url=p.getProperty("url");
             username=p.getProperty("username");
             pwd=p.getProperty("pwd");
             // 记载驱动
             Class.forName(driver);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     // 封装一个得到 Connection的方法
     public static Connection getConn() throws SQLException{
         return DriverManager.getConnection(url, username, pwd);
     }
     // 封装一个关闭连接的方法
     public static void closeConn(Connection conn,PreparedStatement ps,ResultSet rs){
         if(conn!=null){
             try {
                 conn.close();
             } catch (SQLException e) {
                 e.printStackTrace();
             }
         }
         if(ps!=null){
             try {
                 ps.close();
             } catch (SQLException e) {
                 e.printStackTrace();
             }
         }
         if(rs!=null){
             try {
                 rs.close();
             } catch (SQLException e) {
                 e.printStackTrace();
             }
         }
     }
 }

com.tz.test 测试包

 package com.tz.test;

 import org.junit.Test;

 import com.tz.dao.StudentDao;
 import com.tz.dao.impl.StudentDaoImpl;
 import com.tz.entity.Student;

 public class TestStudentDao {
     @Test
     public void testadd(){
         // 向上造型
         StudentDao dao=new StudentDaoImpl();
         Student s=new Student(1010,"刘能","男","123","铁岭象牙山");
         dao.addStudent(s);
     }
     @Test
     public void testdelete(){
         StudentDao dao=new StudentDaoImpl();
         int a=dao.deleteStudent(1010);
         System.out.println(a);
     }
     @Test
     public void testupdate(){
         StudentDao dao=new StudentDaoImpl();
         Student s=new Student(1010,"刘德华","男","123","中国香港");
         Student st=dao.updateStudent(s);
         System.out.println(st);
     }
     @Test
     public void testfindByid(){
         StudentDao dao=new StudentDaoImpl();
         Student st=dao.findById(1010);
         System.out.println(st);
     }

 }