用数据库实现CRUD

已于 2022-10-01 15:46:55 修改
阅读量154 收藏
点赞数
分类专栏： MySql small project 文章标签： java 数据库 mysql
于 2022-09-30 17:07:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44251806/article/details/127126550
版权

用数据库实现增删改查
druid.properties文件

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
username=root password=123456 initialSize=5 maxActive=10 maxWait=3000
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>
<!--https://mvnrepository.com/-->
    <groupId>org.example</groupId>
    <artifactId>a20220927</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>
</project>

用户类：

package a1.entity;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;
//DTO 数据传输对象
@Data
public class User implements Serializable {
    private Long id;
    private String username;
    private transient String password;
    private Date birth;
    private Boolean sex;
    private Double salary;
    }

工具类:
Jdbc工具类

package a1.util;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;

public final class JdbcUtil {
    private JdbcUtil() {
    }

    private static DataSource dataSource;

    static {
        try {
            Properties pp = new Properties();
            pp.load(JdbcUtil.class.getResourceAsStream("druid.properties"));
            dataSource = DruidDataSourceFactory.createDataSource(pp);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public static Connection getConnection() throws Exception {
        return dataSource.getConnection();
    }

    public static PreparedStatement creatPreparedStatement(Connection connection, String sql, Object... params) throws Exception {
        PreparedStatement ps = null;
        if (connection != null && StringUtil.isNotBlank(sql)) {
            ps = connection.prepareStatement(sql);
            if (params != null && params.length > 0) {
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
            }
        }
        return ps;
    }

    public static ResultSet executeQuery(Connection connection, String sql, Object... params) throws Exception {
        ResultSet rs = null;
        PreparedStatement ps = creatPreparedStatement(connection, sql, params);
        if (ps != null)
            rs = ps.executeQuery();
        return rs;
    }

    public static int executeUpdate(Connection connection, String sql, Object... params) throws Exception {
        int res = -1;
        PreparedStatement ps = creatPreparedStatement(connection, sql, params);
        if (ps != null)
            res = ps.executeUpdate();
        return res;
    }

    public static void close(ResultSet rs, PreparedStatement ps, Connection con) throws Exception {
        try {
            if (rs != null)
                rs.close();
        } finally {
            try {
                if (ps != null)
                    ps.close();
            } finally {
                if (con != null)
                    con.close();
            }
        }
    }
}

String工具类

package a1.util;

import java.security.MessageDigest;
import java.util.Base64;

public final class StringUtil {
    private StringUtil(){}
    public static boolean isBlank(String str){
        return str==null || str.trim().length()<1;
    }
    public static boolean isNotBlank(String str){
        return !isBlank(str);
    }
    public static String toMd5(String source,String salt){
        try {
            MessageDigest md = MessageDigest.getInstance("md5");
            source+=salt;
            byte[] target=md.digest(source.getBytes());
            return Base64.getEncoder().encodeToString(target);
        } catch (Exception e){
            e.printStackTrace();
        }
        return "";
    }
}

DaoFactory工具类

package a1.util;

import a1.dao.IUserDao;
import a1.dao.UserDaoImpl;

public class DaoFactory {
    private DaoFactory(){}
    private static IUserDao userDao= new UserDaoImpl();
    public static IUserDao getUserDao(){
        return new UserDaoImpl();
    }
}

Dao
接口类

package a1.dao;

import a1.entity.User;

import java.util.List;

public interface IUserDao {
    public User login(User user) throws Exception;

    public boolean add(User user);

    public boolean delete(String username);

    public boolean modify(User user);

    public List<User> search();

    public boolean isExistsName(String username);
}

实现类

package a1.dao;

import a1.entity.User;
import a1.util.DaoFactory;
import a1.util.JdbcUtil;
import a1.util.StringUtil;
import lombok.SneakyThrows;

import java.sql.Connection;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class UserDaoImpl implements IUserDao {
    @Override
    public User login(User user) throws Exception {
        User user1 = null;
        if (user == null || StringUtil.isBlank(user.getUsername()) || StringUtil.isBlank(user.getPassword()))
            throw new IllegalArgumentException("参数错误");
        String sql = "select * from tb_users where username = ? and password = ?";
        List<Object> list = new ArrayList<>();
        list.add(user.getUsername());
        list.add(StringUtil.toMd5(user.getPassword(), user.getUsername()));
        //list.add(user.getPassword());
        Connection con = null;
        ResultSet rs = null;
        try {
            con = JdbcUtil.getConnection();
            rs = JdbcUtil.executeQuery(con, sql, list.toArray());
            if (rs.next()) {
                user1 = getObject(rs);
            }
        } finally {
            JdbcUtil.close(rs, null, con);
        }
        return user1;
    }

    @SneakyThrows
    public boolean isExistsName(String username) {
        boolean res = true;
        if (StringUtil.isBlank(username))
            throw new IllegalArgumentException("参数错误!");
        String sql = "select * from tb_users where username=?";
        Connection connection = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtil.getConnection();
            resultSet = JdbcUtil.executeQuery(connection, sql, username);
            if (!resultSet.next())
                res = false;
        } finally {
            JdbcUtil.close(resultSet, null, connection);
        }
        return res;
    }

    @SneakyThrows
    @Override
    public boolean add(User user) {
        if (user == null || user.getUsername() == null || user.getPassword() == null)
            throw new IllegalArgumentException("用户不能为空");
        int res = -1;
        List<Object> list = new ArrayList<>();
        StringBuilder ss1 = new StringBuilder("insert into tb_users(username,password");
        StringBuilder ss2 = new StringBuilder(")values(?,?");
        list.add(user.getUsername());
        list.add(user.getPassword());
        if (user.getBirth() != null) {
            ss1.append(",birth");
            ss2.append(",?");
            list.add(new java.sql.Date(user.getBirth().getTime()));
        }
        if (user.getSex() != null) {
            ss1.append(",sex");
            ss2.append(",?");
            list.add(user.getSex());
        }
        if (user.getSalary() != null) {
            ss1.append(",salary");
            ss2.append(",?");
            list.add(user.getSalary());
        }
        String sql = ss1.toString() + ss2.toString() + ")";
        Connection con = null;
        try {
            con = JdbcUtil.getConnection();
            res = JdbcUtil.executeUpdate(con, sql, list.toArray());
        } finally {
            JdbcUtil.close(null, null, con);
        }
        return res > 0;
    }

    @SneakyThrows
    @Override
    public boolean delete(String username) {
        int res = 0;
        if (StringUtil.isBlank(username))
            throw new IllegalArgumentException("没有此用户!");
        Connection con = null;
        String sql = "delete from tb_users where username = ?";
        try {
            con = JdbcUtil.getConnection();
            res = JdbcUtil.executeUpdate(con, sql, username);
        } finally {
            JdbcUtil.close(null, null, con);
        }
        return res > 0;
    }

    @SneakyThrows
    @Override
    public boolean modify(User user) {
        int res = -1;
        if (user == null || user.getId() == null)
            throw new IllegalArgumentException("用户不能为空");
        List<Object> list = new ArrayList<>();
        StringBuilder ss = new StringBuilder("update tb_users set id = ? ");
        list.add(user.getId());
        if (StringUtil.isNotBlank(user.getUsername())) {
            ss.append(",username = ?");
            list.add(user.getUsername());
        }
        if (StringUtil.isNotBlank(user.getPassword())) {
            ss.append(",password = ?");
            list.add(StringUtil.toMd5(user.getPassword(), user.getUsername()));
        }
        if (user.getBirth() != null) {
            ss.append(",birth = ?");
            list.add(new java.sql.Date(user.getBirth().getTime()));
        }
        if (user.getSex() != null) {
            ss.append(",sex = ?");
            list.add(user.getSex());
        }
        if (user.getSalary() != null) {
            ss.append(",salary = ?");
            list.add(user.getSalary());
        }
        ss.append(" where id = " + user.getId());
        Connection con = null;
        try {
            con = JdbcUtil.getConnection();
            res = JdbcUtil.executeUpdate(con, ss.toString(), list.toArray());
        } finally {
            JdbcUtil.close(null, null, con);
        }
        return res > 0;
    }

    @SneakyThrows
    @Override
    public List<User> search() {
        String sql = "select * from tb_users";
        Connection con = null;
        ResultSet rs = null;
        List<User> list = new ArrayList<>();
        try {
            con = JdbcUtil.getConnection();
            rs = JdbcUtil.executeQuery(con, sql, null);
            while (rs.next()) {
                User user = getObject(rs);
                list.add(user);
            }
        } finally {
            JdbcUtil.close(rs, null, con);
        }
        return list;
    }

    protected User getObject(ResultSet rs) throws Exception {
        User user = new User();
        user.setId(rs.getLong("id"));
        user.setUsername(rs.getString("username"));
        user.setPassword(rs.getString("password"));
        user.setBirth(rs.getDate("birth"));
        user.setSex(rs.getBoolean("sex"));
        user.setSalary(rs.getDouble("salary"));
        return user;
    }

    public static void main(String[] args) {
        IUserDao userDao = DaoFactory.getUserDao();
        User user = new User();
//        user.setId(11L);
//        user.setBirth(new Date());
//        user.setUsername("AAA");
//        user.setSalary(9000.);
//        boolean res = userDao.modify(user);
//        System.out.println(res);

//        user.setBirth(new Date());
//        user.setUsername("AAA1");
//        user.setPassword("123456");
//        user.setSalary(9000.);
//        boolean res = userDao.add(user);
//        System.out.println(res);

//        userDao.delete("AAA1");

        userDao.search().forEach(System.out::println);

    }


}

主方法

package a1.app;

import a1.dao.IUserDao;
import a1.entity.User;
import a1.util.DaoFactory;
import a1.util.StringUtil;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Main {
    private static User sessionUser = null;
    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static IUserDao userDao = DaoFactory.getUserDao();

    public static void main(String[] args) throws Exception {
        while (true) {
            menu();
            String inputNum = br.readLine();
            switch (inputNum) {
                case "1":
                    while (true) {
                        System.out.println("请登录系统");
                        if (sessionUser == null) {
                            String username = inputString("用户名称");
                            String password = inputString("用户口令");
//            System.out.println(username+"::"+password);
                            User user = new User();
                            user.setUsername(username);
                            user.setPassword(password);
                            user = userDao.login(user);
                            if (user != null) {
                                sessionUser = user;
                                System.out.println("登录成功!");
                                break;
                            } else
                                System.out.println("登录失败！请重新登录");
                        }
                    }
                    break;
                case "2":
                    User user = new User();
                    while (true) {
                        String username = inputString("用户名称");
                        String password = inputString("用户口令");
                        String repassword = inputString("确认口令");
                        Date birth = inputDate("出生日期");
                        String ssex = inputString("性别");
                        boolean sex = "男".equals(ssex);
                        Double salary = inputDouble("就业薪资");
                        if (!password.equals(repassword)) {
                            System.out.println("两次输入口令必须一致 ");
                        } else {
                            if (userDao.isExistsName(username)) {
                                System.out.println("用户名称已经被占用!");
                            } else {
                                user.setUsername(username);
                                user.setPassword(StringUtil.toMd5(user.getPassword(), user.getUsername()));
                                user.setSex(sex);
                                user.setSalary(salary);
                                user.setBirth(birth);
                                break;
                            }
                        }
                    }
                    userDao.add(user);
                    System.out.println("新增用户成功!");
                    break;
                case "0":
                    System.out.println("0");
                    System.exit(0);
                    break;
                case "3":
                    User user1 = modifyUser();
                    boolean res1 = userDao.modify(user1);
                    System.out.println(res1 ? "修改成功" : "修改失败");
                    break;
                case "4":
                    System.out.println("请输入要删除的用户名称：");
                    String username = br.readLine();
                    boolean res = userDao.delete(username);
                    System.out.println(res ? "删除成功" : "删除失败");
                    break;
                case "5":
                    if (userDao.search() != null) {
                        userDao.search().forEach(System.out::println);
                    }
                    break;
                case "6":
                    sessionUser = null;
                    break;
                default:
                    break;
            }
        }
    }

    public static User modifyUser() throws Exception {
        User res = new User();
//            System.out.println("请输入要修改的用户信息");
        System.out.println("请输入id：");
        Long id = Long.parseLong(br.readLine());
        String username = inputString("用户名称", 2);
        String password = inputString("用户密码", 6, 20);
        String repasswprd = inputString("确认密码", 6, 20);
        Date birth = inputDate("生日");
        String ssex = inputString("性别");
        boolean sex = "男".equals(ssex);
        Double salary = inputDouble("就业薪资");
        if (!password.equals(repasswprd))
            System.out.println("两次输入的密码不一致!!!");
        else if (userDao.isExistsName(username))
            System.out.println("该用户名已存在");
        else {
            res.setId(id);
            res.setUsername(username);
            res.setPassword(password);
            res.setBirth(birth);
            res.setSex(sex);
            res.setSalary(salary);
        }
        return res;
    }

//    private static void inputLoginInfo(BufferedReader br) throws Exception {
//        User user = new User();
//        String username = inputString("用户名称", 2, 10);
//        String password = inputString("密码", 6, 20);
//    }

    public static void menu() {
        System.out.println("欢迎使用本系统...");
        System.out.println("=============================================================");
        System.out.println("1----登录系统                       2----注册新用户");
        if (sessionUser != null) {
            System.out.println("3----修改用户信息                    4----删除用户信息");
            System.out.println("5----查看所有用户信息                 6----退出登录");
        }
        //当用户登录成功，显示所有用户信息、修改指定编号的用户信息、删除指定编号的用户信息所有用户信息
        System.out.println("0----退出系统");
        System.out.println("=============================================================");
        if (sessionUser == null) System.out.println("请选择(0-2)");
        else System.out.println("请选择(0-6)");
    }

    public static String inputString(String labelName, int... params) {
        String res = null;
        while (true) {
            System.out.println("请输入" + labelName + ":");
            try {
                res = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (res != null && res.trim().length() > 0) {
                if (params != null && params.length > 0) {
                    if (params.length <= 1) {
                        if (res.length() >= params[0])
                            break;
                    } else if (params.length >= 2) {
                        if (res.length() >= params[0] && res.length() <= params[1])
                            break;
                    }
                } else
                    break;
            }
            System.out.println("您输入的数据不合法，请重新输入！");
        }
        return res;
    }

    public static Date inputDate(String labelName) {
        Date res = null;
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        while (true) {
            String ss = null;
            System.out.println("请输入" + labelName + ":");
            try {
                ss = br.readLine();
                res = df.parse(ss);
                break;
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("您输入的数据不合法，请重新输入！");
        }
        return res;
    }

    public static Double inputDouble(String labelName) {
        Double res = null;
        while (true) {
            System.out.println("请输入" + labelName + ":");
            try {
                res = Double.valueOf(String.valueOf(br.readLine()));
                break;
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("您输入的数据不合法，请重新输入！");
        }
        return res;
    }
}

此系统实现了对于数据库的CRUD功能

做梦追仙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA使用Oracle数据库实现CRUD
qq_36622473的博客
12-25 469
JAVA使用Oracle数据库实现CRUD 一、数据库建表 -- Create table create table EMP ( username VARCHAR2(10), password VARCHAR2(9), age NUMBER(4), id VARCHAR2(9) ) tablespace USER_TS_DATA pctfree 10 ...
jsp mysql登录实现crud_JSP+DAO实现数据库的CRUD
weixin_30739835的博客
02-07 204
今天在看李兴华《JavaWeb实战经典》时候，看到了用JSP+DAO整合起来做了一个数据库的增删改查操作。程序不难，但是具备借鉴意义。一般来说javaweb项目主要操作就是操作数据库，其本质也就是操作数据库。什么mvc，javabean从某种角度都是多余的，如果用户会写sql，那要View干什么，直接数据库查找不就好了？一般来说可以实现一个最简单BS项目，可以有这么几个模式：1 JSP + JD...
数据库的CRUD操作
weixin_40055163的博客
10-16 2176
数据库的CRUD操作 1 SQL分类 DDL(Data Definition Language)数据定义语言。 用来定义数据库对象：数据库，表，列等。关键字：create, drop,alter 等。 DML(Data Manipulation Language)数据操作语言。 用来对数据库中表的数据进行增删改。关键字：insert, delete, update 等。 DQL(Data Query Language)数据查询语言。 用来查询数据库中表的记录(数据)。关键字：select, where 等
MyBaits操作数据库之CRUD
Common的博客
12-18 858
MyBaits操作数据库之CRUD
JDBC操作1：实现对数据库crud操作
weixin_43498449的博客
05-21 800
目录 1. JDBC概念 1.1 什么是JDBC 1.2 JDBC实现形式 1.3 jdbc操作API介绍 1.4 jdbc操作步骤（固定） 2. JDBC实现对数据库crud操作 2.1 第一步 加载数据库驱动 2.2 代码实现查询 2.3 代码实现添加操作 2.4代码实现修改操作 2.5代码实现删除操作 1. JDBC概念 1.1 什么是JDBC （1）Java Database Connectivity，java数据库连接 （2）java里面针对操作数据库，提供..
笨蛋学C++之 C++对数据库实现CRUD
YSL_Monet的博客
05-01 708
使用C++的CRUD操作数据库
【MySQL数据库】CRUD 增 删 改 查 超详解，有这一篇就够了！
2302_79806056的博客
05-24 1722
经过一段时间对MySQL增删查改（Insert, Delete, Select, Update）四大核心操作的学习与实践，我深刻体会到了数据库管理的复杂性和艺术性。以下是对这一学习过程的深入反思，旨在总结经验，明确改进方向，不断提升数据库操作的效率与安全性。增（Insert）数据验证的重要性。
使用 Flask 连接数据库和用户登录功能进行数据库的CRUD
jakelihua
03-10 1640
简介：在 Web 应用中，连接数据库是一项基本任务，而用户登录功能是很多应用的核心部分。本文将演示如何使用 Flask 框架连接数据库，并实现一个简单的用户登录功能。将创建一个名为user的数据库表，其中包含账号、密码和名字字段。还将实现一个登录页面，以及登录成功后跳转到的页面，显示用户姓名。
使用MyBatis实现CRUD
Mr. Xu的博客
11-03 736
MyBatis介绍： ​ mybatis 是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。 ​ mybatis 通过xml 或注解的方式将执行的各种statement 配置起来，并通过java 对象和statement 中sql的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql并将结果映射为 java 对象并返回。 采用 ORM (
JDBC技术，使用PreparedStatement实现数据库的CRUD操作
学废了的阿串的博客
12-02 287
JDBC技术中使用PreparedStatement实现数据库的CRUD操作，避免SQL注入漏洞。
JavaMysql数据库实现单表CRUD
06-14
自写的简单实现JavaMysql数据库实现单表CRUD的jay包，简单实现，欢迎批评指正。
android sqlite数据库封装 实现crud
03-06
数据库的方式，常用在存储一系列的结构复杂的数据，轻量级的数据库SQlit使用起来还是比较简单，但是总想能像hibernate似的框架可以进行下封装，实现orm并且可以实现简单的rcud。项目中只有封装包，使用过程很简单，...
SpringBoot整合MongoDB实现对数据库的CRUD小demo.zip
04-25
数据库和传统的关系型数据库差不多的概念，每个数据库含有多个集合，每个数据库最后会作为文件储存至服务器中，另外还有一些特殊的数据库进行了保留 （2）集合（table）： 在MongoDB中，数据是以文档的形式存储的，...
android数据库的crud操作
11-11
#### 四、实现CRUD操作 为了实现具体的CRUD操作，我们需要为每个实体创建一个具体的DAO类。例如，这里我们创建了一个名为`SimpleMessageDao`的类，该类实现了`EntityDao, Integer>`接口。 ##### 4.1 ...
crud-basic-python:使用本地Postgres数据库的Crud的基本实现
03-07
在这个场景中，我们将关注使用Python连接到本地PostgreSQL数据库进行CRUD操作的方法。 1. **安装必要的库** 在Python中与PostgreSQL数据库交互，我们需要安装`psycopg2`库。你可以使用pip来安装： ``` pip ...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1213
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 502
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 803
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 278
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
Java JDBC教程：实现数据库的CRUD操作
课程目标在于使学生能够理解JDBC的工作原理，熟练掌握Connection、Statement、PreparedStatement和ResultSet等接口的使用，以便在实际项目中灵活运用JDBC与数据库进行交互。通过学习，学生应能够编写出高效、安全的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值