欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

SpringBoot + Mybatis Plus 整合 Redis的詳細步驟

 更新時間：2025年03月18日 10:38:19   作者：測試開發(fā)小白變怪獸  
文章詳細介紹了Redis在用戶管理系統(tǒng)中的應用,包括用戶信息緩存、Token存儲、接口限流、重復提交攔截和熱點數據預加載等場景,并提供了具體的實現方案和步驟,感興趣的朋友一起看看吧

Redis 在用戶管理系統(tǒng)中的典型應用場景

結合你的用戶增刪改查接口，以下是 Redis 的實用場景和具體實現方案：

場景作用實現方案
用戶信息緩存減少數據庫壓力，加速查詢響應使用 Spring Cache + Redis 注解緩存
登錄 Token 存儲分布式 Session 或 JWT Token 管理將 Token 與用戶信息綁定，設置過期時間
接口限流防止惡意刷接口基于 Redis 計數器實現滑動窗口限流
重復提交攔截防止用戶重復提交表單用 Redis 存儲請求唯一標識，設置短期過期
熱點數據預加載提前緩存高頻訪問數據定時任務 + Redis 存儲

Mac M1 安裝 Redis 詳細步驟

1. 通過 Homebrew 安裝 Redis

# 安裝 Homebrew（如果尚未安裝）
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
# 安裝 Redis
brew install redis

2. 啟動 Redis 服務

# 前臺啟動（測試用，Ctrl+C 退出）
redis-server
# 后臺啟動（推薦）
brew services start redis

3. 驗證安裝

# 連接 Redis 客戶端
redis-cli ping  # 應返回 "PONG"

Spring Boot 3 整合 Redis

1. 添加依賴

在 pom.xml 中：

		<!-- Spring Cache 核心依賴 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

        <!-- Redis 驅動 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>

2. 配置 Redis 連接

application.yml：

spring:
  data:
    redis:
      host: localhost
      port: 6379
      # password: your-password  # 如果設置了密碼
      lettuce:
        pool:
          max-active: 8
          max-idle: 8

3. 示例

配置類

package com.example.spring_demo01.config;
import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.*;
import java.time.Duration;
@Configuration
public class RedisConfig {
    // 配置 RedisTemplate
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // Key 序列化
        template.setKeySerializer(new StringRedisSerializer());
        // Value 序列化為 JSON
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        // Hash 結構序列化
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
    // 配置緩存管理器
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
                .entryTtl(Duration.ofMinutes(30)); // 設置默認過期時間
        return RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
    }
}

接口限流工具類

package com.example.spring_demo01.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
@Component
public class RateLimiter {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    public boolean allowRequest(String userId) {
        String key = "rate_limit:" + userId;
        long now = System.currentTimeMillis();
        long windowMs = 60_000; // 1 分鐘
        // 移除窗口外的請求記錄
        redisTemplate.opsForZSet().removeRangeByScore(key, 0, now - windowMs);
        // 統(tǒng)計當前窗口內請求數
        Long count = redisTemplate.opsForZSet().zCard(key);
        if (count != null && count >= 10) {
            return false; // 超過限制
        }
        // 記錄本次請求
        redisTemplate.opsForZSet().add(key, UUID.randomUUID().toString(), now);
        redisTemplate.expire(key, windowMs, TimeUnit.MILLISECONDS);
        return true;
    }
}

實體類

package com.example.spring_demo01.entity;
import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;
import java.io.Serializable;
@Data
@TableName("user")
@JsonIgnoreProperties(ignoreUnknown = true) // 防止 JSON 反序列化問題
public class User implements Serializable { // 實現 Serializable
    @TableId(type = IdType.AUTO) // 主鍵自增
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

service層

package com.example.spring_demo01.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.spring_demo01.entity.User;
import com.example.spring_demo01.mapper.UserMapper;
import com.example.spring_demo01.service.UserService;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import java.io.Serializable;
@Service
public class UserServiceImpl
        extends ServiceImpl<UserMapper, User>
        implements UserService {
    // 對 MyBatis Plus 的 getById 方法添加緩存
    @Cacheable(value = "user", key = "#id")
    @Override
    public User getById(Serializable id) {
        return super.getById(id);
    }
    // 更新時清除緩存
    @CacheEvict(value = "user", key = "#entity.id")
    @Override
    public boolean updateById(User entity) {
        return super.updateById(entity);
    }
    // 刪除時清除緩存
    @CacheEvict(value = "user", key = "#id")
    @Override
    public boolean removeById(Serializable id) {
        return super.removeById(id);
    }
}

controller層

package com.example.spring_demo01.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.spring_demo01.annotation.AdminOnly;
import com.example.spring_demo01.entity.User;
import com.example.spring_demo01.service.UserService;
import com.example.spring_demo01.utils.RateLimiter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;
import java.time.Duration;
import java.util.List;
import java.util.UUID;
@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private RateLimiter rateLimiter;
    // ------------------------------ 增 ------------------------------
    @PostMapping
    public String addUser(@RequestBody User user, @RequestHeader String clientId) {
        String key = "SUBMIT_LOCK:" + clientId + ":" + user.hashCode();
        // 10秒內不允許重復提交
        Boolean success = redisTemplate.opsForValue()
                .setIfAbsent(key, "", Duration.ofSeconds(10));
        if (Boolean.FALSE.equals(success)) {
            throw new RuntimeException("請勿重復提交");
        }
        userService.save(user);
        return "新增成功";
    }
    // ------------------------------ 刪 ------------------------------
    @DeleteMapping("/{id}")
    public String deleteUser(@PathVariable Long id) {
        userService.removeById(id);
        return "刪除成功";
    }
    @DeleteMapping("/batch")
    public String deleteBatch(@RequestBody List<Long> ids) {
        userService.removeByIds(ids);
        return "批量刪除成功";
    }
    // ------------------------------ 改 ------------------------------
    @PutMapping
    public String updateUser(@RequestBody User user) {
        userService.updateById(user);
        return "更新成功";
    }
    // ------------------------------ 查 ------------------------------
    @GetMapping("/{id}")
    @AdminOnly
    public User getUserById(@PathVariable Long id) {
        return userService.getById(id);
    }
    @GetMapping("/list")
    public List<User> listUsers(
            @RequestParam(required = false) String name,
            @RequestParam(required = false) Integer age) {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        if (name != null) {
            wrapper.like("name", name); // 模糊查詢姓名
        }
        if (age != null) {
            wrapper.eq("age", age);     // 精確查詢年齡
        }
        return userService.list(wrapper);
    }
    @GetMapping("/page")
    public Page<User> pageUsers(
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize,
            @RequestHeader(value = "Authorization") String token) {
        // 從 Token 中獲取用戶ID
        log.info("token:{}", token);
        log.info("User:{}", redisTemplate.opsForValue().get(token.split(" ")[1]));
        User user = (User) redisTemplate.opsForValue().get(token.split(" ")[1]);
        if (user == null) throw new RuntimeException("未登錄");
        // 限流校驗
        if (!rateLimiter.allowRequest("PAGE_" + user.getId())) {
            throw new RuntimeException("請求過于頻繁");
        }
        return userService.page(new Page<>(pageNum, pageSize));
    }
    // ------------------------------ other ------------------------------
    @GetMapping("/error")
    public String getError() {
        throw new RuntimeException();
    }
    @PostMapping("/login")
    public String login(@RequestBody User user) {
        log.info("login user:{}", user);
        // 驗證用戶邏輯（示例簡化）
        User dbUser = userService.getOne(new QueryWrapper<User>()
                .eq("id", user.getId())
                .eq("name", user.getName()));
        if (dbUser == null) {
            throw new RuntimeException("登錄失敗");
        }
        // 生成 Token 并存儲
        String token = "TOKEN_" + UUID.randomUUID();
        redisTemplate.opsForValue().set(
                token,
                dbUser,
                Duration.ofMinutes(30)
        );
        return token;
    }
}

在啟動類添加注解：

package com.example.spring_demo01;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
@MapperScan("com.example.spring_demo01.mapper")
@ServletComponentScan // 啟用 Servlet 組件掃描（如 Filter、Servlet）
@EnableCaching // 啟動緩存，Redis使用
public class SpringDemo01Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringDemo01Application.class, args);
    }
}

常見問題排查

Q1: 連接 Redis 超時

  • 檢查服務狀態(tài)：運行 redis-cli ping 確認 Redis 是否正常運行
  • 查看端口占用：lsof -i :6379
  • 關閉防火墻：sudo ufw allow 6379

Q2: Spring Boot 無法注入 RedisTemplate

  • 確認配置類：添加 @EnableCaching 和 @Configuration
  • 檢查序列化器：顯式配置序列化方式避免 ClassCastException
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

總結

通過 Redis 你可以為項目快速實現：

  • 高性能緩存層 - 降低數據庫負載
  • 分布式會話管理 - 支持橫向擴展
  • 精細化流量控制 - 保障系統(tǒng)穩(wěn)定性

到此這篇關于SpringBoot + Mybatis Plus 整合 Redis的詳細步驟的文章就介紹到這了,更多相關SpringBoot Mybatis Plus 整合 Redis內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

相關文章

  • Netty進階之EventExecutorGroup源碼詳解

    Netty進階之EventExecutorGroup源碼詳解

    這篇文章主要介紹了Netty進階之EventExecutorGroup源碼詳解,EventExecutorGroup繼承了JDK的ScheduledExecutroService,那么它就擁有了執(zhí)行定時任務,執(zhí)行提交的普通任務,需要的朋友可以參考下
    2023-11-11
  • 解決IDEA JSP沒有代碼提示問題的幾種方法

    解決IDEA JSP沒有代碼提示問題的幾種方法

    這篇文章主要介紹了解決IDEA JSP沒有代碼提示問題的幾種方法，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
    2019-10-10
  • 淺談java 重寫equals方法的種種坑

    淺談java 重寫equals方法的種種坑

    這篇文章主要介紹了淺談java 重寫equals方法的種種“坑”，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
    2020-01-01
  • 深入了解final在java中的應用

    深入了解final在java中的應用

    談到final關鍵字，想必很多人都不陌生，在使用匿名內部類的時候可能會經常用到final關鍵字。另外，Java中的String類就是一個final類，那么今天我們就來了解final這個關鍵字的用法。
    2019-06-06
  • Java對象和Json文本轉換工具類的實現

    Java對象和Json文本轉換工具類的實現

    Json?是一個用于Java對象和Json文本相互轉換的工具類，本文主要介紹了Java對象和Json文本轉換工具類，具有一定的參考價值，感興趣的可以了解一下
    2022-03-03
  • JAVA生成短8位UUID的實例講解

    JAVA生成短8位UUID的實例講解

    這篇文章主要介紹了JAVA生成短8位UUID的實例講解，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧
    2021-01-01
  • Java并發(fā)編程ReentrantReadWriteLock加讀鎖流程

    Java并發(fā)編程ReentrantReadWriteLock加讀鎖流程

    這篇文章主要介紹了Java并發(fā)編程ReentrantReadWriteLock加讀鎖流程，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
    2023-05-05
  • Springboot獲取前端反饋信息并存入數據庫的實現代碼

    Springboot獲取前端反饋信息并存入數據庫的實現代碼

    這篇文章主要介紹了Springboot獲取前端反饋信息并存入數據庫的實現代碼,本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下
    2021-03-03
  • 舉例講解Java中的Stream流概念

    舉例講解Java中的Stream流概念

    這篇文章主要介紹了舉例講解Java中的Stream流概念,是Java入門學習中的基礎知識,需要的朋友可以參考下
    2015-09-09
  • 利用Spring Social輕松搞定微信授權登錄的方法示例

    利用Spring Social輕松搞定微信授權登錄的方法示例

    這篇文章主要介紹了利用Spring Social輕松搞定微信授權登錄的方法示例，小編覺得挺不錯的，現在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧
    2018-12-12

最新評論