Maven_Spring_Redis 实例

最新推荐文章于 2024-08-18 02:07:47 发布
最新推荐文章于 2024-08-18 02:07:47 发布
阅读量1k 收藏
点赞数
分类专栏： java 文章标签： redis spring maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhiguoliu11/article/details/72876279
版权

Linux_Redis 安装笔记
Linux_Redis_Cluster 安装笔记

这里写图片描述

BaseDao.java

package com.demo.redis.dao;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;

public abstract class BaseDao<K, V, HK, HV> {

    @Autowired
    protected RedisTemplate<K, V> redisTemplate;

    public void deleteKey(K key) {
        redisTemplate.delete(key);
    }

    public void set(K key, V value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public void set(K key, V value, final long timeout, final TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    public V get(final Object key) {
        return redisTemplate.opsForValue().get(key);
    }

    // List
    public void setForList(K key, long index, V value) {
        redisTemplate.boundListOps(key).set(index, value);
    }

    public Long leftPushForList(K key, V value) {
        return redisTemplate.opsForList().leftPush(key, value);
    }

    public Long leftPushAllForList(K key, V... values) {
        return redisTemplate.opsForList().leftPushAll(key, values);
    }

    public Long leftPushAllForList(K key, Collection<V> values) {
        return redisTemplate.opsForList().leftPushAll(key, values);
    }

    public Long rightPushForList(K key, V value) {
        return redisTemplate.opsForList().rightPush(key, value);
    }

    public Long rightPushAllForList(K key, V... values) {
        return redisTemplate.opsForList().rightPushAll(key, values);
    }

    public Long rightPushAllForList(K key, Collection<V> values) {
        return redisTemplate.opsForList().rightPushAll(key, values);
    }

    public void updateList(K key, long index, V value) {// 修改
        redisTemplate.boundListOps(key).set(index, value);
    }

    public void leftPopForList(K key) {
        redisTemplate.boundListOps(key).leftPop();
    }

    public void removeFromList(K key, long index, V value) {// 修改
        redisTemplate.boundListOps(key).remove(index, value);
    }

    public void getListValue(K key, long index) {// 查詢单个值
        redisTemplate.boundListOps(key).index(index);
    }

    public Long sizeOfList(K key) {// size
        return redisTemplate.boundListOps(key).size();
    }

    public List<V> getList(K key) {// 查询所有
        return redisTemplate.boundListOps(key).range(0, sizeOfList(key));
    }

    public List<V> getSubList(K key, long start, long end) {// 查询部分列表
        return redisTemplate.boundListOps(key).range(start, end);
    }

    // Set
    public Long addSet(K key, Set<V> values) {
        Long count = (long) 0;
        for (V v : values) {
            count += redisTemplate.boundSetOps(key).add(v);
        }

        return count;
    }

    public Long removeFromSet(K key, V value) {
        return redisTemplate.boundSetOps(key).remove(value);
    }

    public Long sizeOfSet(K key) {
        return redisTemplate.boundSetOps(key).size();
    }

    public Set<V> getSet(K key) {
        return redisTemplate.boundSetOps(key).members();
    }

    // Map<K, V>
    public void putAllForMap(K key, Map<? extends HK, ? extends HV> ageMap) {
        redisTemplate.boundHashOps(key).putAll(ageMap);
    }

    public Map<HK, HV> getMap(K key) {
        return (Map<HK, HV>) redisTemplate.boundHashOps(key).entries();
    }

    public Boolean hasHashKey(K key, Object hashKey) {
        return redisTemplate.boundHashOps(key).hasKey(hashKey);
    }

    public void setForMap(K key, Object hashKey, Object hashValue) {
        redisTemplate.boundHashOps(key).put(hashKey, hashValue);
    }

    public Set<HK> hashKeys(K key) {
        return (Set<HK>) redisTemplate.boundHashOps(key).keys();
    }

    public Object getHashValue(K key, Object hashKey) {
        return redisTemplate.boundHashOps(key).get(hashKey);
    }

    public Long removeFromMap(K key, Object hashKey) {
        return redisTemplate.boundHashOps(key).delete(hashKey);
    }
}

UserDao.java

package com.demo.redis.dao.impl;

import org.springframework.stereotype.Repository;

import com.demo.redis.dao.BaseDao;

@Repository
public class UserDao extends BaseDao<String, String, String, String> {

}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="  
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder location="classpath:redis.properties" />
    <context:component-scan base-package="com.demo.redis"></context:component-scan>

    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="maxTotal" value="${redis.maxActive}" />
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>

    <bean id="connectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
        p:host-name="${redis.host}" p:port="${redis.port}" p:pool-config-ref="poolConfig" />

    <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
        <property name="connectionFactory" ref="connectionFactory" />
    </bean>

</beans>

applicationContext2.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="  
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder location="classpath:redis.properties" />
    <context:component-scan base-package="com.demo.redis"></context:component-scan>

    <bean id="redisClusterConfig"
        class="org.springframework.data.redis.connection.RedisClusterConfiguration">
        <property name="maxRedirects" value="6"></property>
        <property name="clusterNodes">
            <set>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.216.139"></constructor-arg>
                    <constructor-arg name="port" value="7001"></constructor-arg>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.216.139"></constructor-arg>
                    <constructor-arg name="port" value="7002"></constructor-arg>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.216.139"></constructor-arg>
                    <constructor-arg name="port" value="7003"></constructor-arg>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.216.139"></constructor-arg>
                    <constructor-arg name="port" value="7004"></constructor-arg>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.216.139"></constructor-arg>
                    <constructor-arg name="port" value="7005"></constructor-arg>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.216.139"></constructor-arg>
                    <constructor-arg name="port" value="7006"></constructor-arg>
                </bean>
            </set>
        </property>
    </bean>

    <bean id="redisConnectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <constructor-arg name="clusterConfig" ref="redisClusterConfig" />
        <property name="timeout" value="5000" />
        <!-- <property name="poolConfig" ref="poolConfig"/> -->
    </bean>

    <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
        <property name="connectionFactory" ref="redisConnectionFactory" />
    </bean>

</beans>

log4j.properties

# log dir
#logdir=D:/remote/logs

# Global logging configuration,  debug < info < warn < error < fatal
# log4j.rootLogger = [debug], [info], [warn], [error], [fatal], [stdout]
log4j.rootLogger=info, stdout


# Console output
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyy-MM-dd HH:mm:ss } [%t] %5p %c{1}:%L - %m%n

# error output
log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.error.MaxFileSize=10MB
#log4j.appender.error.MaxBackupIndex=10
log4j.appender.error.File=${logdir}/error.txt
log4j.appender.error.layout=org.apache.log4j.PatternLayout
log4j.appender.error.layout.ConversionPattern=%d %-5p (%13F:%L) %3x - %m%n

# debug output
log4j.appender.debug=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.debug.MaxFileSize=10MB
#log4j.appender.debug.MaxBackupIndex=10
log4j.appender.debug.File=${logdir}/debug.txt
log4j.appender.debug.layout=org.apache.log4j.PatternLayout
log4j.appender.debug.layout.ConversionPattern=%d %-5p (%13F:%L) %3x - %m%n

# info output
log4j.appender.debug=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.debug.MaxFileSize=10MB
#log4j.appender.debug.MaxBackupIndex=10
log4j.appender.debug.File=${logdir}/info.txt
log4j.appender.debug.layout=org.apache.log4j.PatternLayout
log4j.appender.debug.layout.ConversionPattern=%d %-5p (%13F:%L) %3x - %m%n

redis.properties

# Redis settings  
redis.host=192.168.216.132
redis.port=6379
#redis.pass=java2000_wl  


redis.maxIdle=300  
redis.maxActive=600  
redis.maxWait=1000  
redis.testOnBorrow=true

RedisClusterTest.java

package com.demo.redis.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.demo.redis.dao.impl.UserDao;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath*:applicationContext2.xml" })
public class RedisClusterTest {

    @Autowired
    private UserDao userDao;

    @Test
    public void opsForValue() {
        // userDao.set("key1", "value1");
        // System.out.println(userDao.get("key1"));

        for (int i = 0; i < 100; i++) {
            userDao.set("key" + i, "value" + i);
            System.out.println(userDao.get("key" + i));
        }
    }

    // @Test
    public void opsForList() {
        userDao.deleteKey("names");

        List<String> names = new ArrayList<String>();
        names.add("zhangsan");
        names.add("lisi");
        names.add("wangwu");
        names.add("zhaoliu");

        userDao.rightPushAllForList("names", names);// 从左向右添加数据

        long size = userDao.sizeOfList("names");
        List<String> namesFromRedis = userDao.getList("names"); // 返回列表
        for (String name : namesFromRedis) {
            System.out.println(name);
        }

        System.out.println("-----------------------------------------");
        userDao.setForList("names", 1, "lili1");

        namesFromRedis = userDao.getList("names");
        for (String name : namesFromRedis) {
            System.out.println(name);
        }

        System.out.println("-----------------------------------------");
        userDao.leftPopForList("names");
        size = userDao.sizeOfList("names");
        namesFromRedis = userDao.getList("names");
        for (String name : namesFromRedis) {
            System.out.println(name);
        }

        System.out.println("-----------------------------------------");
        System.out.println(userDao.sizeOfList("names"));// 4
        userDao.deleteKey("names");// 删除key
        System.out.println(userDao.sizeOfList("names"));// 0

    }

    // @Test
    public void opsForSet() {
        userDao.deleteKey("names");

        Set<String> names = new HashSet<String>();
        names.add("zhangsan");
        names.add("lisi");
        names.add("wangwu");
        names.add("zhaoliu");

        userDao.addSet("names", names);

        long size = userDao.sizeOfSet("names");// size
        System.out.println("-----------------------------------------");
        userDao.removeFromSet("names", "zhangsan");
        Set<String> nameSet = userDao.getSet("names");// 返回set
        for (String name : nameSet) {
            System.out.println(name);
        }
    }

    // @Test
    public void opsForHash() {
        userDao.deleteKey("ages");

        Map<String, String> ageMap = new HashMap<String, String>();
        ageMap.put("zhangsan", "24");
        ageMap.put("lisi", "25");
        ageMap.put("wangwu", "26");

        System.out.println("-----------------------------------------");
        userDao.putAllForMap("ages", ageMap);
        ageMap = userDao.getMap("ages");
        for (String name : ageMap.keySet()) {
            System.out.println(name + "," + ageMap.get(name));
        }

        if (userDao.hasHashKey("ages", "zhangsan")) {
            userDao.setForMap("ages", "zhangsan", "23");
        }

        System.out.println("-----------------------------------------");
        userDao.removeFromMap("ages", "wangwu");
        Set<String> names = userDao.hashKeys("ages");
        for (String name : names) {
            System.out.println(name + "," + userDao.getHashValue("ages", name));// 查询
        }

    }

}

RedisTest.java

package com.demo.redis.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.demo.redis.dao.impl.UserDao;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath*:applicationContext.xml" })
public class RedisTest {

    @Autowired
    private UserDao userDao;

    @Test
    public void opsForValue() {
        userDao.set("key1", "value1");
        System.out.println(userDao.get("key1"));
    }

    // @Test
    public void opsForList() {
        userDao.deleteKey("names");

        List<String> names = new ArrayList<String>();
        names.add("zhangsan");
        names.add("lisi");
        names.add("wangwu");
        names.add("zhaoliu");

        userDao.rightPushAllForList("names", names);// 从左向右添加数据

        long size = userDao.sizeOfList("names");
        List<String> namesFromRedis = userDao.getList("names"); // 返回列表
        for (String name : namesFromRedis) {
            System.out.println(name);
        }

        System.out.println("-----------------------------------------");
        userDao.setForList("names", 1, "lili1");

        namesFromRedis = userDao.getList("names");
        for (String name : namesFromRedis) {
            System.out.println(name);
        }

        System.out.println("-----------------------------------------");
        userDao.leftPopForList("names");
        size = userDao.sizeOfList("names");
        namesFromRedis = userDao.getList("names");
        for (String name : namesFromRedis) {
            System.out.println(name);
        }

        System.out.println("-----------------------------------------");
        System.out.println(userDao.sizeOfList("names"));// 4
        userDao.deleteKey("names");// 删除key
        System.out.println(userDao.sizeOfList("names"));// 0

    }

    // @Test
    public void opsForSet() {
        userDao.deleteKey("names");

        Set<String> names = new HashSet<String>();
        names.add("zhangsan");
        names.add("lisi");
        names.add("wangwu");
        names.add("zhaoliu");

        userDao.addSet("names", names);

        long size = userDao.sizeOfSet("names");// size
        System.out.println("-----------------------------------------");
        userDao.removeFromSet("names", "zhangsan");
        Set<String> nameSet = userDao.getSet("names");// 返回set
        for (String name : nameSet) {
            System.out.println(name);
        }
    }

    // @Test
    public void opsForHash() {
        userDao.deleteKey("ages");

        Map<String, String> ageMap = new HashMap<String, String>();
        ageMap.put("zhangsan", "24");
        ageMap.put("lisi", "25");
        ageMap.put("wangwu", "26");

        System.out.println("-----------------------------------------");
        userDao.putAllForMap("ages", ageMap);
        ageMap = userDao.getMap("ages");
        for (String name : ageMap.keySet()) {
            System.out.println(name + "," + ageMap.get(name));
        }

        if (userDao.hasHashKey("ages", "zhangsan")) {
            userDao.setForMap("ages", "zhangsan", "23");
        }

        System.out.println("-----------------------------------------");
        userDao.removeFromMap("ages", "wangwu");
        Set<String> names = userDao.hashKeys("ages");
        for (String name : names) {
            System.out.println(name + "," + userDao.getHashValue("ages", name));// 查询
        }

    }

}

pom.xml

<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>com.demo</groupId>
    <artifactId>maven-spring-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <dependencies>
        <!-- junit单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- log4j日志 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.21</version>
        </dependency>

        <!-- spring整合Junit -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.0.RELEASE</version>
            <scope>test</scope>
        </dependency>

        <!-- spring核心包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.0.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.7.6.RELEASE</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

    </dependencies>
</project>

maven-spring-redis源码

zhiguoliu11
关注
专栏目录
redis maven java_Maven+SSM使用redis做缓存 Spring5（JavaConfig注解配置）
weixin_28630185的博客
02-21 198
1. 配置环境Redis 4 安装教程自行googleSpring 5.0.9Mybatis 3.4.62. 依赖注意：默认你配置好了SSM的依赖环境，我只说在SSM配好过后怎么把redis加进去我用的依赖是如下的版本，基本都没有最新jar包的教程，网上的老教程千奇百怪，真的是痛心。如果你不是用的spring-data-redis的2.X的版本你可以不用看了，看了也没用。2.9.02.1.0.RE...
maven-spring-redis
06-06
spring整合redis，redis单点和集群测试。
spring+maven 整合 redis
aSmart_Q的博客
06-03 444
1.通过pom.xml配置redis需要的包 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> <dependency> <groupId>com.alibaba&...
maven项目中使用redis
最新发布
weixin_41050538的博客
08-18 97
我整理的一些关于【Maven】的项目学习资料（附讲解～～）和大家一起分享、学习一下：https://d.51cto.com/xltfovMaven项目中使用Redis的入门指南 在现代软件开发中，Redis是一种非常流行的NoSQL数据库，广泛应用于缓存、实时统计等场景。本文将通过一个简单的流程，教你在Maven项目中使...
基于maven整合spring和redis
平凡之路
07-07 4332
1.导入别人的maven工程,报错The type org.springframework.core.NestedRuntimeException cannot be resolved. It is indirectly referenced from required .class files原因是:pom.xml缺少spring核心包的依赖感谢~~点击链接2.linux下启动redisnohup
Spring 整合 Redis
弹指天下
04-19 622
pom构建： [html] view plaincopyprint? modelVersion>4.0.0modelVersion>   groupId>com.x.redisgroupId>   artifactId>springredisartifactId>   version>0.0.1-SNAPSHOTversion>     
redis+spring+maven构建项目（带有缓存）
椭圆的博客
06-13 2197
pom.xml<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
spring_redis maven实例
11-23
Spring Redis Maven实例是一个非常实用的学习资源，特别适合那些想要了解如何在Java应用中集成和使用Redis作为缓存或数据存储的初学者。Redis是一个高性能的键值存储系统，而Spring框架则是Java开发中的常用工具，...
Spring mvc整合redis实例(redis连接池)
09-19
在Maven项目中，可以在pom.xml文件中添加`spring-data-redis`和`jedis`库，这两个库分别提供了Spring对Redis的支持和Jedis，一个Java客户端连接Redis。 ```xml <groupId>org.springframework.data <artifactId>...
springcache+redis springboot maven
12-18
3. 创建RedisCacheManager：在Spring Boot的配置类中，创建一个`RedisCacheManager`实例，用于管理缓存。 ```java @Bean public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) { ...
Maven+ Redis+Spring开发实例
全栈软件工程师-陈征峰的博客
07-14 2180
手把手讲授Maven+ Redis+Spring开发实例
springmvc集成redis的Demo基于maven（内有redis）
05-12
该项目使用spring4.2和redis集成的一个小demo，其中包含32位和64位的redis客户端和服务器端，项目导入即可运行（需要maven环境）
maven版spring-data-redis简单示例
03-06
基于spring的子项目spring-data-redis写的一个基于hash类型的用户CRUD,经过简单的封装，可以实现通用CRUD，请事先安装好redis，配置文件redis.properties请做相应修改，希望对你有帮助。
redis+spring+maven平台搭建
bin的主栏
09-25 327
一、什么是Redis？       redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此
五、maven项目搭建 ssm框架之spring整合redis
SoulFeeling的博客
08-27 796
ssm框架搭建完成后，算是完成第一步，可以根据自己的需求来发开自己的程序，接下里要做的是学一下程序开发的一些中间插件比如说redis、mq等一些工具，现在就来一边学一边做 环境准备： 1.ubuntu 14 2.redis4.0.tar.gz 将redis 压缩包上传到ubunt服务器上/alidata/filepackage   （主要用来放置软件安装包的） 1、解压redis4.0压
Maven构建spring+redis项目
做技术，贵在学习与坚持！
07-25 2424
需要使用的jar文件列表:
Java maven使用 Redis
买不起冰露的博客
07-19 568
1连接到 redis 服务 在pom.xml中配置 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> <dependency> <gro
Spring Boot与Redis深度整合指南
- **添加依赖**：在 Maven 项目的 pom.xml 文件中引入 Spring Boot 对 Redis 支持的依赖，如 `spring-boot-starter-data-redis`。 - **配置 Redis**：在 application.yml 或 application.properties 配置文件中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值