1. Python技术站首页
  2. 其他
  3. Java

将原生JDBC封装实现CRUD的案例

• Java

针对“将原生JDBC封装实现CRUD的案例”的完整攻略，我来为您进行详细讲解。

什么是JDBC？

Java 数据库连接（Java Database Connectivity，简称JDBC），是Java语言中用来规范客户端程序如何访问数据库的应用程序接口，提供了一系列的类和接口，使得Java程序可以方便地对各种关系型数据库进行操作。

为什么需要封装JDBC？

JDBC提供的技术过于原始繁琐，长期使用原生JDBC将会带来很多问题，例如代码冗余、维护成本较高、易错等。因此，一些开发者通过封装原生JDBC，将其封装成一个类库、框架，业务开发人员可以直接使用统一且简洁的接口进行数据库操作，从而提高开发效率。

封装JDBC实现CRUD示例

为了展示如何封装原生JDBC实现CRUD，我们提供以下两个示例。

示例一：连接池封装

  1. 首先，需要导入以下依赖：
<!-- 数据库连接池依赖 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.3</version>
</dependency>

<!-- JdbcTemplate依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>4.3.10.RELEASE</version>
</dependency>
  1. 定义一个连接池，通过连接池类的getDataSource()方法获取JdbcTemplate对象。
import com.alibaba.druid.pool.DruidDataSource;
import javax.sql.DataSource;

/**
 * 数据库连接池
 */
public class DbPool {

    private final DruidDataSource dataSource;

    public DbPool() {
        dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
    }

    public DataSource getDataSource() {
        return dataSource;
    }

}
  1. 封装基于JdbcTemplate的数据库操作类

JdbcTemplate是Spring Framework提供的一个用于简化JDBC操作的工具类。在此基础上，我们可以很方便地进行增删改查操作。

import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;
import java.util.List;

/**
 * 封装基于JdbcTemplate的数据库操作类
 */
public class Dao {

    private final JdbcTemplate jdbcTemplate;

    public Dao() {
        DataSource dataSource = new DbPool().getDataSource();
        jdbcTemplate = new JdbcTemplate(dataSource);
    }

    public List<User> queryAll() {
        String sql = "select * from user";
        List<User> userList = jdbcTemplate.query(sql, new UserMapper());
        return userList;
    }

    public int insert(User user) {
        String sql = "insert into user(name, age) values (?, ?)";
        Object[] params = {user.getName(), user.getAge()};
        int rows = jdbcTemplate.update(sql, params);
        return rows;
    }

    public int update(User user) {
        String sql = "update user set name = ?, age = ? where id = ?";
        Object[] params = {user.getName(), user.getAge(), user.getId()};
        int rows = jdbcTemplate.update(sql, params);
        return rows;
    }

    public int delete(Long id) {
        String sql = "delete from user where id = ?";
        Object[] params = {id};
        int rows = jdbcTemplate.update(sql, params);
        return rows;
    }

}

示例二：ORM框架封装

在封装JDBC的过程中，ORM（对象关系映射）框架也是非常常见的一种方式。Hibernate和MyBatis是两个比较流行的ORM框架。

在这里，我们以MyBatis为例，详细演示如何封装原生JDBC。

  1. 步骤一：在pom.xml中导入以下依赖
<!-- MySQL Connector驱动包 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.22</version>
</dependency>

<!-- MyBatis依赖 -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.5</version>
</dependency>

<!-- Spring Framework依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>4.3.10.RELEASE</version>
</dependency>
  1. 步骤二：在resource目录下定义以下两个文件：

mybatis-config.xml文件，在这个文件中定义了数据库连接信息、映射文件路径、别名等信息。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <typeAlias alias="User" type="com.example.User"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/UserMapper.xml"/>
    </mappers>
</configuration>

UserMapper.xml文件，这个文件定义了SQL语句和结果映射。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.UserMapper">
    <resultMap id="BaseResultMap" type="User">
        <id column="id" jdbcType="BIGINT" property="id"/>
        <result column="name" jdbcType="VARCHAR" property="name"/>
        <result column="age" jdbcType="INTEGER" property="age"/>
    </resultMap>
    <select id="selectById" resultMap="BaseResultMap">
        select *
        from user
        where id = #{id,jdbcType=BIGINT}
    </select>
    <select id="selectAll" resultMap="BaseResultMap">
        select *
        from user
    </select>
    <insert id="insert" parameterType="User">
        insert into user (name, age)
        values (#{name,jdbcType=VARCHAR}, #{age,jdbcType=INTEGER})
    </insert>
    <update id="update" parameterType="User">
        update user
        set
        name = #{name,jdbcType=VARCHAR},
        age = #{age,jdbcType=INTEGER}
        where id = #{id,jdbcType=BIGINT}
    </update>
    <delete id="delete" parameterType="java.lang.Long">
        delete from user
        where id = #{id,jdbcType=BIGINT}
    </delete>
</mapper>
  1. 步骤三：定义相应的User实体类，如下所示：
public class User {

    private Long id;

    private String name;

    private Integer age;

    // setter和getter方法
}
  1. 步骤四：定义UserMapper接口，如下所示：
public interface UserMapper {

    User selectById(Long id);

    List<User> selectAll();

    int insert(User user);

    int update(User user);

    int delete(Long id);

}
  1. 步骤五：定义基于MyBatis的DAO，通过SqlSession连接Mapper接口。
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
 * 基于MyBatis的DAO
 */
public class UserDao {

    private final SqlSession sqlSession;

    public UserDao() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession = sqlSessionFactory.openSession();
    }

    public User selectById(Long id) {
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        return userMapper.selectById(id);
    }

    public List<User> selectAll() {
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        return userMapper.selectAll();
    }

    public int insert(User user) {
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        int rows = userMapper.insert(user);
        sqlSession.commit();
        return rows;
    }

    public int update(User user) {
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        int rows = userMapper.update(user);
        sqlSession.commit();
        return rows;
    }

    public void delete(Long id) {
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        userMapper.delete(id);
        sqlSession.commit();
    }

}

至此，我们已经学会了如何利用MyBatis框架，将原生JDBC封装实现CRUD的案例。

希望本文的讲解能够对您有所帮助，谢谢！

阅读剩余 84%

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：将原生JDBC封装实现CRUD的案例 - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年5月20日
下一篇 2023年5月20日

相关文章

  • 老生常谈Java反射机制(必看篇)

    老生常谈Java反射机制(必看篇) 什么是Java反射机制？ Java反射机制是Java提供的一种能够在运行时获取对象的信息以及修改对象的内容的方法。通过反射机制，程序可以获取任意一个类的内部信息，并且可以操作类、构造器、方法、成员变量等。 反射机制的应用场景 通过配置文件来读取实例化的对象 对框架类进行扩展 调试时查看对象的属性信息 反射机制的基本用法 获…

    Java 2023年5月26日
    00

  • Java前后端的JSON传输方式(前后端JSON格式转换)

    下面是针对Java前后端的JSON传输方式以及前后端JSON格式转换的完整攻略。 一、JSON格式简介 JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。JSON格式常用于Web应用程序之间的数据传输。 1.1 JSON格式规则 在JSON中，数据格式采用键值对的形式，键值…

    Java 2023年5月26日
    00

  • Java中String和StringBuffer及StringBuilder 有什么区别

    Java中String、StringBuffer和StringBuilder都是关于字符串的类，但它们有着不同的特点和用法。 String类 String类是Java中的一个不可变类，一旦声明并赋值，它的实际内容就无法再被改变了。这是由于它的内部实现是通过一个指向char数组的final引用来实现的。换句话说，一旦String对象被创建，这个引用就不能指向另…

    Java 2023年5月27日
    00

  • Java项目中如何访问WEB-INF下jsp页面

    在Java Web项目中，JSP页面一般会放在WEB-INF目录下以保证安全性。但在某些情况下，需要在Java代码中访问这些JSP页面。以下是Java项目中如何访问WEB-INF下JSP页面的完整攻略。 使用JSP的内部跳转方法： request.getRequestDispatcher("/WEB-INF/jsp/xxx.jsp").f…

    Java 2023年5月26日
    00

  • Java利用套接字实现应用程序对数据库的访问

    Java利用套接字实现应用程序对数据库的访问，需要经过以下步骤： 配置数据库信息：在Java应用程序中，我们可以通过配置文件比如Property文件来存储数据库信息，比如数据库名称、用户名、密码、地址、端口等等。 建立连接：使用Java JDBC API中的该库驱动连接数据库。 字段验证：避免SQL注入攻击，对输入的字段进行验证和过滤。 构建SQL语句：使用…

    Java 2023年6月1日
    00

  • 详解Java的继承

    详解Java的继承 Java中的继承是一种面向对象编程中非常重要的概念，它可以让子类拥有父类的属性和方法，同时也可以通过继承来实现代码的复用和继承树的建立。本文将详解Java的继承，包括继承的语法、继承的作用和细节问题，通过两个实例来帮助理解。 继承的语法 在Java中，使用关键字 extends 来创建子类并继承父类。例如： class Child ext…

    Java 2023年5月26日
    00

  • vue 实现axios拦截、页面跳转和token 验证

    下面我将详细讲解“Vue 实现 Axios 拦截、页面跳转和 Token 验证”的完整攻略。 简介 在 Vue 中，我们常常使用 Axios 发起网络请求。而为了保证数据的安全性和用户的登录状态，我们需要进行拦截、跳转和 Token 验证。下面是具体的实现步骤。 实现步骤 1. 安装依赖 首先，需要在项目中安装两个依赖：axios 和 vue-router。…

    Java 2023年6月16日
    00

  • SpringBoot中时间类型 序列化、反序列化、格式处理示例代码

    下面我就来为您详细讲解“SpringBoot中时间类型 序列化、反序列化、格式处理示例代码”的完整攻略。 1. 背景介绍 在实际开发中，我们经常会遇到时间类型的序列化、反序列化、格式处理问题，SpringBoot在处理时间类型时提供了很多便利，本文将介绍SpringBoot中时间类型的序列化、反序列化、格式处理示例代码。 2. 时间类型的序列化 在Sprin…

    Java 2023年5月20日
    00
合作推广
合作推广
分享本页
返回顶部