jdbc增删改查进行封装

jdbc封装

1   dao （代码分层）
    com.aaa.dao       存放dao相关的类型 例如  StudentDAOImpl  处理 数据库的链接 存取数据
    com.aaa.servlet   存放servlet相关的类 例如：StudentServlet 处理 与浏览器交互的类
    com.aaa.entity    存放实体类    例如 Student    接受数据库对象模型
    com.aaa.util      存放工具类    例如  DBUtil
2   练习 模拟 servlet调用 dao
    2.1 创建一个数据库表 Student( id name age )
    2.2 创建数据库表对应的实体类 （为什么要创建实体类？作用：以后数据库表中的数据 提取到 java中的时候 用 对象来存储）
    2.3 创建DAO
        A 组成 两部分： 接口 （ 声明 ）和 实现类
          接口的命名规则例如： IStudentDAO     I 代表这是一个接口 Student 对应业务名称（表名） DAO 后缀 表明当前是一个dao接口
          实现类的命名规则例如： StudentDAOImpl    Student 代表业务名称(表明) DAOImpl 代表dao接口的实现
          为什么需要接口+实现类？ 因为 我们需要一个多态的特征。
          ---------------------多态------------------------
          什么是多态？ 多种状态
          如何产生多态？ 继承多态     父类的引用 子类的对象 例如 ：  Animal a = new Dog();    基本上不用
                         接口多态     接口的应用  实现类的对象  例如： IStudentDAO  dao = new StudentDAOImpl();
          为什么要使用多态？  程序解耦  解除程序的耦合性
          （不使用多态会产生什么问题？）
          ------------------------------------------------
        B 接口声明的方法(接口中该写哪些方法)
          重要：根据业务需求   /     CRUD 增删改查
     2.4 接口中 声明 五个方法    （一个方法：返回值  参数   试想一下 这个业务的sql ）
         A 添加新学生
         B 根据id删除学生
         C 根据id修改学生
         D 根据id查询学生
         E 查询所有学生
     2.5 对方法完成实现
     2.6 测试代码
3  jdbc封装
    我们发现 在dao的实现类中 有很多重复代码 我们可以将其封装起来
    3.1 创建一个类 DBUtil
    3.2 加载驱动和建立链接的代码 完全一样
        加載驅動写到静态代码快中 ：因为 驱动只需要加载一次即可 比如：你安装了一台电脑  只需要下载一次qq 以后直接使用就可以了
                                   类的静态代码块 随着类的加载 只执行一次
        建立链接的代码 单独创建一个方法 通过返回值返回链接对象：为什么链接要链接多次 因为链接用完了就关闭了
    3.3 关闭的代码也需要封装
    3.4 增删改的预处理代码 也基本一样

    4.11日 练习 1 dao的创建   2 增删改的三个方法（声明） 3 学会使用 DBUtil 4 弄清楚 executeupdate的原理 5 能自主封装
        最终目的 dao封装 20分钟

1.创建实体类

package com.aaa.entity;

/**
 *  学生实体类 ---- table student
 */
public class Student {
    /* 成员变量  属性 */
    private  int  id;
    private  String  name;
    private  int  age;

    /*构造函数*/
    public Student() {

    }
    public Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    /*set和get*/
    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 int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    /*toString*/
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2.创建DAO(接口)

package com.aaa.dao;

import com.aaa.entity.Student;

/**
 * 学生表的DAO
 */
public interface IStudentDAO {

    /**
     * 添加新学生
     * insert  into student  （name,age） values (?,?);
     * 两个以上的参数 全用对象出传参
     * @param  学生对象 里面存放当这需要添加的学生信息
     * @return  boolean  成功返回 true  失败 返回 false
     */
    boolean add(Student s);

    /**\
     * 根据id删除学生
     * delete from student where id = ？
     */
     boolean  delete(int  id);

    /**
     * 根据id修改学生
     * update student set name = ？，age= ? where id = ?
     */
    boolean update(Student s);

}

2.1创建dao层 （实现类）

package com.aaa.dao.impl;

import com.aaa.dao.IStudentDAO;
import com.aaa.entity.Student;
import com.aaa.util.DBUtil;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class StudentDAOImpl implements IStudentDAO {

   //借助工具类  增加数据
    @Override
    public boolean add(Student s) {

        String sql = "insert into student (name,age) values (?,?)";
        return DBUtil.executeUpdate(sql,s.getName(),s.getAge());

    }
//借助工具类  删除
    @Override
    public boolean delete(int id) {
        String sql = "delete from student where id = ?";

        return DBUtil.executeUpdate(sql,id);

    }
     //借助工具类   修改数据
    @Override
    public boolean update(Student s) {
        String sql = "update student set name=?,age=? where id = ?";

        return DBUtil.executeUpdate(sql,s.getName(),s.getAge(),s.getId());
    }

//查询所有 
@Override
    public List<Map<String, Object>> getAllStu() {
        //原生代码
       /* try {
            List<Map<String,Object>> list=new ArrayList<>();
            Connection conn = DBUtils.getConnection();
            String sql="select * from student";

            PreparedStatement ps = conn.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            while(rs.next()){
                Map<String,Object> maps=new HashMap<>();
                maps.put("id",rs.getObject("id"));
                maps.put("name",rs.getObject("name"));
                maps.put("age",rs.getObject("age"));
                list.add(maps);
            }
            return list;

        } catch (SQLException e) {
            e.printStackTrace();
        }*/

         //借助工具类  查询所有
        String sql="select * from student";
        List<Map<String, Object>> list = DBUtils.executeQuery(sql);
        if (list.size()>0){
            return list;
        }
       return null;
    }

 

}

工具类

package com.aaa.util;

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

public class DBUtil {

    static {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

     public static Connection getConnection(){
         try {
             return DriverManager.getConnection("jdbc:mysql://localhost:3306/test?characterEnconding=UTF-8", "root", "123456");
         } catch (SQLException e) {
             e.printStackTrace();
         }
         return null;
     }
     /** 增删改的通用方法
     * @param  String sql  要执行的sql
      * @param  Object[] obj    对象类型的数组  里面存放着 sql执行的占位符参数
      *              【name，age，id】
     *                【id】
      *               【name，age】
      *         Object... 可变参数
     * */
    public static boolean executeUpdate(String sql,Object... args){

        PreparedStatement ps = null;
        try {
            ps = getConnection().prepareStatement(sql);

            for (int i=0;i<args.length;i++){
                ps.setObject(i+1,args[i]);
            }

       /*     ps.setObject(1,s.getName());
            ps.setObject(2,s.getAge());
            ps.setObject(3,s.getId());*/

            int i = ps.executeUpdate();
            if (i>0)return true;
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //关闭
        }

        return false;
    }

/**
     * 查询的通用方法
     * @param sql
     * @param args
     * @return
     */
    public static List<Map<String, Object>> executeQuery(String sql, Object... args) {

        try {
            /**
             * 需要将所有数据都存到List中  每一行 用一个map存放
             */
            List<Map<String, Object>> list = new ArrayList<>();
            Connection conn = DBUtils.getConnection();
            PreparedStatement ps = conn.prepareStatement(sql);
            /**
             * 有可能有参数 查询不是所有 而是查询其中几条
             */
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            /**
             * 执行sql
             */
            ResultSet rs = ps.executeQuery();
            /**
             *获得本次查询的总列数
             */
            int count = rs.getMetaData().getColumnCount();

            while (rs.next()) {
                Map<String, Object> maps = new HashMap<>();
                for (int i = 1; i <= count; i++) {
                    /**
                     * 获得每列的字段名
                     */
                    String name = rs.getMetaData().getColumnLabel(i);
                    maps.put(name, rs.getObject(i));

                }
                /**
                 * 将每行的map存放到List中
                 */
                list.add(maps);
            }
            return list;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 关闭的通用方法
     */
    private static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
        try {
            if (rs != null) {
                rs.close();
            }
            if (ps != null) {
                ps.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

 

}

测试类（模拟Servlet）

package com.aaa.servlet;

import com.aaa.dao.IStudentDAO;
import com.aaa.dao.impl.StudentDAOImpl;
import com.aaa.entity.Student;
import org.junit.Test;

public class JavaTest {

    @Test
    public void test1(){

        Student s = new Student(1, "测试吃饭", 28);

        /*测试 dao 的增删改*/
        IStudentDAO dao = new StudentDAOImpl();

        /*增*/
        dao.add(s);

        dao.delete(3);

        dao.update(s);

 //查询所有 借助工具类   增删改代码可不写
        IStudentDAO sd=new StudentDAOImpl();
        List<Map<String, Object>> allStu = sd.getAllStu();
        System.out.println(allStu);

 

    }

}

 

转载于:https://www.cnblogs.com/qurui1998/p/10690622.html