Redis在项目中的17种使用场景

Redis 是一个开源的高性能键值对数据库，它以其内存中数据存储、键过期策略、持久化、变乱、丰富的数据范例支持以及原子操作等特性，在许多项目中扮演着关键脚色。以下是V哥整理的17个Redis在项目中常见的使用场景：
  

• 缓存：Redis 可以作为应用步调的缓存层，减少数据库的读取压力，提高数据访问速度。
  
• 会话存储：在 Web 应用中，Redis 可以用来存储用户的会话信息，如登录状态、购物车内容等。
  
• 排行榜和计数器：Redis 支持原子操作，非常适合实现及时排行榜、点赞数、访问计数等功能。
  
• 消息队列：Redis 可以作为消息队列系统，用于处理异步任务，例如邮件发送、后台任务处理等。
  
• 及时分析：Redis 可以用于及时分析，如用户行为分析、及时统计信息等。
  
• 分布式锁：在分布式系统中，Redis 可以用于实现分布式锁，确保在多个节点之间共享资源的同等性。
  
• 发布/订阅：Redis 提供了发布/订阅模式，可以用于实现消息广播，例如及时通知系统。
  
• 限流：Redis 可以用于实现限流功能，防止系统过载，如 API 调用频率限制。
  
• 数据过期：Redis 支持设置数据的过期时间，自动清算过期数据，适用于暂时数据存储。
  
• 全页缓存：Redis 可以缓存整个页面的输出，减少数据库查询和页面渲染时间。
  
• 社交功能：在社交网络应用中，Redis 可以用于存储好友关系、用户状态更新等。
  
• 及时保举系统：Redis 可以用于存储用户的行为数据和偏好，实现及时保举。
  
• 地理位置信息：Redis 支持 Geospatial 索引，可以用于实现地理位置相干的查询和保举。
  
• 时间序列数据：Redis 可以存储时间序列数据，用于监控和分析。
  
• 任务调度：Redis 可以用于任务调度，例如定时任务的执行。
  
• 数据共享：在微服务架构中，Redis 可以作为服务间共享数据的媒介。
  
• 持久化：固然 Redis 是内存数据库，但它也支持数据持久化，可以在系统故障后恢复数据。
  

Redis 的使用场景非常广泛，可以根据项目的详细需求来选择符合的应用方式。
下面V哥依次对17种业务场景举例说明和解释：
1. 缓存

针对Redis作为缓存层的使用场景，我将提供一个简单的Java Spring Boot应用案例，该应用使用Redis缓存来提高数据库查询的服从。
场景形貌
假设我们有一个在线书店，用户可以查看册本的详细信息。每次用户请求册本详情时，后端必要查询数据库以获取册本信息。为了提高性能，我们可以使用Redis缓存来存储热门册本的信息，以减少对数据库的查询次数。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Web
  
• Spring Data Redis
  
• Redis客户端驱动，如lettuce或jedis
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 定义册本实体类
  
  1. public class Book {
  2.     private String id;
  3.     private String title;
  4.     private String author;
  5.     // 省略构造函数、getter和setter方法
  6. }

  复制代码
• 创建册本服务接口和实现类
  
  1. public interface BookService {
  2.     Book getBookById(String id);
  3. }
  5. @Service
  6. public class BookServiceImpl implements BookService {
  7.    
  8.     @Autowired
  9.     private BookRepository bookRepository;
  10.    
  11.     @Autowired
  12.     private StringRedisTemplate redisTemplate;
  14.     @Override
  15.     public Book getBookById(String id) {
  16.         // 尝试从Redis缓存中获取书籍
  17.         Book cachedBook = redisTemplate.opsForValue().get(id);
  18.         if (cachedBook != null) {
  19.             return cachedBook;
  20.         }
  21.         
  22.         // 如果缓存中没有，从数据库查询
  23.         Book book = bookRepository.findById(id).orElse(null);
  24.         if (book != null) {
  25.             // 将查询结果放入缓存，设置过期时间为10分钟
  26.             redisTemplate.opsForValue().set(id, book, 10, TimeUnit.MINUTES);
  27.         }
  28.         return book;
  29.     }
  30. }

  复制代码
  
  
• 创建册本仓库接口
  
  1. public interface BookRepository extends JpaRepository<Book, String> {
  2. }

  复制代码
  
  
• 创建控制器
  
  1. @RestController
  2. @RequestMapping("/books")
  3. public class BookController {
  5.     @Autowired
  6.     private BookService bookService;
  8.     @GetMapping("/{id}")
  9.     public ResponseEntity<Book> getBook(@PathVariable String id) {
  10.         Book book = bookService.getBookById(id);
  11.         if (book != null) {
  12.             return ResponseEntity.ok(book);
  13.         } else {
  14.             return ResponseEntity.notFound().build();
  15.         }
  16.     }
  17. }

  复制代码
  详细解释
  

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 定义册本实体类：这是一个简单的POJO类，代表数据库中的册本记录。
  
• 创建册本服务：BookService接口定义了获取册本的方法。BookServiceImpl实现了这个接口，并使用BookRepository从数据库获取数据。同时，它还使用了StringRedisTemplate来操作Redis缓存。
  
• 缓存逻辑：在getBookById方法中，首先尝试从Redis缓存中获取册本信息。如果缓存中存在，直接返回；如果不存在，则从数据库查询，并把效果存入缓存，同时设置10分钟的过期时间。
  
• 创建控制器：BookController提供了一个RESTful API端点/books/{id}，用于根据册本ID获取册本信息。
  通过这种方式，我们可以显著减少对数据库的查询次数，特别是对于热门册本，从而提高应用的性能和响应速度。
  2. 会话存储
  
  针对Redis作为会话存储的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis来存储用户会话信息。
  场景形貌
  假设我们正在开辟一个Web应用步调，用户必要登录以访问某些受掩护的资源。为了管理用户会话，我们可以使用Redis来存储会话信息，而不是将它们存储在服务器的内存中或数据库中。
  创建Spring Boot项目
  使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
  设置Redis毗连
  在src/main/resources/application.properties中设置Redis服务器的毗连信息：
  
  1. spring.redis.host=localhost
  2. spring.redis.port=6379server.servlet.session.persistent=falseserver.servlet.session.timeout=15spring.session.store-type=redis

  复制代码
  编写业务代码
  

• 创建用户实体类
  
  1. public class User {
  2.     private String username;
  3.     private String password;
  4.     // 省略构造函数、getter和setter方法
  5. }

  复制代码
• 创建用户存储库接口
  
  1. @Service
  2. public class InMemoryUserRepository implements UserDetailsService {
  4.     private static final Map<String, User> users = new HashMap<>();
  6.     static {
  7.         users.put("user", new User("user", "password"));
  8.         // 添加更多用户...
  9.     }
  11.     @Override
  12.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  13.         User user = users.get(username);
  14.         if (user == null) {
  15.             throw new UsernameNotFoundException("User not found with username: " + username);
  16.         }
  17.         return new org.springframework.security.core.userdetails.User(
  18.                 user.getUsername(),
  19.                 user.getPassword(),
  20.                 new ArrayList<>()
  21.         );
  22.     }
  23. }

  复制代码
• 设置Spring Security
  
  1. @Configuration
  2. @EnableWebSecurity
  3. public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
  5.     @Autowired
  6.     private UserDetailsService userDetailsService;
  8.     @Override
  9.     protected void configure(HttpSecurity http) throws Exception {
  10.         http
  11.             .authorizeRequests()
  12.                 .antMatchers("/admin/**").hasRole("ADMIN")
  13.                 .antMatchers("/user/**").hasAnyRole("USER", "ADMIN")
  14.                 .antMatchers("/", "/home", "/register").permitAll()
  15.                 .anyRequest().authenticated()
  16.             .and()
  17.             .formLogin()
  18.                 .loginPage("/login")
  19.                 .permitAll()
  20.             .and()
  21.             .logout()
  22.                 .permitAll();
  23.     }
  25.     @Autowired
  26.     public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
  27.         auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
  28.     }
  30.     @Bean
  31.     public PasswordEncoder passwordEncoder() {
  32.         return new BCryptPasswordEncoder();
  33.     }
  34. }

  复制代码
• 创建登录和登出控制器
  
  1. @Controller
  2. public class WebController {
  4.     @GetMapping("/login"
  5.     public String login() {
  6.         return "login";
  7.     }
  9.     @GetMapping("/admin"
  10.     public String adminPage() {
  11.         return "admin";
  12.     }
  14.     @GetMapping("/user"
  15.     public String userPage() {
  16.         return "user";
  17.     }
  19.     @PostMapping("/logout"
  20.     public String logout(HttpServletRequest request) {
  21.         request.getSession().invalidate();
  22.         return "redirect:/login?logout";
  23.     }
  24. }

  复制代码
• 创建登录页面（login.html）
  

这是一个简单的HTML页面，包含表单用于用户登录。
详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口，并设置了Spring Session的存储范例为Redis。
  
• 创建用户实体类：这是一个简单的POJO类，代表用户信息。
  
• 用户存储库接口：InMemoryUserRepository实现了UserDetailsService接口，用于Spring Security的认证过程。现实应用中，应毗连到数据库来获取用户信息。
  
• 设置Spring Security：WebSecurityConfig类设置了Spring Security的认证和授权规则。它还设置了自定义的登录页面和登出逻辑。
  
• 创建控制器：WebController提供了访问不同页面的路由和登出逻辑。
  
• 登录页面：login.html是用户登录的前端页面。
  

通过这种方式，Spring Session会自动管理用户的会话信息，并将其存储在Redis中。当用户登录时，会话信息将被存储在Redis中，而不是传统的服务器端HttpSession中。这使得会话信息可以在多个服务器实例之间共享，非常适合于分布式摆设的Web应用步调。别的，Redis的高性能也有助于提高应用步调的响应速度。
3. 排行榜和计数器

针对Redis作为排行榜和计数器的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis来实现一个简单的文章点赞功能，并将点赞数用作排行榜的依据。
场景形貌
假设我们正在开辟一个博客平台，用户可以对文章举行点赞。我们希望根据文章的点赞数来显示一个及时更新的热门文章排行榜。
创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis 服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

假设我们有一个电商平台，必要处理用户的订单。为了提高服从，我们希望将订单处理任务异步化，即用户下单后，订单信息将被发送到一个队列中，然后由一个或多个后台服务来异步处理这些订单。
创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：
通过这种方式，我们可以使用Redis的原子操作和高性能特性来实现一个高效的点赞和排行榜功能。每次用户点赞时，Redis都会原子性地更新点赞数，而获取排行榜时，我们可以快速地从Redis中检索和排序数据，从而提供及时的热门文章排行。
4. 消息队列

针对Redis作为消息队列的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis的发布/订阅功能来实现一个简单的任务队列。
场景形貌
假设我们有一个电商平台，必要处理用户的订单。为了提高服从，我们希望将订单处理任务异步化，即用户下单后，订单信息将被发送到一个队列中，然后由一个或多个后台服务来异步处理这些订单。

• 定义文章实体类
  
  1. public class Article {
  2.     private String id;
  3.     private String title;
  4.     private int likeCount;
  5.     // 省略构造函数、getter和setter方法
  6. }

  复制代码
• 创建文章服务接口和实现类
  
  1. @Service
  2. public class ArticleService {
  4.     @Autowired
  5.     private StringRedisTemplate redisTemplate;
  7.     public void likeArticle(String articleId) {
  8.         // 增加文章的点赞数
  9.         redisTemplate.opsForValue().increment(articleId, 1);
  10.     }
  12.     public List<Article> getTopLikedArticles(int topN) {
  13.         // 获取topN个点赞数最多的文章
  14.         Set<String> articleIds = redisTemplate.keys("article:*:likeCount");
  15.         List<Article> topArticles = new ArrayList<>();
  16.         for (String id : articleIds) {
  17.             int likeCount = (Integer) redisTemplate.opsForValue().get(id);
  18.             Article article = new Article();
  19.             article.setId(id.replace("article:", "").replace(":likeCount", ""));
  20.             article.setTitle("文章标题待查询");
  21.             article.setLikeCount(likeCount);
  22.             topArticles.add(article);
  23.         }
  24.         // 根据点赞数排序
  25.         topArticles.sort((a1, a2) -> a2.getLikeCount() - a1.getLikeCount());
  26.         return topArticles.subList(0, topN);
  27.     }
  28. }

  复制代码
• 创建控制器
  
  1. @RestController
  2. @RequestMapping("/articles")
  3. public class ArticleController {
  5.     @Autowired
  6.     private ArticleService articleService;
  8.     @PostMapping("/{id}/like")
  9.     public ResponseEntity<String> likeArticle(@PathVariable String id) {
  10.         articleService.likeArticle(id);
  11.         return ResponseEntity.ok("点赞成功");
  12.     }
  14.     @GetMapping("/top/{topN}")
  15.     public ResponseEntity<List<Article>> getTopLikedArticles(@PathVariable int topN) {
  16.         List<Article> topArticles = articleService.getTopLikedArticles(topN);
  17.         return ResponseEntity.ok(topArticles);
  18.     }
  19. }

  复制代码
  详细解释
  
• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 定义文章实体类：这是一个简单的POJO类，代表文章信息，包括文章ID、标题和点赞数。
  
• 创建文章服务：ArticleService提供了两个方法，likeArticle用于增长文章的点赞数，getTopLikedArticles用于获取点赞数最多的前N篇文章。
  
• 点赞逻辑：在likeArticle方法中，我们使用StringRedisTemplate的increment操作来原子性地增长文章的点赞数。
  
• 获取排行榜逻辑：在getTopLikedArticles方法中，我们首先获取所有文章的点赞数键，然后构建一个包含文章点赞数的列表。接着，我们对这个列表举行排序，以获取点赞数最多的前N篇文章。
  
• 创建控制器：ArticleController提供了两个RESTful API端点，/articles/{id}/like用于点赞文章，/articles/top/{topN}用于获取点赞数最多的前N篇文章。
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 设置Redis消息队列
  

创建一个设置类来设置发布者和订阅者使用的通道。

1. @Configuration
2. public class RedisConfig {
4.     @Bean
5.     public RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory connectionFactory) {
6.         RedisMessageListenerContainer container = new RedisMessageListenerContainer();
7.         container.setConnectionFactory(connectionFactory);
8.         container.addMessageListener(new MessageListenerImpl(), new PatternTopic("order-channel"));
9.         return container;
10.     }
11. }

复制代码

2.实现消息监听器

1. @Component
2. public class MessageListenerImpl implements MessageListener<String, String> {
4.     @Override
5.     public void onMessage(Message<String, String> message, byte[] pattern) {
6.         String orderData = message.getBody();
7.         processOrder(orderData);
8.     }
10.     private void processOrder(String orderData) {
11.         // 处理订单逻辑
12.         System.out.println("Processing order: " + orderData);
13.         // 假设订单处理成功
14.     }
15. }

复制代码

3.创建订单服务

1. @Service
2. public class OrderService {
4.     @Autowired
5.     private ReactiveRedisTemplate<String, String> reactiveRedisTemplate;
7.     public Mono<Void> placeOrder(String orderData) {
8.         return reactiveRedisTemplate.convertAndSend("order-channel", orderData)
9.                                    .then();
10.     }
11. }

复制代码

1. 4.创建控制器

复制代码

1. @RestController
2. @RequestMapping("/orders")
3. public class OrderController {
5.     @Autowired
6.     private OrderService orderService;
8.     @PostMapping
9.     public Mono<ResponseEntity<?>> placeOrder(@RequestBody String orderData) {
10.         return orderService.placeOrder(orderData)
11.                           .then(Mono.just(ResponseEntity.ok().build()))
12.                           .defaultIfEmpty(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build());
13.     }
14. }

复制代码

详细解释

• 设置Redis消息队列：RedisConfig设置类设置了Redis消息监听器容器，它将监听名为order-channel的通道。
  
• 实现消息监听器：MessageListenerImpl实现了MessageListener接口，用于接收并处剃头送到order-channel的消息。每当有新消息到达时，onMessage方法会被调用，订单数据将被传递到processOrder方法举行处理。
  
• 创建订单服务：OrderService服务中定义了placeOrder方法，它使用ReactiveRedisTemplate的convertAndSend方法将订单数据发布到order-channel。
  
• 创建控制器：OrderController提供了一个POST端点/orders，用于接收订单数据。当接收到订单请求时，它将调用OrderService的placeOrder方法将订单数据发送到Redis消息队列，并返回相应的响应。
  

通过这种方式，我们可以将订单处理逻辑异步化，提高系统的整体性能和响应能力。用户下单后，前端可以立刻收到响应，而订单处理则在后台异步举行。这种模式适用于必要高吞吐量和快速响应的业务场景。
5. 及时分析

针对Redis作为及时分析使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis的Sorted Set来实现一个简单的用户在线时长统计和分析功能。
场景形貌
假设我们正在开辟一个在线教诲平台，必要统计每个用户的在线时长，并根据这些数据生成及时的在线时长排行榜。
创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

1. # application.properties
2. redisson.address=redis://localhost:6379

复制代码

• 用户在线时长服务接口和实现类
  
  1. @Service
  2. public class OnlineDurationService {
  4.     @Autowired
  5.     private StringRedisTemplate redisTemplate;
  7.     public void updateUserOnlineDuration(String userId, long duration) {
  8.         // 使用Sorted Set存储用户ID和在线时长
  9.         redisTemplate.opsForZSet().incrementScore("user:online:duration", userId, duration);
  10.     }
  12.     public Set<String> getTopUsersByOnlineDuration(int topN) {
  13.         // 获取在线时长最长的前N个用户
  14.         Set<String> topUsers = redisTemplate.opsForZSet().reverseRange("user:online:duration", 0, topN - 1);
  15.         return topUsers;
  16.     }
  17. }

  复制代码
• 用户登录和登出逻辑
  
  1. @Controller
  2. public class UserController {
  4.     @Autowired
  5.     private OnlineDurationService onlineDurationService;
  7.     @PostMapping("/user/{userId}/login")
  8.     public ResponseEntity<String> userLogin(@PathVariable String userId) {
  9.         // 用户登录逻辑，可以是任何触发登录的事件
  10.         return ResponseEntity.ok("User " + userId + " logged in");
  11.     }
  13.     @PostMapping("/user/{userId}/logout")
  14.     public ResponseEntity<String> userLogout(@PathVariable String userId) {
  15.         // 用户登出时记录在线时长
  16.         long duration = // 计算用户在线时长的逻辑
  17.         onlineDurationService.updateUserOnlineDuration(userId, duration);
  18.         return ResponseEntity.ok("User " + userId + " logged out");
  19.     }
  20. }

  复制代码
• 获取在线时长排行榜
  
  1. @RestController
  2. @RequestMapping("/users")
  3. public class UserRankController {
  5.     @Autowired
  6.     private OnlineDurationService onlineDurationService;
  8.     @GetMapping("/online-duration/top/{topN}")
  9.     public ResponseEntity<Set<String>> getTopUsersByOnlineDuration(@PathVariable int topN) {
  10.         Set<String> topUsers = onlineDurationService.getTopUsersByOnlineDuration(topN);
  11.         return ResponseEntity.ok(topUsers);
  12.     }
  13. }

  复制代码
  详细解释
  
• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 用户在线时长服务：OnlineDurationService服务中定义了两个方法，updateUserOnlineDuration用于更新用户的在线时长，这里使用Redis的Sorted Set数据结构，将用户ID作为成员，在线时长作为分数举行存储。getTopUsersByOnlineDuration方法用于获取在线时长最长的前N个用户。
  
• 用户登录和登出逻辑：在UserController中，定义了用户登录和登出的RESTful API。用户登录时，可以执行任何触发登录的逻辑；用户登出时，盘算在线时长并通过OnlineDurationService服务更新到Redis中。
  
• 获取在线时长排行榜：UserRankController提供了一个GET端点/users/online-duration/top/{topN}，用于获取在线时长最长的前N个用户。
  

通过这种方式，我们可以使用Redis的Sorted Set来存储和排序用户的在线时长，实现一个高效的及时在线时长统计和分析功能。每当用户登出时，系统都会更新用户的在线时长，并可以快速地根据在线时长对用户举行排名，从而提供一个动态的在线时长排行榜。这对于在线教诲平台等必要监控用户活跃度的业务场景非常有用。
6. 分布式锁

针对Redis作为分布式锁的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redisson作为客户端来实现分布式锁。
场景形貌
假设我们有一个高流量的电子商务网站，必要执行一些资源密集型的操作，比如生成日报表。为了防止多个实例同时执行这些操作，我们必要一个分布式锁来确保每次只有一个实例可以执行这些操作。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  
• Spring Boot Starter Web
  
• Redisson
  
• Spring Boot Starter Cache（可选，如果必要使用Spring的缓存抽象）
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redisson毗连
在src/main/resources/application.properties或application.yml中设置Redisson客户端毗连到Redis服务器：

1. # application.properties
2. redisson.address=redis://localhost:6379

复制代码

或者

1. # application.yml
2. redisson:
3.   address: "redis://localhost:6379"

复制代码

编写业务代码

• 设置Redisson
  

创建一个设置类来设置Redisson客户端。

1. @Configuration
2. public class RedissonConfig {
4.     @Bean(destroyMethod = "shutdown")
5.     public RedissonClient redissonClient() {
6.         RedissonClientConfig config = new RedissonClientConfig();
7.         config.useSingleServer().setAddress(redisson.address);
8.         return Redisson.create(config);
9.     }
11.     @Value("${redisson.address}")
12.     private String redissonAddress;
13. }

复制代码

        2.使用分布式锁
创建一个服务类来执行必要分布式锁掩护的资源密集型操作。

1. @Service
2. public class ReportService {
4.     @Autowired
5.     private RedissonClient redissonClient;
7.     public void generateDailyReport() {
8.         RLock lock = redissonClient.getLock("dailyReportLock");
9.         try {
10.             // 尝试获取锁，最多等待3秒，锁的自动过期时间设置为10秒
11.             if (lock.tryLock(3, 10, TimeUnit.SECONDS)) {
12.                 // 执行生成日报表的操作
13.                 System.out.println("Generating daily report...");
14.                 // 模拟长时间运行的任务
15.                 TimeUnit.SECONDS.sleep(5);
16.                 System.out.println("Daily report generated.");
17.             }
18.         } catch (InterruptedException e) {
19.             Thread.currentThread().interrupt();
20.         } finally {
21.             // 释放锁
22.             lock.unlock();
23.         }
24.     }
25. }

复制代码

        3.创建控制器

1. @RestController
2. @RequestMapping("/reports")
3. public class ReportController {
5.     @Autowired
6.     private ReportService reportService;
8.     @GetMapping("/daily")
9.     public ResponseEntity<String> generateDailyReport() {
10.         reportService.generateDailyReport();
11.         return ResponseEntity.ok("Daily report generation triggered.");
12.     }
13. }

复制代码

 
详细解释

• 设置Redisson毗连：在设置文件中指定Redis服务器的地址，并创建一个RedissonClient Bean。
  
• 使用分布式锁：ReportService服务中的generateDailyReport方法使用Redisson的RLock来获取一个名为dailyReportLock的分布式锁。tryLock方法尝试获取锁，并指定最多等待时间和锁的自动过期时间。如果乐成获取锁，则执行生成日报表的操作；如果获取锁失败，则方法将立刻返回，不会执行任何操作。
  
• 创建控制器：ReportController提供了一个GET端点/reports/daily，用于触发生成日报表的操作。
  

通过这种方式，我们可以确保在分布式系统中，即使有多个实例运行，也只有一个实例可以执行生成日报表的操作，从而避免资源辩论和重复劳动。Redisson客户端简化了Redis分布式锁的使用，使得在Spring Boot应用中实现分布式锁变得简单而高效。
7. 发布/订阅

针对Redis作为发布/订阅消息队列的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis的发布/订阅功能来实现一个简单的及时消息通知系统。
场景形貌
假设我们正在开辟一个社交媒体平台，必要实现一个功能，当用户发布新帖子时，他/她的关注者可以或许及时收到通知。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Data Redis Reactive (对于响应式编程)
  
• Spring WebFlux (响应式Web框架)
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 设置发布/订阅通道
  

创建一个设置类来定义发布者和订阅者使用的通道。

1. @Configuration
2. public class RedisPubSubConfig {
4.     @Bean
5.     public ReactiveRedisConnectionFactory reactiveRedisConnectionFactory(LettuceClientConfiguration clientConfig) {
6.         return new LettuceConnectionFactory(clientConfig);
7.     }
9.     @Bean
10.     public RedisMessageListenerContainer redisMessageListenerContainer(ReactiveRedisConnectionFactory connectionFactory) {
11.         RedisMessageListenerContainer container = new RedisMessageListenerContainer();
12.         container.setConnectionFactory(connectionFactory);
13.         container.addMessageListener(new PostNotificationListener(), new PatternTopic("newPostChannel"));
14.         return container;
15.     }
17.     @Bean
18.     public LettuceClientConfiguration clientConfig() {
19.         return LettuceClientConfiguration.defaultConfiguration();
20.     }
22.     @Component
23.     public class PostNotificationListener implements MessageListener<String, String> {
25.         @Override
26.         public void onMessage(Message<String, String> message) {
27.             // 处理接收到的帖子通知
28.             String postContent = message.getBody();
29.             System.out.println("New post notification received: " + postContent);
30.             // 这里可以添加逻辑，比如通知关注者
31.         }
32.     }
33. }

复制代码

        2.发送新帖子通知
创建一个服务类来发送新帖子的通知。

1. @Service
2. public class PostService {
4.     @Autowired
5.     private ReactiveRedisTemplate<String, String> reactiveRedisTemplate;
7.     public Mono<Void> publishNewPostNotification(String postContent) {
8.         return reactiveRedisTemplate.convertAndSend("newPostChannel", postContent);
9.     }
10. }

复制代码

3.创建控制器
创建一个控制器来处理新帖子的发布请求。

1. @RestController
2. @RequestMapping("/posts")
3. public class PostController {
5.     @Autowired
6.     private PostService postService;
8.     @PostMapping
9.     public Mono<ResponseEntity<?>> createPost(@RequestBody String postContent) {
10.         return postService.publishNewPostNotification(postContent)
11.                          .then(Mono.just(ResponseEntity.ok().build()))
12.                          .defaultIfEmpty(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build());
13.     }
14. }

复制代码

详细解释

• 设置发布/订阅通道：RedisPubSubConfig设置类设置了ReactiveRedisConnectionFactory和RedisMessageListenerContainer。PostNotificationListener实现了MessageListener接口，用于接收并处理新帖子的通知。
  
• 发送新帖子通知：PostService服务中的publishNewPostNotification方法使用ReactiveRedisTemplate的convertAndSend方法将新帖子的内容发布到newPostChannel通道。
  
• 创建控制器：PostController提供了一个POST端点/posts，用于接收新帖子的内容。当接收到新帖子的请求时，它将调用PostService的publishNewPostNotification方法将新帖子的内容发送到Redis通道，并返回相应的响应。
  

通过这种方式，我们可以使用Redis的发布/订阅功能来实现一个高效的及时消息通知系统。每当有新帖子发布时，Redis会将通知消息发布到newPostChannel通道，所有订阅了该通道的监听器（如PostNotificationListener）都会收到消息并举行处理，比如通知帖子作者的关注者。这种模式适用于必要及时通信和通知的业务场景，如社交媒体、及时聊天应用等。
8. 限流

针对Redis作为限流功能的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis来实现API的限流。
场景形貌
假设我们正在开辟一个公共API服务，该服务必要对外部请求举行限流，以防止滥用和过载。我们希望对每个IP地址每分钟的请求次数举行限制。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Web
  
• Spring Boot Starter Data Redis
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
    int limit() default 10; // 默认每分钟请求次数限制
    long timeout() default 60; // 默认时间窗口为60秒
}
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建限流注解
  

定义一个自定义注解，用于标识必要限流的API。

1. @Target(ElementType.METHOD)
2. @Retention(RetentionPolicy.RUNTIME)
3. public @interface RateLimit {
4.     int limit() default 10; // 默认每分钟请求次数限制
5.     long timeout() default 60; // 默认时间窗口为60秒
6. }

复制代码

2.创建限流拦截器
实现一个拦截器来检查请求频率。

1. public class RateLimiterInterceptor implements HandlerInterceptor {
3.     private final RedisTemplate<String, Integer> redisTemplate;
4.     private final String rateLimitKeyPrefix = "rate_limit:";
6.     public RateLimiterInterceptor(RedisTemplate<String, Integer> redisTemplate) {
7.         this.redisTemplate = redisTemplate;
8.     }
10.     @Override
11.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
12.         String ip = request.getRemoteAddr();
13.         String methodName = ((MethodSignature) (handler)).getMethod().getName();
14.         String rateLimitKey = rateLimitKeyPrefix + methodName + ":" + ip;
16.         int currentCount = redisTemplate.opsForValue().increment(rateLimitKey);
17.         if (currentCount > 1) {
18.             // 如果当前计数大于1，则说明请求已超过限制
19.             response.sendError(HttpServletResponse.SC_TOO_MANY_REQUESTS, "Too many requests, please try again later.");
20.             return false;
21.         }
23.         // 设置过期时间
24.         redisTemplate.expire(rateLimitKey, RateLimit.class.cast(((MethodSignature) handler).getMethod().getAnnotation(RateLimit.class)).timeout(), TimeUnit.SECONDS);
25.         return true;
26.     }
27. }

复制代码

3.设置拦截器
设置拦截器以应用于所有控制器。

1. @Configuration
2. public class WebConfig implements WebMvcConfigurer {
4.     @Autowired
5.     private RateLimiterInterceptor rateLimiterInterceptor;
7.     @Override
8.     public void addInterceptors(InterceptorRegistry registry) {
9.         registry.addInterceptor(rateLimiterInterceptor);
10.     }
11. }

复制代码

4.应用限流注解
在必要限流的API上应用自定义的RateLimit注解。

1. @RestController
2. public class ApiController {
4.     @RateLimit(limit = 5, timeout = 60) // 每分钟最多5个请求
5.     @GetMapping("/api/resource")
6.     public ResponseEntity<String> getLimitedResource() {
7.         return ResponseEntity.ok("Access to limited resource");
8.     }
9. }

复制代码

详细解释

• 创建限流注解：定义了一个RateLimit注解，它包含限制的请求次数和时间窗口。
  
• 创建限流拦截器：RateLimiterInterceptor实现了HandlerInterceptor接口，用于在请求处理之前检查请求频率。它使用RedisTemplate来递增每个IP地址的请求计数，并设置计数的过期时间。
  
• 设置拦截器：WebConfig类实现了WebMvcConfigurer接口，用于注册RateLimiterInterceptor拦截器，使其应用于所有的控制器方法。
  
• 应用限流注解：在ApiController中的getLimitedResource方法上应用了RateLimit注解，指定了每分钟最多5个请求的限制。
  

通过这种方式，我们可以使用Redis的原子递增操作和键过期特性来实现API的限流。每次请求都会检查当前IP的请求计数，如果超过限制，则返回429错误码（Too Many Requests）。这有助于掩护API免受滥用，并确保服务的稳固性和可用性。
9. 数据过期

针对Redis作为数据过期自动清算的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis来存储暂时数据，比如用户会话信息，并设置过期时间以自动清算这些数据。
场景形貌
假设我们正在开辟一个Web应用，用户登录后生成的会话信息必要在用户登出或一定时间后自动扫除。我们可以使用Redis来存储这些会话信息，并使用它的过期时间特性来自动清算这些会话。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Data Redis
  
• Spring Session Data Redis
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连和Spring Session
在src/main/resources/application.properties中设置Redis服务器的毗连信息以及Spring Session的存储范例：

1. spring.redis.host=localhost
2. spring.redis.port=6379spring.session.store-type=redis

复制代码

编写业务代码

• 设置Spring Session Redis
  

创建设置类以启用Spring Session的Redis支持：

1. @Configuration
2. @EnableRedisHttpSession
3. public class SessionConfig {
4.     // 配置类不需要额外代码，@EnableRedisHttpSession将自动配置所需的Bean
5. }

复制代码

2.用户登录和登出逻辑
创建一个控制器来处理用户登录和登出，并存储会话信息：

1. @Controller
2. public class SessionController {
4.     // 用户登录后，Spring Session会自动存储会话信息到Redis
5.     @PostMapping("/login")
6.     public String login(SessionStatus sessionStatus, String username) {
7.         sessionStatus.setAttribute("username", username);
8.         return "loginSuccess";
9.     }
11.     // 用户登出时，清除会话信息
12.     @PostMapping("/logout")
13.     public String logout(SessionStatus sessionStatus) {
14.         sessionStatus.invalidate();
15.         return "logoutSuccess";
16.     }
17. }

复制代码

3.设置会话超时
创建一个设置类来设置会话的超时时间：

1. @Configuration
2. public class SessionTimeoutConfig {
4.     @Bean
5.     public ConfigurableServletWebServerFactory<?> webServerFactory() {
6.         TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
7.         factory.setSessionTimeout(30); // 设置会话超时时间（以分钟为单位）
8.         return factory;
9.     }
10. }

复制代码

详细解释

• 设置Redis毗连和Spring Session：在application.properties中设置了Redis服务器的地址和端口，并指定Spring Session使用Redis作为存储。
  
• 设置Spring Session Redis：SessionConfig类通过@EnableRedisHttpSession注解启用了Spring Session的Redis支持。Spring Session将自动管理HTTP Session，并将其存储在Redis中。
  
• 用户登录和登出逻辑：SessionController控制器提供了登录和登出的处理逻辑。在用户登录时，会将用户名存储到会话中。在用户登出时，会话将被无效化，Spring Session会自动从Redis中扫除会话信息。
  
• 设置会话超时：SessionTimeoutConfig设置类设置了会话的超时时间。Tomcat的TomcatServletWebServerFactory用于设置会话超时时间，这个时间之后，即使用户没有显式登出，会话也会被自动扫除。
  

通过这种方式，我们可以确保用户的会话信息在一定时间后自动从Redis中扫除，无需手动干预。这不光有助于释放Redis存储空间，还可以提高应用的安全性，防止旧会话被滥用。别的，Spring Session的自动管理简化了会话管理的复杂性，使得开辟者可以更专注于业务逻辑的实现。
10. 全页缓存

针对Redis作为全页缓存的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis来缓存整个页面的HTML内容。
场景形貌
假设我们正在开辟一个消息网站，该网站的首页包含多个消息文章的摘要信息。由于首页访问频率很高，我们希望将整个首页的内容缓存起来，以减少数据库的查询次数和页面渲染时间。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Web
  
• Spring Boot Starter Data Redis
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建消息文章服务
  
  1. @Service
  2. public class NewsService {
  4.     // 假设有一个方法来获取新闻列表
  5.     public List<Article> getNewsList() {
  6.         // 这里是获取新闻列表的逻辑
  7.         return Collections.emptyList();
  8.     }
  9. }

  复制代码
• 设置Redis缓存
  

创建一个设置类来设置Spring Cache和Redis缓存。

1. @Configuration
2. @EnableCaching
3. public class CacheConfig {
5.     @Bean
6.     public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
7.         RedisCacheManager cacheManager = new RedisCacheManager(connectionFactory);
8.         // 设置缓存过期时间（例如5分钟）
9.         cacheManager.setDefaultExpiration(300);
10.         return cacheManager;
11.     }
12. }

复制代码

3.创建控制器和视图
创建一个控制器来返回首页，并使用Redis缓存整个页面。

1. @Controller
2. public class NewsController {
4.     @Autowired
5.     private NewsService newsService;
7.     @Autowired
8.     private CacheManager cacheManager;
10.     @GetMapping("/")
11.     @Cacheable(value = "homePage", condition = "#root.caches[0].name == 'homePage'")
12.     public String homePage(Model model) {
13.         // 尝试从缓存中获取页面
14.         model.addAttribute("newsList", newsService.getNewsList());
15.         return "home";
16.     }
17. }

复制代码

 4.创建Thymeleaf模板
创建一个Thymeleaf模板home.html来渲染首页。

1. <!DOCTYPE html>
2. <html xmlns:th="http://www.thymeleaf.org">
3. <head>
4.     <title>首页</title>
5. </head>
6. <body>
7.     <h1>新闻首页</h1>
8.     <div th:each="article : ${newsList}">
9.         <h2 th:text="${article.title}"></h2>
10.         <p th:text="${article.summary}"></p>
11.     </div>
12. </body>
13. </html>

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 创建消息文章服务：NewsService服务包含获取消息列表的逻辑。
  
• 设置Redis缓存：CacheConfig设置类通过@EnableCaching注解启用了Spring的缓存支持，并设置了一个RedisCacheManager Bean来管理Redis缓存。
  
• 创建控制器和视图：NewsController控制器中的homePage方法使用@Cacheable注解来指定缓存的名称（这里是homePage）。当这个方法被调用时，Spring会检查指定的缓存中是否存在该页面的缓存。如果存在，就直接返回缓存的内容；如果不存在，就执行方法并将效果存储到缓存中。
  
• 创建Thymeleaf模板：home.html是一个Thymeleaf模板，用于渲染消息列表。
  

通过这种方式，我们可以使用Redis来缓存整个页面的内容。首页的访问非常频繁，通过缓存可以显著减少数据库的查询次数和页面渲染时间，提高网站的响应速度和性能。别的，Spring的缓存抽象和Thymeleaf模板使得实现全页缓存变得简单而高效。
11. 社交功能

针对Redis作为社交功能存储的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis来存储用户的社交关系信息，如好友列表和用户状态更新。
场景形貌
假设我们正在开辟一个社交网络平台，用户可以添加好友，而且可以发布状态更新。我们必要存储每个用户的好友列表以及状态更新的时间线。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Data Redis
  
• Spring Web
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 定义用户和状态更新实体类
  

1. public class User {
2.     private String id;
3.     private String name;
4.     // 省略构造函数、getter和setter方法
5. }
7. public class StatusUpdate {
8.     private String userId;
9.     private String content;
10.     private Instant timestamp;
11.     // 省略构造函数、getter和setter方法
12. }

复制代码

• 创建社交服务
  

1. @Service
2. public class SocialService {
4.     @Autowired
5.     private StringRedisTemplate redisTemplate;
7.     public void addFriend(String userOneId, String userTwoId) {
8.         // 使用集合存储用户的好友列表
9.         redisTemplate.opsForSet().add("friends:" + userOneId, userTwoId);
10.         redisTemplate.opsForSet().add("friends:" + userTwoId, userOneId);
11.     }
13.     public Set<String> getFriends(String userId) {
14.         // 获取用户的好友列表
15.         return redisTemplate.opsForSet().members("friends:" + userId);
16.     }
18.     public void postStatusUpdate(String userId, String content) {
19.         // 使用列表存储用户的状态更新时间线
20.         StatusUpdate statusUpdate = new StatusUpdate(userId, content, Instant.now());
21.         redisTemplate.opsForList().rightPush("timeline:" + userId, statusUpdate);
22.     }
24.     public List<StatusUpdate> getStatusUpdates(String userId) {
25.         // 获取用户的状态更新时间线
26.         return redisTemplate.opsForList().range("timeline:" + userId, 0, -1);
27.     }
28. }

复制代码

• 创建控制器
  

1. @RestController
2. @RequestMapping("/social")
3. public class SocialController {
5.     @Autowired
6.     private SocialService socialService;
8.     @PostMapping("/addFriend")
9.     public ResponseEntity<String> addFriend(@RequestParam String userOneId, @RequestParam String userTwoId) {
10.         socialService.addFriend(userOneId, userTwoId);
11.         return ResponseEntity.ok("Friends added successfully");
12.     }
14.     @GetMapping("/friends/{userId}")
15.     public ResponseEntity<Set<String>> getFriends(@PathVariable String userId) {
16.         Set<String> friends = socialService.getFriends(userId);
17.         return ResponseEntity.ok(friends);
18.     }
20.     @PostMapping("/status")
21.     public ResponseEntity<String> postStatusUpdate(@RequestParam String userId, @RequestParam String content) {
22.         socialService.postStatusUpdate(userId, content);
23.         return ResponseEntity.ok("Status updated successfully");
24.     }
26.     @GetMapping("/timeline/{userId}")
27.     public ResponseEntity<List<StatusUpdate>> getStatusUpdates(@PathVariable String userId) {
28.         List<StatusUpdate> updates = socialService.getStatusUpdates(userId);
29.         return ResponseEntity.ok(updates);
30.     }
31. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 定义用户和状态更新实体类：User类代表用户信息，StatusUpdate类代表用户的状态更新信息。
  
• 创建社交服务：SocialService服务提供了添加好友、获取好友列表、发布状态更新和获取状态更新时间线的方法。好友列表使用Redis的Set数据结构存储，确保好友关系是无序且不重复的。状态更新时间线使用List数据结构存储，新的状态更新会被添加到列表的尾部。
  
• 创建控制器：SocialController控制器提供了四个RESTful API端点，分别用于添加好友、获取好友列表、发布状态更新和获取状态更新时间线。
  

通过这种方式，我们可以使用Redis的高性能和数据结构特性来实现社交网络平台中的社交功能。Redis的Set和List数据结构非常适合存储和管理好友关系和状态更新时间线，可以或许提供快速的读写性能，满足社交网络平台的需求。
12. 及时保举系统

针对Redis作为及时保举系统存储的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis来存储用户行为数据和偏好，以及提供一个简单的保举功能。
场景形貌
假设我们正在开辟一个电子商务平台，我们希望根据用户的浏览和购买汗青来保举商品。我们将使用Redis来存储用户的这些行为数据，并根据这些数据生成保举。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Data Redis
  
• Spring Web
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建商品和用户实体类
  

1. public class Product {
2.     private String id;
3.     private String name;
4.     // 省略构造函数、getter和setter方法
5. }
7. public class User {
8.     private String id;
9.     private String username;
10.     // 省略构造函数、getter和setter方法
11. }

复制代码

• 创建保举服务
  

1. @Service
2. public class RecommendationService {
4.     @Autowired
5.     private StringRedisTemplate redisTemplate;
7.     public void recordView(String userId, String productId) {
8.         // 记录用户查看的商品
9.         redisTemplate.opsForList().leftPush("user:" + userId + ":views", productId);
10.     }
12.     public List<String> recommendProducts(String userId) {
13.         // 简单推荐算法：返回用户查看次数最多的商品
14.         Set<String> viewedProducts = redisTemplate.opsForSet().members("user:" + userId + ":views");
15.         Map<String, Long> productViewCounts = new HashMap<>();
16.         viewedProducts.forEach(productId -> {
17.             long count = redisTemplate.opsForValue().decrement("user:" + userId + ":views:" + productId);
18.             productViewCounts.put(productId, count);
19.         });
21.         return productViewCounts.entrySet().stream()
22.                 .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
23.                 .map(Map.Entry::getKey)
24.                 .collect(Collectors.toList());
25.     }
26. }

复制代码

• 创建控制器
  

1. @RestController
2. @RequestMapping("/recommendations")
3. public class RecommendationController {
5.     @Autowired
6.     private RecommendationService recommendationService;
8.     @PostMapping("/view")
9.     public ResponseEntity<String> recordProductView(@RequestParam String userId, @RequestParam String productId) {
10.         recommendationService.recordView(userId, productId);
11.         return ResponseEntity.ok("View recorded");
12.     }
14.     @GetMapping("/products")
15.     public ResponseEntity<List<String>> getRecommendations(@RequestParam String userId) {
16.         List<String> recommendedProducts = recommendationService.recommendProducts(userId);
17.         return ResponseEntity.ok(recommendedProducts);
18.     }
19. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 创建商品和用户实体类：Product类代表商品信息，User类代表用户信息。
  
• 创建保举服务：
  
  
  
  • recordView方法用于记任命户查看的商品。这里使用Redis的List来存储用户的浏览汗青，每次用户查看商品时，商品ID被推入到对应用户的List中。
    
  • recommendProducts方法提供了一个简单的保举算法。首先，获取用户的浏览汗青中的所有商品ID，然后统计每个商品的浏览次数（这里简化处理，每次查看减少商品ID对应的计数器）。最后，根据浏览次数对商品举行排序，并返回用户浏览次数最多的商品列表。
    
  
  
• 创建控制器：
  
  
  
  • recordProductView端点用于记任命户查看商品的行为。
    
  • getRecommendations端点用于获取保举商品列表。
    
  
  

通过这种方式，我们可以使用Redis的高性能和简单的数据结构来快速记任命户行为并生成保举。固然这里的保举算法非常简单，但它展示了怎样使用Redis来实现及时保举系统的底子功能。在现实应用中，保举算法可能会更复杂，涉及机器学习模子和更丰富的用户行为数据。
13. 地理位置信息

针对Redis作为地理位置信息存储的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis的Geospatial索引来实现基于地理位置的保举功能。
场景形貌
假设我们正在开辟一款基于位置的社交应用，用户可以查看附近的其他用户或地点。我们必要存储用户的地理位置，并可以或许查询给定位置附近的用户。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。（确保Redis版本支持Geospatial索引，如Redis 3.2以上）
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Data Redis Reactive（如果使用响应式编程）
  
• Spring Web
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建用户实体类
  

1. public class User {
2.     private String id;
3.     private String name;
4.     private double longitude;
5.     private double latitude;
6.     // 省略构造函数、getter和setter方法
7. }

复制代码

• 创建地理位置服务
  

1. @Service
2. public class GeoLocationService {
4.     @Autowired
5.     private RedisTemplate<String, User> redisTemplate;
7.     public void addLocation(String userId, double longitude, double latitude) {
8.         User user = new User(userId, "username", longitude, latitude);
9.         // 使用Geospatial索引存储用户位置
10.         redisTemplate.opsForGeo().add("userLocations", new GeoLocation(user.getLongitude(), user.getLatitude()), userId);
11.     }
13.     public List<User> getUsersNearby(double longitude, double latitude, double radius) {
14.         // 查询给定位置附近的用户
15.         List<GeoWithin> nearbyUsersGeo = redisTemplate.opsForGeo().radius("userLocations",
16.                 new Circle(new GeoCoordinate(latitude, longitude), radius),
17.                 RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs());
18.         
19.         List<User> nearbyUsers = new ArrayList<>();
20.         for (GeoWithin geoWithin : nearbyUsersGeo) {
21.             nearbyUsers.add(redisTemplate.opsForValue().get(geoWithin.getMember()));
22.         }
23.         return nearbyUsers;
24.     }
25. }

复制代码

• 创建控制器
  

1. @RestController
2. @RequestMapping("/users")
3. public class UserController {
5.     @Autowired
6.     private GeoLocationService geoLocationService;
8.     @PostMapping("/addLocation")
9.     public ResponseEntity<String> addLocation(@RequestParam String userId,
10.                                                @RequestParam double longitude,
11.                                                @RequestParam double latitude) {
12.         geoLocationService.addLocation(userId, longitude, latitude);
13.         return ResponseEntity.ok("User location added");
14.     }
16.     @GetMapping("/nearby")
17.     public ResponseEntity<List<User>> getUsersNearby(@RequestParam double longitude,
18.                                                       @RequestParam double latitude,
19.                                                       @RequestParam double radius) {
20.         List<User> nearbyUsers = geoLocationService.getUsersNearby(longitude, latitude, radius);
21.         return ResponseEntity.ok(nearbyUsers);
22.     }
23. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 创建用户实体类：User类代表用户信息，包括用户的ID、名称、经度和纬度。
  
• 创建地理位置服务：
  
  
  
  • addLocation方法用于将用户的地理位置信息存储到Redis的Geospatial索引中。这里使用RedisTemplate的opsForGeo方法来添加位置信息。
    
  • getUsersNearby方法用于查询给定位置附近的用户。使用radius方法来查找指定半径内的用户，然后从Redis中获取这些用户的详细信息。
    
  
  
• 创建控制器：
  
  
  
  • addLocation端点答应用户添加其地理位置信息。
    
  • getUsersNearby端点答应查询指定位置和半径内的附近用户。
    
  
  

通过这种方式，我们可以使用Redis的Geospatial索引来存储和查询地理位置信息。这对于必要基于地理位置提供服务的应用非常有用，如社交网络、共享出行、当地服务保举等。Redis的Geospatial索引提供了高效的邻近查询功能，可以快速找到指定范围内的用户或其他地理位置相干的实体。
14. 时间序列数据

针对Redis作为时间序列数据存储的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis来存储和查询时间序列数据。
场景形貌
假设我们正在开辟一个监控系统，必要记录服务器的CPU使用率随时间厘革的数据。我们将使用Redis的时间序列数据结构来存储这些监控数据，并可以或许查询任意时间范围内的CPU使用率。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。（确保Redis版本支持时间序列数据结构，可能必要使用RedisModules如RedisTimeSeries）
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Data Redis
  
• Spring Web
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建监控数据实体类
  

1. public class CpuUsageData {
2.     private Instant timestamp;
3.     private double cpuUsage;
5.     // 省略构造函数、getter和 setter 方法
6. }

复制代码

• 创建监控服务
  

1. @Service
2. public class MonitoringService {
4.     @Autowired
5.     private LettuceConnectionFactory connectionFactory;
7.     public void logCpuUsage(String serverId, double cpuUsage) {
8.         // 记录CPU使用率数据
9.         CpuUsageData data = new CpuUsageData(Instant.now(), cpuUsage);
10.         // 使用Lettuce客户端的命令执行器来与RedisTimeSeries模块交互
11.         StatefulRedisConnection<String, CpuUsageData> connection = connectionFactory.connect();
12.         try {
13.             RedisTimeSeriesCommands<String, CpuUsageData> ts = connection.sync();
14.             ts.add(serverId, data.getTimestamp().toEpochMilli() / 1000, data);
15.         } finally {
16.             connection.close();
17.         }
18.     }
20.     public List<CpuUsageData> getCpuUsageHistory(String serverId, Instant start, Instant end) {
21.         // 查询指定时间范围内的CPU使用率历史数据
22.         List<CpuUsageData> history = new ArrayList<>();
23.         StatefulRedisConnection<String, CpuUsageData> connection = connectionFactory.connect();
24.         try {
25.             RedisTimeSeriesCommands<String, CpuUsageData> ts = connection.sync();
26.             Range range = Range.create(start.toEpochMilli() / 1000, end.toEpochMilli() / 1000);
27.             Cursor<CpuUsageData> cursor = ts.rangeRead(serverId, range);
28.             while (cursor.hasNext()) {
29.                 history.add(cursor.next().getValue());
30.             }
31.         } finally {
32.             connection.close();
33.         }
34.         return history;
35.     }
36. }

复制代码

• 创建控制器
  

1. @RestController
2. @RequestMapping("/monitoring")
3. public class MonitoringController {
5.     @Autowired
6.     private MonitoringService monitoringService;
8.     @PostMapping("/logCpuUsage")
9.     public ResponseEntity<String> logCpuUsage(@RequestParam String serverId, @RequestParam double cpuUsage) {
10.         monitoringService.logCpuUsage(serverId, cpuUsage);
11.         return ResponseEntity.ok("CPU usage logged");
12.     }
14.     @GetMapping("/cpuUsageHistory")
15.     public ResponseEntity<List<CpuUsageData>> getCpuUsageHistory(@RequestParam String serverId,
16.                                                                  @RequestParam Instant start,
17.                                                                  @RequestParam Instant end) {
18.         List<CpuUsageData> history = monitoringService.getCpuUsageHistory(serverId, start, end);
19.         return ResponseEntity.ok(history);
20.     }
21. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 创建监控数据实体类：CpuUsageData类代表CPU使用率数据，包括时间戳和CPU使用率。
  
• 创建监控服务：
  
  
  
  • logCpuUsage方法用于记录服务器的CPU使用率。使用Lettuce客户端的同步下令执行器与RedisTimeSeries模块交互，将数据添加到时间序列中。
    
  • getCpuUsageHistory方法用于查询指定时间范围内的CPU使用率汗青数据。使用rangeRead方法从时间序列中读取数据。
    
  
  
• 创建控制器：
  
  
  
  • logCpuUsage端点答应记录服务器的CPU使用率。
    
  • getCpuUsageHistory端点答应查询指定时间范围内的CPU使用率汗青数据。
    
  
  

通过这种方式，我们可以使用Redis的RedisTimeSeries模块来存储和查询时间序列数据。这对于必要监控和分析随时间厘革的数据的应用非常有用，如服务器监控、网站访问量分析等。RedisTimeSeries提供了高效的时间序列数据存储和查询功能，可以快速插入和检索大量时间戳数据。
15. 任务调度

针对Redis作为任务调度的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis的延迟队列特性来实现任务调度。
场景形貌
假设我们正在开辟一个定时任务管理系统，必要安排一些任务在未来的某个时间点执行。我们将使用Redis的schedule下令来安排任务的执行。
情况准备

• 安装Java开辟情况。
  
• 安装支持schedule下令的Redis版本（Redis 5.0及以上版本）。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Data Redis
  
• Spring Web
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建任务调度服务
  

1. @Service
2. public class TaskSchedulingService {
4.     @Autowired
5.     private RedisTemplate<String, Runnable> redisTemplate;
7.     public void scheduleTask(Runnable task, long delay, TimeUnit timeUnit) {
8.         // 将任务和延迟时间存储到Redis中
9.         redisTemplate.opsForValue().set(
10.             "task:" + task.hashCode(), 
11.             task, 
12.             timeUnit.toSeconds(delay), 
13.             timeUnit
14.         );
15.         // 使用schedule命令安排任务在未来执行
16.         String scheduleCommand = String.format(
17.             "SCHEDULE %d %s", 
18.             System.currentTimeMillis() + timeUnit.toMillis(delay), 
19.             "task:" + task.hashCode()
20.         );
21.         redisTemplate.execute((RedisConnection connection) -> {
22.             connection.schedule(scheduleCommand);
23.             return null;
24.         });
25.     }
26. }

复制代码

• 创建详细的任务
  

1. public class SampleTask implements Runnable {
2.     @Override
3.     public void run() {
4.         System.out.println("Task is running: " + LocalDateTime.now());
5.         // 执行任务逻辑
6.     }
7. }

复制代码

• 创建控制器
  

1. @RestController
2. @RequestMapping("/tasks")
3. public class TaskController {
5.     @Autowired
6.     private TaskSchedulingService taskSchedulingService;
8.     @PostMapping("/schedule")
9.     public ResponseEntity<String> scheduleTask(@RequestParam long delay, @RequestParam TimeUnit timeUnit) {
10.         taskSchedulingService.scheduleTask(new SampleTask(), delay, timeUnit);
11.         return ResponseEntity.ok("Task scheduled for execution at " + LocalDateTime.now().plusNanos(timeUnit.toNanos(delay)));
12.     }
13. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 创建任务调度服务：scheduleTask方法用于安排一个Runnable任务在未来的某个时间点执行。首先，任务被存储到Redis中，并设置相应的延迟时间。然后，使用Redis的schedule下令安排任务在未来执行。
  
• 创建详细的任务：SampleTask类实现了Runnable接口，定义了任务的详细执行逻辑。
  
• 创建控制器：scheduleTask端点答应用户安排任务在未来执行。用户必要提供延迟时间和时间单元。
  

通过这种方式，我们可以使用Redis的schedule下令来安排任务的执行。这对于必要执行定时任务的应用非常有用，如定时数据备份、定时发送通知等。通过Redis的延迟队列特性，我们可以简化任务调度的复杂性，而且可以或许灵活地安排任务在未来的任意时间点执行。
16. 数据共享

针对Redis作为数据共享的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis来实现微服务架构中的服务间数据共享。
场景形貌
假设我们有一个电商平台，它由多个微服务构成，比如用户服务、产品服务和订单服务。这些服务必要共享购物车数据，以确保用户在平台上的购物体验是连贯的。我们将使用Redis来存储和共享购物车数据。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Data Redis
  
• Spring Web
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建购物车项实体类
  

1. public class CartItem {
2.     private String productId;
3.     private int quantity;
4.     // 省略构造函数、getter和setter方法
5. }

复制代码

• 创建购物车服务
  

1. @Service
2. public class CartService {
4.     @Autowired
5.     private StringRedisTemplate redisTemplate;
7.     public void addToCart(String cartId, String productId, int quantity) {
8.         // 将购物车项存储到Redis的Hash结构中
9.         redisTemplate.opsForHash().put("cart:" + cartId, productId, quantity);
10.     }
12.     public Map<String, Integer> getCart(String cartId) {
13.         // 从Redis获取购物车内容
14.         return redisTemplate.opsForHash().entries("cart:" + cartId);
15.     }
16. }

复制代码

• 创建控制器
  

1. @RestController
2. @RequestMapping("/cart")
3. public class CartController {
5.     @Autowired
6.     private CartService cartService;
8.     @PostMapping("/{cartId}/items")
9.     public ResponseEntity<String> addToCart(@PathVariable String cartId,
10.                                              @RequestParam String productId,
11.                                              @RequestParam int quantity) {
12.         cartService.addToCart(cartId, productId, quantity);
13.         return ResponseEntity.ok("Item added to cart");
14.     }
16.     @GetMapping("/{cartId}")
17.     public ResponseEntity<Map<String, Integer>> getCart(@PathVariable String cartId) {
18.         Map<String, Integer> cart = cartService.getCart(cartId);
19.         return ResponseEntity.ok(cart);
20.     }
21. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 创建购物车项实体类：CartItem类代表购物车中的商品项，包含商品ID和数量。
  
• 创建购物车服务：
  
  
  
  • addToCart方法用于将商品项添加到用户的购物车中。使用Redis的Hash结构来存储购物车数据，其中cart:加上cartId作为Hash的键，productId作为字段名，quantity作为字段值。
    
  • getCart方法用于从Redis获取用户的购物车内容。
    
  
  
• 创建控制器：
  
  
  
  • addToCart端点答应用户将商品添加到购物车中。
    
  • getCart端点答应用户获取其购物车的内容。
    
  
  

通过这种方式，我们可以使用Redis的高性能和数据共享能力来实现微服务架构中的服务间数据共享。购物车数据被存储在Redis中，可以被不同的微服务实例访问和修改，确保了数据的同等性和及时性。这对于必要高度协同工作的分布式系统非常有用，如电商平台、在线协作工具等。
17. 持久化

针对Redis作为任务调度使用场景，下面是一个Java Spring Boot应用的案例，其中使用Spring的@Scheduled注解与Redisson联合来实现任务调度。
场景形貌
假设我们有一个自动化的营销平台，必要定期（例如每天破晓1点）执行一些任务，比如发送时势通讯邮件给订阅用户。我们将使用Spring的定时任务功能联合Redisson来确保分布式情况下任务的准时和准确执行。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Web
  
• Spring Boot Starter Data Redis
  
• Redisson
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建任务执行服务
  

1. @Service
2. public class ScheduledTaskService {
4.     public void executeTask() {
5.         // 执行任务的逻辑，例如发送邮件
6.         System.out.println("Executing scheduled task: " + LocalDateTime.now());
7.     }
8. }

复制代码

• 设置Redisson
  

创建一个设置类来设置Redisson客户端。

1. @Configuration
2. public class RedissonConfig {
4.     @Bean(destroyMethod = "shutdown")
5.     public RedissonClient redissonClient() {
6.         RedissonClientConfig config = new RedissonClientConfig();
7.         config.useSingleServer().setAddress("redis://" + spring.redis.host + ":" + spring.redis.port);
8.         return Redisson.create(config);
9.     }
11.     @Value("${spring.redis.host}")
12.     private String redisHost;
14.     @Value("${spring.redis.port}")
15.     private int redisPort;
16. }

复制代码

• 创建定时任务设置
  

使用Redisson的RedissonScheduledExecutorService来创建一个分布式的调度器。

1. @Configuration
2. public class ScheduledConfig {
4.     @Bean
5.     public RedissonScheduledExecutorService redissonScheduledExecutorService(RedissonClient redissonClient) {
6.         return redissonClient.getExecutorService("myScheduler");
7.     }
8. }

复制代码

• 创建定时任务
  

使用Spring的@Scheduled注解和Redisson的调度器来执行定时任务。

1. @Component
2. public class ScheduledTasks {
4.     @Autowired
5.     private ScheduledTaskService taskService;
7.     @Autowired
8.     private RedissonScheduledExecutorService scheduler;
10.     @Scheduled(cron = "0 0 1 * * ?") // 每天凌晨1点执行
11.     public void scheduledTask() {
12.         scheduler.schedule(() -> taskService.executeTask(), 0, TimeUnit.SECONDS);
13.     }
14. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 创建任务执行服务：ScheduledTaskService服务包含现实要执行的任务逻辑。
  
• 设置Redisson：RedissonConfig设置类设置了Redisson客户端，用于后续创建分布式调度器。
  
• 创建定时任务设置：ScheduledConfig设置类创建了一个RedissonScheduledExecutorService Bean，它将被用作分布式任务调度器。
  
• 创建定时任务：ScheduledTasks组件包含一个用@Scheduled注解的方法，该方法根据指定的cron表达式触发。当触发时，它使用Redisson的调度器来安排任务的执行。
  

通过这种方式，我们可以使用Spring的定时任务功能和Redisson的分布式调度器来实现任务调度。这确保了即使在分布式系统中，任务也能准时和准确地执行，避免了任务执行的辩论和重复。这对于必要定时执行的任务，如发送时势通讯、数据备份、陈诉生成等场景非常有用

• 创建社交服务
  

1. @Service
2. public class SocialService {
4.     @Autowired
5.     private StringRedisTemplate redisTemplate;
7.     public void addFriend(String userOneId, String userTwoId) {
8.         // 使用集合存储用户的好友列表
9.         redisTemplate.opsForSet().add("friends:" + userOneId, userTwoId);
10.         redisTemplate.opsForSet().add("friends:" + userTwoId, userOneId);
11.     }
13.     public Set<String> getFriends(String userId) {
14.         // 获取用户的好友列表
15.         return redisTemplate.opsForSet().members("friends:" + userId);
16.     }
18.     public void postStatusUpdate(String userId, String content) {
19.         // 使用列表存储用户的状态更新时间线
20.         StatusUpdate statusUpdate = new StatusUpdate(userId, content, Instant.now());
21.         redisTemplate.opsForList().rightPush("timeline:" + userId, statusUpdate);
22.     }
24.     public List<StatusUpdate> getStatusUpdates(String userId) {
25.         // 获取用户的状态更新时间线
26.         return redisTemplate.opsForList().range("timeline:" + userId, 0, -1);
27.     }
28. }

复制代码

• 创建控制器
  

1. @RestController
2. @RequestMapping("/social")
3. public class SocialController {
5.     @Autowired
6.     private SocialService socialService;
8.     @PostMapping("/addFriend")
9.     public ResponseEntity<String> addFriend(@RequestParam String userOneId, @RequestParam String userTwoId) {
10.         socialService.addFriend(userOneId, userTwoId);
11.         return ResponseEntity.ok("Friends added successfully");
12.     }
14.     @GetMapping("/friends/{userId}")
15.     public ResponseEntity<Set<String>> getFriends(@PathVariable String userId) {
16.         Set<String> friends = socialService.getFriends(userId);
17.         return ResponseEntity.ok(friends);
18.     }
20.     @PostMapping("/status")
21.     public ResponseEntity<String> postStatusUpdate(@RequestParam String userId, @RequestParam String content) {
22.         socialService.postStatusUpdate(userId, content);
23.         return ResponseEntity.ok("Status updated successfully");
24.     }
26.     @GetMapping("/timeline/{userId}")
27.     public ResponseEntity<List<StatusUpdate>> getStatusUpdates(@PathVariable String userId) {
28.         List<StatusUpdate> updates = socialService.getStatusUpdates(userId);
29.         return ResponseEntity.ok(updates);
30.     }
31. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 定义用户和状态更新实体类：User类代表用户信息，StatusUpdate类代表用户的状态更新信息。
  
• 创建社交服务：SocialService服务提供了添加好友、获取好友列表、发布状态更新和获取状态更新时间线的方法。好友列表使用Redis的Set数据结构存储，确保好友关系是无序且不重复的。状态更新时间线使用List数据结构存储，新的状态更新会被添加到列表的尾部。
  
• 创建控制器：SocialController控制器提供了四个RESTful API端点，分别用于添加好友、获取好友列表、发布状态更新和获取状态更新时间线。
  

通过这种方式，我们可以使用Redis的高性能和数据结构特性来实现社交网络平台中的社交功能。Redis的Set和List数据结构非常适合存储和管理好友关系和状态更新时间线，可以或许提供快速的读写性能，满足社交网络平台的需求。
12. 及时保举系统

针对Redis作为及时保举系统存储的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis来存储用户行为数据和偏好，以及提供一个简单的保举功能。
场景形貌
假设我们正在开辟一个电子商务平台，我们希望根据用户的浏览和购买汗青来保举商品。我们将使用Redis来存储用户的这些行为数据，并根据这些数据生成保举。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Data Redis
  
• Spring Web
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建商品和用户实体类
  

1. public class Product {
2.     private String id;
3.     private String name;
4.     // 省略构造函数、getter和setter方法
5. }
7. public class User {
8.     private String id;
9.     private String username;
10.     // 省略构造函数、getter和setter方法
11. }

复制代码

• 创建保举服务
  

1. @Service
2. public class RecommendationService {
4.     @Autowired
5.     private StringRedisTemplate redisTemplate;
7.     public void recordView(String userId, String productId) {
8.         // 记录用户查看的商品
9.         redisTemplate.opsForList().leftPush("user:" + userId + ":views", productId);
10.     }
12.     public List<String> recommendProducts(String userId) {
13.         // 简单推荐算法：返回用户查看次数最多的商品
14.         Set<String> viewedProducts = redisTemplate.opsForSet().members("user:" + userId + ":views");
15.         Map<String, Long> productViewCounts = new HashMap<>();
16.         viewedProducts.forEach(productId -> {
17.             long count = redisTemplate.opsForValue().decrement("user:" + userId + ":views:" + productId);
18.             productViewCounts.put(productId, count);
19.         });
21.         return productViewCounts.entrySet().stream()
22.                 .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
23.                 .map(Map.Entry::getKey)
24.                 .collect(Collectors.toList());
25.     }
26. }

复制代码

• 创建控制器
  

1. @RestController
2. @RequestMapping("/recommendations")
3. public class RecommendationController {
5.     @Autowired
6.     private RecommendationService recommendationService;
8.     @PostMapping("/view")
9.     public ResponseEntity<String> recordProductView(@RequestParam String userId, @RequestParam String productId) {
10.         recommendationService.recordView(userId, productId);
11.         return ResponseEntity.ok("View recorded");
12.     }
14.     @GetMapping("/products")
15.     public ResponseEntity<List<String>> getRecommendations(@RequestParam String userId) {
16.         List<String> recommendedProducts = recommendationService.recommendProducts(userId);
17.         return ResponseEntity.ok(recommendedProducts);
18.     }
19. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 创建商品和用户实体类：Product类代表商品信息，User类代表用户信息。
  
• 创建保举服务：
  
  
  
  • recordView方法用于记任命户查看的商品。这里使用Redis的List来存储用户的浏览汗青，每次用户查看商品时，商品ID被推入到对应用户的List中。
    
  • recommendProducts方法提供了一个简单的保举算法。首先，获取用户的浏览汗青中的所有商品ID，然后统计每个商品的浏览次数（这里简化处理，每次查看减少商品ID对应的计数器）。最后，根据浏览次数对商品举行排序，并返回用户浏览次数最多的商品列表。
    
  
  
• 创建控制器：
  
  
  
  • recordProductView端点用于记任命户查看商品的行为。
    
  • getRecommendations端点用于获取保举商品列表。
    
  
  

通过这种方式，我们可以使用Redis的高性能和简单的数据结构来快速记任命户行为并生成保举。固然这里的保举算法非常简单，但它展示了怎样使用Redis来实现及时保举系统的底子功能。在现实应用中，保举算法可能会更复杂，涉及机器学习模子和更丰富的用户行为数据。
13. 地理位置信息

针对Redis作为地理位置信息存储的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis的Geospatial索引来实现基于地理位置的保举功能。
场景形貌
假设我们正在开辟一款基于位置的社交应用，用户可以查看附近的其他用户或地点。我们必要存储用户的地理位置，并可以或许查询给定位置附近的用户。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。（确保Redis版本支持Geospatial索引，如Redis 3.2以上）
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Data Redis Reactive（如果使用响应式编程）
  
• Spring Web
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建用户实体类
  

1. public class User {
2.     private String id;
3.     private String name;
4.     private double longitude;
5.     private double latitude;
6.     // 省略构造函数、getter和setter方法
7. }

复制代码

• 创建地理位置服务
  

1. @Service
2. public class GeoLocationService {
4.     @Autowired
5.     private RedisTemplate<String, User> redisTemplate;
7.     public void addLocation(String userId, double longitude, double latitude) {
8.         User user = new User(userId, "username", longitude, latitude);
9.         // 使用Geospatial索引存储用户位置
10.         redisTemplate.opsForGeo().add("userLocations", new GeoLocation(user.getLongitude(), user.getLatitude()), userId);
11.     }
13.     public List<User> getUsersNearby(double longitude, double latitude, double radius) {
14.         // 查询给定位置附近的用户
15.         List<GeoWithin> nearbyUsersGeo = redisTemplate.opsForGeo().radius("userLocations",
16.                 new Circle(new GeoCoordinate(latitude, longitude), radius),
17.                 RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs());
18.         
19.         List<User> nearbyUsers = new ArrayList<>();
20.         for (GeoWithin geoWithin : nearbyUsersGeo) {
21.             nearbyUsers.add(redisTemplate.opsForValue().get(geoWithin.getMember()));
22.         }
23.         return nearbyUsers;
24.     }
25. }

复制代码

• 创建控制器
  

1. @RestController
2. @RequestMapping("/users")
3. public class UserController {
5.     @Autowired
6.     private GeoLocationService geoLocationService;
8.     @PostMapping("/addLocation")
9.     public ResponseEntity<String> addLocation(@RequestParam String userId,
10.                                                @RequestParam double longitude,
11.                                                @RequestParam double latitude) {
12.         geoLocationService.addLocation(userId, longitude, latitude);
13.         return ResponseEntity.ok("User location added");
14.     }
16.     @GetMapping("/nearby")
17.     public ResponseEntity<List<User>> getUsersNearby(@RequestParam double longitude,
18.                                                       @RequestParam double latitude,
19.                                                       @RequestParam double radius) {
20.         List<User> nearbyUsers = geoLocationService.getUsersNearby(longitude, latitude, radius);
21.         return ResponseEntity.ok(nearbyUsers);
22.     }
23. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 创建用户实体类：User类代表用户信息，包括用户的ID、名称、经度和纬度。
  
• 创建地理位置服务：
  
  
  
  • addLocation方法用于将用户的地理位置信息存储到Redis的Geospatial索引中。这里使用RedisTemplate的opsForGeo方法来添加位置信息。
    
  • getUsersNearby方法用于查询给定位置附近的用户。使用radius方法来查找指定半径内的用户，然后从Redis中获取这些用户的详细信息。
    
  
  
• 创建控制器：
  
  
  
  • addLocation端点答应用户添加其地理位置信息。
    
  • getUsersNearby端点答应查询指定位置和半径内的附近用户。
    
  
  

通过这种方式，我们可以使用Redis的Geospatial索引来存储和查询地理位置信息。这对于必要基于地理位置提供服务的应用非常有用，如社交网络、共享出行、当地服务保举等。Redis的Geospatial索引提供了高效的邻近查询功能，可以快速找到指定范围内的用户或其他地理位置相干的实体。
14. 时间序列数据

针对Redis作为时间序列数据存储的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis来存储和查询时间序列数据。
场景形貌
假设我们正在开辟一个监控系统，必要记录服务器的CPU使用率随时间厘革的数据。我们将使用Redis的时间序列数据结构来存储这些监控数据，并可以或许查询任意时间范围内的CPU使用率。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。（确保Redis版本支持时间序列数据结构，可能必要使用RedisModules如RedisTimeSeries）
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Data Redis
  
• Spring Web
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建监控数据实体类
  

1. public class CpuUsageData {
2.     private Instant timestamp;
3.     private double cpuUsage;
5.     // 省略构造函数、getter和 setter 方法
6. }

复制代码

• 创建监控服务
  

1. @Service
2. public class MonitoringService {
4.     @Autowired
5.     private LettuceConnectionFactory connectionFactory;
7.     public void logCpuUsage(String serverId, double cpuUsage) {
8.         // 记录CPU使用率数据
9.         CpuUsageData data = new CpuUsageData(Instant.now(), cpuUsage);
10.         // 使用Lettuce客户端的命令执行器来与RedisTimeSeries模块交互
11.         StatefulRedisConnection<String, CpuUsageData> connection = connectionFactory.connect();
12.         try {
13.             RedisTimeSeriesCommands<String, CpuUsageData> ts = connection.sync();
14.             ts.add(serverId, data.getTimestamp().toEpochMilli() / 1000, data);
15.         } finally {
16.             connection.close();
17.         }
18.     }
20.     public List<CpuUsageData> getCpuUsageHistory(String serverId, Instant start, Instant end) {
21.         // 查询指定时间范围内的CPU使用率历史数据
22.         List<CpuUsageData> history = new ArrayList<>();
23.         StatefulRedisConnection<String, CpuUsageData> connection = connectionFactory.connect();
24.         try {
25.             RedisTimeSeriesCommands<String, CpuUsageData> ts = connection.sync();
26.             Range range = Range.create(start.toEpochMilli() / 1000, end.toEpochMilli() / 1000);
27.             Cursor<CpuUsageData> cursor = ts.rangeRead(serverId, range);
28.             while (cursor.hasNext()) {
29.                 history.add(cursor.next().getValue());
30.             }
31.         } finally {
32.             connection.close();
33.         }
34.         return history;
35.     }
36. }

复制代码

• 创建控制器
  

1. @RestController
2. @RequestMapping("/monitoring")
3. public class MonitoringController {
5.     @Autowired
6.     private MonitoringService monitoringService;
8.     @PostMapping("/logCpuUsage")
9.     public ResponseEntity<String> logCpuUsage(@RequestParam String serverId, @RequestParam double cpuUsage) {
10.         monitoringService.logCpuUsage(serverId, cpuUsage);
11.         return ResponseEntity.ok("CPU usage logged");
12.     }
14.     @GetMapping("/cpuUsageHistory")
15.     public ResponseEntity<List<CpuUsageData>> getCpuUsageHistory(@RequestParam String serverId,
16.                                                                  @RequestParam Instant start,
17.                                                                  @RequestParam Instant end) {
18.         List<CpuUsageData> history = monitoringService.getCpuUsageHistory(serverId, start, end);
19.         return ResponseEntity.ok(history);
20.     }
21. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 创建监控数据实体类：CpuUsageData类代表CPU使用率数据，包括时间戳和CPU使用率。
  
• 创建监控服务：
  
  
  
  • logCpuUsage方法用于记录服务器的CPU使用率。使用Lettuce客户端的同步下令执行器与RedisTimeSeries模块交互，将数据添加到时间序列中。
    
  • getCpuUsageHistory方法用于查询指定时间范围内的CPU使用率汗青数据。使用rangeRead方法从时间序列中读取数据。
    
  
  
• 创建控制器：
  
  
  
  • logCpuUsage端点答应记录服务器的CPU使用率。
    
  • getCpuUsageHistory端点答应查询指定时间范围内的CPU使用率汗青数据。
    
  
  

通过这种方式，我们可以使用Redis的RedisTimeSeries模块来存储和查询时间序列数据。这对于必要监控和分析随时间厘革的数据的应用非常有用，如服务器监控、网站访问量分析等。RedisTimeSeries提供了高效的时间序列数据存储和查询功能，可以快速插入和检索大量时间戳数据。
15. 任务调度

针对Redis作为任务调度的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis的延迟队列特性来实现任务调度。
场景形貌
假设我们正在开辟一个定时任务管理系统，必要安排一些任务在未来的某个时间点执行。我们将使用Redis的schedule下令来安排任务的执行。
情况准备

• 安装Java开辟情况。
  
• 安装支持schedule下令的Redis版本（Redis 5.0及以上版本）。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Data Redis
  
• Spring Web
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建任务调度服务
  

1. @Service
2. public class TaskSchedulingService {
4.     @Autowired
5.     private RedisTemplate<String, Runnable> redisTemplate;
7.     public void scheduleTask(Runnable task, long delay, TimeUnit timeUnit) {
8.         // 将任务和延迟时间存储到Redis中
9.         redisTemplate.opsForValue().set(
10.             "task:" + task.hashCode(), 
11.             task, 
12.             timeUnit.toSeconds(delay), 
13.             timeUnit
14.         );
15.         // 使用schedule命令安排任务在未来执行
16.         String scheduleCommand = String.format(
17.             "SCHEDULE %d %s", 
18.             System.currentTimeMillis() + timeUnit.toMillis(delay), 
19.             "task:" + task.hashCode()
20.         );
21.         redisTemplate.execute((RedisConnection connection) -> {
22.             connection.schedule(scheduleCommand);
23.             return null;
24.         });
25.     }
26. }

复制代码

• 创建详细的任务
  

1. public class SampleTask implements Runnable {
2.     @Override
3.     public void run() {
4.         System.out.println("Task is running: " + LocalDateTime.now());
5.         // 执行任务逻辑
6.     }
7. }

复制代码

• 创建控制器
  

1. @RestController
2. @RequestMapping("/tasks")
3. public class TaskController {
5.     @Autowired
6.     private TaskSchedulingService taskSchedulingService;
8.     @PostMapping("/schedule")
9.     public ResponseEntity<String> scheduleTask(@RequestParam long delay, @RequestParam TimeUnit timeUnit) {
10.         taskSchedulingService.scheduleTask(new SampleTask(), delay, timeUnit);
11.         return ResponseEntity.ok("Task scheduled for execution at " + LocalDateTime.now().plusNanos(timeUnit.toNanos(delay)));
12.     }
13. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 创建任务调度服务：scheduleTask方法用于安排一个Runnable任务在未来的某个时间点执行。首先，任务被存储到Redis中，并设置相应的延迟时间。然后，使用Redis的schedule下令安排任务在未来执行。
  
• 创建详细的任务：SampleTask类实现了Runnable接口，定义了任务的详细执行逻辑。
  
• 创建控制器：scheduleTask端点答应用户安排任务在未来执行。用户必要提供延迟时间和时间单元。
  

通过这种方式，我们可以使用Redis的schedule下令来安排任务的执行。这对于必要执行定时任务的应用非常有用，如定时数据备份、定时发送通知等。通过Redis的延迟队列特性，我们可以简化任务调度的复杂性，而且可以或许灵活地安排任务在未来的任意时间点执行。
16. 数据共享

针对Redis作为数据共享的使用场景，下面是一个Java Spring Boot应用的案例，其中使用Redis来实现微服务架构中的服务间数据共享。
场景形貌
假设我们有一个电商平台，它由多个微服务构成，比如用户服务、产品服务和订单服务。这些服务必要共享购物车数据，以确保用户在平台上的购物体验是连贯的。我们将使用Redis来存储和共享购物车数据。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Data Redis
  
• Spring Web
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建购物车项实体类
  

1. public class CartItem {
2.     private String productId;
3.     private int quantity;
4.     // 省略构造函数、getter和setter方法
5. }

复制代码

• 创建购物车服务
  

1. @Service
2. public class CartService {
4.     @Autowired
5.     private StringRedisTemplate redisTemplate;
7.     public void addToCart(String cartId, String productId, int quantity) {
8.         // 将购物车项存储到Redis的Hash结构中
9.         redisTemplate.opsForHash().put("cart:" + cartId, productId, quantity);
10.     }
12.     public Map<String, Integer> getCart(String cartId) {
13.         // 从Redis获取购物车内容
14.         return redisTemplate.opsForHash().entries("cart:" + cartId);
15.     }
16. }

复制代码

• 创建控制器
  

1. @RestController
2. @RequestMapping("/cart")
3. public class CartController {
5.     @Autowired
6.     private CartService cartService;
8.     @PostMapping("/{cartId}/items")
9.     public ResponseEntity<String> addToCart(@PathVariable String cartId,
10.                                              @RequestParam String productId,
11.                                              @RequestParam int quantity) {
12.         cartService.addToCart(cartId, productId, quantity);
13.         return ResponseEntity.ok("Item added to cart");
14.     }
16.     @GetMapping("/{cartId}")
17.     public ResponseEntity<Map<String, Integer>> getCart(@PathVariable String cartId) {
18.         Map<String, Integer> cart = cartService.getCart(cartId);
19.         return ResponseEntity.ok(cart);
20.     }
21. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 创建购物车项实体类：CartItem类代表购物车中的商品项，包含商品ID和数量。
  
• 创建购物车服务：
  
  
  
  • addToCart方法用于将商品项添加到用户的购物车中。使用Redis的Hash结构来存储购物车数据，其中cart:加上cartId作为Hash的键，productId作为字段名，quantity作为字段值。
    
  • getCart方法用于从Redis获取用户的购物车内容。
    
  
  
• 创建控制器：
  
  
  
  • addToCart端点答应用户将商品添加到购物车中。
    
  • getCart端点答应用户获取其购物车的内容。
    
  
  

通过这种方式，我们可以使用Redis的高性能和数据共享能力来实现微服务架构中的服务间数据共享。购物车数据被存储在Redis中，可以被不同的微服务实例访问和修改，确保了数据的同等性和及时性。这对于必要高度协同工作的分布式系统非常有用，如电商平台、在线协作工具等。
17. 持久化

针对Redis作为任务调度使用场景，下面是一个Java Spring Boot应用的案例，其中使用Spring的@Scheduled注解与Redisson联合来实现任务调度。
场景形貌
假设我们有一个自动化的营销平台，必要定期（例如每天破晓1点）执行一些任务，比如发送时势通讯邮件给订阅用户。我们将使用Spring的定时任务功能联合Redisson来确保分布式情况下任务的准时和准确执行。
情况准备

• 安装Java开辟情况。
  
• 安装Redis并确保其运行。
  
• 创建一个Spring Boot项目，并添加以下依靠：
  

• Spring Boot Starter Web
  
• Spring Boot Starter Data Redis
  
• Redisson
  

创建Spring Boot项目
使用Spring Initializr (https://start.spring.io/) 创建一个项目，并添加所需的依靠。
设置Redis毗连
在src/main/resources/application.properties中设置Redis服务器的毗连信息：

1. spring.redis.host=localhost
2. spring.redis.port=6379

复制代码

编写业务代码

• 创建任务执行服务
  

1. @Service
2. public class ScheduledTaskService {
4.     public void executeTask() {
5.         // 执行任务的逻辑，例如发送邮件
6.         System.out.println("Executing scheduled task: " + LocalDateTime.now());
7.     }
8. }

复制代码

• 设置Redisson
  

创建一个设置类来设置Redisson客户端。

1. @Configuration
2. public class RedissonConfig {
4.     @Bean(destroyMethod = "shutdown")
5.     public RedissonClient redissonClient() {
6.         RedissonClientConfig config = new RedissonClientConfig();
7.         config.useSingleServer().setAddress("redis://" + spring.redis.host + ":" + spring.redis.port);
8.         return Redisson.create(config);
9.     }
11.     @Value("${spring.redis.host}")
12.     private String redisHost;
14.     @Value("${spring.redis.port}")
15.     private int redisPort;
16. }

复制代码

• 创建定时任务设置
  

使用Redisson的RedissonScheduledExecutorService来创建一个分布式的调度器。

1. @Configuration
2. public class ScheduledConfig {
4.     @Bean
5.     public RedissonScheduledExecutorService redissonScheduledExecutorService(RedissonClient redissonClient) {
6.         return redissonClient.getExecutorService("myScheduler");
7.     }
8. }

复制代码

• 创建定时任务
  

使用Spring的@Scheduled注解和Redisson的调度器来执行定时任务。

1. @Component
2. public class ScheduledTasks {
4.     @Autowired
5.     private ScheduledTaskService taskService;
7.     @Autowired
8.     private RedissonScheduledExecutorService scheduler;
10.     @Scheduled(cron = "0 0 1 * * ?") // 每天凌晨1点执行
11.     public void scheduledTask() {
12.         scheduler.schedule(() -> taskService.executeTask(), 0, TimeUnit.SECONDS);
13.     }
14. }

复制代码

详细解释

• 设置Redis毗连：在application.properties中设置了Redis服务器的地址和端口。
  
• 创建任务执行服务：ScheduledTaskService服务包含现实要执行的任务逻辑。
  
• 设置Redisson：RedissonConfig设置类设置了Redisson客户端，用于后续创建分布式调度器。
  
• 创建定时任务设置：ScheduledConfig设置类创建了一个RedissonScheduledExecutorService Bean，它将被用作分布式任务调度器。
  
• 创建定时任务：ScheduledTasks组件包含一个用@Scheduled注解的方法，该方法根据指定的cron表达式触发。当触发时，它使用Redisson的调度器来安排任务的执行。
  

通过这种方式，我们可以使用Spring的定时任务功能和Redisson的分布式调度器来实现任务调度。这确保了即使在分布式系统中，任务也能准时和准确地执行，避免了任务执行的辩论和重复。这对于必要定时执行的任务，如发送时势通讯、数据备份、陈诉生成等场景非常有用
[code][/code]






















免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。