Java整合spring和springboot访问redis

最新推荐文章于 2024-10-15 22:16:32 发布
最新推荐文章于 2024-10-15 22:16:32 发布
阅读量178 收藏
点赞数
分类专栏： Redis 文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Kiven_ch/article/details/119548254
版权
本文介绍了如何使用Java的Jedis库以及Spring框架来访问和操作Redis缓存。首先，展示了通过Jedis直接进行连接、设置键值对、操作列表等基本操作。接着，详细阐述了在Spring环境中配置Redis，包括Spring配置文件、属性文件的设置，并提供了测试用例。最后，演示了在SpringBoot项目中配置Redis，创建RedisTemplate以及通过控制器进行增删查改操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Java程序访问Redis

采用jedis API进行访问即可

  1. 关闭RedisServer端的防火墙
    systemctl stop firewalld（默认）
systemctl disable firewalld.service（设置开启不启动）
  2. 新建maven项目后导入Jedis包
    pom.xml
    <dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>2.9.0</version>
</dependency>
  3. 写程序
    @Test
public void testConn(){
	//与Redis建立连接 IP+port
	Jedis redis = new Jedis("192.168.127.128", 6379);
	//在Redis中写字符串 key value
	redis.set("jedis:name:1","jd-zhangfei");
	//获得Redis中字符串的值
	System.out.println(redis.get("jedis:name:1"));
	//在Redis中写list
	redis.lpush("jedis:list:1","1","2","3","4","5");
	//获得list的长度
	System.out.println(redis.llen("jedis:list:1"));
}

Spring访问Redis

  1. 创建spring工程后引入相关的依赖
    <properties>
        <spring.version>5.2.14.RELEASE</spring.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>2.2.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>11</source>
                    <target>11</target>
                    <testSource>11</testSource>
                    <testTarget>11</testTarget>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
  1. 创建spring配置文件和redis配置文件
    首先是spring配置文件 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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="classpath*:redis.properties"></context:property-placeholder>

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

    <bean id="redisConfiguration" class="org.springframework.data.redis.connection.RedisStandaloneConfiguration">
        <property name="hostName" value="${redis.host}"></property>
        <property name="port" value="${redis.port}"></property>
    </bean>

    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <constructor-arg ref="redisConfiguration"></constructor-arg>
        <property name="timeout" value="${redis.timeout}"></property>
        <property name="poolConfig" ref="jedisPoolConfig"></property>
    </bean>
    
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory"></property>
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer">
            </bean>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"></bean>
        </property>
    </bean>

</beans>

然后是redis客户端的配置文件redis.properties

redis.maxTotal=10
redis.maxIdle=5
redis.maxWaitMillis=20000
redis.testOnBorrow=false
redis.host=192.168.31.10
redis.port=6379
redis.timeout=50000
  1. 创建测试类
/**
 * @author Elvis
 * @create 2021-08-08 22:47
 */

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;

import java.io.Serializable;

/**
 * @program: redis-study
 * @Description
 * @author Elvis
 * @date 2021-08-08 22:47    
 */
public class RedisTest {

    ClassPathXmlApplicationContext applicationContext = null;
    RedisTemplate<Serializable, Serializable> redisTemplate = null;

    @Before
    public void before() {
        applicationContext = new ClassPathXmlApplicationContext("classpath*:applicationContext.xml");
        redisTemplate = (RedisTemplate) applicationContext.getBean("redisTemplate");

    }

    @Test
    public void test1() {
        redisTemplate.opsForValue().set("name", "zhaoyun");
    }

    @Test
    public void test2() {
        String name = (String) redisTemplate.opsForValue().get("name");
        System.out.println(name);
    }

}

先执行插入，再执行查询
在这里插入图片描述

SpringBoot访问Redis

  1. 新建工程后添加pom依赖
        <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.4.2</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>11</source>
                    <target>11</target>
                    <testSource>11</testSource>
                    <testTarget>11</testTarget>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
  2. 添加配置文件application.yml
    spring:
  redis:
    host: 192.168.31.10
    port: 6379
    jedis:
      pool:
        max-active: 8
        max-idle: 1
        max-wait: 20000
    client-type: jedis
  3. 添加配置类RedisConfig
    package com.elvis.config;
/**
 * @author Elvis
 * @create 2021-08-09 7:43
 */

import org.springframework.beans.factory.annotation.Autowired;
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.StringRedisSerializer;

/**
 * @program: redis-study
 * @Description
 * @author Elvis
 * @date 2021-08-09 7:43    
 */
@Configuration
public class RedisConfig {

    @Autowired
    RedisConnectionFactory connectionFactory;

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setStringSerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate;
    }
}
  4. 添加RedisController
    package com.elvis.controller;
/**
 * @author Elvis
 * @create 2021-08-09 7:48
 */

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @program: redis-study
 * @Description
 * @author Elvis
 * @date 2021-08-09 7:48    
 */
@RestController
@RequestMapping("/redis")
public class RedisController {

    @Autowired
    RedisTemplate<String, Object> redisTemplate;

    @RequestMapping("/put")
    public String put(@RequestParam(required = true) String key,
                      @RequestParam(required = true) String value) {
        redisTemplate.opsForValue().set(key, value);
        return "success";
    }

    @RequestMapping("/get")
    public String get(@RequestParam(required = true) String key) {
        Object o = redisTemplate.opsForValue().get(key);
        return (String) o;
    }
}
  5. 修改Application并运行
    package com.elvis;
/**
 * @author Elvis
 * @create 2021-08-09 8:08
 */

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

/**
 * @program: redis-study
 * @Description
 * @author Elvis
 * @date 2021-08-09 8:08    
 */
@SpringBootApplication
@EnableCaching
public class RunBoot {
    public static void main(String[] args) {
        SpringApplication.run(RunBoot.class, args);
    }
}
    在这里插入图片描述
    在这里插入图片描述
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
Asurplus
10-23 22万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
【SpringBoot】50、SpringBoot为Redis的key统一加上前缀
热门推荐
Asurplus
08-12 21万+
我们在实际的项目应用中，Redis一般都是用来缓存热点数据，一台服务器可能部署了多个应用，应用直接的 Redis 数据需要加上前缀区分开来，我们可以使用序列化的方式，统一为所有的 key 加上前缀 一、关于在 SpringBoot 中整合 Redis https://lizhou.blog.youkuaiyun.com/article/details/98358258 二、关于在 SpringBoot 中整合 Redis 实现序列化存储Java对象 https://lizhou.blog.youkuaiyun.com/artic
spring整合redis
07-24
spring 整合redis 封装redistemplate工具类
java spring redis_在Spring中使用Redis
weixin_39944375的博客
02-12 502
在教程《在Java程序中使用Redis》中介绍了在没有封装情况下使用 Java API 的缺点，需要自己编写规则把 Java 对象和 Redis 的字符串进行相互转换，而在 Spring 中这些问题都可以轻松处理。在 Spring 中使用 Redis，除了需要 jedis.jar 外，还需要下载 spring-data-redis.jar，这里值得注意的是 jar 包和 Spring 版本兼容的问...
java spring中使用redis
Forward
05-23 1061
pom文件下添加配置： <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.8.2</version&gt...
java spring redis_Spring集成Redis详解代码示例
weixin_39714307的博客
02-12 203
本文章从头开始介绍Spring集成Redis的示例。Eclipse工程结构如下图为我的示例工程的结构图，采用Maven构建。其中需要集成Spring，因此需要beans.xml文件配置spring的依赖注入，redis.properties配置连接服务器的配置信息。其中工程中beans.xml和redis.properties文件直接放在了根目录，有需要的读者可以放到resource目录中。POM...
Spring数据和Redis
最佳 Java 编程
05-30 246
本文是我们学院课程的一部分，标题为Redis NoSQL键值存储 。 这是Redis的速成班。 您将学习如何安装Redis并启动服务器。 此外，您将在Redis命令行中乱七八糟。 接下来是更高级的主题，例如复制，分片和集群，同时还介绍了Redis与Spring Data的集成。 在这里查看 ！ 目录 1.简介 2.先决条件 3.选择Redis Java客户端 4...
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
11-10
【微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单】这篇文章主要讲解了如何在微服务架构中使用SpringBoot整合Redis来构建一个基于Redis Stream的消息队列，以此来实现实时、高效的异步秒杀...
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
【Java】SpringBoot 快速整合Redis
最新发布
2401_84502663的博客
10-15 1100
Redis是一种高性能开源的基于内存的，采用键值对存储的非关系型数据库，它支持多种数据结构，包括字符串、哈希表、列表、集合、有序集合等。Redis的特点之一是数据存储在内存中，因此读写速度非常快。以下是Redis的一些主要特点和作用：1.高性能： Redis的数据存储在内存中，读写速度非常快，这使得它成为处理大量请求的理想选择。2.数据结构丰富： Redis支持多种数据结构，包括字符串、哈希表、列表、集合、有序集合等。这使得它可以应用于各种不同的场景，如缓存、消息队列、计数器等。
Redis应用--在Java和Spring中使用Redis
纯洁2016的博客
01-30 450
一、Java使用Redis 1.导入Redis依赖 在pom文件中添加Jedis(Java Redis)依赖：(具体版本根据实际使用情况而定) <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <ve...
使用Java操作Redis
weixin_45915206的博客
08-09 436
Spring Data Redis中提供了一个高度封装的类：RedisTemplate，针对 Jedis 客户端中大量api进行了归类封装,将同一类型操作封装为operation接口
java中使用redis和spring中调用redis
为梦想而奋斗，无悔_一叶扁舟的点滴成长！
02-09 1750
1.需要的jar包，配置的pom.xml文件 &lt;!-- redis缓存 --&gt; &lt;dependency&gt; &lt;groupId&gt;redis.clients&lt;/groupId&gt; &lt;artifactId&gt;jedis&lt;/artifactId&gt; &lt;...
使用Java（Springboot）操作Redis
jzd1997的专栏
02-07 1万+
1、 redis简介  redis是Nosql数据库中使用较为广泛的非关系型内存数据库，redis内部是一个key-value存储系统。它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set –有序集合)和hash（哈希类型，类似于Java中的map）。Redis基于内存运行并支持持久化的NoSQL数据库，是当前最热门的N
Spring整合redis使用Java操作redis
qq_17254307的博客
01-03 4011
项目结构配置文件web.xml redis.properties redis.host1=127.0.0.1 redis.host2=127.0.0.2 redis.port=6379 redis.timeout=20000 redisContext.xml这里使用的spring3.0 ignore-unresolvable=”true”这属性是加载redis.properties文件需要在spri
Java中使用Redis
zipp的博客
12-06 4万+
redis的安装(windows) 安装版和解压版,解压版需要配置环境变量 下载地址 : https://github.com/MSOpenTech/redis/releases 启动redis cmd窗口中输入 redis-server.exe (确保redis路径已加入环境变量中) 启动成功后显示,此窗口关闭redis服务器也就会关闭 默认端口6379 连接red...
Java中使用Redis（jedis连接池连接redis/spring集成redis）
weixin_38364973的博客
04-24 7691
开始在 Java 中使用 Redis 前， 我们需要确保已经安装了 redis 服务及 Java redis 驱动1、下载最新驱动包：https://mvnrepository.com/artifact/redis.clients/jedis；commons-pool2-2.4.2.jar；（Apache连接池）2、将jar包放入lib中3、import redis.clients.jedis.J...
Java基础之《spring与redis通讯原理》
csj50的专栏
07-27 567
1、spring连接redis底层主要采用了redis集成组件包：spring-boot-starter-data-redis和commons-pool2 <!--redis启动器--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </...
Spring整合Redis集群并使用Java简单操作
weixin_42465125的博客
02-23 697
Redis集群搭建参考文章：https://blog.youkuaiyun.com/weixin_42465125/article/details/87885133 新建一个Maven工程，工程结构如下： 然后在pom文件添加如下依赖： &lt;dependency&gt; &lt;groupId&gt;junit&lt;/groupId&gt; &lt;artifactId&gt...
外卖系统整合开发：Springboot与Redis实践
Reggie外卖整合代码是基于Spring Boot框架进行开发的外卖系统项目，它结合了Redis和Maven来处理数据缓存和项目依赖管理。该项目以Java语言编写，利用Spring Boot提供的快速开发特性，简化了外卖系统的构建和部署流程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值