图书保举（协同过滤）算法的实现：基于订单购买实现相似用户的图书保举

代码部分

1. package com.ruoyi.system.service.impl;
3. import com.ruoyi.system.domain.Book;
4. import com.ruoyi.system.domain.MyOrder;
5. import com.ruoyi.system.mapper.BookMapper;
6. import com.ruoyi.system.mapper.MyOrderMapper;
7. import com.ruoyi.system.service.IBookRecommendService;
8. import org.slf4j.Logger;
9. import org.slf4j.LoggerFactory;
10. import org.springframework.beans.factory.annotation.Autowired;
11. import org.springframework.data.redis.core.RedisTemplate;
12. import org.springframework.scheduling.annotation.Scheduled;
13. import org.springframework.stereotype.Service;
14. import org.springframework.transaction.annotation.Transactional;
16. import javax.annotation.PostConstruct;
17. import java.util.*;
18. import java.util.concurrent.TimeUnit;
19. import java.util.stream.Collectors;
21. @Service
22. public class BookRecommendServiceImpl implements IBookRecommendService {
24.     private static final Logger log = LoggerFactory.getLogger(BookRecommendServiceImpl.class);
26.     @Autowired
27.     private MyOrderMapper orderMapper;
29.     @Autowired
30.     private BookMapper bookMapper;
32.     @Autowired
33.     private RedisTemplate<String, Object> redisTemplate;
35.     private static final String USER_SIMILARITY_KEY = "recommend:user:similarity";
36.     private static final double SIMILARITY_THRESHOLD = 0.000001; // 相似度阈值
38.     /**
39.      * 应用启动时初始化推荐数据
40.      */
41.     @PostConstruct
42.     public void init() {
43.         log.info("检查推荐数据初始化状态...");
44.         try {
45.             if(!hasRecommendationData()) {
46.                 log.info("未检测到推荐数据，开始初始化计算...");
47.                 preComputeUserSimilarities();
48.             } else {
49.                 log.info("推荐数据已存在，跳过初始化计算");
50.             }
51.         } catch (Exception e) {
52.             log.error("推荐数据初始化失败", e);
53.         }
54.     }
56.     /**
57.      * 检查是否存在推荐数据
58.      */
59.     private boolean hasRecommendationData() {
60.         Set<String> keys = redisTemplate.keys(USER_SIMILARITY_KEY + ":*");
61.         return keys != null && !keys.isEmpty();
62.     }
64.     @Override
65.     @Transactional(readOnly = true)
66.     public List<Book> recommendBooksByUserCF(Long userId, int limit) {
67.         if (userId == null || limit <= 0) {
68.             return Collections.emptyList();
69.         }
70.         try {
71.             // 1. 从Redis获取用户相似度数据
72.             Map<Object, Object> similarityScoresObj = redisTemplate.opsForHash()
73.                     .entries(USER_SIMILARITY_KEY + ":" + userId);
74.             if (similarityScoresObj == null || similarityScoresObj.isEmpty()) {
75.                 log.debug("用户 {} 无相似用户数据", userId);
76.                 return Collections.emptyList();
77.             }
78.             // 2. 转换数据类型
79.             Map<Long, Double> similarityScores = convertSimilarityMap(similarityScoresObj);
80.             // 3. 获取最相似的N个用户
81.             List<Long> similarUserIds = getTopSimilarUsers(similarityScores, 10);
82.             if (similarUserIds.isEmpty()) {
83.                 return Collections.emptyList();
84.             }
85.             // 4. 获取推荐图书
86.             return generateRecommendations(userId, similarUserIds, limit);
87.         } catch (Exception e) {
88.             log.error("为用户 {} 生成推荐时发生错误", userId, e);
89.             return Collections.emptyList();
90.         }
91.     }
93.     /**
94.      * 转换相似度Map数据类型
95.      */
96.     private Map<Long, Double> convertSimilarityMap(Map<Object, Object> rawMap) {
97.         return rawMap.entrySet().stream()
98.                 .collect(Collectors.toMap(
99.                         e -> Long.parseLong(e.getKey().toString()),
100.                         e -> Double.parseDouble(e.getValue().toString())
101.                 ));
102.     }
104.     /**
105.      * 获取最相似的用户ID列表
106.      */
107.     private List<Long> getTopSimilarUsers(Map<Long, Double> similarityScores, int topN) {
108.         return similarityScores.entrySet().stream()
109.                 .filter(e -> e.getValue() >= SIMILARITY_THRESHOLD)
110.                 .sorted(Map.Entry.<Long, Double>comparingByValue().reversed())
111.                 .limit(topN)
112.                 .map(Map.Entry::getKey)
113.                 .collect(Collectors.toList());
114.     }
116.     /**
117.      * 生成推荐图书列表
118.      */
119.     private List<Book> generateRecommendations(Long targetUserId, List<Long> similarUserIds, int limit) {
120.         // 1. 获取相似用户订单
121.         List<MyOrder> similarUserOrders = orderMapper.selectCompletedOrdersByUserIds(similarUserIds);
123.         // 2. 获取目标用户已购图书
124.         Set<Long> purchasedBooks = getPurchasedBooks(targetUserId);
126.         // 3. 计算图书推荐分数
127.         Map<Long, Double> bookScores = calculateBookScores(similarUserOrders, purchasedBooks);
129.         // 4. 获取推荐图书
130.         return getTopRecommendedBooks(bookScores, limit);
131.     }
133.     /**
134.      * 获取用户已购图书ID集合
135.      */
136.     private Set<Long> getPurchasedBooks(Long userId) {
137.         List<MyOrder> orders = orderMapper.selectCompletedOrdersByUserId(userId);
138.         if (orders == null || orders.isEmpty()) {
139.             return Collections.emptySet();
140.         }
141.         return orders.stream()
142.                 .map(order -> order.getBookId())
143.                 .collect(Collectors.toSet());
144.     }
145.     /**
146.      * 计算图书推荐分数
147.      */
148.     private Map<Long, Double> calculateBookScores(List<MyOrder> similarUserOrders, Set<Long> purchasedBooks) {
149.         Map<Long, Double> bookScores = new HashMap<>();
151.         for (MyOrder order : similarUserOrders) {
152.             Long bookId = order.getBookId();
153.             if (!purchasedBooks.contains(bookId)) {
154.                 bookScores.merge(bookId, (double) order.getQuantity(), Double::sum);
155.             }
156.         }
158.         return bookScores;
159.     }
161.     /**
162.      * 获取评分最高的推荐图书
163.      */
164.     private List<Book> getTopRecommendedBooks(Map<Long, Double> bookScores, int limit) {
165.         if (bookScores.isEmpty()) {
166.             return Collections.emptyList();
167.         }
169.         List<Long> recommendedBookIds = bookScores.entrySet().stream()
170.                 .sorted(Map.Entry.<Long, Double>comparingByValue().reversed())
171.                 .limit(limit)
172.                 .map(Map.Entry::getKey)
173.                 .collect(Collectors.toList());
175.         return bookMapper.selectBookByIds(recommendedBookIds);
176.     }
178.     @Override
179.     @Transactional
180.     public void preComputeUserSimilarities() {
181.         log.info("开始计算用户相似度矩阵...");
182.         long startTime = System.currentTimeMillis();
184.         try {
185.             // 1. 清空旧数据
186.             clearExistingSimilarityData();
188.             // 2. 获取所有用户ID（有完成订单的）
189.             List<Long> userIds = orderMapper.selectAllUserIdsWithCompletedOrders();
190.             log.info("找到{}个有订单的用户", userIds.size());
192.             if (userIds.isEmpty()) {
193.                 log.warn("没有找到任何用户订单数据！");
194.                 return;
195.             }
197.             // 3. 构建用户-图书评分矩阵
198.             Map<Long, Map<Long, Integer>> ratingMatrix = buildRatingMatrix(userIds);
200.             // 4. 计算并存储相似度
201.             computeAndStoreSimilarities(userIds, ratingMatrix);
203.             long duration = (System.currentTimeMillis() - startTime) / 1000;
204.             log.info("用户相似度矩阵计算完成，耗时{}秒", duration);
205.         } catch (Exception e) {
206.             log.error("计算用户相似度矩阵失败", e);
207.             throw e;
208.         }
209.     }
211.     /**
212.      * 清空现有相似度数据
213.      */
214.     private void clearExistingSimilarityData() {
215.         Set<String> keys = redisTemplate.keys(USER_SIMILARITY_KEY + ":*");
216.         if (keys != null && !keys.isEmpty()) {
217.             redisTemplate.delete(keys);
218.             log.info("已清除{}个旧的用户相似度记录", keys.size());
219.         }
220.     }
222.     /**
223.      * 构建用户-图书评分矩阵
224.      */
225.     private Map<Long, Map<Long, Integer>> buildRatingMatrix(List<Long> userIds) {
226.         Map<Long, Map<Long, Integer>> ratingMatrix = new HashMap<>();
227.         for (Long userId : userIds) {
228.             List<MyOrder> orders = orderMapper.selectCompletedOrdersByUserId(userId);
229.             if (orders == null || orders.isEmpty()) {
230.                 continue;
231.             }
232.             Map<Long, Integer> userRatings = new HashMap<>();
233.             for (MyOrder order : orders) {
234.                 if (order == null || order.getBookId() == null) {
235.                     continue;
236.                 }
237.                 Long bookId = order.getBookId();
238.                 Integer quantity = Math.toIntExact(order.getQuantity() != null ? order.getQuantity() : 0);
239.                 userRatings.merge(bookId, quantity, (oldVal, newVal) -> oldVal + newVal);
240.             }
241.             ratingMatrix.put(userId, userRatings);
242.         }
243.         return ratingMatrix;
244.     }
245.     /**
246.      * 计算并存储用户相似度
247.      */
248.     private void computeAndStoreSimilarities(List<Long> userIds, Map<Long, Map<Long, Integer>> ratingMatrix) {
249.         int computedPairs = 0;
250.         for (int i = 0; i < userIds.size(); i++) {
251.             Long userId1 = userIds.get(i);
252.             Map<Long, Integer> ratings1 = ratingMatrix.get(userId1);
253.             Map<String, String> similarities = new HashMap<>();
254.             // 只计算后续用户，避免重复计算
255.             for (int j = i + 1; j < userIds.size(); j++) {
256.                 Long userId2 = userIds.get(j);
257.                 Map<Long, Integer> ratings2 = ratingMatrix.get(userId2);
258.                 double similarity = computeCosineSimilarity(ratings1, ratings2);
259.                 if (similarity >= SIMILARITY_THRESHOLD) {
260.                     similarities.put(userId2.toString(), String.valueOf(similarity));
261.                     computedPairs++;
262.                 }
263.             }
264.             if (!similarities.isEmpty()) {
265.                 String key = USER_SIMILARITY_KEY + ":" + userId1;
266.                 redisTemplate.opsForHash().putAll(key, similarities);
267.                 redisTemplate.expire(key, 7, TimeUnit.DAYS);
268.             }
269.             // 定期打印进度
270.             if (i % 100 == 0 || i == userIds.size() - 1) {
271.                 log.info("已处理 {}/{} 用户", i + 1, userIds.size());
272.             }
273.         }
274.         log.info("共计算{}对用户相似关系", computedPairs);
275.     }
277.     /**
278.      * 计算余弦相似度
279.      */
280.     private double computeCosineSimilarity(Map<Long, Integer> ratings1, Map<Long, Integer> ratings2) {
281.         // 获取共同评价的图书
282.         Set<Long> commonBooks = new HashSet<>(ratings1.keySet());
283.         commonBooks.retainAll(ratings2.keySet());
284.         if (commonBooks.isEmpty()) {
285.             return 0.0;
286.         }
287.         // 计算点积和范数
288.         double dotProduct = 0.0;
289.         double norm1 = 0.0;
290.         double norm2 = 0.0;
291.         // 计算共同图书的部分
292.         for (Long bookId : commonBooks) {
293.             int r1 = ratings1.get(bookId);
294.             int r2 = ratings2.get(bookId);
295.             dotProduct += r1 * r2;
296.             norm1 += r1 * r1;
297.             norm2 += r2 * r2;
298.         }
299.         // 计算各自独有的部分
300.         norm1 += ratings1.keySet().stream()
301.                 .filter(bookId -> !commonBooks.contains(bookId))
302.                 .mapToDouble(bookId -> Math.pow(ratings1.get(bookId), 2))
303.                 .sum();
304.         norm2 += ratings2.keySet().stream()
305.                 .filter(bookId -> !commonBooks.contains(bookId))
306.                 .mapToDouble(bookId -> Math.pow(ratings2.get(bookId), 2))
307.                 .sum();
308.         if (norm1 == 0 || norm2 == 0) {
309.             return 0.0;}
310.         return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
311.     }
313.     /**
314.      * 定时任务：每天凌晨3点更新相似度矩阵
315.      */
316.     @Scheduled(cron = "0 0 3 * * ?")
317.     public void scheduledSimilarityUpdate() {
318.         log.info("定时任务：开始更新用户相似度矩阵...");
319.         try {
320.             preComputeUserSimilarities();
321.             log.info("定时任务：用户相似度矩阵更新完成");
322.         } catch (Exception e) {
323.             log.error("定时任务：更新用户相似度矩阵失败", e);
324.         }
325.     }
326. }

复制代码

协同过滤解析

协同过滤保举算法原理与实现分析

这个代码实现了一个基于用户的协同过滤(User-based Collaborative Filtering)保举体系，下面我将结合代码详细解析协同过滤算法的原理和实现方式。
1. 协同过滤基本概念

协同过滤(CF)是保举体系中最经典的算法之一，核心思想是：
“相似用户喜好的物品，你也大概喜好”
1.1 两种主要范例

• 基于用户的协同过滤(User-CF)：代码中实现的就是这种
  
• 基于物品的协同过滤(Item-CF)
  

2. 代码实现的User-CF流程

2.1 团体流程

• 离线盘算阶段：
  
  
  
  • 构建用户-物品评分矩阵
    
  • 盘算并存储用户相似度
    
  
  
• 在线保举阶段：
  
  
  
  • 查找相似用户
    
  • 基于相似用户的偏好天生保举
    
  
  

2.2 核心代码解析

(1) 离线盘算阶段 (preComputeUserSimilarities)

1. public void preComputeUserSimilarities() {
2.     // 1. 清空旧数据
3.     clearExistingSimilarityData();
4.    
5.     // 2. 获取所有用户ID
6.     List<Long> userIds = orderMapper.selectAllUserIdsWithCompletedOrders();
7.    
8.     // 3. 构建评分矩阵
9.     Map<Long, Map<Long, Integer>> ratingMatrix = buildRatingMatrix(userIds);
10.    
11.     // 4. 计算并存储相似度
12.     computeAndStoreSimilarities(userIds, ratingMatrix);
13. }

复制代码

评分矩阵构建：

• 用户为行，图书为列
  
• 值为购买数目(作为评分)
  

相似度盘算：

• 利用余弦相似度(Cosine Similarity)
  
• 只存储相似度高于阈值(SIMILARITY_THRESHOLD)的关系
  

(2) 相似度盘算 (computeCosineSimilarity)

1. private double computeCosineSimilarity(Map<Long, Integer> ratings1, Map<Long, Integer> ratings2) {
2.     // 获取共同评价的图书
3.     Set<Long> commonBooks = new HashSet<>(ratings1.keySet());
4.     commonBooks.retainAll(ratings2.keySet());
5.    
6.     // 计算点积和范数
7.     double dotProduct = 0.0;
8.     double norm1 = 0.0;
9.     double norm2 = 0.0;
10.    
11.     // 计算余弦相似度
12.     return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
13. }

复制代码

余弦相似度公式：

1. similarity = (A·B) / (||A|| * ||B||)

复制代码

(3) 在线保举阶段 (recommendBooksByUserCF)

1. public List<Book> recommendBooksByUserCF(Long userId, int limit) {
2.     // 1. 获取用户相似度数据
3.     Map<Long, Double> similarityScores = getSimilarityScores(userId);
4.    
5.     // 2. 获取最相似的N个用户
6.     List<Long> similarUserIds = getTopSimilarUsers(similarityScores, 10);
7.    
8.     // 3. 生成推荐
9.     return generateRecommendations(userId, similarUserIds, limit);
10. }

复制代码

3. 关键技术点

3.1 数据存储优化

• Redis存储：用户相似度矩阵存储在Redis中，键格式为recommend:user:similarity:{userId}
  
• 定期更新：通过@Scheduled天天破晓3点更新
  

3.2 性能优化

• 只盘算上三角矩阵：避免重复盘算(A-B和B-A的相似度雷同)
  
• 阈值过滤：只存储故意义的相似关系(SIMILARITY_THRESHOLD)
  
• 分批处置惩罚：每处置惩罚100个用户打印进度
  

3.3 保举天生逻辑

• 清除用户已购买的图书
  
• 根据相似用户的购买记录加权盘算保举分数
  
• 按分数排序返回TopN保举
  

4. 协同过滤的优缺点

长处：

• 不必要物品内容信息：仅依靠用户举动数据
  
• 能发现潜伏爱好：大概保举出意想不到的物品
  
• 表明性强：可以告诉用户"由于和你相似的用户也喜好"
  

缺点：

• 冷启动题目：新用户/新物品缺乏数据
  
• 希奇性题目：用户-物品矩阵通常非常希奇
  
• 盘算复杂度高：用户增长时相似度盘算本钱呈平方级增长
  

5. 代码中的工程化实践

• 定时使命：@Scheduled定期更新相似度矩阵
  
• 启动初始化：@PostConstruct检查数据是否必要初始化
  
• 非常处置惩罚：美满的try-catch和日记记录
  
• 性能监控：记录关键步调的实行时间
  
• 资源清算：盘算前先打扫旧数据
  

这个实现是一个典范的生产级协同过滤保举体系，均衡了算法效果和工程实践，得当中等规模的电商平台利用。对于更大规模的体系，大概必要思量更复杂的优化如分布式盘算、近似算法等。