Springboot怎么快速集成Redis?

news2024/9/28 5:26:15

前言

其实在Springboot中集成redis是一个非常简单的事情,但是为什么要单独输出一篇文章来记录这个过程呢?第一个原因是,我记性不是太好,这次把这个过程记录下,在新的项目搭建的时候或者需要在本地集成redis做一些其他相关联技术的测试分析的时候,可以很快找到集成方法;第二个原因是,最早我记得Spring项目里集成redis的时候,用的是jedis作为客户端,而在Springboot2.0后,这一事实改变了,默认的是lettuce。作为一个成熟的程序员来说,我是乐于拥抱变化的,改变意味着新的可能。

文章示例环境配置信息
jdk版本:1.8
开发工具:Intellij iDEA 2020.1
springboot:2.3.9.RELEASE

依赖配置

Springboot本身已经提供好了关于redis的starter,即spring-boot-starter-data-redis,在使用redis连接池的时候会依赖到commons-pool2包。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

application.properties配置

单机模式

redis单机模式下,配置的连接参数是比较简单的,有主机ip、端口、连接验证密码,如果使用了连接池,再加连接池的几个参数就算配置完成了;

#单机模式
#redis主机ip
spring.redis.host=localhost
#redis对外提供服务端口
spring.redis.port=6379
#redis连接验证密码
spring.redis.password=fanfu123
#redis连接池配置-最大保持闲置的连接数
spring.redis.lettuce.pool.max-idle=16
#redis连接池配置-最大活跃的连接数
spring.redis.lettuce.pool.max-active=20
#redis连接池配置-最大等待时间,单位毫秒
spring.redis.lettuce.pool.max-wait=1

集群模式

集群模式下与单机模式的连接参数配置最大的区别就在于,这里配置的是多个节点主机ip+端口,多个节点之间英文逗号隔开;另外就是一些集群模式特有的参数,如重定向次数、集群刷新等;

#集群模式
#集群节点ip+端口,多个节点之间以英文逗号隔开
spring.redis.cluster.nodes=172.18.229.61:6380,172.18.229.61:6381,172.18.229.61:6382,172.18.229.61:6383,172.18.229.61:6384,172.18.229.61:6385;
#密码
spring.redis.password=fanfu123
#最大重定向次数
spring.redis.cluster.max-redirects=5
#是否开启集群刷新功能
spring.redis.lettuce.cluster.refresh.adaptive=false
#集群刷新间隔
spring.redis.lettuce.cluster.refresh.period=10M

redis密码更新

redis的配置文件,我本机操作系统是windows,使用了redis.windows.conf配置文件,更改内容如下:

requirepass fanfu123

单元测试

1、在redis.windows.conf配置文件中配置好密码,然后启动redis,这里我写了一个windwos上的批处理文件start.bat来启动redis,start.bat内容如下:

title redis-6385
redis-server.exe redis.windows.conf

2、在项目里增加依赖配置spring-boot-starter-data-redis和commons-pool2,并在application.properties中配置好redis的连接信息;

3、编写单元测试,使用redisTemplate对象往redis中设置一个key-value的键值对并读取;RedisTemplate是spring-data-redis提供的一个操作reids的类,可以直接注入单元测试或其他spring的bean中使用;

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    public void test() {
        redisTemplate.opsForValue().set("username", "凡夫");
        String name = redisTemplate.opsForValue().get("name").toString();
        Assert.isTrue(name.equals("凡夫"), "xxxx");
    }
}

单元测试执行结果,发现key是这样的“\xAC\xED\x00\x05t\x00\x08username”,出现这样类似乱码的现象是因为注入的redisTemplate对象使用了默认的序列化方式JdkSerializationRedisSerializer,具体就是使用redisTemplate对象把key存储到redis中的时候,就会先使用JdkSerializationRedisSerializer对key进行序列化,序列后的结果存储在redis服务端;

这样在观察redis中存储的key时不太直观,为了解决redis中key使用默认序列化产生类似乱码的现象,需要重新定义redisTemplate对象并注入到Spring容器中,这里key的序列化使用StringRedisSerializer的方式,就可以消除上面类似乱码的现象;value类型是String,默认的序列化方式是StringRedisSerializer;value的类型是object,默认的序列化方式是JdkSerializationRedisSerializer;而一般经常使用的对象序列化方式是Jackson2JsonRedisSerializer;

这里再简单梳理一下redis本身提供的几种序列化方式 :

GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化

Jackson2JsonRedisSerializer: 序列化object对象为json字符串

JdkSerializationRedisSerializer: 序列化java对象

StringRedisSerializer: 简单的字符串序列化

@Configuration
public class RedisConfig {
        @Bean(name = "redisTemplate")
        public RedisTemplate<String, Object> getRedisTemplate(RedisConnectionFactory factory) {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
            redisTemplate.setConnectionFactory(factory);
            //key采用string的序列化方式
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            redisTemplate.setKeySerializer(stringRedisSerializer);
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                    ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
            jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
            jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
            //value的序列化方式采用jackson
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            //hash的key也采用string的序列化方式
            redisTemplate.setHashKeySerializer(stringRedisSerializer);
            //hash的value也采用jackson的序列化方式
            redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
}

工具类封装

redis有五种数据类型,分别是String、hash、list、set、zset,spring-data-redis中的redisTemplate针对每种类型value的操作命令都进行封装,如下:

ValueOperations valueOperations = redisTemplate.opsForValue();//string
HashOperations hashOperations = redisTemplate.opsForHash();//hash
ListOperations listOperations = redisTemplate.opsForList();//list
SetOperations setOperations = redisTemplate.opsForSet();//set
ZSetOperations zSetOperations = redisTemplate.opsForZSet();//zset

为了方便使用,可以单独封装成一个工具类,使用的时候直接通过工具类来操作,如下:

@Component
public class RedisService {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 给一个指定的 key 值附加过期时间
     * @param key
     * @param time
     * @return
     */
    public boolean expire(String key, long time) {
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }

    /**
     * 根据key 获取过期时间
     * @param key
     * @return
     */
    public long getTime(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断指定的key是否存在
     * @param key
     * @return
     */
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 移除指定key的过期时间
     * @param key
     * @return
     */
    public boolean persist(String key) {
        return redisTemplate.boundValueOps(key).persist();
    }

    /**
     * 根据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 void set(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 将值放入缓存并设置时间
     * @param key   键
     * @param value 值
     * @param time  时间(秒) -1为无期限
     * @return true成功 false 失败
     */
    public void set(String key, String value, long time) {
        if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            redisTemplate.opsForValue().set(key, value);
        }
    }

    /**
     * 批量添加 key (重复的键会覆盖)
     * @param keyAndValue
     */
    public void batchSet(Map<String, String> keyAndValue) {
        redisTemplate.opsForValue().multiSet(keyAndValue);
    }

    /**
     * 批量添加 key-value 只有在键不存在时,才添加
     * map 中只要有一个key存在,则全部不添加
     * @param keyAndValue
     */
    public void batchSetIfAbsent(Map<String, String> keyAndValue) {
        redisTemplate.opsForValue().multiSetIfAbsent(keyAndValue);
    }

    /**
     * 对一个 key-value 的值进行加减操作,
     * 如果该 key 不存在 将创建一个key 并赋值该 number
     * 如果 key 存在,但 value 不是长整型 ,将报错
     * @param key
     * @param number
     */
    public Long increment(String key, long number) {
        return redisTemplate.opsForValue().increment(key, number);
    }

    /**
     * 对一个 key-value 的值进行加减操作,
     * 如果该 key 不存在 将创建一个key 并赋值该 number
     * 如果 key 存在,但 value 不是 纯数字 ,将报错
     * @param key
     * @param number
     */
    public Double increment(String key, double number) {
        return redisTemplate.opsForValue().increment(key, number);
    }

    /**
     * 将数据放入set缓存
     * @param key 键
     * @return
     */
    public void sSet(String key, String value) {
        redisTemplate.opsForSet().add(key, value);
    }

    /**
     * 获取变量中的值
     * @param key 键
     * @return
     */
    public Set<Object> members(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 随机获取变量中指定个数的元素
     * @param key   键
     * @param count 值
     * @return
     */
    public List randomMembers(String key, long count) {
        List list = redisTemplate.opsForSet().randomMembers(key, count);
        return list;
    }

    /**
     * 随机获取变量中的元素
     * @param key 键
     * @return
     */
    public Object randomMember(String key) {
        return redisTemplate.opsForSet().randomMember(key);
    }

    /**
     * 弹出变量中的元素
     * @param key 键
     * @return
     */
    public Object pop(String key) {
        return redisTemplate.opsForSet().pop("setValue");
    }

    /**
     * 获取变量中值的长度
     * @param key 键
     * @return
     */
    public long setSize(String key) {
        return redisTemplate.opsForSet().size(key);
    }

    /**
     * 根据value从一个set中查询,是否存在
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }

    /**
     * 检查给定的元素是否在变量中
     * @param key 键
     * @param obj 元素对象
     * @return
     */
    public boolean isMember(String key, Object obj) {
        return redisTemplate.opsForSet().isMember(key, obj);
    }

    /**
     * 转移变量的元素值到目的变量
     * @param key     键
     * @param value   元素对象
     * @param destKey 元素对象
     * @return
     */
    public boolean move(String key, String value, String destKey) {
        return redisTemplate.opsForSet().move(key, value, destKey);
    }

    /**
     * 批量移除set缓存中元素
     * @param key    键
     * @param values 值
     * @return
     */
    public void remove(String key, Object... values) {
        redisTemplate.opsForSet().remove(key, values);
    }

    /**
     * 通过给定的key求2个set变量的差值
     * @param key     键
     * @param destKey 键
     * @return
     */
    public Set difference(String key, String destKey) {
        return redisTemplate.opsForSet().difference(key, destKey);
    }

    /**
     * 加入缓存
     * @param key 键
     * @param map 键
     * @return
     */
    public void add(String key, Map<String, String> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }

    /**
     * 获取 key 下的 所有  hashkey 和 value
     * @param key 键
     * @return
     */
    public Map<Object, Object> getHashEntries(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 验证指定 key 下 有没有指定的 hashkey
     * @param key
     * @param hashKey
     * @return
     */
    public boolean hashKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    /**
     * 获取指定key的值string
     * @param key     键
     * @param hashKey 键
     * @return
     */
    public String getMapString(String key, String hashKey) {
        return redisTemplate.opsForHash().get(key, hashKey).toString();
    }

    /**
     * 获取指定的值Int
     * @param key     键
     * @param hashKey 键
     * @return
     */
    public Integer getMapInt(String key, String hashKey) {
        return (Integer) redisTemplate.opsForHash().get(key, hashKey);
    }

    /**
     * 弹出元素并删除
     * @param key 键
     * @return
     */
    public String popValue(String key) {
        return redisTemplate.opsForSet().pop(key).toString();
    }

    /**
     * 删除指定 hash 的 HashKey
     * @param key
     * @param hashKeys
     * @return 删除成功的 数量
     */
    public Long delete(String key, String... hashKeys) {
        return redisTemplate.opsForHash().delete(key, hashKeys);
    }

    /**
     * 给指定 hash 的 hashkey 做增减操作
     * @param key
     * @param hashKey
     * @param number
     * @return
     */
    public Long increment(String key, String hashKey, long number) {
        return redisTemplate.opsForHash().increment(key, hashKey, number);
    }

    /**
     * 给指定 hash 的 hashkey 做增减操作
     * @param key
     * @param hashKey
     * @param number
     * @return
     */
    public Double increment(String key, String hashKey, Double number) {
        return redisTemplate.opsForHash().increment(key, hashKey, number);
    }

    /**
     * 获取 key下的所有hashkey字段
     * @param key
     * @return
     */
    public Set<Object> hashKeys(String key) {
        return redisTemplate.opsForHash().keys(key);
    }

    /**
     * 获取指定hash下面的键值对数量
     *
     * @param key
     * @return
     */
    public Long hashSize(String key) {
        return redisTemplate.opsForHash().size(key);
    }


    /**
     * 在变量左边添加元素值
     *
     * @param key
     * @param value
     * @return
     */
    public void leftPush(String key, Object value) {
        redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 获取集合指定位置的值。
     *
     * @param key
     * @param index
     * @return
     */
    public Object index(String key, long index) {
        return redisTemplate.opsForList().index("list", 1);
    }

    /**
     * 获取指定区间的值。
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public List<Object> range(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    /**
     * 如果pivot值存在于集合内,把一个value值放到第一个出现的pivot值的前面
     *
     * @param key
     * @param pivot
     * @param value
     * @return
     */
    public void leftPush(String key, String pivot, String value) {
        redisTemplate.opsForList().leftPush(key, pivot, value);
    }

    /**
     * 向左边批量添加参数元素。
     *
     * @param key
     * @param values
     * @return
     */
    public void leftPushAll(String key, String... values) {
        redisTemplate.opsForList().leftPushAll(key, values);
    }

    /**
     * 向集合最右边添加元素。
     *
     * @param key
     * @param value
     * @return
     */
    public void leftPushAll(String key, String value) {
        redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 向左边批量添加参数元素。
     *
     * @param key
     * @param values
     * @return
     */
    public void rightPushAll(String key, String... values) {
        redisTemplate.opsForList().rightPushAll(key, values);
    }

    /**
     * 向已存在的集合中添加元素。
     *
     * @param key
     * @param value
     * @return
     */
    public void rightPushIfPresent(String key, Object value) {
        redisTemplate.opsForList().rightPushIfPresent(key, value);
    }

    /**
     * 向已存在的集合中添加元素。
     *
     * @param key
     * @return
     */
    public long listLength(String key) {
        return redisTemplate.opsForList().size(key);
    }

    /**
     * 移除集合中的左边第一个元素。
     *
     * @param key
     * @return
     */
    public void leftPop(String key) {
        redisTemplate.opsForList().leftPop(key);
    }

    /**
     * 移除集合中左边的元素在等待的时间里,如果超过等待的时间仍没有元素则退出。
     *
     * @param key
     * @return
     */
    public void leftPop(String key, long timeout, TimeUnit unit) {
        redisTemplate.opsForList().leftPop(key, timeout, unit);
    }

    /**
     * 移除集合中右边的元素。
     *
     * @param key
     * @return
     */
    public void rightPop(String key) {
        redisTemplate.opsForList().rightPop(key);
    }

    /**
     * 在等待的时间里移除集合中右边的元素,如果超过等待的时间仍没有元素则退出。
     *
     * @param key
     * @return
     */
    public void rightPop(String key, long timeout, TimeUnit unit) {
        redisTemplate.opsForList().rightPop(key, timeout, unit);
    }
}

Jedis和Lettuce

jedis和Lettuce都是Redis的客户端,它们都可以连接Redis服务器,但是在SpringBoot2.0之后默认都是使用的Lettuce这个客户端连接Redis服务器。因为当使用Jedis客户端连接Redis服务器的时候,每个线程都要拿自己创建的Jedis实例去连接Redis客户端,当有很多个线程的时候,不仅开销大需要反复的创建关闭一个Jedis连接,而且也是线程不安全的,一个线程通过Jedis实例更改Redis服务器中的数据之后会影响另一个线程。

但是如果使用Lettuce这个客户端连接Redis服务器的时候,就不会出现上面的情况,Lettuce底层使用的是Netty,当有多个线程都需要连接Redis服务器的时候,可以保证只创建一个Lettuce连接,使所有的线程共享这一个Lettuce连接,这样可以减少创建关闭一个Lettuce连接时候的开销;而且这种方式也是线程安全的,不会出现一个线程通过Lettuce更改Redis服务器中的数据之后而影响另一个线程的情况

总结

通过这篇文章可以了解到什么呢?

1、springboot集成redis时的依赖引入、连接参数是如何配置的?

2、如何选择redisTemplate中key-value序列化方式;

3、redis的五种数据类型常用操作对应的java封装;

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/399245.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

51红外循迹智能车——红外循迹模块设计

目录 赛道环境 红外传感器的特征 TCRT5000传感器 LM339单限电压比较器 LM339简介 ​编辑 单限电压比较器仿真 红外循迹模块的设计 红外循迹模块原理图 红外循迹模块原理图讲解 赛道环境 上图为赛道示意图&#xff0c;两端为黑色&#xff0c;中间为白色 红外传感器的…

小孩用什么样的台灯比较好?2023眼科医生青睐的儿童台灯推荐

小孩子属于眼睛比较脆弱的人群&#xff0c;所以选购护眼台灯时&#xff0c;选光线温和的比较好&#xff0c;而且调光、显色效果、色温、防蓝光等方面也要出色&#xff0c;否则容易导致孩子近视。 1、调光。台灯首先是照度高&#xff0c;国AA级&#xff0b;大功率发光&#xff0…

Yolov5目标检测算法解析:模型结构

Yolov5系列是Yolo家族新一代的模型&#xff0c;相比于之前的版本Yolov3和Yolov4&#xff0c;相同的是&#xff0c;它依然采用锚框&#xff08;anchor&#xff09;对目标的尺寸进行回归的思想&#xff0c;保持大中小多种尺度特征输出&#xff0c;所不同的是&#xff0c;Yolov5系…

SQL 进阶刷题笔记

SQL 进阶刷题笔记 一、MySQL 进阶 这里主要是 MySQL 刷题相关笔记&#xff0c;方便后面温习和查阅&#xff0c;希望可以帮到大家&#xff01;&#xff01;&#xff01; 题1 请计算每张SQL类别试卷发布后&#xff0c;当天5级以上的用户作答的人数uv和平均分avg_score&#xff0…

TCP和UDP对比

TCP和UDP对比 UDP(用户数据报协议) 无连接(指的是逻辑连接关系,不是物理上的连接) 支持单播、多播以及广播,也就是UDP支持一对一、一对多、一对全 面向应用报文的,对应用层交付的报文直接打包 无连接不可靠的传输服务(适用于IP电话、视频会议等实时应用),不使用流量控制和…

易优cms range 范围判断标签

range 范围判断标签 【基础用法】 标签&#xff1a;range 描述&#xff1a;范围判断标签包括in notin between notbetween四个标签&#xff0c;都用于判断变量是否中某个范围。 用法&#xff1a; {eyou:range name$eyou.field.typeid value1,2,3,4 typein} 输出内容 {/e…

HTTPS加密解析

日升时奋斗&#xff0c;日落时自省 目录 1、加密解释 2、对称加密 3、非对称加密 4、证书 HTTPS&#xff08;HyperText Transfer Protocol over Secure Socket Layer&#xff09;也是一个应用层协议&#xff0c;是在HTTP协议的基础上引入了一个加密层 HTTP协议内容都是按…

卷积神经网络(CNN)基础知识

文章目录CNN的组成层卷积层卷积运算卷积的变种分组卷积转置卷积空洞卷积可变形卷积卷积层的输出尺寸和参数量CNN的组成层 在卷积神经⽹络中&#xff0c;⼀般包含5种类型的⽹络层次结构&#xff1a;输入层、卷积层、激活层、池化层和输出层。 输入层&#xff08;input layer&a…

Android Audio HAL 服务

在 Android 系统中&#xff0c;Audio HAL 服务用于管理对音频硬件的访问&#xff0c;AudioFlinger 通过 Audio HAL 服务访问音频硬件。这里以 Android Automotive (AAOS) 版模拟器为例&#xff0c;来看 Audio HAL 服务的设计、实现和访问&#xff0c;代码分析基于 android-12.1…

【JavaSE】数组的定义和使用(下)

数组的定义和使用&#xff08;下&#xff09;4. 数组练习4.1 模拟实现toString4.2 数组拷贝4.3 比较两个数组是否相同4.4 填充数组4.3 求数组中元素的平均值4.4 查找数组中指定元素&#xff08;顺序查找&#xff09;4.5 查找数组中指定元素&#xff08;二分查找&#xff09;4.6…

力扣-树节点

大家好&#xff0c;我是空空star&#xff0c;本篇带大家了解一道中等的力扣sql练习题。 文章目录前言一、题目&#xff1a;608. 树节点二、解题1.正确示范①提交SQL运行结果2.正确示范②提交SQL运行结果3.正确示范③提交SQL运行结果4.正确示范④提交SQL运行结果5.其他总结前言 …

基于nvidia xavier智能车辆自动驾驶域控制器设计与实现-百度Apollo架构(二)

智能车辆操作系统 智能车辆操作系统是智能车辆系统的重要组成部分。现代汽车软件组件通常首 先由不同的供应商开发&#xff0c;然后在有限的资源下由制造商进行集成[42]。智能车辆操作 系统需要采用模块化和分层化设计思想来兼容传感器、分布式通信和自动驾驶通用 框架等模块&a…

适当的合同管理有什么积极影响?若管理不善有什么后果?

合同管理将决定合同是主要的风险因素还是业务增长的工具。事实是&#xff0c;如何处理合同会影响企业的底线。据研究显示&#xff0c;糟糕的合同管理使企业每年损失超过9%的收入。实施合同管理最佳实践将帮助企业提高合同签约效率。 什么是合同管理&#xff1f; 合同管理是对合…

玩转CodeQLpy之用友GRP-U8漏洞挖掘

0x01 前言CodeQLpy是作者使用python3实现的基于CodeQL的java代码审计工具&#xff0c;github地址https://github.com/webraybtl/CodeQLpy。通过CodeQLpy可以辅助代码审计人员快速定位代码中的问题&#xff0c;目前支持对SprintBoot的jar包&#xff0c;SpringMVC的war包&#xf…

初探git——版本控制工具git实用教程

文章目录前言基本配置基本操作1.初始化2.查看修改状态(status)3.添加工作区到暂存区4.提交暂存区到本地仓库5.查看提交日志6.版本回退7.添加文件至忽略列表分支1.基本命令2.分支冲突git远程仓库1.创建远程仓库2.配置公钥3.操作远程仓库idea配置git前言 Git是目前世界上最先进的…

九龙证券|业绩增长态势向好 沪市数字产业公司活力迸发

3月8日晚间&#xff0c;中国联通发表年报并举行成绩说明会&#xff0c;年报显现&#xff0c;公司2022年完成经营收入&#xff08;兼并报表&#xff09;3549.44亿元&#xff0c;同比增加8.30%&#xff1b;归属于母公司股东净利润72.99亿元&#xff0c;同比增加15.80%&#xff0c…

【计算机视觉】Zero-shot, One-shot和Few-shot的理解

机器学习任务按照对 样本量 的需求可以分为&#xff1a;传统监督式学习、Few-shot Learning、One-shot Learning、Zero-shot Learning。 文章目录一、传统监督式学习二、Zero-shot learning &#xff08;零样本学习&#xff0c;简称ZSL&#xff09;三、Few-shot learning3.1 什…

【SpringMVC】 一文掌握 》》》 @RequestMapping注解

个人简介&#xff1a;Java领域新星创作者&#xff1b;阿里云技术博主、星级博主、专家博主&#xff1b;正在Java学习的路上摸爬滚打&#xff0c;记录学习的过程~ 个人主页&#xff1a;.29.的博客 学习社区&#xff1a;进去逛一逛~ RequestMapping注解一、SpringMVC环境准备1.相…

阿里云服务器使用教程:CentOS 7 安装JDK及Tomcat(以jdk1.8、tomcat9.0.37为例)

目录 1、下载JDK及Tomcat的安装包并上传至服务器 2、安装JDK 3、安装Tomcat 4、Tomcat启动后无法打开Tomcat首页的原因 1、下载JDK及Tomcat的安装包并上传至服务器 &#xff08;1&#xff09;下载JDK1.8版本压缩包 官网&#xff1a;Java Downloads | Oracle &#xff08…

C++回顾(十七)—— 类型转换

17.1 static_cast(expr) static_cast强制类型转换 用于基本类型间的转换&#xff0c;但不能用于基本类型指针之间的转换 用于有继承关系类对象之间的转换和类指针之间的转换 static_cast是在编译期间转换的&#xff0c;无法在运行时检测类型 所以类类型之间的转换有可能存在风…