springboot用redis点赞、统计

最新推荐文章于 2024-01-24 19:25:06 发布
最新推荐文章于 2024-01-24 19:25:06 发布
阅读量530 收藏 2
点赞数
分类专栏： SpringBoot redis 文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luojiawen208/article/details/128580645
版权 
package org.example.userlike;


public enum LikedStatusEum {
    LIKE(1,"点赞"),
    UNLIKE(0,"取消点赞");

    private final Integer status;
    private final String statusName;

    LikedStatusEum(Integer status, String statusName) {
        this.status = status;
        this.statusName = statusName;
    }

    public Integer getStatus() {
        return status;
    }

    public String getStatusName() {
        return statusName;
    }
}

package org.example.userlike;

public class RedisKeyUtils {
    /**
     * 保存用户点赞数据的key
     *
     * @date 2021/9/26 14:44
     */
    public static final String MAP_KEY_USER_LIKED = "MAP_USER_LIKED";
    /**
     * 保存用户被点赞数量的key
     *
     * @date 2021/9/26 14:44
     */
    public static final String MAP_KEY_USER_LIKED_COUNT = "MAP_USER_LIKED_COUNT";

    /**
     * 拼接被点赞的用户id和点赞的人的id作为key。格式 222222::333333
     *
     * @param likedUserId 被点赞的人id
     * @param likedPostId 点赞的人的id
     * @return
     */
    public static String getLikedKey(String likedUserId, String likedPostId) {
        return likedUserId +
                "::" +
                likedPostId;
    }
}
package org.example.userlike;

import lombok.Data;

import java.io.Serializable;

@Data
public class UserLikCountDTO implements Serializable {

    private String infoId;
    private Integer value;

    public UserLikCountDTO(String infoId, Integer value) {
        this.infoId = infoId;
        this.value = value;
    }
}


package org.example.userlike;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserLikesDto {
    private String infoId;
    private String likeUserId;
    private Integer status;

}

 

package org.example.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.data.redis.core.StringRedisTemplate;

@Configuration
@EnableCaching
public class RedisConfig {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Bean
    public KeyGenerator keyGenerator() {
        return (target, method, params) -> {
            StringBuilder sb = new StringBuilder();
            sb.append(target.getClass().getName());
            sb.append(method.getName());
            for (Object obj : params) {
                sb.append(obj.toString());
            }
            return sb.toString();
        };

    }
//    @Bean
//    public CacheManager cacheManager(RedisTemplate redisTemplate) {
//        return new RedisCacheManager(redisTemplate);
//    }

    @Bean
    public StringRedisSerializer stringRedisSerializer() {
        return new StringRedisSerializer();
    }

    @Bean("redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setKeySerializer(stringRedisSerializer());
        template.setHashKeySerializer(stringRedisSerializer());
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

 

package org.example.business;

import org.example.userlike.UserLikCountDTO;
import org.example.userlike.UserLikesDto;

import java.util.List;

public interface UserLikeService {

    Object likeStatus(String infoId, String likeUserId);

    List<UserLikesDto> getLikedDataFromRedis();

    List<UserLikCountDTO> getLikedCountFromRedis();
}

 

package org.example.business.impl;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.example.business.UserLikeService;
import org.example.entity.UserLikesEntity;
import org.example.mapper.UserLikesDao;
import org.example.userlike.LikedStatusEum;
import org.example.userlike.RedisKeyUtils;
import org.example.userlike.UserLikCountDTO;
import org.example.userlike.UserLikesDto;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Service
@RequiredArgsConstructor(onConstructor_ = {@Autowired})
public class UserLikeServiceImpl implements UserLikeService {

    private final RedisTemplate redisTemplate;
    private final UserLikesDao userLikesDao;

    public Object likeStatus(String infoId, String likeUserId) {
        if (redisTemplate.opsForHash().hasKey(RedisKeyUtils.MAP_KEY_USER_LIKED, RedisKeyUtils.getLikedKey(infoId, likeUserId))) {
            String o = redisTemplate.opsForHash().get(RedisKeyUtils.MAP_KEY_USER_LIKED, RedisKeyUtils.getLikedKey(infoId, likeUserId)).toString();
            if ("1".equals(o)) {
                unLikes(infoId, likeUserId);
                return LikedStatusEum.UNLIKE;
            }
            if ("0".equals(o)) {
                likes(infoId, likeUserId);
                return LikedStatusEum.LIKE;
            }
        }
        UserLikesEntity userLikes = userLikesDao.selectOne(Wrappers.<UserLikesEntity>lambdaQuery().eq(UserLikesEntity::getInfoId,infoId).eq(UserLikesEntity::getLikeUserId,likeUserId));
        if (userLikes == null) {
            UserLikesEntity userLikes1 = new UserLikesEntity();
            userLikes1.setInfoId(infoId);
            userLikes1.setLikeUserId(likeUserId);
            userLikesDao.insert(userLikes1);
            likes(infoId, likeUserId);
            return LikedStatusEum.LIKE;
        }
        if (userLikes.getStatus() == 1) {
            unLikes(infoId, likeUserId);
            return LikedStatusEum.UNLIKE;
        }

        if (userLikes.getStatus() == 0) {
            likes(infoId, likeUserId);
            return LikedStatusEum.LIKE;
        }
        return "";
    }

    public void likes(String infoId, String likeUserId) {
        String likedKey = RedisKeyUtils.getLikedKey(infoId, likeUserId);
        redisTemplate.opsForHash().increment(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, infoId, 1);
        redisTemplate.opsForHash().put(RedisKeyUtils.MAP_KEY_USER_LIKED, likedKey, LikedStatusEum.LIKE.getStatus());
    }

    public void unLikes(String infoId, String likeUserId) {
        String likedKey = RedisKeyUtils.getLikedKey(infoId, likeUserId);
        redisTemplate.opsForHash().increment(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, infoId, -1);
        redisTemplate.opsForHash().delete(RedisKeyUtils.MAP_KEY_USER_LIKED, likedKey);
    }


    public List<UserLikesDto> getLikedDataFromRedis() {
        Cursor<Map.Entry<Object, Object>> scan = redisTemplate.opsForHash().scan(RedisKeyUtils.MAP_KEY_USER_LIKED, ScanOptions.NONE);
        List<UserLikesDto> list = new ArrayList<>();
        while (scan.hasNext()) {
            Map.Entry<Object, Object> entry = scan.next();
            String key = (String) entry.getKey();
            String[] split = key.split("::");
            String infoId = split[0];
            String likeUserId = split[1];
            Integer value = (Integer) entry.getValue();
            //组装成 UserLike 对象
            UserLikesDto userLikeDetail = new UserLikesDto(infoId, likeUserId, value);
            list.add(userLikeDetail);
            //存到 list 后从 Redis 中删除
//            redisTemplate.opsForHash().delete(RedisKeyUtils.MAP_KEY_USER_LIKED, key);
        }
        return list;
    }

    public List<UserLikCountDTO> getLikedCountFromRedis() {
        Cursor<Map.Entry<Object, Object>> cursor = redisTemplate.opsForHash().scan(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, ScanOptions.NONE);
        List<UserLikCountDTO> list = new ArrayList<>();
        while (cursor.hasNext()) {
            Map.Entry<Object, Object> map = cursor.next();
            String key = (String) map.getKey();
            Integer value = (Integer) map.getValue();
            UserLikCountDTO userLikCountDTO = new UserLikCountDTO(key, value);
            list.add(userLikCountDTO);
//            redisTemplate.opsForHash().delete(RedisKeyUtils.MAP_KEY_USER_LIKED_COUNT, key);
        }
        return list;
    }


}


 @GetMapping("/userLinke")
    public Object userLinke(){
        return userLikeService.likeStatus("1","2");
    }

    @GetMapping("/getLikedDataFromRedis")
    public List<UserLikesDto> getLikedDataFromRedis(){
        return userLikeService.getLikedDataFromRedis();
    }

    @GetMapping("/getLikedCountFromRedis")
    public List<UserLikCountDTO> getLikedCountFromRedis(){
        return userLikeService.getLikedCountFromRedis();
    }

 

 

package org.example.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.util.Date;

@Data
@TableName("user_likes")
public class UserLikesEntity {

    @TableId("id")
    private String id;

    @TableField("info_id")
    private String infoId;

    @TableField("create_time")
    private Date createTime;

    @TableField("like_user_id")
    private String likeUserId;

    @TableField("update_time")
    private Date updateTime;

    @TableField("status")
    private Integer status;
}

package org.example.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.util.Date;

@Data
@TableName("video")
public class VideoEntity {

    @TableId("likes_number")
    private String id;

    /**
     * 点赞数
     */
    @TableField("likes_number")
    private Integer likesNumber;

    /**
     * 评论数
     */
    @TableField("comments_number")
    private Integer commentsNumber;

    /**
     * 分享数
     */
    @TableField("share_number")
    private Integer shareNumber;

    @TableField("create_time")
    private Date createTime;

    @TableField("create_user")
    private String createUser;

    @TableField("update_time")
    private Date updateTime;

    @TableField("update_user")
    private String updateUser;
}

server:
  port: 8282

spring:
  #数据库配置
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    #初始化时建立物理连接的个数，连接池的设置config druid
    druid:
      driverClassName: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://175.18.147.97:3306/nacos?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8
      username: admin
      password: 
      # 初始连接数
      initialSize: 5
      # 最小连接池数量
      minIdle: 10
      # 最大连接池数量
      maxActive: 20
      # 配置获取连接等待超时的时间
      maxWait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 300000
      # 配置一个连接在池中最大生存的时间，单位是毫秒
      maxEvictableIdleTimeMillis: 900000
      # 配置检测连接是否有效
      validationQuery: SELECT 1 FROM DUAL
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      webStatFilter:
        enabled: true
      statViewServlet:
        enabled: true
        # 设置白名单，不填则允许所有访问
        allow:
        url-pattern: /druid/*
        # 控制台管理用户名和密码
        login-username: zccz-admin
        login-password: 123456
      filter:
        stat:
          enabled: true
          # 慢SQL记录
          log-slow-sql: true
          slow-sql-millis: 1000
          merge-sql: true
        wall:
          config:
            multi-statement-allow: true
  # redis 配置
  redis:
    # 地址
    host: 192.168.1.7
    # 密码
    password: 1234
    # 端口，默认为6379
    port: 6379
    # 数据库索引
    database: 0
    # 连接超时时间
    timeout: 10s
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms

 

CREATE TABLE `user_likes` (
  `id` varchar(32) NOT NULL COMMENT '点赞信息ID',
  `info_id` varchar(32) DEFAULT NULL COMMENT '点赞对象id',
  `create_time` datetime DEFAULT NULL COMMENT '时间',
  `like_user_id` varchar(32) DEFAULT NULL COMMENT '点赞人ID',
  `update_time` datetime DEFAULT NULL,
  `status` int(11) DEFAULT '0' COMMENT '0 取消 1 点赞',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE KEY `agdkey` (`like_user_id`,`info_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC COMMENT='点赞记录表';
<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>nacos</artifactId>
  <version>1.0-SNAPSHOT</version>
  <modules>
    <module>provider</module>
    <module>customer</module>
  </modules>

  <packaging>pom</packaging>

  <name>nacos</name>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <spring.boot.version>2.1.0.RELEASE</spring.boot.version>
<!--    <spring.boot.version>2.6.5</spring.boot.version>-->
    <spring.cloud.alibaba.version>2.1.0.RELEASE</spring.cloud.alibaba.version>
    <java.version>1.8</java.version>
    <lombok.version>1.18.24</lombok.version>
    <druid-spring-boot.version>1.2.11</druid-spring-boot.version>
    <mybatis-plus-boot.version>3.5.2</mybatis-plus-boot.version>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>${spring.boot.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-alibaba-dependencies</artifactId>
        <version>${spring.cloud.alibaba.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- aop切面 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

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

    <dependency>
      <groupId>cn.hutool</groupId>
      <artifactId>hutool-all</artifactId>
      <version>5.8.5</version>
    </dependency>
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-pool2</artifactId>
      <version>2.0</version>
    </dependency>

    <dependency>
      <groupId>com.alibaba.cloud</groupId>
      <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <dependency>
      <groupId>com.alibaba.cloud</groupId>
      <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-bootstrap</artifactId>
      <version>3.1.0</version>
    </dependency>

    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>${lombok.version}</version>
    </dependency>

    <!--数据库连接-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid-spring-boot-starter</artifactId>
      <version>${druid-spring-boot.version}</version>
    </dependency>
    <dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-boot-starter</artifactId>
      <version>${mybatis-plus-boot.version}</version>
    </dependency>



  </dependencies>



  <build>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
  </build>
</project>

<黑科技T_T
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
微信几亿人在线的点赞、取消点赞系统，用Redis如何实现？
技术领导力
11-18 2414
点击“技术领导力”关注∆每天早上8:30推送作者：solocoder来源：http://rrd.me/eX4HA点赞功能大家都不会陌生，像微信这样的社交产品中都有，但别看功能小，想要做好需要考虑的东西还挺多的，如海量数据的分布式存储、分布式缓存、多IDC的数据一致性、访问路由到机房的算法等等。本文介绍大型社交平台点赞系统的设计思路，基于 SpringCloud, 用户发起点赞、取消点赞后先存入...
SpringBoot + Redis 实现点赞功能的缓存和定时持久化（附源码）
Java知音
02-05 2310
0.前言本文基于Springboot利用Redis实现点赞功能的缓存和定时持久化接口。用户对浏览内容进行【点赞/取赞】，并发送【点赞/取赞】请求到后端，这些信息先存入Redis中缓存，再每隔两小时将Redis中的内容直接写入数据库持久化存储。1.项目目录结构2.Redis缓存点赞消息1.设计思路用户点赞一条数据，设置状态为0，并且更新被点赞内容的likeCount+1用户取消点赞一条数据，设置状态...
如何使用Redis的Hash来实现一个定时持久化到数据库的点赞功能
weixin_59441154的博客
07-05 583
这篇文章是关于使用redis中的hash存储结构来保存点赞数据，并加入了定时任务框架quartz，让redis中的数据写入到mysql，这篇文章是对我上一篇实现点赞功能的优化和拓展，若有不足请大家指出。 (如何高效的使用java实现类似抖音的评论点赞列表（互动消息）以及点赞的基本操作 - 掘金 (juejin.cn))由于点赞可能是用户频繁点击的操作，有时会发生误触等，就会多次发起请求，会增加mysql的压力。点赞时先把点赞数据存储到redis中，在每隔一段时间后把redis中的数据写入到mysql中，若用
Java使用Springboot+Redis实现点赞功能
ChristineTX的博客
09-28 6910
1. 流程图 流程图 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zec3qocj-1632797596589)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210928102514830.png)] 实现思路 由于点赞属于一种频繁的提交操作，如果直接选用数据库做存储，对于数据库的压力比较大。这里考虑使用缓存作为中间层，然后定时的将数据持久化数据库，降低数据库的读写压力。缓
springboot记录api的访问次数
03-12
springboot入门工程,可是开始计数,终止计数,清空计数.只保存最近一分钟以内的访问次数
Redis集成springboot实现点赞收藏功能+定时同步数据库——开发笔记
m0_60394632的博客
08-31 2751
之前学习了redis的一系列命令，但应用在springboot项目中这还是第一次，现在有个需求要实现一个点赞，收藏，浏览量的功能，记录了一下整个过程，小白一枚，可能数据结构的设计和算法都有考虑不周的地方，请大佬们指教。...
基于SpringBoot+Redis实现点赞/排行榜功能，可同理实现收藏/关注功能，可拓展实现共同好友/共同关注/关注推送功能
都随它大小便吧
11-22 2414
简单记录一下在SpringBoot项目中，使用Redis实现点赞/排行榜功能，可同理实现收藏/关注功能，可拓展实现共同好友/共同关注/关注推送功。主要用到了Redis中的Set集合和ZSet集合。
微服务SpringBoot 整合Redis 实现点赞、点赞排行榜
wanghuichen的博客
11-24 9486
如何使用 实现点赞、点赞排行榜功能？ Redis 一键搞定！
SpringBoot整合Redis——实现点赞功能
申俏雅的博客
12-13 1166
标签系统：可以将每个标签作为Set的一个元素，然后用Set进行标签的各种操作，比如求交集、并集、差集等，以便于实现文章、商品等的分类和搜索。去重：Set中的元素不能重复，因此可以用来存储去重后的数据。
社区系统源码：基于 SpringBoot + MyBatis + MySQL + Redis + Kafka
05-08
Java社区系统源码并提供详细的开发文档和配套教程，包含帖子、评论、私信、系统通知、点赞、关注、搜索、用户设置、数据统计等模块。 核心技术栈 后端： Spring Spring Boot 2.1.5 RELEASE Spring MVC ORM：MyBatis ...
Echo::unicorn: 开源社区系统：基于 SpringBoot + MyBatis + MySQL + Redis + Kafka + Elasticsearch + Spring Security + ... 并提供详细的开发文档和配套教程。包含帖子、评论、私信、系统通知、点赞、关注、搜索、用户设置、数据统计等模块
04-11
Echo 是一套前后端不分离的开源社区系统，基于目前主流 Java Web 技术栈（SpringBoot + MyBatis + MySQL + Redis + Kafka + Elasticsearch + Spring Security + ...），并提供详细的开发文档和配套教程。包含帖子、...
基于SpringBoot 仿牛客网讨论社区项目
04-03
实现了邮箱注册、验证码登录、发帖、评论、私信、点赞、关注、统计网站访问次数等功能，数据库使用Mybatis、Redis，使用Kafka构建系统通知，使用Elasticsearch构建全文搜索功能。 包含数据库文件、项目源码等
weixin063传染病防控宣传系统的设计与实现+springboot（源码+部署说明+演示视频+源码介绍+lw）.rar
最新发布
04-05
本资源是一个关于传染病防控宣传系统的...缓存优化：使用Redis对热点数据进行缓存，提高系统性能。 总之，本资源提供了一个基于Spring Boot的传染病防控宣传系统，涵盖了多种技术，实现了丰富的功能，适合学习和参考。
java spring实现仿牛客网讨论社区项目
02-29
使用Redis的set实现点赞，zset实现关注，并使用Redis存储登录ticket和验证码，解决分布式session问题。 使用Redis高级数据类型HyperLogLog统计UV(Unique Visitor),使用Bitmap统计DAU(Daily Active User)。 使用Kafka...
springboot - redis记录并统计网页浏览量
ws6afa88的博客
10-10 6651
最近开发个人博客，想统计单网页浏览量，一开始是想把浏览量记录在数据库，后来想想每次点击网页就要去做数据库更新操作，实际项目是不会允许的，还是老老实实用redis来处理吧！ 0. 需求 网页列表显示时按评论数倒序排列 进入单页页面时，该页面浏览量自动+1 系统启动时，将数据库中的浏览量，评论数，点赞数添加到redis数据库中 系统关闭时，自动将redis中数据更新到mysql数据库中 之所以选择在启动和关闭时进行redis与mysql数据交换，也是为了防止高并发。 1. 效果 数据按照“评论数”倒序排列
spring boot 定时任务更新浏览数、点赞数
a631258447的博客
01-24 2161
SpringBoot配置定时任务可以直接使用自带的Scheduled，这相当于一个轻量级的Quartz，它可以让我们直接使用注解来完成定时任务的配置。 1.定时任务方法 /** * 定时任务 * * @author lyj * @since 2.0 */ @Configuration @EnableScheduling public class TigerDataApproveT
Springboot + Redis 实现简单的点赞功能
perfect_jjj的博客
01-24 495
最近做的项目中涉及到对学校进行点赞的功能，现在整理一下具体的思路。 1.点赞、取消点赞的功能，点赞数据一直会变，如果使用关系型数据库，比如Mysql，需要经常修改数据库的数据，对磁盘进行写操作，性能不高，考虑使用Redis缓存点赞总数。 2.点赞需要用到用户、学校两个对象，Redis数据格式可以设计为 例如： 3.根据点赞状态去判断是点赞还是取消点赞，当点赞的时候，则插入一条如上面格式的数据到缓存。当取消点赞的时候，则根据Redis的key，把缓存中的数据删除。
SpringBoot项目AOP+自定义注解实现菜单点击量统计
你那么害怕明天，怎么能过好今天！
09-22 1551
一：在添加aop的依赖 <!-- aop依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 注意：在完成了引入AOP依赖包后，
SpringBoot AOP实现接口次数访问统计
紫芝的博客
09-23 4115
1 理论基础 1.1 AOP是什么 面向切面编程（AOP，Aspect Oriented Programming） 可以通过预编译方式和运行时动态代理，实现在不修改源代码的情况下，给程序动态增强功能的的一种技术 1.2 AOP能做什么 统计接口访问次数 数据库事务处理 增强功能：在不改动源代码的基础上，为接口增加一些额外的功能 2 Demo代码 2.1 引入依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="h
SpringBoot整合Redis点赞功能的简单实现
04-16
好的，关于SpringBoot整合Redis点赞功能的简单实现，可以按以下步骤实现： 1. 在SpringBoot中引入Redis依赖。 2. 创建一个Redis工具类，用于连接Redis。 3. 创建一个点赞服务类，处理点赞操作。 4. 在点赞服务类中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值