springboot+redis

最新推荐文章于 2021-12-17 17:17:11 发布
最新推荐文章于 2021-12-17 17:17:11 发布
阅读量321 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37670707/article/details/88740903
版权

pom.xml

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

1.application.properties配置信息
spring.redis.database=0
spring.redis.host=172.18.23.114
spring.redis.port=6379
spring.redis.password=
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=10
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.timeout=0

2.redis配置类

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 com.fasterxml.jackson.databind.ObjectMapper;

/**
*

  • <redis配置类>

  • @author

  • @date
    */
    @Configuration
    public class RedisConfig {

    @Bean
    @SuppressWarnings(“all”)
    public RedisTemplate<String, Object> redisTemplate(
    RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
    template.setConnectionFactory(factory);
    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);
    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;
    }
    }

3.redis工具类

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

import org.apache.commons.lang.StringUtils;
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 com.naxin.warehouse.common.constants.ErrorCodes;
import com.naxin.warehouse.common.exception.ServerException;
import com.naxin.warehouse.log.LogUtil;

@Component
public final class RedisUtil {

@Autowired
private RedisTemplate<String, Object> redisTemplate;

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

/**
 * 根据key 获取过期时间
 * 
 * @param key
 *            键 不能为null
 * @return 时间(秒) 返回0代表为永久有效
 */
public long getExpire(String key) throws RuntimeException {
	if (StringUtils.isBlank(key)) {
		throw new ServerException(ErrorCodes.REDIS_ERROR.getErrCode(),
				ErrorCodes.REDIS_ERROR.getErrMsg());
	}
	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) {
		LogUtil.error("RedisUtil hasKey()", "", e);
		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(CollectionUtils.arrayToList(key));
		}
	}
}

/**
 * 普通缓存获取
 * 
 * @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) {
		LogUtil.error("RedisUtil set()", "", e);
		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) {
		LogUtil.error("RedisUtil set()", "", e);
		return false;
	}
}

/**
 * 递增
 * 
 * @param key
 *            键
 * @param delta
 *            要增加几
 * @return
 */
public long incr(String key, long delta) throws ServerException {
	if (delta < 0) {
		throw new ServerException(ErrorCodes.REDIS_ERROR.getErrCode(),
				ErrorCodes.REDIS_ERROR.getErrMsg());
	}
	return redisTemplate.opsForValue().increment(key, delta);
}

/**
 * 递减
 * 
 * @param key
 *            键
 * @param delta
 *            要减少几
 * @return
 */
public long decr(String key, long delta) throws ServerException {
	if (delta < 0) {
		throw new ServerException(ErrorCodes.REDIS_ERROR.getErrCode(),
				ErrorCodes.REDIS_ERROR.getErrMsg());
	}
	return redisTemplate.opsForValue().increment(key, -delta);
}

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

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

/**
 * HashMap
 * 
 * @param key
 *            键
 * @param map
 *            对应多个键值
 * @return true 成功 false 失败
 */
public boolean addMap(String key, Map<String, Object> map) {
	try {
		redisTemplate.opsForHash().putAll(key, map);
		return true;
	} catch (Exception e) {
		LogUtil.error("RedisUtil addMap()", "", e);
		return false;
	}
}

/**
 * HashMap 并设置时间
 * 
 * @param key
 *            键
 * @param map
 *            对应多个键值
 * @param time
 *            时间(秒)
 * @return true成功 false失败
 */
public boolean addMap(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) {
		LogUtil.error("RedisUtil addMap()", "", e);
		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) {
		LogUtil.error("RedisUtil hset()", "", e);
		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) {
		LogUtil.error("RedisUtil hset()", "", e);
		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)
 * @return
 */
public double hincr(String key, String item, double by) {
	return redisTemplate.opsForHash().increment(key, item, by);
}

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

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

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

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

/**
 * 将set数据放入缓存
 * 
 * @param key
 *            键
 * @param time
 *            时间(秒)
 * @param values
 *            值 可以是多个
 * @return 成功个数
 */
public long addSet(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) {
		LogUtil.error("RedisUtil addSet()", "", e);
		return 0;
	}
}

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

/**
 * 移除值为value的
 * 
 * @param key
 *            键
 * @param values
 *            值 可以是多个
 * @return 移除的个数
 */
public long remove(String key, Object... values) {
	try {
		Long count = redisTemplate.opsForSet().remove(key, values);
		return count;
	} catch (Exception e) {
		LogUtil.error("RedisUtil remove()", "", e);
		return 0;
	}
}

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

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

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

/**
 * 向缓存中的list追加元素
 * 
 * @param key
 *            键
 * @param value
 *            值
 * @return
 */
public boolean addList(String key, Object value) {
	try {
		redisTemplate.opsForList().rightPush(key, value);
		return true;
	} catch (Exception e) {
		LogUtil.error("RedisUtil addList()", "", e);
		return false;
	}
}

/**
 * 向缓存中的list追加元素
 * 
 * @param key
 *            键
 * @param value
 *            值
 * @param time
 *            时间(秒)
 * @return
 */
public boolean addList(String key, Object value, long time) {
	try {
		redisTemplate.opsForList().rightPush(key, value);
		if (time > 0)
			expire(key, time);
		return true;
	} catch (Exception e) {
		LogUtil.error("RedisUtil addList()", "", e);
		return false;
	}
}

/**
 * 将list放入缓存
 * 
 * @param key
 *            键
 * @param value
 *            值
 * @param time
 *            时间(秒)
 * @return
 */
public boolean addList(String key, List<Object> value) {
	try {
		redisTemplate.opsForList().rightPushAll(key, value);
		return true;
	} catch (Exception e) {
		LogUtil.error("RedisUtil addList()", "", e);
		return false;
	}
}

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

/**
 * 根据索引修改list中的某条数据
 * 
 * @param key
 *            键
 * @param index
 *            索引
 * @param value
 *            值
 * @return
 */
public boolean updateByIndex(String key, long index, Object value) {
	try {
		redisTemplate.opsForList().set(key, index, value);
		return true;
	} catch (Exception e) {
	LogUtil.error("RedisUtil updateByIndex()", "", e);
		return false;
	}
}

/**
 * 移除N个值为value
 * 
 * @param key
 *            键
 * @param count
 *            移除多少个
 * @param value
 *            值
 * @return 移除的个数
 */
public long remove(String key, long count, Object value) {
	try {
		Long remove = redisTemplate.opsForList().remove(key, count, value);
		return remove;
	} catch (Exception e) {
		LogUtil.error("RedisUtil remove()", "", e);
		return 0;
	}
}

/**
 * 
 * <批量删除，key的格式为 xxx:xxx>
 * 
 * @param key
 *            void
 * @throws
 */
public void del(String key) {
	try {
		Set<String> keys = redisTemplate.keys(key + ":*");
		redisTemplate.delete(keys);
	} catch (Exception e) {
		LogUtil.error("RedisUtil del()", "模糊删除", e);
	}
}

}

百里山川
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot+redis
weixin_66307949的博客
06-21 1268
1.导入依赖 2.建立连接（测试类中，另外写一个测试方法） 1.设置键和值 1.取值 3.关闭 hash 1.连接 2.存储 3.获取hash 全部获取 4.关闭 lpush源码 set jedis连接池 1.创建一个配置对象 2.创建连接池对象 jedispool源码 把池子配置进去，本机和端口 3.得到Jedis获取连接 设置数据 获取 4.关闭连接 新建一个工
springboot-redis
super--man的博客
12-18 316
在springboot中用redis可以做很多事情，比如：缓存、session同步、分布式锁 源码：https://gitee.com/chaoren5789/study​​​​​​​ 1、缓存 添加缓存：@Cacheable(value="users") 原理是将返回值序列化为json串存在redis,查询的时候反序列化为对象返回。但是项目启动的以后一定要清除缓存，防止缓存对象字段改变...
Redis---------springboot整合Redis实例
热门推荐
lucky
08-04 1万+
之前用SpringBoot+MyBatisPlus+SpringMVC整合搭建了一个基础web开发框架，使用这三个框架搭建出来项目结构非常的清爽，没有过多的配置文件，各个模块之间有清晰的联系，非常适合敏捷开发。 最近学习了Redis这个基于内存的，Key-Value数据形式的高性能数据库，感觉学习了入门之后很简单，没有体会到它具体能干嘛，我就想着使用Redis这个数据库来整合之前搭建的框架，利用
springboot+redis项目实战
Dreamer.
02-22 923
1.在springboot项目的pom.xml 文件里加入redis的jar依赖 <?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" ...
springboot + redis
CaBCo的博客
12-17 2980
缓存穿透 ~ 缓存击穿 ~ 缓存雪崩
最最最简单的SpringBoot+Redis
03-04
标题 "最最最简单的SpringBoot+Redis" 描述了如何在SpringBoot项目中集成和使用Redis，这是一个流行的Java开发框架和一个高效的键值存储系统。接下来，我们将深入探讨这个主题，详细讲解SpringBoot与Redis的集成，...
springboot+redis实现查询附近商铺功能.zip
05-20
在本项目"springboot+redis实现查询附近商铺功能.zip"中，主要展示了如何利用Spring Boot框架结合Redis缓存系统来实现在web应用中查询附近的商业店铺。以下将详细阐述涉及的关键知识点： 1. **Spring Boot**： ...
vue+springboot+redis+kaptcha实现登录验证码
04-10
本教程将介绍如何结合Vue.js前端框架、Spring Boot后端框架、Redis缓存服务以及Kaptcha验证码技术，实现一个前后端分离的登录页面验证码功能。这个组合可以提供高效、安全且用户友好的验证机制。 首先，Vue.js是一...
Springboot+redis+mybatisplus实例
03-07
在IT行业中，Spring Boot、Redis和MyBatis-Plus是三个非常重要的技术组件，它们各自在不同的领域发挥着关键作用。下面将详细讲解这三个技术及其整合应用。 **Spring Boot** Spring Boot是由Pivotal团队提供的全新...
springboot+redis过期事件监听实现过程解析
08-19
SpringBoot+Redis过期事件监听实现过程解析 本文主要介绍了SpringBoot+Redis过期事件监听实现过程的详细解析，旨在帮助读者更好地理解和掌握相关技术。通过示例代码的详细介绍，对大家的学习或者工作具有一定的参考...
Uniapp软件库全新带勋章功能/包含前后端源码
08-14
Uniapp软件库全新带勋章功能，搭建好后台 在前端找到 util 这个文件 把两个js文件上面的填上自己的域名，电脑需要下载：HBuilderX 登录账号 没有账号就注册账号，然后上传文件，打包选择 “发行” 可以打包app h5等等。 后端安装： 1、下载源码到服务器目录 2、设置运行目录为 public 3、配置伪静态 4、修改数据库账号密码config/database.php点击导入， 5、访问域名即可
【独家首发】基于矮猫鼬优化算法DMOA-GMDH的锂电池寿命SOC估计算法研究Matlab实现.rar
最新发布
08-14
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
基于Android五子棋设计与实现.docx
08-14
基于Android五子棋设计与实现.docx
MultiVideoDemo.rar
08-14
MultiVideoDemo.rar 博客地址：https://lw112190.blog.csdn.net/article/details/141200926
探索深度学习的时间奥秘：长短时记忆单元（LSTM）
08-14
神经网络是一种受人脑结构启发的数学模型，它由大量的节点（或称为“神经元”）相互连接构成。这些节点通常组织成层，包括输入层、隐藏层和输出层。每个神经元可以接收来自前一层的输入，通过某种激活函数处理这些输入，然后将结果传递给下一层的神经元。 神经网络能够通过学习大量的数据来识别模式和特征，这使得它们在图像识别、语音识别、自然语言处理等领域有着广泛的应用。它们也可以用于预测、分类和回归等任务。 训练神经网络通常涉及到一个称为“反向传播”的过程，通过这个过程，网络可以调整其内部参数（权重和偏置），以便更好地完成特定的任务。这个过程通常需要大量的计算资源，并且伴随着梯度下降或其他优化算法来最小化损失函数，从而提高模型的性能。 随着深度学习技术的发展，神经网络变得更加复杂和强大，出现了各种类型的网络结构，比如卷积神经网络（CNNs）用于图像处理，循环神经网络（RNNs）用于序列数据，以及长短期记忆网络（LSTMs）等。
【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf
08-14
【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf【亚马逊】2024亚马逊全球消费趋势及选品报告(第五期).pdf
ssm_126_mysql_实习支教中小学学校信息管理系统_.zip
08-14
本系统的后台语言使用的是JSP，JSP是一种动态编程语言，可以对数据进行增删改查等操作。在JSP、ASP、PHP等动态语言出现之前，很多网站就只能用静态的HTML语言宣传自己的网站，但这种网站不具备数据的存储操作功能，因为无法连接数据库，本系统使用的JSP语言可以与HTML语言有效的结合起来，不仅可以将各类素材展现在页面上，还可以将数据保存在数据库中。 选择JSP技术开发主要因为其有以下几个优点： （1）首先就是因为JSP的结构清晰、易于理解，而且JSP是面向对象的编程语言，可以使用封装、继承和多态等技术，可以使用类和对象的思想解决很多问题，可以极大的提高编码效率。 （2）选择JSP的第二个原因就是它在浏览器中的响应速度较快，可以提高本系统运行的速度。 （3）选择JSP作为本系统开发技术的第三个原因就是它具备较为稳定的连接数据库的方法，可以使数据稳定地进行存储和更新。
流程管理，从认识到文化.pptx
08-14
流程管理，从认识到文化.pptx
ssm_114_mysql_高校自习室预约系统_.zip
08-14
本次的功能设计主要围绕着学生和管理员两个角色，对于学生的用户功能设计上主要包括以下的一些方面： 1、自习室信息的查看，学生可以对自习室的信息进行查看，查看自习室的空位和预约情况； 2、自习室的在线预约，学生可以在线申请自习室的预约。 3、在线签到功能，学生可以在线进行自习室的预约签到，实现在线打卡。 对于系统管理员的主要功能包括： 1、对于个人信息的管理维护，包括对于管理员自身以及学生的个人信息； 2、自习室的信息管理和维护，管理员可以添加新的自习室或者对存量的自习室信息进行维护； 3、班级管理，管理员可以进行学生班级的管理，可以在线进行班级的添加； 4、自习室预约管理，管理员可以在线对自习室的预约情况进行查看与管理； 5、惩罚管理，对于未按照预约前往自习室的学生，管理员可以进行惩罚。
springboot +redis
06-05
通过使用 Spring Data Redis，我们可以轻松地将 Redis 数据库连接到 Spring 应用程序中，并通过提供模板类来操作 Redis 数据库。 以下是 Spring Boot + Redis 的一些常见应用场景： 1. 缓存数据 - Redis 是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值