Java与Redis解锁高效数据处理的密码

为什么选择 Redis

Java 操作 Redis 的常见方式

Jedis：经典老炮登场

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.7.0</version>
</dependency>

import redis.clients.jedis.Jedis;

public class JedisExample {
    public static void main(String[] args) {
        // 建立连接
        Jedis jedis = new Jedis("localhost", 6379);
        // 设置键值对
        jedis.set("name", "Java Redis");
        // 获取值
        String value = jedis.get("name");
        System.out.println("获取到的值：" + value);
        // 关闭连接
        jedis.close();
    }
}

Lettuce：后起之秀崛起

<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.1.7.RELEASE</version>
</dependency>

import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisCommands;
import io.lettuce.core.StatefulRedisConnection;

public class LettuceExample {
    public static void main(String[] args) {
        // 创建RedisClient
        RedisClient redisClient = RedisClient.create("redis://localhost:6379");
        // 建立连接
        StatefulRedisConnection<String, String> connection = redisClient.connect();
        // 获取同步命令执行器
        RedisCommands<String, String> syncCommands = connection.sync();
        // 设置键值对
        syncCommands.set("message", "Hello, Lettuce!");
        // 获取值
        String value = syncCommands.get("message");
        System.out.println("获取到的值：" + value);
        // 关闭连接
        connection.close();
        redisClient.shutdown();
    }
}

Spring Data Redis：企业级的得力助手

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class RedisService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }
}

Java 操作 Redis 的实战案例

缓存数据，加速查询

spring:
  redis:
    host: localhost
    port: 6379
    password: 
    database: 0

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class BookService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 模拟从数据库查询书籍
    public Book getBookFromDatabase(Long bookId) {
        // 这里可以编写实际的数据库查询逻辑，例如使用JPA或MyBatis
        // 此处仅为示例，直接返回一个固定的Book对象
        Book book = new Book();
        book.setId(bookId);
        book.setTitle("Java核心技术");
        book.setAuthor("Cay S. Horstmann");
        return book;
    }

    public Book getBookById(Long bookId) {
        String key = "book:" + bookId;
        Book book = (Book) redisTemplate.opsForValue().get(key);
        if (book == null) {
            book = getBookFromDatabase(bookId);
            if (book != null) {
                redisTemplate.opsForValue().set(key, book);
            }
        }
        return book;
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class BookController {

    @Autowired
    private BookService bookService;

    @GetMapping("/books/{id}")
    public Book getBook(@PathVariable Long id) {
        return bookService.getBookById(id);
    }
}

实现排行榜，实时竞争一目了然

import redis.clients.jedis.Jedis;
import java.util.Set;
import redis.clients.jedis.Tuple;

public class UserScoreRank {
    private Jedis jedis;

    public UserScoreRank() {
        jedis = new Jedis("localhost", 6379);
    }

    // 添加用户积分
    public void addUserScore(String userId, double score) {
        jedis.zadd("user_score_rank", score, userId);
    }

    // 获取排行榜前列的用户
    public Set<Tuple> getTopUsers(int n) {
        return jedis.zrevrangeWithScores("user_score_rank", 0, n - 1);
    }

    public static void main(String[] args) {
        UserScoreRank rank = new UserScoreRank();
        rank.addUserScore("user1", 80);
        rank.addUserScore("user2", 90);
        rank.addUserScore("user3", 75);
        Set<Tuple> topUsers = rank.getTopUsers(3);
        for (Tuple user : topUsers) {
            System.out.println("用户ID：" + user.getElement() + "，积分：" + user.getScore());
        }
    }
}

构建消息队列，异步处理任务

import redis.clients.jedis.Jedis;

public class TaskQueue {
    private Jedis jedis;

    public TaskQueue() {
        jedis = new Jedis("localhost", 6379);
    }

    // 添加任务到队列
    public void addTask(String task) {
        jedis.rpush("task_queue", task);
    }

    // 从队列中获取任务
    public String getTask() {
        return jedis.lpop("task_queue");
    }

    public static void main(String[] args) {
        TaskQueue queue = new TaskQueue();
        queue.addTask("任务1");
        queue.addTask("任务2");
        String task = queue.getTask();
        System.out.println("获取到的任务：" + task);
    }
}

注意事项与常见问题解决

内存淘汰策略选择

缓存穿透、击穿和雪崩应对

缓存穿透

缓存击穿

缓存雪崩

数据序列化问题处理