AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Spring boot整合Redis（入门教程）

2022-11-28 336
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
简介： jedis：采用直连，多个线程操作的话，是不安全的。如果想要避免不安全的，使用jedis pool连接池！更像BIO模式lettuce：采用netty，实例可以在多个线程中进行共享，不存在线程不安全的情况，可以减少线程数据，更像NIO模式

源码分析

SpringBoot2.x之后，原来使用的jedis被替换为了lettuce

SpringBoot 所有的配置类，都有一个自动配置类 RedisAutoConfiguration
每一个自动配置类都绑定一个properties配置文件 RedisProperties

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean(name = {"redisTemplate"} ) //可以自定义一个redisTemplate来替换默认的
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        //默认的RedisTemplate没有过多的设置，redis对象都是需要序列化的
        //两个泛型都是Object，Object的类型，后期使用需要强制转换<String,Object>
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean//由于String是redis中最常用的类型，所以单独提出来一个bean
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        return new StringRedisTemplate(redisConnectionFactory);
    }
}

redis相关配置可以查看源码中的RedisProperties类，@EnableConfigurationProperties({RedisProperties.class})

注解介绍：

注解 作用
@Configuration 用于定义配置类，可替换xml配置文件，被注解的类内部包含有一个或多个被@Bean注解的方法
@EnableConfigurationProperties 使使用 @ConfigurationProperties 注解的类生效
@ConditionalOnMissingBean 判断当前需要注入Spring容器中的bean的实现类是否已经含有，有的话不注入，没有就注入

jedis VS lettuce

jedis：采用直连，多个线程操作的话，是不安全的。如果想要避免不安全的，使用jedis pool连接池！更像BIO模式

lettuce：采用netty，实例可以在多个线程中进行共享，不存在线程不安全的情况，可以减少线程数据，更像NIO模式

整合测试

导入依赖

<!--操作redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置连接

#配置redis
spring.redis.host=127.0.0.1
spring.redis.port=6379
#spring.redis.database=0  //默认是数据库0

测试

存入字符串

@SpringBootTest
class RedisSpringbootApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        //获取redis的连接对象
        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        connection.flushDb();
        connection.flushAll();
        redisTemplate.opsForValue().set("mykey0", "呼呼");
        System.out.println(redisTemplate.opsForValue().get("mykey0"));
    }

}

在Redis可视化管理软件中显示结果：
在这里插入图片描述

存入对象

User类：

@Component
@AllArgsConstructor
@NoArgsConstructor
@Data
//在开发中，所有的pojo类都会序列化
public class User implements Serializable{
    private String name;
    private int age;
}

测试程序：

@Test
    public void test(){
        //真实开发中都使用json来传递对象
        User user = new User();
        user.setName("笨笨熊2");
        user.setAge(4);
        redisTemplate.opsForValue().set("user",user);
        System.out.println(redisTemplate.opsForValue().get("user"));
    }

User类未序列化时运行结果：
在这里插入图片描述
使User类 implements Serializable，从而序列化。

序列化后可正常运行，在Redis可视化管理软件中显示结果：
在这里插入图片描述

查看源码发现由于Redis默认序列化是方式是JdkSerializationRedisSerializer，因此可读性较差
在这里插入图片描述
在这里插入图片描述

五大数据类型操作

五种数据类型的API操作和Linux下的指令一样，具体可参照另一篇文章
Redis中五大基本数据类型和三种特殊数据类型详解

操作代码 操作说明
redisTemplate 操作不用数据类型，api和指令一样
opsForValue() 操作字符串
opsForList() 操作List
opsForSet() 操作Set
opsForHash 操作Hash
opsForZSet 操作ZSet

除了基本的操作，常用的方法都可以直接通过redisTemplate操作，比如事务和基本CRUD（增删改查）

自定义RedisConfig

自定义配置类中使用Jackson2JsonRedisSerializer进行序列化

@Configuration
public class RedisConfig {
    //编写配置类，可模仿RedisAutoConfiguration配置类，该类在开发中可直接使用
    @Bean
    @SuppressWarnings("all")
    //@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        //由于源码autoConfig中是<Object, Object>，开发中一般直接使用<String,Object>
        RedisTemplate<String, Object> template = new RedisTemplate();
        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.setKeySerializer(stringRedisSerializer);
        //value序列化采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //hash的value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

存入对象

 @Test
    public void test(){
        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        connection.flushAll();
        //真实开发中都使用json来传递对象
        User user = new User();
        for (int i=1;i<=10;i++){
            user.setName("笨笨熊"+i);
            user.setAge(i);
            redisTemplate.opsForValue().set("user"+i,user);
        }
    }

Redis可视化工具中：
在这里插入图片描述

Redis工具类（常用API）

@Component
public class RedisUtils {
    //注入自定义redisTemplate
    @Autowired
    @Qualifier("redisTemplate")
    private RedisTemplate redisTemplate;
    /**========================================================================*/

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间（秒）
     * @return boolean
     **/
    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 键
     * @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 键
     **/
    public void del(String... key) {
        if (key != null && key.length > 0) {
            redisTemplate.delete(key[0]);
        } else {
            redisTemplate.delete(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;
        }

    }
}
文章标签：
云数据库 Tair（兼容 Redis）
Java
容器
数据可视化
NoSQL
Linux
Redis
Spring
API
数据格式
XML
关键词：
云数据库 Tair（兼容 Redis）spring
springboot云数据库 Tair（兼容 Redis）
spring云数据库 Tair（兼容 Redis）
Spring redis
Spring boot
IT觅语
目录
相关文章
HELLO程序员
|
1月前
|
NoSQL Java 调度
分布式锁与分布式锁使用 Redis 和 Spring Boot 进行调度锁（不带 ShedLock）
分布式锁是分布式系统中用于同步多节点访问共享资源的机制，防止并发操作带来的冲突。本文介绍了基于Spring Boot和Redis实现分布式锁的技术方案，涵盖锁的获取与释放、Redis配置、服务调度及多实例运行等内容，通过Docker Compose搭建环境，验证了锁的有效性与互斥特性。
HELLO程序员
114 0
分布式锁与分布式锁使用 Redis 和 Spring Boot 进行调度锁（不带 ShedLock）
wanderInk
|
6月前
|
NoSQL 安全 Java
深入理解 RedisConnectionFactory：Spring Data Redis 的核心组件
在 Spring Data Redis 中，`RedisConnectionFactory` 是核心组件，负责创建和管理与 Redis 的连接。它支持单机、集群及哨兵等多种模式，为上层组件（如 `RedisTemplate`）提供连接抽象。Spring 提供了 Lettuce 和 Jedis 两种主要实现，其中 Lettuce 因其线程安全和高性能特性被广泛推荐。通过手动配置或 Spring Boot 自动化配置，开发者可轻松集成 Redis，提升应用性能与扩展性。本文深入解析其作用、实现方式及常见问题解决方法，助你高效使用 Redis。
wanderInk
626 4
Adrian_
|
3月前
|
NoSQL Java Redis
Redis基本数据类型及Spring Data Redis应用
Redis 是开源高性能键值对数据库，支持 String、Hash、List、Set、Sorted Set 等数据结构，适用于缓存、消息队列、排行榜等场景。具备高性能、原子操作及丰富功能，是分布式系统核心组件。
Adrian_
445 2
蓝易云
|
5月前
|
消息中间件 缓存 NoSQL
基于Spring Data Redis与RabbitMQ实现字符串缓存和计数功能（数据同步）
总的来说，借助Spring Data Redis和RabbitMQ，我们可以轻松实现字符串缓存和计数的功能。而关键的部分不过是一些"厨房的套路"，一旦你掌握了这些套路，那么你就像厨师一样可以准备出一道道饕餮美食了。通过这种方式促进数据处理效率无疑将大大提高我们的生产力。
蓝易云
210 32
源码世界
|
4月前
|
机器学习/深度学习 数据采集 人机交互
springboot+redis互联网医院智能导诊系统源码，基于医疗大模型、知识图谱、人机交互方式实现
智能导诊系统基于医疗大模型、知识图谱与人机交互技术，解决患者“知症不知病”“挂错号”等问题。通过多模态交互（语音、文字、图片等）收集病情信息，结合医学知识图谱和深度推理，实现精准的科室推荐和分级诊疗引导。系统支持基于规则模板和数据模型两种开发原理：前者依赖人工设定症状-科室规则，后者通过机器学习或深度学习分析问诊数据。其特点包括快速病情收集、智能病症关联推理、最佳就医推荐、分级导流以及与院内平台联动，提升患者就诊效率和服务体验。技术架构采用 SpringBoot+Redis+MyBatis Plus+MySQL+RocketMQ，确保高效稳定运行。
源码世界
305 0
互联网课堂
|
7月前
|
存储 人工智能 NoSQL
SpringBoot整合Redis、ApacheSolr和SpringSession
本文介绍了如何使用SpringBoot整合Redis、ApacheSolr和SpringSession。SpringBoot以其便捷的配置方式受到开发者青睐，通过引入对应的starter依赖，可轻松实现功能整合。对于Redis，可通过配置RedisSentinel实现高可用；SpringSession则提供集群Session管理，支持多种存储方式如Redis；整合ApacheSolr时，借助Zookeeper搭建SolrCloud提高可用性。文中详细说明了各组件的配置步骤与代码示例，方便开发者快速上手。
互联网课堂
124 11
Quan_Chen
|
7月前
|
NoSQL Java API
微服务——SpringBoot使用归纳——Spring Boot 中集成Redis——Spring Boot 集成 Redis
本文介绍了在Spring Boot中集成Redis的方法，包括依赖导入、Redis配置及常用API的使用。通过导入`spring-boot-starter-data-redis`依赖和配置`application.yml`文件，可轻松实现Redis集成。文中详细讲解了StringRedisTemplate的使用，适用于字符串操作，并结合FastJSON将实体类转换为JSON存储。还展示了Redis的string、hash和list类型的操作示例。最后总结了Redis在缓存和高并发场景中的应用价值，并提供课程源代码下载链接。
Quan_Chen
1761 0
Quan_Chen
|
7月前
|
NoSQL Java Redis
微服务——SpringBoot使用归纳——Spring Boot 中集成Redis——Redis 安装
本教程介绍在 VMware 虚拟机（CentOS 7）或阿里云服务器中安装 Redis 的过程，包括安装 gcc 编译环境、下载 Redis（官网或 wget）、解压安装、修改配置文件（如 bind、daemonize、requirepass 等设置）、启动 Redis 服务及测试客户端连接。通过 set 和 get 命令验证安装是否成功。适用于初学者快速上手 Redis 部署。
Quan_Chen
172 0
风水道人
|
NoSQL Java Redis
SpringBoot集成Redis解决表单重复提交接口幂等（亲测可用）
SpringBoot集成Redis解决表单重复提交接口幂等（亲测可用）
风水道人
792 0
Sunny_yiyi
|
NoSQL Java Redis
SpringBoot集成Redis
SpringBoot集成Redis
Sunny_yiyi
563 0

热门文章

最新文章

  • 1
    构建基于Java的AI智能体：使用LangChain4j与Spring AI实现RAG应用
  • 2
    Spring Security权限管理解析
  • 3
    从零学 Dropwizard：手把手搭轻量 Java 微服务，告别 Spring 臃肿
  • 4
    Spring Security通用权限管理模型解析
  • 5
    Spring Cloud 微服务治理技术详解与实践指南
  • 6
    零代码改造 + 全链路追踪！Spring AI 最新可观测性详细解读
  • 7
    【SpringBoot（二）】带你认识Yaml配置文件类型、SpringMVC的资源访问路径 和 静态资源配置的原理！
  • 8
    Spring框架优化：提高Java应用的性能与适应性
  • 9
    基于springboot的儿童家长教育能力提升学习系统
  • 10
    【SpringBoot（一）】Spring的认知、容器功能讲解与自动装配原理的入门，带你熟悉Springboot中基本的注解使用
  • 1
    基于springboot+vue.js的在线骑行网站附带文章和源代码设计说明文档ppt
    173
  • 2
    基于springboot+vue.js的医院急诊系统附带文章和源代码设计说明文档ppt
    878
  • 3
    基于springboot+vue.js的校园体育场馆（设施）使用管理网站附带文章和源代码设计说明文档ppt
    275
  • 4
    基于springboot+vue.js的电影订票及评论网站附带文章和源代码设计说明文档ppt
    151
  • 5
    基于springboot+vue.js的基于java的教学辅助平台附带文章和源代码设计说明文档ppt
    120
  • 6
    基于springboot+vue.js的基于多维分类的知识管理系统附带文章和源代码设计说明文档ppt
    157
  • 7
    基于springboot+vue.js的大学城水电管理系统附带文章和源代码设计说明文档ppt
    89
  • 8
    基于springboot+vue.js的基于保信息学科平台系统附带文章和源代码设计说明文档ppt
    87
  • 9
    基于微信平台的报刊订阅小程序+springboot+vue.js附带文章和源代码设计说明文档ppt
    146
  • 10
    基于微信小程序的在线点餐+springboot+vue.js附带文章和源代码设计说明文档ppt
    159

    • 相关课程

    更多
  • SpringBoot快速掌握 - 核心技术
  • SpringBoot快速掌握 - 高级应用
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Springboot项目云开发快速迁移
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库
    • 下一篇
    阿里云oss简介和如何对接使用