spring boot构建基础版web项目(三)-springboot、redis数据缓存整合

最新推荐文章于 2024-08-17 17:52:41 发布
最新推荐文章于 2024-08-17 17:52:41 发布
阅读量447 收藏 1
点赞数
分类专栏： Spring Boot系列 文章标签： spring boot整合redis spring boot整合redis单机+集群 spring boot整合redis单机 spring boot整合redis集群
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/millery22/article/details/79729030
版权

原文作者：程序猿杨鲍
转载声明：转载请注明原文地址，注意版权维护，谢谢！

写前说明

在spring+spring mvc+mybatis模式下，使用的最多的就是jedis，但是spring boot整合了redis后，依然可以使用jedis，但是同时也提供了一个RedisTemplate和StringRedisTemplate，RedisTemplate使用的序列化类是默认JdkSerializationRedisSerializer，而StringRedisTemplate使用的序列化类默认是StringRedisSerializer，因此在存储的方式上也是有所不同。简单的说就是RedisTemplate的key和value可以是任意类型的数据，但是StringRedisTemplate的key和value只能是String，如果存储其他类型，序列化和反序列化会存在问题。综合来说，如果使用spring提供的redis连接就使用RedisTemplate，兼容性更高，如果使用jedis就无所谓了，因为它默认就是支持各种数据类型的键值。
另外Redis群的搭建可以参考[Redis集群的简单搭建和实现(待提供)]。

准备工作

需要在新建立一个模块utui-common，这个模块用于存放Redis封装的工具类，在utui-dao中加入对utui-common的依赖坐标。

依赖的加入
<dependency>
	<groupId>com.springboot.utui</groupId>
	<artifactId>utui-common</artifactId>
	<version>1.0-SNAPSHOT</version>
</dependency>
模块结构
|-utui-common
	|-src
		|-main
			|-java
				|-com.springboot.utui.common
					|-utils
						|-RedisClientUtil
springboot整合集成RedisTemplate方式实现
父pom.xml

添加spring-boot-starter-redis的依赖jar

<!-- spring整合redis -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-redis</artifactId>
	<version>1.4.7.RELEASE</version>
</dependency>
application.properties
#-------------------------------- redis properties  start --------------------------------#
# redis数据库索引(默认是0)
spring.redis.datasource=0
# redis服务器地址
spring.redis.host=127.0.0.1
# redis服务端口
spring.redis.port=6379
# redis服务器密码(默认是空)
spring.redis.password=
# 连接池最大连接数(-1表示不限制)
spring.redis.pool.max-active=10
# 连接池最小空闲连接数
spring.redis.pool.max-idle=10
# 连接池最大空闲连接数
spring.redis.pool.min-idle=0
# 最大阻塞等待时间(-1表示不限制,单位：毫秒)
spring.redis.max-wait=3000
# 连接超时时间(单位：毫秒)
spring.redis.timeout=5000
# 集群节点(三主三从)
# spring.redis.cluster.nodes=127.0.0.1:6379,127.0.0.1:6380,127.0.0.1:6381,127.0.0.1:6382,127.0.0.1:6383,127.0.0.1:6384
#-------------------------------- redis properties  end --------------------------------#
RedisClientUtil.java

utui-common下添加RedisClientUtil类，用于封装Redis的一些公用方法，为了写这个封装花了挺长时间，并都测试了一遍，基本没有问题，如果项目中有使用，需要封装Redis工具类，可以直接拿去，不谢。

@Component
@Slf4j
public class RedisClientUtil {

    @Autowired
    RedisTemplate<String, String> redisTemplate;

    /**
     * 键值对设值
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public <K, V> Boolean set(K key, V value) {
        return redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            connection.set(JSON.toJSONBytes(key), JSON.toJSONBytes(value));
            return true;
        });
    }

    /**
     * 键值对设值和有效时间
     *
     * @param key   键
     * @param value 值
     * @param time  有效时间(单位：秒)
     * @return
     */
    public <K, V> Boolean setEx(K key, V value, long time) {
        return redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            connection.setEx(JSON.toJSONBytes(key), time, JSON.toJSONBytes(value));
            return true;
        });
    }

    /**
     * 查询键值对
     *
     * @param key           键
     * @param typeReference 返回类型
     * @param <K>           键类型
     * @param <R>           返回类型
     * @return
     */
    public <K, R> R get(K key, TypeReference<R> typeReference) {
        byte[] redisValue = redisTemplate.execute((RedisCallback<byte[]>) connection -> connection.get(JSON.toJSONBytes(key)));
        if (redisValue == null) return null;
        return JSONObject.parseObject(new String(redisValue), typeReference);
    }

    /**
     * 存储Hash结构数据(批量)
     *
     * @param outerKey 外键
     * @param map      内键-内值
     * @return
     */
    public <O, I, V> Boolean hSetMap(O outerKey, Map<I, V> map) {
        if (map == null || map.isEmpty()) return false;
        Map<byte[], byte[]> byteMap = new HashMap<>();
        map.forEach((innerKey, innerValue) -> byteMap.put(JSON.toJSONBytes(innerKey), JSON.toJSONBytes(innerValue)));
        return redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            connection.hMSet(JSON.toJSONBytes(outerKey), byteMap);
            return true;
        });
    }

    /**
     * 存储Hash结构数据
     *
     * @param outerKey   外键
     * @param innerKey   内键
     * @param innerValue 值
     * @return
     */
    public <O, I, V> Boolean hSet(O outerKey, I innerKey, V innerValue) {
        Map<I, V> map = new HashMap<>();
        map.put(innerKey, innerValue);
        return this.hSetMap(outerKey, map);
    }

    /**
     * 获取Hash结构Map集合，内键和内值键值对封装成Map集合
     *
     * @param outerKey       外键
     * @param innerKeyType   内键类型
     * @param innerValueType 值类型
     * @return
     */
    public <O, I, V> Map<I, V> hGetMap(O outerKey, TypeReference<I> innerKeyType, TypeReference<V> innerValueType) {
        Map<byte[], byte[]> redisMap = redisTemplate.execute
                ((RedisCallback<Map<byte[], byte[]>>) connection -> connection.hGetAll(JSON.toJSONBytes(outerKey)));
        if (redisMap == null) return null;
        Map<I, V> resultMap = new HashMap<>();
        redisMap.forEach((key, value) -> resultMap.put(JSONObject.parseObject
                (new String(key), innerKeyType), JSONObject.parseObject(new String(value), innerValueType)));
        return resultMap;
    }

    /**
     * 查询Hash结构的值
     *
     * @param outerKey      外键
     * @param innerKey      内键
     * @param typeReference 值类型
     * @return
     */
    public <O, I, V> V hGet(O outerKey, I innerKey, TypeReference<V> typeReference) {
        byte[] redisResult = redisTemplate.execute((RedisCallback<byte[]>)
                connection -> connection.hGet(JSON.toJSONBytes(outerKey), JSON.toJSONBytes(innerKey)));
        if (redisResult == null) return null;
        return JSONObject.parseObject(new String(redisResult), typeReference);

    }

    /**
     * 删除键值对
     *
     * @param keys 键
     * @return
     */
    public <K> Long del(List<K> keys) {
        if (keys == null || keys.isEmpty()) return 0L;
        byte[][] keyBytes = new byte[keys.size()][];
        int index = 0;
        for (K key : keys) {
            keyBytes[index] = JSON.toJSONBytes(key);
            index++;
        }
        return redisTemplate.execute((RedisCallback<Long>) connection -> connection.del(keyBytes));
    }

    /**
     * 删除Hash结构内键和值
     *
     * @param outerKey  外键
     * @param innerKeys 内键
     * @return
     */
    public <O, I> Long hDel(O outerKey, List<I> innerKeys) {
        if (innerKeys == null || innerKeys.isEmpty()) return 0L;
        byte[][] innerKeyBytes = new byte[innerKeys.size()][];
        int index = 0;
        for (I key : innerKeys) {
            innerKeyBytes[index] = JSON.toJSONBytes(key);
            index++;
        }
        return redisTemplate.execute((RedisCallback<Long>) connection ->
                connection.hDel(JSON.toJSONBytes(outerKey), innerKeyBytes));
    }
}

这里很方便，因为在spring和redis整合后，启动项目时，spring会自动从application.properties中读取redis的信息，并根据这些信息构建RedisTemplate和StringRedisTemplate对象，交由Spring管理。因此这里可以直接注入。

RedisClientController.java

在com.springboot.utui.web.controller包下创建一个RedisClientController类，用于测试整合结果。

@Controller
@RequestMapping("/redis")
@Slf4j
public class RedisClientController {

    @Autowired
    private RedisClientUtil redisClient;

    /**
     * 测试键值对
     */
    @RequestMapping(method = RequestMethod.GET, value = "/testKv")
    @ResponseBody
    public String testKv() {
        Boolean insertResult = redisClient.set("test-key-1", "test-value-1");
        redisClient.set("test-key-2", "test-value-2");
        redisClient.set("test-key-3", "test-value-3");
        String getResult = redisClient.get("test-key-1", new TypeReference<String>() {
        });
        return "insertResult:" + insertResult + ",getResult:" + getResult;
    }

    /**
     * 测试Hash结构
     */
    @RequestMapping(method = RequestMethod.GET, value = "/testKm")
    @ResponseBody
    public String testKm() {
        Boolean hSetResult = redisClient.hSet("test-hSet-outer", "test-hSet-innerKey", "test-hSet-innerValue");
        Map<String, String> innerMap = new HashMap<>();
        innerMap.put("test-hSetMap-innerKey-1", "test-hSetMap-innerValue-1");
        innerMap.put("test-hSetMap-innerKey-2", "test-hSetMap-innerValue-2");
        innerMap.put("test-hSetMap-innerKey-3", "test-hSetMap-innerValue-3");
        Boolean hSetMapResult = redisClient.hSetMap("test-hSetMap-outer", innerMap);
        String hGetResult = redisClient.hGet("test-hSet-outer", "test-hSet-innerKey", new TypeReference<String>() {
        });
        Map<String, String> hGetMapResult = redisClient.hGetMap("test-hSetMap-outer", new TypeReference<String>() {
        }, new TypeReference<String>() {
        });
        return "hSetResult:" + hSetResult + ",hGetResult:" + hGetResult + ",hSetMapResult:" + hSetMapResult + ",hGetMapResult:" + hGetMapResult;
    }

    /**
     * 测试删除
     */
    @RequestMapping(method = RequestMethod.GET, value = "/testDel")
    @ResponseBody
    public String testDel() {
        List<String> delList = new ArrayList<>();
        delList.add("test-key-1");
        delList.add("test-key-2");
        Long delNum = redisClient.del(delList);
        String delAfter = redisClient.get("test-key-1", new TypeReference<String>() {
        });
        List<String> hDelList = new ArrayList<>();
        hDelList.add("test-hSetMap-innerKey-1");
        hDelList.add("test-hSetMap-innerKey-2");
        Long hDelNum = redisClient.hDel("test-hSet-outer", hDelList);
        String hDelAfter = redisClient.hGet("test-hSet-outer", "test-hSetMap-innerKey-1", new TypeReference<String>() {
        });
        return "delNum:" + delNum + ",delAfter:" + delAfter + ",hDelNum:" + hDelNum + ",hDelAfter:" + hDelAfter;
    }
}
功能验证

步骤：
1. 启动项目
2. 浏览器访问：http://localhost:8080/redis/testKv,响应结果：insertResult:true,getResult:test-value-1
3. 浏览器访问：http://localhost:8080/redis/testKm,响应结果：hSetResult:true,hGetResult:test-hSet-innerValue,hSetMapResult:true,hGetMapResult:{test-hSetMap-innerKey-3=test-hSetMap-innerValue-3, test-hSetMap-innerKey-2=test-hSetMap-innerValue-2, test-hSetMap-innerKey-1=test-hSetMap-innerValue-1}
4. 浏览器访问：http://localhost:8080/redis/testDel,响应结果：delNum:2,delAfter:null,hDelNum:0,hDelAfter:null

####单机和集群
上面的操作步骤都是基于一台redis服务器来做的，如果是基于多台redis服务，也就是集群，这里只要将spring.redis.host/spring.redis.port注释掉，将spring.redis.cluster.nodes注释放开就可以了，没有其他什么操作，就是这么简单，其他代码都不需要动，上手测试即可。

springboot整合集成jedis方式实现(单机模式)
JedisPoolBootConfig.java

在com.springboot.utui.web下建立config包，创建JedisPoolBootConfig类。

@Configuration
public class JedisPoolBootConfig {
	@Value("${spring.redis.host}")
	private String redisHost;
	@Value("${spring.redis.port}")
	private int redisPort;
	@Value("${spring.redis.max-wait}")
	private Integer maxWait;
	@Value("${spring.redis.pool.max-active}")
	private Integer maxActive;
	@Value("${spring.redis.pool.max-idle}")
	private Integer maxIdle;
	@Value("${spring.redis.pool.min-idle}")
	private Integer minIdle;
	@Value("${spring.redis.timeout}")
	private int timeout;

	@Bean
	public ShardedJedisPool getShardedJedisPool() {
		//Jedis配置信息
		JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
		jedisPoolConfig.setMaxTotal(maxActive);
		jedisPoolConfig.setMaxIdle(maxIdle);
		jedisPoolConfig.setMinIdle(minIdle);
		jedisPoolConfig.setMaxWaitMillis(maxWait);
		JedisShardInfo shardInfo = new JedisShardInfo(redisHost, redisPort, timeout);
		List<JedisShardInfo> shardInfos = new ArrayList<>();
		shardInfos.add(shardInfo);
		return new ShardedJedisPool(jedisPoolConfig, shardInfos);
	}

	@Bean
	public JedisPool getJedisPool() {
		//Jedis配置信息
		JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
		jedisPoolConfig.setMaxTotal(maxActive);
		jedisPoolConfig.setMaxIdle(maxIdle);
		jedisPoolConfig.setMinIdle(minIdle);
		jedisPoolConfig.setMaxWaitMillis(maxWait);
		return new JedisPool(jedisPoolConfig, redisHost, redisPort, timeout);
	}
}
RedisClientController.java

在RedisClientController.java中导入ShardedJedisPool\JedisPool对象并添加测试方法。

@Autowired
private ShardedJedisPool shardedJedisPool;
@Autowired
private JedisPool jedisPool;
/**
 * 测试JedisShardedJedis
 */
@RequestMapping(method = RequestMethod.GET, value = "/testShardedJedis")
@ResponseBody
public String testShardedJedis() {
	ShardedJedis sharJedis = shardedJedisPool.getResource();
	sharJedis.set("sharJedis-test", "sharJedis-test-value");
	return "sharJedis:" + sharJedis.get("sharJedis-test-value");
}

/**
 * 测试JedisPool
 */
@RequestMapping(method = RequestMethod.GET, value = "/testJedisPool")
@ResponseBody
public String testJedisPool() {
	Jedis jedis = jedisPool.getResource();
	jedis.set("jedis-test", "jedis-test-value");
	return "jedis:" + jedis.get("jedis-test");
}

运行项目测试后得到相应的结果，这里ShardedJedisPool和JedisPool是两种实现单机Redis服务的方式，二者去其一即可，这里作为演示就都写出来。

springboot整合集成jedis方式实现(集群模式)
JedisClusterConfig.java

在com.springboot.utui.web.config包中创建JedisClusterConfig类。

@Configuration
public class JedisClusterConfig {
	@Value("${spring.redis.cluster.nodes}")
	private String redisNodes;
	@Value("${spring.redis.max-wait}")
	private Integer maxWait;
	@Value("${spring.redis.pool.max-idle}")
	private Integer maxIdle;
	@Value("${spring.redis.pool.min-idle}")
	private Integer minIdle;
	@Value("${spring.redis.timeout}")
	private int timeout;

	@Bean
	public JedisCluster getJedisCluster() {
		String[] cNodes = redisNodes.split(",");
		Set<HostAndPort> nodes = new HashSet<>();
		for (String cNode : cNodes) {
			String[] hp = cNode.split(":");
			nodes.add(new HostAndPort(hp[0], Integer.valueOf(hp[1])));
		}
		JedisPoolConfig poolConfig = new JedisPoolConfig();
		poolConfig.setMaxWaitMillis(maxWait);
		poolConfig.setMaxIdle(maxIdle);
		poolConfig.setMinIdle(minIdle);
		return new JedisCluster(nodes, timeout, poolConfig);
	}
}
RedisClientController.java

在RedisClientController.java中导入JedisCluster对象并添加测试方法。

@Autowired
private JedisCluster jedisCluster;
/**
 * 测试JedisCluster
 */
@RequestMapping(method = RequestMethod.GET, value = "/testJedisCluster")
@ResponseBody
public String testJedisCluster() {
	jedisCluster.set("jedisCluster-test", "jedisCluster-test-value");
	return "jedisCluster:" + jedisCluster.get("jedisCluster-test");
}

运行项目测试浏览器访问得到对应结果。

程序猿洞晓
关注
专栏目录
【SpringBoot】整合Redis（使用spring-boot-starter-data-redis）
qq_27579471的博客
08-03 9895
前言 Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端，比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache。 Lettuce 和 Jedis 的都是连接Redis Server的客户端程序。Jedis在实现上是直连redis server，多线程环境下非线
SpringbootRedis
06-15
springboot整合redis,并且封装好的一套api，下载配置好即可使用
springboot与redis
qq_44189274的博客
08-03 1824
springboot对redis的操作封装了两个StringRedisTemplate和RedisTemplate类，StringRedisTemplate是RedisTemplate的子类，StringRedisTemplate它只能存储字符串类型，无法存储对象类型。上面的RedisTemplate需要每次都指定key value以及field的序列化方式，可以创建一个配置类，为RedisTemplate指定好序列化。使用RedisTemplate 必须要指定序列化方式，默认使用jdk序列化方式。....
SpringBoot与Redis
qq_55917018的博客
12-26 920
“spring-data-redis” 是 Spring 框架为 Redis 提供的简化抽象。底层可以支持Jedis、Lettuce等客户端API（Spring Boot 2.x 后Lettuce为默认客户端API），并提供RedisTemplatehe、Repository和整合Spring缓存等多种简便的使用方式。
springboot和redis
qq_39023116的博客
08-31 558
暑假的时候抽时间看了看redis，感觉还不算太难，也可能是我没深究。今天学了springboot整合redis，记录一下。 首先引入依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-redis&lt...
springboot与redis整合
weixin_43992845的博客
08-03 162
每一个spring的配置类都有一个自动配置类， XXXAutoConfiguration 每一个自动配置类都绑定一个properties类xxxProperties 1.源码分析： 2.操作（redisTemplate） 3.配置开发使用的template模板 /**配置RedisConfig模板，取代springBoot默认的配置 * Created by admin on 2020/8/3. */ @Configuration public class RedisConfig { .
案例实战-SpringBoot整合Redis实现缓存分页数据查询
06-19
总的来说，通过Spring Boot和Redis的整合，我们可以在不牺牲数据新鲜度的前提下，提高数据查询的效率，减轻数据库的负担。在这个案例实战中，我们学习了如何配置Redis连接，如何使用`@Cacheable`注解实现缓存，以及...
spring-boot-redis-guava-caffeine-cache:springboot 使用 redis guava caffeine 缓存示例
05-17
本项目"spring-boot-redis-guava-caffeine-cache"主要探讨了如何在Spring Boot应用中集成Redis、Guava和Caffeine三种不同的缓存策略。 首先，Redis是一款开源的内存数据结构存储系统，常被用作数据库、缓存和消息...
若依单体项目-springboot+js-无redis-无vue
02-20
【标题】"若依单体项目-springboot+js-无redis-无vue" 暗示这是一个基于Spring Boot框架的后台系统，采用JavaScript作为前端技术，但未使用Redis作为缓存服务，也没有采用Vue.js进行前端开发。下面将详细阐述这些...
SpringBoot Redis缓存数据实现解析
08-25
SpringBoot Redis 缓存数据实现解析 在本文中，我们将详细介绍使用 SpringBoot 实现 Redis 缓存数据的方法。通过示例代码，读者可以了解到缓存数据的实现细节，提高学习和工作效率。 首先，需要在 pom.xml 文件中...
SpringBoot和Redis的交互数据操作以及Redis的持久化/删除策略和缓存问题
最新发布
weixin_71072718的博客
08-17 1243
当我们客户端访问不存在的数据时，先请求redis，但是此时redis中没有数据， 此时会访问到数据库，但是数据库中也没有数据，这个数据穿透了缓存，直击数据库，我们都知道数据 库能够承载的并发不如redis这么高，如果大量的请求同时过来访问这种不存在的数据，这些请求就都会 访问到数据库，简单的解决方案就是哪怕这个数据在数据库中也不存在，我们也把这个数据存入到redis 中去，这样，下次用户过来访问这个不存在的数据，那么在redis中也能找到这个数据就不会进入到缓存了。是用于指定该实体类对应的数据库表名。
Spring Boot中使用Redis
shaopengjie的博客
08-23 8836
1.Redis是基于内存的key-value结构数据库优点：基于内存存储，读写性能高适合存储热点数据（短时间被被大量用户读取的数据）2.NoSQL,泛指非关系型数据库，是关系型数据库的补充3.Redis应用场景：缓存，任务队列，消息队列，分布式锁,下载的redis是源文件，需要进行编译安装，Windows版本百度即可5.Linux下安装Redis安装过程中如果报错：You need tcl x.x or newer in order to run the Redis test。
spring boot集成redis
feigeswjtu的专栏
12-07 1863
遵守“约定大于配置”原则的Spring boot集成常用的NO SQL是很方便的，本例拿redis做一个简单的demo，使用Redis的set和get命令。 引入redis的依赖包。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-b
SpringBoot整合Redis
zhang19903848257的博客
03-21 358
SpringBoot Data Redis 简介 Spring Boot Data(数据)Redis 中提供了RedisTemplate和StringRedisTemplate，其中StringRedisTemplate是RedisTemplate的子类，两个方法基本一致，不同之处主要体现在操作的数据类型不同，RedisTemplate中的两个泛型都是object，意味着存储的key和value都可以是一个对象，而SstringRedisTemplatc的两个泛型都是String，意味着StringRedi
Spring boot 整合redis
weixin_50235024的博客
10-12 301
前言 这篇文章是小编学习spring boot整合redis的笔记。文章详细介绍了springboot如何整合redis，若没有安装redis的读者，可以参考这篇博客。 安装windows版redis教程 1. 重要概念 1. redis简介 REmote DIctionary Server(Redis) 是一个由 Salvatore Sanfilippo 写的 key-value 存储系统，是跨平台的非关系型数据库。 Redis支持五种数据类...
Redis框架与SpringBoot的整合及详细学习汇总
swy2560666141的博客
04-23 1160
同源策略是浏览器的一个安全功能，不同源的客户端脚本在没有明确授权的情况下，不能读写对方资源。所以a.com下的js脚本采用ajax读取b.com里面的文件数据是会报错的。先来说说什么是源 • 源（origin）就是协议、域名和端口号。若地址里面的协议、域名和端口号均相同则属于同源。以下是相对于。
spring-boot整合redis 总结
朝着光前进
02-06 4736
spring-boot整合redis 总结 项目整合redis，如何实现最少写配置代码，从而实现redis客户端实例的注入。Spring提供了一些注解来帮助开发人员减少配置文件的编写。 1，创建RedisConfig类，使用@Configuration 和 @bean来管理 redis的工具类@Configuration public class RedisConfig { @Autowired
Spring与Spring boot对redis的简单使用
qq_52861718的博客
04-27 228
Spring与Spring boot对redis的简单使用前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： i
Spring整合Redis实现高效数据缓存
"本文主要探讨了如何在Spring框架下整合Redis来实现数据缓存，以提高系统的性能。通过使用Redis作为缓存系统，可以减轻数据库的负担，特别是对于那些频繁查询但更新频率较低的数据。文章提供了整合Redis的具体步骤，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序猿洞晓

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值