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);
    }
    
    
}