牛客项目学习第四章

一、Redis入门

• Redis是一款基于键值对的NoSQL数据库，它的值支持多种数据结构：
  字符串(strings)、哈希(hashes)、列表(lists)、集合(sets)、有序集合(sorted sets)等。
• Redis将所有的数据都存放在内存中，所以它的读写性能十分惊人。
  同时，Redis还可以将内存中的数据以快照或日志的形式保存到硬盘上，以保证数据的安全性。
• Redis典型的应用场景包括：缓存、排行榜、计数器、社交网络、消息队列等。

redis相关链接：官网，github

Redis使用演示

1.reids默认有16个库，从0-15，可以使用下边的语句切换

select [index]

2.刷新数据库FLUSHDB命令，如下

3.String类型的演示

set key value [EX seconds] [PX milliseconds] [NX|XX]
get key
incr key
decr key

4.hash类型数据

hset key field value
hget key field

5.list类型数据

lpush key value [value ...]
llen key
lindex key index
lrange key start stop
lpop key
rpush key value [value ...]
rpop key

6.set类型数据

sadd key member [member ...]
scard key  //统计集合中有多少元素，输出个数
spop key [count]  //随机从集合中弹出数据
smembers key  //相比于scard来说，输出set中所有的member

7.sortset类型数据

zadd key [NX|XX] [CH] [INCR] score member [score member ...]
zcard key
zscore key member
zrank key member  //返回排名
zrange key start stop [WITHSCORES]

8.常用命令

keys *
type key
exists key [key ...]
del key
expire key seconds

二、 Spring整合Redis

• 引入依赖
  • spring-boot-starter-data-redis
• 配置Redis
  • 配置数据库参数
  • 编写配置类，构造RedisTemplate
• 访问Redis
  • redisTemplate.opsForValue()
  • redisTemplate.opsForHash()
  • redisTemplate.opsForList()
  • redisTemplate.opsForSet()
  • redisTemplate.opsForZSet()

导包

日常操作你懂得

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

配置Redis

application.properties中

• database=11表示使用第12个库

因为RedisTemplate是类型的不利于我们操作所以要写一个配置类

RedisConfig 配置类

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String,Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        //设置key的序列化方式
        template.setKeySerializer(RedisSerializer.string());
        //设置value的序列化方式
        template.setValueSerializer(RedisSerializer.json());
        //设置hash的key序列化方式
        template.setHashKeySerializer(RedisSerializer.string());
        //设置hash的value的序列化方式
        template.setHashValueSerializer(RedisSerializer.json());
        template.afterPropertiesSet();
        return template;
    }
}

RedisTemplate访问redis

1.写一个测试类

@SpringBootTest
@ContextConfiguration(classes = CommunityApplication.class)
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testStrings() {
        String redisKey = "test:count";

        redisTemplate.opsForValue().set(redisKey, 1);

        System.out.println(redisTemplate.opsForValue().get(redisKey));
        System.out.println(redisTemplate.opsForValue().increment(redisKey));
        System.out.println(redisTemplate.opsForValue().decrement(redisKey));
    }

    @Test
    public void testHashes() {
        String redisKey = "test:user";

        redisTemplate.opsForHash().put(redisKey, "id", 1);
        redisTemplate.opsForHash().put(redisKey, "username", "zhangsan");

        System.out.println(redisTemplate.opsForHash().get(redisKey, "id"));
        System.out.println(redisTemplate.opsForHash().get(redisKey, "username"));
    }

    @Test
    public void testLists() {
        String redisKey = "test:ids";

        redisTemplate.opsForList().leftPush(redisKey, 101);
        redisTemplate.opsForList().leftPush(redisKey, 102);
        redisTemplate.opsForList().leftPush(redisKey, 103);

        System.out.println(redisTemplate.opsForList().size(redisKey));
        System.out.println(redisTemplate.opsForList().index(redisKey, 0));
        System.out.println(redisTemplate.opsForList().range(redisKey, 0, 2));

        System.out.println(redisTemplate.opsForList().leftPop(redisKey));
        System.out.println(redisTemplate.opsForList().leftPop(redisKey));
        System.out.println(redisTemplate.opsForList().leftPop(redisKey));
    }

    @Test
    public void testSets() {
        String redisKey = "test:teachers";

        redisTemplate.opsForSet().add(redisKey, "刘备", "关羽", "张飞", "赵云", "诸葛亮");

        System.out.println(redisTemplate.opsForSet().size(redisKey));
        System.out.println(redisTemplate.opsForSet().pop(redisKey));
        System.out.println(redisTemplate.opsForSet().members(redisKey));
    }

    @Test
    public void testSortedSets() {
        String redisKey = "test:students";

        redisTemplate.opsForZSet().add(redisKey, "唐僧", 80);
        redisTemplate.opsForZSet().add(redisKey, "悟空", 90);
        redisTemplate.opsForZSet().add(redisKey, "八戒", 50);
        redisTemplate.opsForZSet().add(redisKey, "沙僧", 70);
        redisTemplate.opsForZSet().add(redisKey, "白龙马", 60);

        System.out.println(redisTemplate.opsForZSet().zCard(redisKey));
        System.out.println(redisTemplate.opsForZSet().score(redisKey, "八戒"));
        System.out.println(redisTemplate.opsForZSet().reverseRank(redisKey, "八戒"));
        System.out.println(redisTemplate.opsForZSet().reverseRange(redisKey, 0, 2));
    }

    @Test
    public void testKeys() {
        redisTemplate.delete("test:user");

        System.out.println(redisTemplate.hasKey("test:user"));

        redisTemplate.expire("test:students", 10, TimeUnit.SECONDS);
    }

    // 多次访问同一个key
    @Test
    public void testBoundOperations() {
        String redisKey = "test:count";
        BoundValueOperations operations = redisTemplate.boundValueOps(redisKey);
        operations.increment();
        operations.increment();
        operations.increment();
        operations.increment();
        operations.increment();
        System.out.println(operations.get());
    }
	//声明式事务作用于整个方法，方法中需要查询时就不合适了，所以演示编程式事务
    // 编程式事务
    @Test
    public void testTransactional() {
        Object obj = redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations operations) throws DataAccessException {
                String redisKey = "test:tx";

                operations.multi();

                operations.opsForSet().add(redisKey, "zhangsan");
                operations.opsForSet().add(redisKey, "lisi");
                operations.opsForSet().add(redisKey, "wangwu");
				//显示为[]，所以一定不要在redis事务中做查询。
                System.out.println(operations.opsForSet().members(redisKey));
                return operations.exec();
            }
        });
        //这里会显示所有的操作结果
        System.out.println(obj);
    }
}

三、点赞

• 点赞
  • 支持对帖子、评论点赞。
  • 第1次点赞，第2次取消点赞。
• 首页点赞数量
  • 统计帖子的点赞数量。
• 详情页点赞数量
  • 统计点赞数量。
  • 显示点赞状态。

Redis生成key的工具类

public class RedisUtil {
    private static final String SPLIT=":";
    private static final String PREFIX_ENTITY_LIKE = "like:entity";
    
    //某个实体的赞
    //key长这个样：like:entity:entityType:entityId
    //value是个set：存的是用户id，为了统计谁给我点了赞
    public static String getEntityLikeKey(int entityType,int entityId){
        return PREFIX_ENTITY_LIKE+SPLIT+entityType+SPLIT+entityId;
    }
}

业务层

@Service
public class LikeService {
    @Autowired
    private RedisTemplate redisTemplate;
    
    //点赞
    public void like(int userId,int entityType,int entityId){
        String entityLikeKey = RedisUtil.getEntityLikeKey(entityType,entityId);
        //第一次点是点赞，第二次点是取消赞
        //先判断是否点过赞  value是set集合存的是userId
        Boolean isMember = redisTemplate.opsForSet().isMember(entityLikeKey, userId);
        if(isMember){
            //说明点过赞，这次是取消赞
            redisTemplate.opsForSet().remove(entityLikeKey,userId);
        }else{
            //说明是第一次点赞
            redisTemplate.opsForSet().add(entityLikeKey,userId);
        }
    }
    //查询实体点赞的数量
    public long findEntityLikeCount(int entityType,int entityId){
        String entityLikeKey = RedisUtil.getEntityLikeKey(entityType,entityId);
        return redisTemplate.opsForSet().size(entityLikeKey);
    }
    //查询某人对某实体的点赞状态
    //返回int 是为了以后业务扩展 比如点了踩啥的记录状态
    public int findEntityLikeStatus(int userId,int entityType,int entityId){
        String entityLikeKey = RedisUtil.getEntityLikeKey(entityType,entityId);
        return redisTemplate.opsForSet().isMember(entityLikeKey,userId)?1:0;
    }
}

表现层：点赞功能的实现

@Controller
public class LikeController {
    @Autowired
    private LikeService likeService;
    @Autowired
    private HostHolder hostHolder;
    
    @RequestMapping(path = "/like",method = RequestMethod.POST)
    @ResponseBody
    public String like(int entityType,int entityId){
        User user = hostHolder.getUser();
        //实现点赞
        likeService.like(user.getId(),entityType,entityId);
        //统计数量
        long likeCount = likeService.findEntityLikeCount(entityType,entityId);
        //状态
        int likeStatus = likeService.findEntityLikeStatus(user.getId(),entityType,entityId);
        Map<String,Object> map = new HashMap<>();
        map.put("likeCount",likeCount);
        map.put("likeStatus",likeStatus);
        return CommunityUtil.getJsonString(0,null,map);
    }
}

处理页面

1.帖子点赞

• href的东西表名跳转的地方是找js的方法
• onclick里的like方法有三个参数
  • this用来标志是哪里点的赞（帖子可以点赞，用户评论也可以点赞）
  • 1表明是给帖子点赞
  • post.id是帖子的id号
• 为了方便显示数据把 赞 这个字用< b >标签包围，11用< i >包围

2.评论点赞

• 2表明给帖子评论点赞，其他同理

3.评论的回复点赞
- 3表示给评论回复点赞

4.处理js

• 新建一个discuss.js

function like(btn,entityType,entityId) {
	$.post(
		CONTEXT_PATH+"/like",
		{"entityType":entityType,"entityId":entityId},
		function (data) {
			/*转化成json*/
			data = $.parseJSON(data);
			if(data.code==0){
				$(btn).children("i").text(data.likeCount);
				$(btn).children("b").text(data.likeStatus==1?"已赞":"赞");
			}else{
				alert(data.msg);
			}
		}
	);
}

表现层：点赞数量的显示

1.首页上点赞数量的显示
HomeController中getIndexPage方法
处理index.html
2.帖子详情·页面上点赞数量的显示

页面处理

四、我收到的赞

• 重构点赞功能
  • 以用户为key，记录点赞数量
  • increment(key)，decrement(key)
• 开发个人主页
  • 以用户为key，查询点赞数量

重构点赞功能

1.在RedisUtil中加一个key
2.LikeService增加一个操作记录用户获得点赞的数量
并用编程式事务完成。想想为啥不用声明式事务—代码中有答案

//点赞
    public void like(int userId,int entityType,int entityId,int entityUserId){  //entityUserId 就是被点赞的user的Id
/*        String entityLikeKey = RedisUtil.getEntityLikeKey(entityType,entityId);
        //第一次点是点赞，第二次点是取消赞
        //先判断是否点过赞  value是set集合存的是userId
        Boolean isMember = redisTemplate.opsForSet().isMember(entityLikeKey, userId);
        if(isMember){
            //说明点过赞，这次是取消赞
            redisTemplate.opsForSet().remove(entityLikeKey,userId);
        }else{
            //说明是第一次点赞
            redisTemplate.opsForSet().add(entityLikeKey,userId);
        }*/
        //编程式事务
        redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations redisOperations) throws DataAccessException {
                String entityLikeKey = RedisUtil.getEntityLikeKey(entityType,entityId);
                String userLikeKey = RedisUtil.getUserLikeKey(entityUserId);
                //判断当前用户有没有点赞，这一步应该在事务开启前执行，因为在事务中的查询不会立即得到结果
                Boolean isMember = redisOperations.opsForSet().isMember(entityLikeKey, userId);
                //事务开启
                redisOperations.multi();
                if(isMember){
                    //说明点过赞，这次是取消赞
                    redisTemplate.opsForSet().remove(entityLikeKey,userId);
                    //被点赞的用户点赞数量减一
                    redisOperations.opsForValue().decrement(userLikeKey);

                }else{
                    //说明是第一次点赞
                    redisTemplate.opsForSet().add(entityLikeKey,userId);
                    //被点赞的用户点赞数量加一
                    redisOperations.opsForValue().increment(userLikeKey);
                }
                return redisOperations.exec();
            }
        });

    }

3.LikeService增加查询某个用户获得赞的数量
4.重构表现层

detail页面

js

开发个人主页

1.UserController增加找用户页面的方法

@Autowired
    private LikeService likeService;
    //个人主页
    @RequestMapping(path = "/profile/{userId}",method = RequestMethod.GET)
    public String getProfilePage(@PathVariable("userId")int userId,Model model){
        User user = userService.findUserById(userId);
        if(user==null){
            throw new RuntimeException("该用户不存在");
        }
        //用户
        model.addAttribute("user",user);
        int likeCount = likeService.findUserLikeCount(user.getId());
        model.addAttribute("likeCount",likeCount);
        return "/site/profile";
    }

2.处理index.html中的链接

所有用户头像也得加链接
这里只处理了首页上的，其他的暂时没有处理。
3.处理profile.html

五、关注、取消关注

• 需求
  • 开发关注、取消关注功能。
  • 统计用户的关注数、粉丝数。
• 关键
  • 若A关注了B，则A是B的Follower（粉丝），B是A的Followee（目标）。
  • 关注的目标可以是用户、帖子、题目等，在实现时将这些目标抽象为实体。

RedisUtil中增加获得key的方法

业务层

@Service
public class FollowService {
    @Autowired
    private RedisTemplate redisTemplate;
    //关注
    public void follow(int userId,int entityType,int entityId){
        //还得依靠事务解决，因为有多次操作
        redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations redisOperations) throws DataAccessException {
                String followee = RedisUtil.getFolloweeKey(userId,entityType);
                String follower = RedisUtil.getFollowerKey(entityType,entityId);
                //启用事务
                redisOperations.multi();
                //userId关注entityId
                redisOperations.opsForZSet().add(followee,entityId,System.currentTimeMillis());
                //entityId的粉丝是userId
                redisOperations.opsForZSet().add(follower,userId,System.currentTimeMillis());
                return redisOperations.exec();
            }
        });
    }
    //取消关注
    public void unFollow(int userId,int entityType,int entityId){
        //还得依靠事务解决，因为有多次操作
        redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations redisOperations) throws DataAccessException {
                String followee = RedisUtil.getFolloweeKey(userId,entityType);
                String follower = RedisUtil.getFollowerKey(entityType,entityId);
                //启用事务
                redisOperations.multi();
                //userId没有关注谁
                redisOperations.opsForZSet().remove(followee,entityId);
                //谁的粉丝没有userId
                redisOperations.opsForZSet().remove(follower,userId);
                return redisOperations.exec();
            }
        });
    }
    //查询关注的实体的数量
    public long findFolloweeCount(int userId,int entityType){
        String followee = RedisUtil.getFolloweeKey(userId,entityType);
        return redisTemplate.opsForZSet().zCard(followee);
    }
    //查询实体的粉丝数量
    public long findFollowerCount(int entityType,int entityId){
        String follower = RedisUtil.getFollowerKey(entityType,entityId);
        return redisTemplate.opsForZSet().zCard(follower);
    }
    //查询当前用户是否关注该实体
    public boolean hasFollowed(int userId,int entityType,int entityId){
        String followee = RedisUtil.getFolloweeKey(userId,entityType);
        return redisTemplate.opsForZSet().score(followee,entityId)!=null?true:false;
    }
}

表现层

FollowController

@Controller
public class FollowController {
    @Autowired
    private FollowService followService;
    @Autowired
    private HostHolder hostHolder;
    @RequestMapping(path = "/follow",method = RequestMethod.POST)
    @ResponseBody
    public String follow(int entityType,int entityId){
        User user = hostHolder.getUser();
        if(user==null){
            throw new RuntimeException("用户没有登录");
        }
        followService.follow(user.getId(),entityType,entityId);
        return CommunityUtil.getJsonString(0,"已关注");
    }
    @RequestMapping(path = "/unfollow",method = RequestMethod.POST)
    @ResponseBody
    public String unfollow(int entityType,int entityId){
        User user = hostHolder.getUser();
        if(user==null){
            throw new RuntimeException("用户没有登录");
        }
        followService.unFollow(user.getId(),entityType,entityId);
        return CommunityUtil.getJsonString(0,"已取消关注");
    }
}

UserController中如下方法增加功能

页面处理

因为各种地方都可以关注，此处只演示在用户主页关注人，其他大同小异
继续改成这样，处理关注按钮

在profile.js中写处理逻辑

$(function(){
	$(".follow-btn").click(follow);
});

function follow() {
	var btn = this;
	if($(btn).hasClass("btn-info")) {
		// 关注TA
		$.post(
			CONTEXT_PATH+"/follow",
			{"entityType":4,"entityId":$(btn).prev().val()},
			function (data) {
				data = $.parseJSON(data);
				if(data.code==0){
					window.location.reload();
				}else{
					alert(data.msg)
				}
			}
		)
	} else {
		// 取消关注
		$.post(
			CONTEXT_PATH+"/unfollow",
			{"entityType":4,"entityId":$(btn).prev().val()},
			function (data) {
				data = $.parseJSON(data);
				if(data.code==0){
					window.location.reload();
				}else{
					alert(data.msg)
				}
			}
		)
		//$(btn).text("关注TA").removeClass("btn-secondary").addClass("btn-info");
	}
}

继续修改profile.html处理显示

六、关注列表、粉丝列表

• 业务层
  • 查询某个用户关注的人，支持分页。
  • 查询某个用户的粉丝，支持分页。
• 表现层
  • 处理“查询关注的人”、“查询粉丝”请求。
  • 编写“查询关注的人”、“查询粉丝”模板。

业务层

FollowService中增加方法

@Autowired
    private UserService userService;
    //查询某个用户关注的人
    public List<Map<String,Object>> findFollowees(int userId,int offset,int limit){
        String followee = RedisUtil.getFolloweeKey(userId,ENTITY_USER);
        Set<Integer> targetIds = redisTemplate.opsForZSet().reverseRange(followee, offset, offset + limit - 1);
        if(targetIds==null){
            return null;
        }
        List<Map<String,Object>> list = new ArrayList<>();
        for(Integer id:targetIds){
            Map<String,Object> map = new HashMap<>();
            User user = userService.findUserById(id);
            //用户
            map.put("user",user);
            Double score = redisTemplate.opsForZSet().score(followee, id);
            //关注时间
            map.put("followTime",new Date(score.longValue()));
            list.add(map);
        }
        return list;
    } 
    //查询某个用户的粉丝
    public List<Map<String,Object>> findFollowers(int userId,int offset,int limit){
        String follower = RedisUtil.getFollowerKey(ENTITY_USER,userId);
        //虽然返回的是set但是是redis内置实现了一个set可以有序排列
        Set<Integer> targetIds = redisTemplate.opsForZSet().reverseRange(follower, offset, offset + limit - 1);
        if(targetIds==null){
            return null;
        }
        List<Map<String,Object>> list = new ArrayList<>();
        for(Integer id:targetIds){
            Map<String,Object> map = new HashMap<>();
            User user = userService.findUserById(id);
            //用户
            map.put("user",user);
            Double score = redisTemplate.opsForZSet().score(follower, id);
            //关注时间
            map.put("followTime",new Date(score.longValue()));
            list.add(map);
        }
        return list;
    }

表现层

1.某个用户关注了谁—FollowController增加如下方法

@Autowired
    private UserService userService;
    @RequestMapping(path="/followees/{userId}",method = RequestMethod.GET)
    public String getFollowees(@PathVariable("userId")int userId, Page page, Model model){
        //页面需要用username
        User user = userService.findUserById(userId);
        if(user==null){
            throw new RuntimeException("该用户不存在");
        }
        model.addAttribute("user",user);
        page.setLimit(5);
        page.setPath("/followees/"+userId);
        page.setRows((int)followService.findFolloweeCount(userId,ENTITY_USER));
        List<Map<String, Object>> followees = followService.findFollowees(userId, page.getOffset(), page.getLimit());
        if(followees!=null){
            for(Map<String,Object> map:followees){
                //判段当前用户对这个用户的关注状态
                User followeeUser = (User)map.get("user");
                boolean hasFollowed = hasFollowed(followeeUser.getId());
                map.put("hasFollowed",hasFollowed);
            }
        }
        model.addAttribute("users",followees);
        return "/site/followee";
    }
    private boolean hasFollowed(int userId){
        if(hostHolder.getUser()==null){
            return false;
        }
        return followService.hasFollowed(hostHolder.getUser().getId(),CommunityContant.ENTITY_USER,userId);
    }

2.某个用户的粉丝

 @RequestMapping(path="/followers/{userId}",method = RequestMethod.GET)
    public String getFollowers(@PathVariable("userId")int userId, Page page, Model model){
        //页面需要用username
        User user = userService.findUserById(userId);
        if(user==null){
            throw new RuntimeException("该用户不存在");
        }
        model.addAttribute("user",user);
        page.setLimit(5);
        page.setPath("/followers/"+userId);
        page.setRows((int)followService.findFollowerCount(ENTITY_USER,userId));
        List<Map<String, Object>> followers = followService.findFollowers(userId, page.getOffset(), page.getLimit());
        if(followers!=null){
            for(Map<String,Object> map:followers){
                //判段当前用户对这个用户的关注状态
                User followeeUser = (User)map.get("user");
                boolean hasFollowed = hasFollowed(followeeUser.getId());
                map.put("hasFollowed",hasFollowed);
            }
        }
        model.addAttribute("users",followers);
        return "/site/follower";
    }

处理页面

1.profile.html

2.followee.html
3.follower.html

同理，仔细点尤其是处理已关注未关注按钮那里

七、优化登录模块

• 使用Redis存储验证码
  • 验证码需要频繁的访问与刷新，对性能要求较高。
  • 验证码不需永久保存，通常在很短的时间后就会失效。
  • 分布式部署时，存在Session共享的问题。
• 使用Redis存储登录凭证
  • 处理每次请求时，都要查询用户的登录凭证，访问的频率非常高。
• 使用Redis缓存用户信息
  • 处理每次请求时，都要根据凭证查询用户信息，访问的频率非常高。

使用Redis存储验证码

最初，我们把验证码存在了session里，这样不好。使用Redis存验证码的好处：

• Redis性能较高
• Redis可以设置失效时间
• 存到Redis里分布式部署的时候避免了Session共享的问题

1.RedisUtil中增加存储验证码的key

2.LoginController里方法
修改getKaptcha方法

修改Login方法

使用Redis存储登录凭证

最初，我们把登陆凭证存到了MySql里，每次都需要频繁的查询，因为设置了拦截器查询登陆状态。替换用login_ticket表存数据

1.RedisUtil中定义key

2.LoginTicketMapper加@Deprecated注解表名不推荐使用
3.重构代码主要集中在UserService和LoginService中
1.LoginService中login方法
2.LoginService中logout方法

3.UserService中findLoginTicket方法

使用Redis缓存用户信息

就是查询用户的时候先从Redis中取，没有的话先从数据库中取然后存到redis中。用户状态变化时直接删除Redis中的数据。
1.RedisUtil中增加key

2.在UserService中封装三个方法：

• 从redis中取数据
  
• redis没有的时候数据库找到user后写入redis
  
• 数据变更时删除缓存
  

3.其他涉及查询User的地方调这三个方法

当然还有其他可以修改的