IDEA2024实现数据库（MYSQL）地增删改查，并将信息存储到redis中（文章后会提供redis地安装包）
这里面前四个@Test代码是结合redis地，就是将增删改查地信息存储到redis中，方便记录。下面4个@Test代码是上一篇文章执行地最基础的对数据库进行增删改查。这里主要提供测试类里面地代码逻辑和redis地存储信息显示，之前基本的User,UserMapper,UserService还有数据库地准备可以看上一篇文章。
·
项目结构：
这里主要提供测试类里面地代码逻辑和redis地存储信息显示，之前基本的User,UserMapper,UserService还有数据库地准备可以看上一篇文章。
整个测试类地代码如下：
package com.example.demo;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import com.google.gson.Gson;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import redis.clients.jedis.Jedis;
import java.time.LocalDateTime;
import static net.sf.jsqlparser.util.validation.metadata.NamedObject.user;
import static org.junit.jupiter.api.Assertions.assertNotNull;
@SpringBootTest
class DemoApplicationTests {
@Autowired
private UserMapper userMapper;
// // 常量USER_KEY用于存储用户信息的key
// private static final String USER_KEY = "user";
// 假设这是你存储用户数据到Redis时使用的键的前缀，实际可以根据业务逻辑调整
private static final String USER_KEY_PREFIX = "user:";
// @Test
// public void demo001(){
// // 借助Jedis，只需一行代码就能连接到Redis
// // 参数为主机名、端口号
// try (Jedis jedis = new Jedis("localhost", 6379)) {
// // 初始化一个用于序列化、反序列化的gson类（google json）
// Gson gson = new Gson();
//
// User user = new User("IQ50zzz", 24);
// // 存储键值对用set方法
// jedis.set(USER_KEY, gson.toJson(user));
// // 读取键值对用get方法
// User userFromRedis = gson.fromJson(jedis.get(USER_KEY), User.class);
//
// System.out.println("get：" + userFromRedis);
//
// System.out.println("exists：" + jedis.exists(USER_KEY));
// System.out.println("del：" + jedis.del(USER_KEY));
// System.out.println("get：" + jedis.get(USER_KEY));
// }
// }
// @Test
// public void test01_select_redis() {
// // 1. 从数据库中查询用户数据
// //User user = userMapper.selectById(2L);
// com.example.demo.entity.User user = userMapper.selectById(2L);
// assertNotNull(user);
//
// // 2. 创建Jedis实例连接到Redis（这里假设Redis运行在本地默认端口6379，可根据实际调整）
// try (Jedis jedis = new Jedis("localhost", 6379)) {
// // 3. 创建Gson对象用于将User对象进行序列化和反序列化
// Gson gson = new Gson();
//
// // 4. 构造存储到Redis中的键，这里使用用户的ID作为后缀，确保键的唯一性，例如 "user:2"
// String redisKey = USER_KEY_PREFIX + user.getId();
//
// // 5. 将查询到的User对象序列化为JSON字符串，并存储到Redis中
// jedis.set(redisKey, gson.toJson(user));
//
// // 6. （可选）从Redis中读取刚存入的数据，验证是否存储成功，反序列化后进行对比
// String storedJson = jedis.get(redisKey);
// User userFromRedis = gson.fromJson(storedJson, User.class);
// assertNotNull(userFromRedis);
// // 可以进一步对比从数据库查询的user和从Redis读取的userFromRedis的各个属性是否一致，此处简单示例断言ID相等
// // assertEquals(user.getId(), userFromRedis.getId());
// }
// }
// @Test
// public void test02_insert_redis() {
// // 1. 创建要插入的用户对象并插入数据库
// User userToInsert = User.builder()
// .userName("newUserName")
// .email("new@example.com")
// .age(25)
// .name("New Name")
// .password("newPassword")
// .build();
// int insertResult = userMapper.insert(userToInsert);
// //assertEquals(1, insertResult); // 断言插入操作成功，通常插入一条记录成功返回值为1
//
// // 2. 获取插入数据的ID，用于后续操作（这里假设插入成功后能通过对象获取到生成的主键ID）
// Long insertedUserId = userToInsert.getId();
// assertNotNull(insertedUserId);
//
// // 3. 创建Jedis实例连接到Redis（这里假设Redis运行在本地默认端口6379，可根据实际调整）
// try (Jedis jedis = new Jedis("localhost", 6379)) {
// // 4. 创建Gson对象用于将User对象进行序列化和反序列化
// Gson gson = new Gson();
//
// // 5. 构造存储到Redis中的键，使用刚插入用户的ID作为后缀，确保键的唯一性，例如 "user:具体ID"
// String redisKey = USER_KEY_PREFIX + insertedUserId;
//
// // 6. 将插入数据库后完整的用户对象序列化为JSON字符串，并存储到Redis中
// jedis.set(redisKey, gson.toJson(userToInsert));
//
// // 7. （可选）从Redis中读取刚存入的数据，验证是否存储成功，反序列化后进行对比
// String storedJson = jedis.get(redisKey);
// User userFromRedis = gson.fromJson(storedJson, User.class);
// assertNotNull(userFromRedis);
// }
// }
// @Test
// public void testDeleteAndSaveToRedis() {
// // 1. 执行删除操作，获取要删除的用户ID（这里假设删除ID为1L的用户记录，可按需调整）
// Long userIdToDelete = 2L;
// int deleteResult = userMapper.deleteById(userIdToDelete);
// assertNotNull(deleteResult);
//
// // 2. 创建Jedis实例连接到Redis（假设Redis在本地默认端口6379，按需修改）
// try (Jedis jedis = new Jedis("localhost", 6379)) {
// // 3. 创建Gson对象用于序列化和反序列化
// Gson gson = new Gson();
//
// // 4. 构造包含删除记录信息的对象，这里包含被删除用户的ID以及删除操作的时间
// DeleteRecordInfo deleteRecordInfo = new DeleteRecordInfo(userIdToDelete, LocalDateTime.now());
//
// // 5. 构造存储到Redis中的键，使用被删除用户的ID作为后缀，保证唯一性，如 "deleted_record:1"
// String redisKey = USER_KEY_PREFIX + userIdToDelete;
//
// // 6. 将包含删除记录信息的对象序列化为JSON字符串，并存入Redis
// jedis.set(redisKey, gson.toJson(deleteRecordInfo));
//
// // 7. （可选）从Redis中读取刚存入的数据，验证是否存储成功，反序列化后对比
// String storedJson = jedis.get(redisKey);
// DeleteRecordInfo retrievedInfo = gson.fromJson(storedJson, DeleteRecordInfo.class);
// assertNotNull(retrievedInfo);
// // 简单验证读取出来的被删除用户ID是否一致（可按需扩展更多验证逻辑）
// //assertEquals(userIdToDelete, retrievedInfo.getDeletedUserId());
// }
// }
//
// // 内部类，用于封装删除记录的相关信息，可根据需求扩展更多属性
// private static class DeleteRecordInfo {
// private Long deletedUserId;
// private LocalDateTime deleteTime;
//
// public DeleteRecordInfo(Long deletedUserId, LocalDateTime deleteTime) {
// this.deletedUserId = deletedUserId;
// this.deleteTime = deleteTime;
// }
//
// public Long getDeletedUserId() {
// return deletedUserId;
// }
//
// public LocalDateTime getDeleteTime() {
// return deleteTime;
// }
// }
@Test
public void testUpdateAndSaveToRedis() {
// 1. 执行修改操作
User userToUpdate = User.builder()
.id(4L)
.password("1277")
.build();
int updateResult = userMapper.updateById(userToUpdate);
assertNotNull(updateResult);
// 2. 创建Jedis实例连接到Redis（假设Redis在本地默认端口6379，按需修改）
try (Jedis jedis = new Jedis("localhost", 6379)) {
// 3. 创建Gson对象用于序列化和反序列化
Gson gson = new Gson();
// 4. 构造包含修改记录信息的对象，这里包含被修改用户的ID以及修改操作的时间，你可按需扩展更多信息，比如修改前的数据等
UpdateRecordInfo updateRecordInfo = new UpdateRecordInfo(userToUpdate.getId(), LocalDateTime.now());
// 5. 构造存储到Redis中的键，使用被修改用户的ID作为后缀，保证唯一性，如 "updated_record:4"
String redisKey = USER_KEY_PREFIX + userToUpdate.getId();
// 6. 将包含修改记录信息的对象序列化为JSON字符串，并存入Redis
jedis.set(redisKey, gson.toJson(updateRecordInfo));
// 7. （可选）从Redis中读取刚存入的数据，验证是否存储成功，反序列化后对比
String storedJson = jedis.get(redisKey);
UpdateRecordInfo retrievedInfo = gson.fromJson(storedJson, UpdateRecordInfo.class);
assertNotNull(retrievedInfo);
// 简单验证读取出来的被修改用户ID是否一致（可按需扩展更多验证逻辑）
//assertEquals(userToUpdate.getId(), retrievedInfo.getUpdatedUserId());
}
}
// 内部类，用于封装修改记录的相关信息，可根据需求扩展更多属性，比如添加修改前的用户数据等
private static class UpdateRecordInfo {
private Long updatedUserId;
private LocalDateTime updateTime;
public UpdateRecordInfo(Long updatedUserId, LocalDateTime updateTime) {
this.updatedUserId = updatedUserId;
this.updateTime = updateTime;
}
public Long getUpdatedUserId() {
return updatedUserId;
}
public LocalDateTime getUpdateTime() {
return updateTime;
}
}
// @Test
// public void test01()_select{
// User user = userMapper.selectById(2L);
// System.out.println(user);
// }
// @Test
// public void test02_insert() {
// User user = User.builder()
// .userName("hhh")
// .email("153@qq.com")
// .age(18)
// .name("a")
// .password("123")
// .build();
// int insert = userMapper.insert(user);
// System.out.println(insert);
// }
// @Test
// public void test03_delete(){
// int user = userMapper.deleteById(1L);
// System.out.println(user);
// }
// @Test
// public void test04_update(){
// User user=User.builder()
// .id(2L)
// .password("1277")
// .build();
// //根据主键id来修改数据库的信息，如果这个对象的成员变量值为null，就不修改数据库的字段名
// int i = userMapper.updateById(user);
// System.out.println(i);
// }
}
这里面前四个@Test代码是结合redis地，就是将增删改查地信息存储到redis中，方便记录。下面4个@Test代码是上一篇文章执行地最基础的对数据库进行增删改查。
首先大家需要下载一个redis地安装包：
用win+r来启动终端，输入下面这条语句，括号里面地是你下载安装包后解压地地址（因为你得进去，然后启动里面地redis_cli）：
启动redis_cli:
输入keys *,可以查看键值对，这个之后可以通过它来判断你地增删改查信息是否存进去了：
当我们执行第一个测试时：test_select_redis:
第二个测试：test_insert_redis:
第三个删除测试时：
第四个修改测试：
如果大家觉得链接终端输入keys比较麻烦，那可以下载一个redis管理器，可以很直观的看到所有地keys和value:
DAMO开发者矩阵，由阿里巴巴达摩院和中国互联网协会联合发起，致力于探讨最前沿的技术趋势与应用成果，搭建高质量的交流与分享平台，推动技术创新与产业应用链接，围绕“人工智能与新型计算”构建开放共享的开发者生态。
更多推荐
6
0- 0
已为社区贡献2条内容
所有评论(0)