springboot依赖之JDBC API

JDBC API

• 依赖名称: JDBC API
• 功能描述: Database Connectivity API that defines how a client may connect and query a database.
• 数据库连接 API，定义客户端如何连接和查询数据库。

在 IntelliJ IDEA 中创建 Spring Boot 项目并使用 JDBC API 进行数据库操作，可以按照以下步骤操作：

<dependency>
	            <groupId>org.springframework.boot</groupId>
	            <artifactId>spring-boot-starter-jdbc</artifactId>
	        </dependency>

源码已开源，可以免费下载
码云gitee： https://gitee.com/CoderChange/springboot-all-dependencies

1. 创建 Spring Boot 项目

1. 打开 IntelliJ IDEA 并点击 “New Project”。

2. 选择 “Spring Initializr”，然后点击 “Next”。

3. 填写项目的基本信息：

   • Group: com.dependencies
   • Artifact: spring-jdbc
   • Name: spring-jdbc
   • Description: spring-jdbc project for Spring Boot
   • Package name: com.dependencies
   • Packaging: Jar
   • Java: 17

4. 选择依赖：

   • Spring Web
   • Spring JDBC
   • MySQL Driver（使用 MySQL 数据库）

5. 点击 “Next”，然后点击 “Finish”，等待 IDEA 下载依赖并初始化项目。
   

2. 添加 MySQL 依赖

在 pom.xml 中确保包含 MySQL 依赖：

<properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

3. 配置数据库连接

在 src/main/resources/application.properties 文件中添加 MySQL 数据库连接信息：

# MySQL Database configuration
spring.datasource.url=jdbc:mysql://localhost:3306/spring-dependencies?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver

# JPA & Hibernate
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

请根据实际情况修改 spring.datasource.url，spring.datasource.username 和 spring.datasource.password。

4. 创建数据库表

在 MySQL 中创建一个名为 spring-dependencies 的数据库，并创建一个示例表：

CREATE DATABASE spring-dependencies;

USE spring-dependencies;

CREATE TABLE `users` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(100) COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '' COMMENT '姓名',
  `email` varchar(100) COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '' COMMENT '邮箱',
  `created_at` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='用户信息表';

5. 编写 JDBC 代码

创建实体类

创建一个简单的用户实体类 User：

package com.dependencies.springjdbc.model;

/**
 * @author zhizhou   2024/7/29 23:23
 */
public class User {
    
    private int id;
    private String name;
    private String email;
   
    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 String getEmail() {
        return email;
    }
    
    public void setEmail(String email) {
        this.email = email;
    }
}

创建 DAO 类

创建一个数据访问对象（DAO）类 UserDao，使用 JDBC 进行数据库操作：

package com.dependencies.springjdbc.dao;

import com.dependencies.springjdbc.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

/**
 * @author zhizhou   2024/7/29 23:23
 */
@Repository
public class UserDao {
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    private static final class UserMapper implements RowMapper<User> {
        public User mapRow(ResultSet rs, int rowNum) throws SQLException {
            User user = new User();
            user.setId(rs.getInt("id"));
            user.setName(rs.getString("name"));
            user.setEmail(rs.getString("email"));
            return user;
        }
    }
    
    public List<User> findAll() {
        return jdbcTemplate.query("SELECT * FROM users", new UserMapper());
    }
    
    public User findById(int id) {
        return jdbcTemplate.queryForObject("SELECT * FROM users WHERE id = ?", new UserMapper(), new Object[]{id});
    }
    
    public int save(User user) {
        return jdbcTemplate.update("INSERT INTO users (name, email) VALUES (?, ?)",
                user.getName(), user.getEmail());
    }
    
    public int update(User user) {
        return jdbcTemplate.update("UPDATE users SET name = ?, email = ? WHERE id = ?",
                user.getName(), user.getEmail(), user.getId());
    }
    
    public int deleteById(int id) {
        return jdbcTemplate.update("DELETE FROM users WHERE id = ?", id);
    }
}

创建服务类

创建一个服务类 UserService，编写封装简单的业务逻辑：

package com.dependencies.springjdbc.service;

import com.dependencies.springjdbc.dao.UserDao;
import com.dependencies.springjdbc.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author zhizhou   2024/7/29 23:29
 */
@Service
public class UserService {
    
    @Autowired
    private UserDao userDao;
    
    public List<User> findAll() {
        return userDao.findAll();
    }
    
    public User findById(int id) {
        return userDao.findById(id);
    }
    
    public int save(User user) {
        return userDao.save(user);
    }
    
    public int update(User user) {
        return userDao.update(user);
    }
    
    public int deleteById(int id) {
        return userDao.deleteById(id);
    }
}

创建控制器类

创建一个简单的控制器类 UserController，处理 用户相关的HTTP 请求：

package com.dependencies.springjdbc.controller;

import com.dependencies.springjdbc.model.User;
import com.dependencies.springjdbc.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @author zhizhou   2024/7/29 23:22
 */

@RestController
@RequestMapping("/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping
    public List<User> findAll() {
        return userService.findAll();
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<User> findById(@PathVariable int id) {
        User user = userService.findById(id);
        if (user != null) {
            return ResponseEntity.ok(user);
        } else {
            return ResponseEntity.notFound().build();
        }
    }
    
    @PostMapping
    public ResponseEntity<String> save(@RequestBody User user) {
        int result = userService.save(user);
        if (result == 1) {
            return ResponseEntity.ok("用户信息创建成功");
        } else {
            return ResponseEntity.status(500).body("用户信息更新失败");
        }
    }
    
    @PutMapping("/{id}")
    public ResponseEntity<String> update(@PathVariable int id, @RequestBody User user) {
        user.setId(id);
        int result = userService.update(user);
        if (result == 1) {
            return ResponseEntity.ok("用户信息更新成功");
        } else {
            return ResponseEntity.status(500).body("用户信息更新失败");
        }
    }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<String> deleteById(@PathVariable int id) {
        int result = userService.deleteById(id);
        if (result == 1) {
            return ResponseEntity.ok("用户信息删除成功");
        } else {
            return ResponseEntity.status(500).body("用户信息删除失败");
        }
    }
}

6. 启动项目

在 IntelliJ IDEA 中，右键点击主类，选择 “Run” 或 “Debug”。项目启动后，使用 Postman 或 curl 进行 HTTP 请求测试，验证各个 CRUD 操作。

示例请求

创建用户

curl -X POST "http://localhost:8080/users" -H "Content-Type: application/json" -d '{"name": "一周一志程序员", "email": "123456@gmail.com"}'

获取所有用户信息列表

curl -X GET "http://localhost:8080/users"

根据 ID 获取用户信息

curl -X GET "http://localhost:8080/users/1"

更新用户信息

curl -X PUT "http://localhost:8080/users/1" -H "Content-Type: application/json" -d '{"name": "一周一志程序员", "email": "654321@qq.com"}'

删除用户信息

curl -X DELETE "http://localhost:8080/users/1"

通过上述步骤，我们可以在 IDEA 中成功创建一个 Spring Boot 项目，并且使用 JDBC API 进行数据库操作。