从零搭建若依(Ruoyi-Vue)管理系统(6)--整合Redis缓存

已于 2022-06-15 15:59:23 修改
阅读量1w 收藏 38
点赞数 3
分类专栏： # 从零搭建若依管理系统 java实战开发 文章标签： redis java 若依 springboot
于 2021-03-12 12:00:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37132495/article/details/114692613
版权

文章目录

本章结束后对应的节选代码文件：Gangbb-Vue-06-Redis
项目地址：https://github.com/Gang-bb/Gangbb-Vue

历史遗留TODO:

  • 第三章
  1. mybatis缓存暂时没用到，后面整合redis后用redis做缓存(整合Redis完成)。
  • 第四章
  1. 登录日志还未实现。(到登录和权限模块完成)
  2. LogAspect从缓存获取当前的用户信息使用模拟的数据(到登录和权限模块完成)

本章将留下TODO：

  • 无

本章将解决TODO:

  • 第三章
  1. mybatis缓存暂时没用到，后面整合redis后用redis做缓存(整合Redis完成)。

1. 添加依赖

1.1 Gangbb-common的pom.xml

<dependencies>
    <!-- redis 缓存操作 begin-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- redis 缓存操作 end-->

    <!-- pool 对象池 begin-->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
    <!-- pool 对象池 end-->
</dependencies>

2. Redis数据库连接信息配置

spring:
  #Redis配置
  redis:
  	# 地址
    host: localhost
    #Redis服务器连接密码（默认为空）
    password:
    # Redis数据库索引（默认为0）
    database: 0
    # 端口，默认为6379
    port: 6379
    # 连接超时时间（毫秒）
    timeout: 10s
    # 这里使用的是lettuce，如果使用Jedis，把下面的lettuce改成Jedis即可
    lettuce:
      pool:
        #连接池中的最大空闲连接
        max-idle: 8
        #连接池中的最小空闲连接
        min-idle: 0
        #连接池最大连接数（使用负值表示没有限制）
        max-active: 8
        #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1

3. 在RedisConfig中自定义RedisTemplate解决序列化问题

若依用了fastjson做了序列化，这里使用jackon。fastjson出事太多了，实际业务开发中尽量少用为妙

@Configuration
@EnableCaching
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        //我们为了自己的开发方便，一般直接使用<String, Objecj>类型
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);

        //Json序列化配置
        Jackson2JsonRedisSerializer 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);
        //String的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }

}

4. 封装RedisUtil --Redis常用命令工具类

若依中对Redis的工具类封装是叫RedisCache，且方法不够丰富。用我自己网上找到的redis封装工具，封装与原生的命令一摸一样！

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author : Gangbb
 * @ClassName : RedisUtil
 * @Description : Redis操作工具类
 * @Date : 2021/3/9 7:26
 */

@Component
public final class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // =============================common============================
    /**
     * 指定缓存失效时间
     * @param key  键
     * @param time 时间(秒)
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }


    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }


    // ============================String=============================

    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */

    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 普通缓存放入并设置时间
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */

    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 递增
     * @param key   键
     * @param delta 要增加几(大于0)
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }


    /**
     * 递减
     * @param key   键
     * @param delta 要减少几(小于0)
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }


    // ================================Map=================================

    /**
     * HashGet
     * @param key  键 不能为null
     * @param item 项 不能为null
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * HashSet 并设置时间
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }


    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }


    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }


    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }


    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     * @param key 键
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0){
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 获取set缓存的长度
     *
     * @param key 键
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */

    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    // ===============================list=================================

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 获取list缓存的长度
     *
     * @param key 键
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 将list放入缓存
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */

    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */

    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }

    }

}

5.Redis测试使用

@RestController
@RequestMapping("/test/redis")
public class TestRedisController {

    private final Logger log = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private RedisUtil redisUtil;

    @GetMapping("/hello")
    public String helloRedis(){
        // 测试写入一个string类型键值,过期时间20S
        redisUtil.set("key1", "Gangbb", 20);
        System.out.println("获取key1值"+ redisUtil.set("key1", "测试redis", 20));
        return "测试redis";
    }

    @Cacheable("cache1")
    @GetMapping("/hello2")
    public String helloRedis2(){
        return "xxredis";
    }

    @GetMapping("/hello3")
    public JSONObject helloRedis3(){
        return getTestDetail();
    }

    public JSONObject getTestDetail() {
        JSONObject retJson = new JSONObject();
        String retCode = "1";
        String retMsg = "操作失败！";
        JSONObject bizDataJson = new JSONObject();
        try {
            TestMybatis testMybatis = new TestMybatis();
            testMybatis.setId(22);
            testMybatis.setName("梁yx");
            testMybatis.setGender("女");

            String key = "TestMybatis::"+testMybatis.getId();
            //向Redis中缓存数据，-1为设置永久时效
            redisUtil.set(key, testMybatis,-1);

            bizDataJson = JSONObject.parseObject(JSON.toJSONString(testMybatis));
            retCode = "0";
            retMsg = "操作成功！";
        } catch (Exception e) {
            log.error(String.valueOf(e));
        }
        retJson.put("retCode", retCode);
        retJson.put("retMsg", retMsg);
        retJson.put("bizData", bizDataJson);
        return retJson;
    }
}

6. Mybatis使用Redis做二级缓存

(若依中未提及该内容)

大概思路：

  1. 实现自定义Mybatis缓存的Cache接口的缓存工具RedisCache
/**
 * @author : Gangbb
 * @ClassName : RedisCache
 * @Description : 自定义Mybatis缓存的Cache接口
 * @Date : 2021/3/9 10:27
 */
public class RedisCache implements Cache {
    private static final Logger logger = LoggerFactory.getLogger(RedisCache.class);

    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private String id;


    public RedisCache(final String id) {
        if (id == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        }
        logger.info("Redis Cache id " + id);
        this.id = id;
    }

    @Override
    public String getId() {
        return this.id;
    }

    @Override
    public void putObject(Object key, Object value) {
        RedisTemplate redisTemplate = getRedisTemplate();
        if (value != null) {
            //向redis中加入数据，有效期是2天
            redisTemplate.opsForValue().set(key.toString(), value, 2, TimeUnit.DAYS);
        }
    }

    @Override
    public Object getObject(Object key) {
        RedisTemplate redisTemplate = getRedisTemplate();
        try {
            if (key != null) {
                Object object = redisTemplate.opsForValue().get(key.toString());
                return object;
            }
        } catch (Exception e) {
            logger.error("redis exception.....");
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public Object removeObject(Object key) {
        RedisTemplate redisTemplate = getRedisTemplate();
        try {
            if (key != null) {
                redisTemplate.delete(key.toString());
            }
        } catch (Exception e) {
        }
        return null;
    }

    @Override
    public void clear() {
        RedisTemplate redisTemplate = getRedisTemplate();
        logger.debug("插入or更新or删除数据库操作,清除对应redis缓存");
        try {
            Set<String> keys = redisTemplate.keys("*:" + this.id + "*");
            if (!CollectionUtils.isEmpty(keys)) {
                redisTemplate.delete(keys);
            }
        } catch (Exception e) {
            logger.error("clear exception....");
        }
    }

    @Override
    public int getSize() {
        RedisTemplate redisTemplate = getRedisTemplate();
        Long size = (Long) redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.dbSize();
            }
        });
        return size.intValue();
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return this.readWriteLock;
    }

    private RedisTemplate getRedisTemplate() {
        if (redisTemplate == null) {
            redisTemplate = SpringUtils.getBean("redisTemplate");
        }
        return redisTemplate;
    }
}
  1. XxxMapper.xml调用该工具，开启使用二级缓存

在这里插入图片描述

  1. 测试

    SysOperationLogServiceImpl、SysOperationLogService、SysOperationLogMapper文件添加内容不再展示，就是简单的添加一个查询所有sys_operation_log库的方法。

    (还需多往库里加点数据，本次测试1000多条记录)

在这里插入图片描述

结果：

image-20210309105411653

可以看到每查询一次，查询命中缓存率就越高，用时就越少。

注意此时如果想要在控制台看到hi用缓存相关信息需要在log4j2.xml日志配置文件中，把mybatis的打印级别设置到debug

image-20210309105901411

redis中：

在这里插入图片描述

Gangbb
关注
专栏目录
若依框架集成redis缓存
猿小白的博客
08-26 4592
本文针对若依单体项目，本文主要介绍如何集成reids 注意：该方法适用于4.6.2版本，其它版本未测。 项目地址：https://gitee.com/y_project/RuoYi 目录 ​​​​​​​​​​​​​​​​​​​​​ 1、添加依赖 2、修改配置 3、增加配置 4、增加工具类 1、添加依赖 ruoyi-common\pom.xml模块添加整合依赖 <!-- sprin...
RuoYi-Vue-Plus（基础知识点jackson、mybatisplus、redis以及Redisson 工具类）
javaxueba的博客
03-19 2775
时区#日期格式#默认转json的属性，这里设置为非空才转json#设置属性命名策略,对应jackson下PropertyNamingStrategy中的常量值，SNAKE_CASE-返回的json驼峰式转下划线，json body下划线传到后端自动转驼峰式#对象为空时是否报错，默认true#返回的java.util.date转换成timestamp#json中含pojo不存在属性时是否失败报错,默认true#是否允许出现单引号,默认false。
【前端必备技能java之若依框架缓存(redis)模块封装梳理与MyBatis最佳实践】
leleshuo
02-05 2352
这里用了很长的篇幅进行了说明redis的封装以及MyBatis的最佳实践
若依框架-功能详解_监控相关
最新发布
m0_74462339的博客
08-06 431
SQL防火墙部分，通过SQL的拦截机制，有效防止错误SQL的执行。当前页面展示的是在线用户的列表，包括每个用户的登录名称、所属部门、登录IP、登录地点、操作系统、使用的浏览器以及登录时间等等。数据监控是若依集成德鲁伊提供的web监控工具，所以该界面并不是由若依开发的，而是德鲁伊提供的，我们需要二次登录。SQL监控部分，可以记录SQL的执行信息，帮助我们快速发现一些慢SQL日志，找到对应SQL可以进行优化，帮助我们提升系统的性能。这样的视图管理界面，便于我们查看系统中的缓存信息并进行相关的操作，非常方便。
若依项目中使用redis做缓存，引入工具类
weixin_44522680的博客
03-01 1225
【代码】若依项目中使用redis做缓存，引入工具类。
若依不分离版集成redis
太子的博客
04-19 1120
话不多说 首先ruoyi-common目录下pom文件添加配置: <!-- springboot整合redis --> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> </dependency>
031-若依pro(ruoyi-vue-pro)Redis 缓存
RichardHLee的博客
09-18 970
编程式缓存：基于 Spring Data Redis 框架的 RedisTemplate 操作模板声明式缓存：基于 Spring Cache 框架的 @Cacheable 等等注解。
若依整合redis
lixibo1的博客
04-19 7878
若依配置redis
ruoyi-vue环境搭建
03-28
在本文中，我们将详细探讨如何搭建`ruoyi-vue`开发环境，这是一个基于Vue.js的后台管理系统。首先，我们需要安装一系列的软件组件，包括Maven、DBeaver、JDK、Node.js以及Redis。接下来，我们将逐一介绍这些组件的...
RuoYi-Vue-Plus（登录流程）
javaxueba的博客
03-27 397
登录按钮：先validate方法 校验表单再通过this.loginForm.rememberMe 判断是否记住密码其中 this.$router.push({ path: this.redirect || "/" }).catch(()=>{});定义在 watch中。
RuoYi-Vue-Plus （若依上传文件配置、systemApplicationRunner 初始化配置、el实现上传文件及图片组件、阿里云OSS上传文件）
javaxueba的博客
05-25 673
路径：src\views\system\oss\index.vue上传文件路径： src\components\FileUpload\index.vue实现技术：el-upload 实现该上传属性，具体api查看element官网选取文件
java开发oa系统源码下载-ruoyi-cms:基于若依的内容管理系统，集成redis，邮件，websocket，可视化oss等
06-05
java开发oa系统源码下载 <<<<<<< HEAD 若依内容管理系统简介 模板管理：用户可以自定义模板，填充对应的数据以便应付不同需求。 主题管理：支持主题上传，切换以及模板，切换不用重启服务器。 缓存管理：支持Redis缓存，提高系统相应速度。同时支持查看缓存,重置缓存。 栏目管理：前端菜单管理，支持多级树，可以应付复杂的导航,已支持额外SEO字段。 分类管理：支持多级树，完全可以应付复杂分类,已支持额外SEO字段。 标签管理：标签用于标记文章特色,已支持额外SEO字段。 文章管理：支持不同类型，多关键字的文章发布。 储存管理：按时间归类，目前至此本地和七牛，后续会有扩展。 邮件管理：邮件在线配置，发送，支持多种类型邮件发送。 websocket模块：内含websocket模块，基本案例单聊，群聊。 配置管理：完整的网站配置，方便SEO，个性化设置。 标签开发：简化主题制作，直接调用Service。 支持用户：丰富内容系统，方便二次开发。 内置淘宝：支持批量上传优惠卷 文章检索系统：使用solr检索文章 链接管理：支持分组,方便做导航类网站 文章相关操作：包含评论,浏览记录,评分
SpringBoot2.0+mybatis3.0+redis+lombok
03-01
这个是SpringBoot2.0注解方式整合mybatis3.0整合redis，整合lombok，内含redis工具类，可直接使用。数据库就最简单的user表，新建下就行
若依Ruoyi-Vue学习笔记
三明治文鱼的博客
06-15 5650
学习开源项目的目标：使用、学习开源项目的流程：从Gitee官网复制url在IDEA中打开（后端），注意前端Vue项目需要额外使用一个idea打开。表：直接执行下的两个sql文件，在本地创建表数据源：修改配置文件中数据源配置使用Docker启动Redis修改Redis配置需要在中修改日志存放位置：启动admin中的springboot启动类 根据项目中的文件进行配置安装依赖，然后启动 2. 登陆功能 2.1 验证码 基本思路 简而言之：前端让后端出一道算术题，后端把题目告诉前端，并把答案放入后端的Redis中
【若依】Redis使用剖析
qq_34844049的博客
10-26 9634
【若依】Redis使用剖析
Java Spring Boot + Vue 实习项目17：Redis缓存
Amzmks的博客
07-11 360
1. 知识点 1.1 缓存一般用于在较短的时间对相同数据频繁读取的场合，将这些输入放入内存，直接从缓存取数据，以提高效率。 1.2 Redis是一个支持网络、可基于内存也可持久化的日志型key-value数据库（通过键查找，NoSQL），在应用中可以充当缓存，提高系统数据查询功能。 1.3 缓存业务数据，第一次查询将结果放在内存中，之后相同的查询直接从内存中读取。 当执行增删改时，将缓存清空。 1.4 缓存数据时，以查询方法的参数为键，以查询结果为值。如果方法的参数是一个类似以JavaBean的对象，用应当
vue前端轮询查询redis缓存数据
qihangVIP4的博客
09-15 2025
前端轮询查询redis缓存数据 /*定义常量 轮询函数开始标志*/ stopTimer: true, mounted(){ // 提前定义 提前挂载函数 this.timerLoss() } // 编辑 this.$refs.xxxx.edit() edit() { // 父组件掉用子组件的函数 // 打开轮询函数 this.stopTimer = false this.timerLoss() } // 轮询 timerLoss() { this.tim
若依和redis的下载和安装
li_a_a的博客
04-02 587
搜索若依，点击进入首页下滑找到Vue前后端分离版本点击下载然后会跳转到gitee中的若依界面（可能需要登录账号）然后有两种方式可以将若依导入到idea中第一种复制链接，打开idea，点击从VCS获取没改中文的找这个输入url，点击克隆第二种下载zip文件并解压进入到这个页面然后先配置数据库以MySQL自带的work beach为例（idea自带数据库的工具，大家可以自己学习使用）打开work beach点击进入MySQL新建一个数据库ry-vue执行ruoyi中的sql语句SQL语句文件在这个目录中然后到i
ruoyi-vue版本（五）ruoyi项目和redis缓存相关的文件与逻辑
一天不写代码难受的博客
01-17 2198
redis
ruoyi-vue-plus和ruiyi-vue区别
05-27
Ruoyi-Vue-Plus 是在 Ruoyi-Vue 的基础上进行了功能扩展和性能优化的版本，它增加了一些新的功能模块，如数据权限管理、在线用户监控、Redis 缓存管理等，同时也对原有功能进行了优化和改进。另外，Ruoyi-Vue-Plus 还添加了一些实用的工具类和代码生成器模板，使开发人员能够更快捷地进行开发。 总的来说，Ruoyi-Vue-Plus 是在 Ruoyi-Vue 的基础上做了一些增强和改进，功能更加完善，性能更加优化，同时也提供了更多的实用工具和模板，方便开发人员进行快速开发。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值