JDBC API
-
依赖名称: JDBC API
-
功能描述: Database Connectivity API that defines how a client may connect and query a database.
-
数据库连接 API,定义客户端如何连接和查询数据库。
JDBC API 是 Java 标准库的一部分,提供低级别的数据库访问。需要手动管理数据库连接、事务、SQL 语句和结果集。适合需要细粒度控制的场景。
在 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 项目
-
打开 IntelliJ IDEA 并点击 “New Project”。
-
选择 “Spring Initializr”,然后点击 “Next”。
-
填写项目的基本信息:
- Group: com.dependencies
- Artifact: spring-jdbc
- Name: spring-jdbc
- Description: spring-jdbc project for Spring Boot
- Package name: com.dependencies
- Packaging: Jar
- Java: 17
-
选择依赖:
- Spring Web
- Spring JDBC
- MySQL Driver(使用 MySQL 数据库)
-
点击 “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
请根据实际情况修改 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 进行数据库操作。