JavaWeb_(视频网站)_七、推荐模块1

推荐算法

　　基于内容的推荐算法

　　基于概率论，用户喜欢一个视频概率和不喜欢一个视频概率，工具类RecommendByContentUtils.java

package com.Gary.betobe.recommend;

import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.Gary.betobe.domain.Tag;
import com.Gary.betobe.domain.User;
import com.Gary.betobe.domain.Video;
import com.Gary.betobe.service.TagService;
import com.Gary.betobe.service.UserService;

@Component
public class RecommendByContentUtils {

    @Autowired
    private TagService tagService;
    
    @Autowired
    private UserService userService;

    //喜欢
    
    // 用户喜欢一个视频的概率
    public Double PUserLikeVideo(String userId)
    {
        //用户喜欢视频个数/（用户喜欢视频个数+用户不喜欢视频个数）（视频的总个数）
        //拿到用户
        User user = userService.findUserById(userId);
        int likeVideo = user.getAgreeVideos().size();
        int dislikeVideo = user.getDisagreeVideos().size();
        if(likeVideo+dislikeVideo == 0 || likeVideo == 0)
        {
            return 0.5D;
        }
        else
        {
            return 1.0 * likeVideo / (likeVideo + dislikeVideo);
        }
    }
    
    // 获得用户喜欢一个标签的概率 p（Gary|喜欢）
    public Double PUserTargetLike(String userId,String target)
    {
        //套公式
        Double answer = 1.0*((CountTermsUserLike(userId,target)) + 1)
                    /(AllTermsUserLikeCount(userId) + getAllTagsCount());
        //answer = 1.0*(CountTerms+1)/AllTerms + |V|
            
        return answer;
    }
    
    //|V|
    private Long getAllTagsCount() {
        //select count(*) from tag
        Long size = (long) tagService.findAllTag().size();
        return size;
    }
    
    // AllTerms返回这c类文档中所有的词数量，
    private Long AllTermsUserLikeCount(String userId) {
        
        return userLikeDocsCount(userId);
    }
    
    // CountTerms返回词i在c类文档中出现的次数
    private Long CountTermsUserLike(String userId, String target) {
        
        return targetInLikeDocsCount(userId,target);
    }
    
    //返回改用户喜欢的文档中所有的词的数量(标签)
    public Long userLikeDocsCount(String userId)
    {
        
        Long target = 0L;
        //用户->喜欢的视频->标签
        //拿到用户
        User user = userService.findUserById(userId);
        //拿到用户下面的所有喜欢的视频
        Set<Video> videos = user.getAgreeVideos();
        //遍历视频
        for(Video video : videos)
        {
            Set<Tag> tags = video.getVideoTags();
            //重复的也要计算
            for(Tag tag :tags)
            {
                target++;
            }
        }
        
        return target;
    }
    
    // 返回该字符串在用户喜欢的文档中出现的次数
    public Long targetInLikeDocsCount(String userId, String target)
    {
        Long count = 0L;
        //拿到用户
        User user = userService.findUserById(userId);
        // 拿到用户喜欢的视频的集合
        Set<Video> videos = user.getAgreeVideos();
        // 遍历集合，拿到用户喜欢的视频中所有的标签
        for(Video video:videos)
        {
            Set<Tag> tags = video.getVideoTags();
            // 如果标签中的tag和传入的target相同，计数器++
            for(Tag tag : tags)
            {
                if(tag.getTag().toUpperCase().equals(target.toUpperCase()))
                {
                    count++;
                    continue;
                }
            }
            
        }
        
        return count;
        
    }
        
    //不喜欢
        
    //用户不喜欢一个标签的概率P(Gary|不喜欢)
    public Double PUserTargetDislike(String userId,String target)
    {
        Double answer = 1.0* (CountTermsUserDislike(userId,target) + 1)
                /(AllTermsUserDislikeCount(userId) + getAllTagsCount());
        
        //answer = 1.0*(CountTerms+1)/AllTerms + |V|
        return answer;
    }
    
    // AllTerms返回这c类文档中所有的词数量，
    public Long AllTermsUserDislikeCount(String userId) {
        // 不喜欢的文档中所有的词数量
        return userDislikeDocsCount(userId);
    }
    
    // CountTerms返回词i在c类文档中出现的次数
    public Long CountTermsUserDislike(String userId,String target) {
        // target在不喜欢的文档中出现的次数
        
        return targetInDislikeDocsCount(userId,target);
    }
    // 返回该字符串target在用户不喜欢的文档中出现的次数
        public Long targetInDislikeDocsCount(String userId, String target) {
            Long count = 0L;
            // 拿到用户
            User user = userService.findUserById(userId);
            // 拿到用户不喜欢的视频的集合
            Set<Video> videos = user.getDisagreeVideos();
            // 遍历集合，拿到用户不喜欢的视频中所有的标签
            for(Video video : videos)
            {
                Set<Tag> tags = video.getVideoTags();
                // 遍历所有标签
                for(Tag tag : tags)
                {
                    // 如果标签中的tag和传入的target相同，计数器++
                    if(tag.getTag().toUpperCase().equals(target.toUpperCase()))
                    {
                        count++;
                        continue;
                    }
                }
                
            }
            return count;
        }

        // 不喜欢的文档中所有的词数量
        public Long userDislikeDocsCount(String userId) {
            
            Long target = 0L;
            // 拿到用户
            User user = userService.findUserById(userId);
            // 拿到用户下面的所有不喜欢的视频
            Set<Video> videos = user.getDisagreeVideos();
            // 遍历视频
            for(Video video : videos)
            {
                Set<Tag> tags = video.getVideoTags();
                // 遍历视频下的标签
                for(Tag tag:tags)
                {
                    target++;
                }
            }
            
            return target;
        }
        
}