jdbc_CRUD——增删改查

迷南。 2022-04-05 06:18 409阅读 0赞

这里做一个简单的jdbc_CRUD增删改查

  1. 在pom.xml中先引入依赖包

    <?xml version=”1.0” encoding=”UTF-8”?>


    4.0.0

    cn.mesmile
    jdbcCRUD
    1.0-SNAPSHOT

    jdbcCRUD

    http://www.example.com


    UTF-8
    1.8
    1.8





    junit
    junit
    4.11
    test



    mysql
    mysql-connector-java
    5.1.21




    commons-beanutils
    commons-beanutils
    1.9.2

  2. 在resources文件夹中配置 db.properties文件

    DriverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/mydata
    username=数据库登陆名
    password=数据库登陆密码

  3. domain层

    package cn.mesmile.domain;

    import java.io.PipedReader;

    public class Student {

    1. private Integer id;
    2. private String name;
    3. private Integer age;
    4. private boolean sex;
    6. /*alt+enter   alt+insert 调用get和set方法*/
    7. public Integer getId() {
    8.     return id;
    9. }
    11. public void setId(Integer id) {
    12.     this.id = id;
    13. }
    15. public String getName() {
    16.     return name;
    17. }
    19. public void setName(String name) {
    20.     this.name = name;
    21. }
    23. public Integer getAge() {
    24.     return age;
    25. }
    27. public void setAge(Integer age) {
    28.     this.age = age;
    29. }
    31. public boolean isSex() {
    32.     return sex;
    33. }
    35. public void setSex(boolean sex) {
    36.     this.sex = sex;
    37. }
    39. @Override
    40. public String toString() {
    41.     return "Student{" +
    42.             "id=" + id +
    43.             ", name='" + name + '\'' +
    44.             ", age=" + age +
    45.             ", sex=" + sex +
    46.             '}';
    47. }

    }

3.dao层
3.1新建BaseDao

  1. package cn.mesmile.dao;
  3. import cn.itsource.jdbcUtil.JDBCUtil;
  4. import org.apache.commons.beanutils.BeanUtils;
  5. import sun.java2d.pipe.SpanIterator;
  7. import java.sql.Connection;
  8. import java.sql.PreparedStatement;
  9. import java.sql.ResultSet;
  10. import java.sql.ResultSetMetaData;
  11. import java.util.ArrayList;
  12. import java.util.HashMap;
  13. import java.util.List;
  14. import java.util.Map;
  16. public class BaseDao {
  17.     /**
  18.      * 针对增删改进行的封装
  19.      * @param sql
  20.      * @return
  21.      * @throws
  22.      */
  23.     public int executeUpdate(String sql,Object... objs) throws Exception {
  24.         //获取连接
  25.         Connection conn = JDBCUtil.newInstance().getConnection();
  26.         //获取语句执行对象
  27.         PreparedStatement pst = conn.prepareStatement(sql);
  28.         //设置参数
  29.         //SQL可能是有参数也可能是无参数
  30.         //设置参数的下标是从1开始，从数组取值的下标从0开始
  31.         for (int i = 1; i <= objs.length; i++) {
  32.             pst.setObject(i, objs[i-1]);
  33.         }
  34.         //执行SQL语句
  35.         int res = pst.executeUpdate();
  36.         //释放资源
  37.         JDBCUtil.newInstance().release(null, pst, conn);
  38.         return res;
  39.     }
  41.     /**
  42.      * 将查询到的多条数据封装到List集合中
  43.      * 任意类型的对象
  44.      * @param sql
  45.      * @param clz
  46.      * @param objs
  47.      * @return
  48.      * @throws Exception
  49.      */
  50.     public <T> List<T> executeQueryAll(String sql,Class<T> clz,Object... objs) throws Exception{
  51.         Connection conn = JDBCUtil.newInstance().getConnection();
  52.         PreparedStatement pst = conn.prepareStatement(sql);
  53.         //设置参数
  54.         for (int i = 1; i <= objs.length; i++) {
  55.             pst.setObject(i, objs[i-1]);
  56.         }
  58.         ResultSet rs = pst.executeQuery();
  59.         //获取结果集的元数据
  60.         ResultSetMetaData rsmd = rs.getMetaData();
  61.         //获取结果集的列数
  62.         int count = rsmd.getColumnCount();
  64.         //查询的是多条数据
  65.         List<T> list=new ArrayList<>();
  66.         //获取结果集中的值
  67.         while (rs.next()) {
  68.             //每次遍历是一个新的map，创建map
  69.             Map<String,Object> map=new HashMap<>();
  70.             //字段名和字段的值怎么在map中对应
  71.             for (int i = 1; i <=count; i++) {
  72.                 //字段名
  73.                 String label = rsmd.getColumnLabel(i);
  74.                 //该字段下的值
  75.                 Object value = rs.getObject(label);
  76.                 //将当前列的数据，添加到map
  77.                 map.put(label, value);
  78.             }
  79.             //对象的创建，使用反射
  80.             T t = clz.newInstance();
  81.             //将数据封装到对象中
  82.             BeanUtils.populate(t, map);
  83.             //添加到list中去
  84.             list.add(t);
  85.         }
  87.         //释放资源
  88.         JDBCUtil.newInstance().release(rs, pst, conn);
  89.         return list;
  90.     }
  92.     /**
  93.      * 将查询单个的SQL语句进行一个封装
  94.      * @param sql
  95.      * @param clz
  96.      * @param objs
  97.      * @return
  98.      * @throws Exception
  99.      */
  100.     public <T> T executeQuery(String sql,Class<T> clz,Object... objs) throws Exception{
  101.         List<T> list = executeQueryAll(sql, clz, objs);
  102.         return list.size()==0?null:list.get(0);
  103.     }
  105. }

3.2新建实例dao

  1. package cn.mesmile.dao;
  3. import cn.itsource.domain.Student;
  5. import java.util.List;
  7. public interface IStudentDao {
  8.     void add(Student student);//添加的方法
  9.     void delete(String id);//删除的方法
  10.     void edit(Student student);//修改的方法
  11.     Student queryOne(String id);//查询一个的方法
  12.     List<Student> queryAll();//查询数据库中所有数据的方法
  13. }

3.3新建dao层实现类

  1. package cn.mesmile.dao.impl;
  3. import cn.itsource.dao.BaseDao;
  4. import cn.itsource.dao.IStudentDao;
  5. import cn.itsource.domain.Student;
  6. import cn.itsource.jdbcUtil.JDBCUtil;
  8. import java.sql.Connection;
  9. import java.sql.SQLInput;
  10. import java.util.List;
  12. public class StudentDaoImpl implements IStudentDao {
  13.     // 新建工具类对象
  14.     static BaseDao dao = new BaseDao();
  16.     @Override// 添加
  17.     public void add(Student student) {
  18.         String sql="insert into student(name,age,sex) values(?,?,?)";
  19.         try {
  20.             // 调用工具类中的方法
  21.             dao.executeUpdate(sql,student.getName(),student.getAge(),student.isSex());
  22.         } catch (Exception e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  27.     @Override // 删除
  28.     public void delete(String id) {
  29.         String sql="delete from student where id=?";
  30.         try {
  31.             dao.executeUpdate(sql,id);
  32.         } catch (Exception e) {
  33.             e.printStackTrace();
  34.         }
  35.     }
  37.     @Override //修改
  38.     public void edit(Student student) {
  39.         String sql="update student set name=?,age=?,sex=? where id=?";
  40.         try {
  41.             dao.executeUpdate(sql,student.getName(),student.getAge(),student.isSex(),student.getId());
  42.         } catch (Exception e) {
  43.             e.printStackTrace();
  44.         }
  45.     }
  47.     @Override //查询一个
  48.     public Student queryOne(String id) {
  49.         String sql="select * from student where id=?";
  50.         try {
  51.             return dao.executeQuery(sql,Student.class,id );
  52.         } catch (Exception e) {
  53.             e.printStackTrace();
  54.         }
  55.         return null;
  56.     }
  58.     @Override //查询所有
  59.     public List<Student> queryAll() {
  60.         String sql="select * from student";
  61.         try {
  62.             return dao.executeQueryAll(sql,Student.class );
  63.         } catch (Exception e) {
  64.             e.printStackTrace();
  65.         }
  66.         return  null;
  67.     }
  68. }

  1. 新建jdbc工具类，用于连接数据库

    package cn.mesmile.jdbcUtil;

    import java.sql.*;
    import java.util.Properties;

    public class JDBCUtil {

    1. private static JDBCUtil instance = null;
    2. private JDBCUtil(){}
    3. private static Properties pro = new Properties();
    5. // 静态代码块，当静态的资源被调用的时候（静态资源包括：构造方法、静态方法），静态代码块就会被调用
    6. static {
    7.     instance = new JDBCUtil();
    8.     try {
    9.         // 加载流对象     通过当前线程对象获得类加载器，再通过类加载器，获得流对象
    10.         pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
    11.         //加载注册驱动
    12.         Class.forName(pro.getProperty("DriverClassName"));
    13.     } catch (Exception e) {
    14.         e.printStackTrace();
    15.     }
    16. }
    18. /**
    19.  * @return 返回的对象是JDBC工具类的对象
    20.  */
    21. public static JDBCUtil newInstance(){
    22.     return instance;
    23. }
    25. /**
    26.  *     此方法用于，获得一个Connection连接对象
    27.  * @return
    28.  */
    29. public Connection getConnection() {
    30.     try {
    31.         // 获得Connection对象
    32.         return DriverManager.getConnection(pro.getProperty("url"), pro.getProperty("username"), pro.getProperty("password"));
    33.     } catch (SQLException e) {
    34.         e.printStackTrace();
    35.     }
    36.     return null;
    37. }
    39. /**
    40.  * 这是一个方便减少冗余度的方法，主要用于  关闭几种流资源连接
    41.  *
    42.  * @param resultSet ：这是一个ResultSet类型的对象
    43.  * @param statement ：这是一个Statement类型的对象
    44.  * @param conn ：这是一个Connection类型的对象
    45.  */
    46. public void release(ResultSet resultSet,Statement statement,Connection conn){
    47.     //先判断是否为空，若不为空才 进行关闭流 （先打开，后关闭）
    48.     try {
    49.         if(resultSet != null)resultSet.close();
    50.     } catch (SQLException e1) {
    51.         e1.printStackTrace();
    52.     }finally{
    53.         if(statement != null)
    54.             try {
    55.                 statement.close();
    56.             } catch (SQLException e) {
    57.                 e.printStackTrace();
    58.             }finally{
    59.                 if(conn != null)
    60.                     try {
    61.                         conn.close();
    62.                     } catch (SQLException e) {
    63.                         e.printStackTrace();
    64.                     }
    65.             }
    66.     }
    67. }

    }

  2. 测试

    package cn.mesmile;

    import static org.junit.Assert.assertTrue;

    import cn.itsource.dao.impl.StudentDaoImpl;
    import cn.itsource.domain.Student;
    import org.junit.Test;

    import java.util.List;

    /**

    • Unit test for simple App.
      /
      public class AppTest {
      /*

      • Rigorous Test :-)
        */
        static StudentDaoImpl studentDao = new StudentDaoImpl();
        @Test
        public void addTest() {
        // 添加
        Student student = new Student();
        student.setName(“管理员”);
        student.setAge(18);
        student.setSex(false);
        studentDao.add(student);
        }
        @Test
        public void delteTest() {
        // 删除
        studentDao.delete(“1”);
        }

        @Test
        public void updateTest(){
        // 修改
        Student student = new Student();
        student.setName(“李四”);
        student.setSex(false);
        student.setAge(19);
        student.setId(1);
        studentDao.edit(student);
        }

        @Test // 通过id查询一个
        public void queryOneTest(){
        Student student = studentDao.queryOne(“2”);
        System.out.println(student);
        }

        @Test // 查询所有的
        public void queryAllTest(){
        List students = studentDao.queryAll();
        System.out.println(students);
        }
        }

测试【查询所有】数据的结果：
在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，409人围观）

还没有评论，来说两句吧...

相关阅读

    相关 MySQL 增删改查

    MySQL 增删改查 虽然经常对数据库进行操作，但有时候一些sql语句还是会忘记，因此总结一下，方便记忆。 一 对库操作 1 创建数据库 > create dat

    梦里梦外;梦里梦外;/ 0 赞/ 479 阅读