jdbc_CRUD——增删改查

编程语言 2018-12-11 10:50:58 阅读次数: 0

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

  1. 在pom.xml中先引入依赖包
<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>cn.mesmile</groupId>
  <artifactId>jdbcCRUD</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>jdbcCRUD</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
  <!-- 测试包  -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
	<!-- mySql依赖包  -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.21</version>
    </dependency>
	<!-- 工具包 -->
    <!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
    <dependency>
      <groupId>commons-beanutils</groupId>
      <artifactId>commons-beanutils</artifactId>
      <version>1.9.2</version>
    </dependency>
  </dependencies>
</project>
  1. 在resources文件夹中配置 db.properties文件
DriverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mydata
username=数据库登陆名
password=数据库登陆密码
  1. domain层
package cn.mesmile.domain;

import java.io.PipedReader;

public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private boolean sex;

    /*alt+enter   alt+insert 调用get和set方法*/
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    public boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

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

3.dao层
3.1新建BaseDao

package cn.mesmile.dao;

import cn.itsource.jdbcUtil.JDBCUtil;
import org.apache.commons.beanutils.BeanUtils;
import sun.java2d.pipe.SpanIterator;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class BaseDao {
    /**
     * 针对增删改进行的封装
     * @param sql
     * @return
     * @throws
     */
    public int executeUpdate(String sql,Object... objs) throws Exception {
        //获取连接
        Connection conn = JDBCUtil.newInstance().getConnection();
        //获取语句执行对象
        PreparedStatement pst = conn.prepareStatement(sql);
        //设置参数
        //SQL可能是有参数也可能是无参数
        //设置参数的下标是从1开始，从数组取值的下标从0开始
        for (int i = 1; i <= objs.length; i++) {
            pst.setObject(i, objs[i-1]);
        }
        //执行SQL语句
        int res = pst.executeUpdate();
        //释放资源
        JDBCUtil.newInstance().release(null, pst, conn);
        return res;
    }

    /**
     * 将查询到的多条数据封装到List集合中
     * 任意类型的对象
     * @param sql
     * @param clz
     * @param objs
     * @return
     * @throws Exception
     */
    public <T> List<T> executeQueryAll(String sql,Class<T> clz,Object... objs) throws Exception{
        Connection conn = JDBCUtil.newInstance().getConnection();
        PreparedStatement pst = conn.prepareStatement(sql);
        //设置参数
        for (int i = 1; i <= objs.length; i++) {
            pst.setObject(i, objs[i-1]);
        }

        ResultSet rs = pst.executeQuery();
        //获取结果集的元数据
        ResultSetMetaData rsmd = rs.getMetaData();
        //获取结果集的列数
        int count = rsmd.getColumnCount();

        //查询的是多条数据
        List<T> list=new ArrayList<>();
        //获取结果集中的值
        while (rs.next()) {
            //每次遍历是一个新的map，创建map
            Map<String,Object> map=new HashMap<>();
            //字段名和字段的值怎么在map中对应
            for (int i = 1; i <=count; i++) {
                //字段名
                String label = rsmd.getColumnLabel(i);
                //该字段下的值
                Object value = rs.getObject(label);
                //将当前列的数据，添加到map
                map.put(label, value);
            }
            //对象的创建，使用反射
            T t = clz.newInstance();
            //将数据封装到对象中
            BeanUtils.populate(t, map);
            //添加到list中去
            list.add(t);
        }

        //释放资源
        JDBCUtil.newInstance().release(rs, pst, conn);
        return list;
    }

    /**
     * 将查询单个的SQL语句进行一个封装
     * @param sql
     * @param clz
     * @param objs
     * @return
     * @throws Exception
     */
    public <T> T executeQuery(String sql,Class<T> clz,Object... objs) throws Exception{
        List<T> list = executeQueryAll(sql, clz, objs);
        return list.size()==0?null:list.get(0);
    }

}

3.2新建实例dao

package cn.mesmile.dao;

import cn.itsource.domain.Student;

import java.util.List;

public interface IStudentDao {
    void add(Student student);//添加的方法
    void delete(String id);//删除的方法
    void edit(Student student);//修改的方法
    Student queryOne(String id);//查询一个的方法
    List<Student> queryAll();//查询数据库中所有数据的方法
}

3.3新建dao层实现类

package cn.mesmile.dao.impl;

import cn.itsource.dao.BaseDao;
import cn.itsource.dao.IStudentDao;
import cn.itsource.domain.Student;
import cn.itsource.jdbcUtil.JDBCUtil;

import java.sql.Connection;
import java.sql.SQLInput;
import java.util.List;

public class StudentDaoImpl implements IStudentDao {
	// 新建工具类对象
    static BaseDao dao = new BaseDao();

    @Override// 添加
    public void add(Student student) {
        String sql="insert into student(name,age,sex) values(?,?,?)";
        try {
            // 调用工具类中的方法
            dao.executeUpdate(sql,student.getName(),student.getAge(),student.isSex());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override // 删除
    public void delete(String id) {
        String sql="delete from student where id=?";
        try {
            dao.executeUpdate(sql,id);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override //修改
    public void edit(Student student) {
        String sql="update student set name=?,age=?,sex=? where id=?";
        try {
            dao.executeUpdate(sql,student.getName(),student.getAge(),student.isSex(),student.getId());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override //查询一个
    public Student queryOne(String id) {
        String sql="select * from student where id=?";
        try {
            return dao.executeQuery(sql,Student.class,id );
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override //查询所有
    public List<Student> queryAll() {
        String sql="select * from student";
        try {
            return dao.executeQueryAll(sql,Student.class );
        } catch (Exception e) {
            e.printStackTrace();
        }
        return  null;
    }
}
  1. 新建jdbc工具类，用于连接数据库
package cn.mesmile.jdbcUtil;

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

public class JDBCUtil {
    private static JDBCUtil instance = null;
    private JDBCUtil(){}
    private static Properties pro = new Properties();

    // 静态代码块，当静态的资源被调用的时候（静态资源包括：构造方法、静态方法），静态代码块就会被调用
    static {
        instance = new JDBCUtil();
        try {
            // 加载流对象     通过当前线程对象获得类加载器，再通过类加载器，获得流对象
            pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
            //加载注册驱动
            Class.forName(pro.getProperty("DriverClassName"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * @return 返回的对象是JDBC工具类的对象
     */
    public static JDBCUtil newInstance(){
        return instance;
    }

    /**
     * 	此方法用于，获得一个Connection连接对象
     * @return
     */
    public Connection getConnection() {
        try {
            // 获得Connection对象
            return DriverManager.getConnection(pro.getProperty("url"), pro.getProperty("username"), pro.getProperty("password"));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 这是一个方便减少冗余度的方法，主要用于  关闭几种流资源连接
     *
     * @param resultSet ：这是一个ResultSet类型的对象
     * @param statement ：这是一个Statement类型的对象
     * @param conn ：这是一个Connection类型的对象
     */
    public void release(ResultSet resultSet,Statement statement,Connection conn){
        //先判断是否为空，若不为空才 进行关闭流 （先打开，后关闭）
        try {
            if(resultSet != null)resultSet.close();
        } catch (SQLException e1) {
            e1.printStackTrace();
        }finally{
            if(statement != null)
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }finally{
                    if(conn != null)
                        try {
                            conn.close();
                        } catch (SQLException e) {
                            e.printStackTrace();
                        }
                }
        }
    }
}
  1. 测试
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<Student> students = studentDao.queryAll();
        System.out.println(students);
    }
}

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

猜你喜欢

转载自blog.csdn.net/suprezheng/article/details/84951474
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
基本数据类型封装类比较 Java源码解读(一) 8种基本类型对应的封装类型
JS实现无缝滚动上
深入解析HashMap原理（基于JDK1.8）
mysql的连接池
关于.htc
linux下的ubuntu12.04图形界面
【数论】好推不好记的扩展欧几里德
设备树详解
cscope + tags 简单设置
xml学习
每日归档
更多
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022