Redis框架与SpringBoot的整合及详细学习汇总

迈不过友情╰ 2024-03-23 16:28 12阅读 0赞

**目录**

springBoot整合Redis

Redis 的优势

Redis安装

Redis数据类型

springboot操作Redis

springboot 配置redis

RedisTemplate及其相关方法

springBoot实现上传下载

RedisTemplate及其相关方法

springBoot实现上传下载

springBoot CORS（跨域资源共享）

springBoot聚合工程

--------------------

### springBoot整合Redis ###

Redis 是完全开源的，遵守 BSD 协议，是一个高性能的 key-value 数据库.

**Redis 与其他 key - value 缓存产品有以下三个特点：**

*  Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
 *  Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
 *  Redis支持数据的备份，即master-slave模式的数据备份。

#### **Redis 的优势** ####

*  性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s
 *  丰富的数据类型 – Redis支持二进制案例的 String, List, Hash, Set 及 zset数据类型操作。
 *  原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。
 *  丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性
 *  Redis 是单线程的，6.0版本开始支持开启多线程。

#### **Redis安装** ####

**下载地址：**[Releases · tporadowski/redis · GitHub][Releases _ tporadowski_redis _ GitHub]。

![dfa1b6c7882c46929533c48754c8f03a.png][]

解压下载后的压缩文件，解压后文件列表如下：

![e4ee4286ae3f44478c5e3f6897e6bdf9.png][]

![b64dc2d3e90c45059c31d5c5725d9c74.png][]

使用cmd窗口打开Redis

![bf244834246a4c0f9086dab923256b18.png][]

**安装Redis数据库客户端**

![09271d5b0b9543b1a761d4bed538eda6.png][]

**库相关指令：**

flushdb  清空当前库
    
    flushall  清空所有库
    
    select   1    切换库

**key的相关指令**

<table> 
 <thead> 
  <tr> 
   <th>指令</th> 
   <th>作用</th> 
   <th>语法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>del</strong></td> 
   <td>删除一个或多个key</td> 
   <td>del keyname</td> 
  </tr> 
  <tr> 
   <td><strong>exists</strong></td> 
   <td>判断一个或多个key是否存在，多个key时有一个存在则就会返回1</td> 
   <td>exists keyname</td> 
  </tr> 
  <tr> 
   <td><strong>expire</strong></td> 
   <td>设置key的生存时间 单位 ：秒</td> 
   <td>expire keyname seconds</td> 
  </tr> 
  <tr> 
   <td><strong>key</strong>s</td> 
   <td>查询所有匹配模式的key ？匹配一个字符 *匹配0-n个字符 [] 满足其中的一个</td> 
   <td>key * key h?llo</td> 
  </tr> 
  <tr> 
   <td><strong>move</strong></td> 
   <td>将key移动到指定的库中</td> 
   <td>move keyname db</td> 
  </tr> 
  <tr> 
   <td><strong>pexpire</strong></td> 
   <td>设置key的生存时间 单位 ：毫秒 设置成功返回1 否则返回0</td> 
   <td>pexpire keyname milliseconds</td> 
  </tr> 
  <tr> 
   <td><strong>ttl</strong></td> 
   <td>以秒为单位返回key的剩余生存时间，返回-1表示永久存储，-2表示key不存在</td> 
   <td>ttl keyname</td> 
  </tr> 
  <tr> 
   <td><strong>randomkey</strong></td> 
   <td>从当前数据库中随机的返回一个key</td> 
   <td>randomkey</td> 
  </tr> 
  <tr> 
   <td><strong>rename</strong></td> 
   <td>重命名key，成功返回ok，否则返回错误信息。</td> 
   <td>rename key newkey</td> 
  </tr> 
  <tr> 
   <td><strong>type</strong></td> 
   <td>返回key所存储的值的类型</td> 
   <td>type keyname</td> 
  </tr> 
 </tbody> 
</table>

#### Redis数据类型 ####

1.String（字符串）

*  string 是 redis 最基本的类型，你可以理解成与 Memcached 一模一样的类型，一个 key 对应一个 value。
 *  string 类型是二进制安全的。意思是 redis 的 string 可以包含任何数据。比如jpg图片或者序列化的对象。
 *  string 类型是 Redis 最基本的数据类型，string 类型的值最大能存储 512MB。

操作指令：

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>SET</strong></td> 
   <td>设置指定 key 的值</td> 
  </tr> 
  <tr> 
   <td><strong>GET</strong></td> 
   <td>获取指定 key 的值。</td> 
  </tr> 
  <tr> 
   <td><strong>GETRANGE</strong></td> 
   <td>返回 key 中字符串值的子字符</td> 
  </tr> 
  <tr> 
   <td><strong>GETSET</strong></td> 
   <td>将给定 key 的值设为 value ，并返回 key 的旧值(old value)。</td> 
  </tr> 
  <tr> 
   <td><strong>SETEX</strong></td> 
   <td>将值 value 关联到 key ，并将 key 的过期时间设为 seconds (以秒为单位)。</td> 
  </tr> 
  <tr> 
   <td><strong>SETNX</strong></td> 
   <td>只有在 key 不存在时设置 key 的值</td> 
  </tr> 
  <tr> 
   <td><strong>STRLEN</strong></td> 
   <td>返回 key 所储存的字符串值的长度。</td> 
  </tr> 
  <tr> 
   <td><strong>MSET</strong></td> 
   <td>同时设置一个或多个 key-value 对。</td> 
  </tr> 
  <tr> 
   <td><strong>MSETNX</strong></td> 
   <td>同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在</td> 
  </tr> 
  <tr> 
   <td><strong>INCR</strong></td> 
   <td>将 key 中储存的数字值增一</td> 
  </tr> 
  <tr> 
   <td><strong>INCRBY</strong></td> 
   <td>将 key 所储存的值加上给定的增量值（increment）</td> 
  </tr> 
  <tr> 
   <td><strong>INCRBYFLOAT</strong></td> 
   <td>将 key 所储存的值加上给定的浮点增量值（increment）</td> 
  </tr> 
  <tr> 
   <td><strong>DECR</strong></td> 
   <td>将 key 中储存的数字值减一。</td> 
  </tr> 
  <tr> 
   <td><strong>DECRBY</strong></td> 
   <td>key 所储存的值减去给定的减量值（decrement）</td> 
  </tr> 
  <tr> 
   <td><strong>APPEND</strong></td> 
   <td>如果 key 已经存在并且是一个字符串， APPEND 命令将指定的 value 追加到该 key 原来值（value）的末尾</td> 
  </tr> 
 </tbody> 
</table>

2.Hash（哈希）

*  Redis hash 是一个键值(key=>value)对集合。
 *  Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。

操作指令：

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>hset</td> 
   <td>设置一个key/value对</td> 
  </tr> 
  <tr> 
   <td>hget</td> 
   <td>获取key对应的value</td> 
  </tr> 
  <tr> 
   <td>hgetall</td> 
   <td>获取所有的key/value对</td> 
  </tr> 
  <tr> 
   <td>hdel</td> 
   <td>删除某个key/value对</td> 
  </tr> 
  <tr> 
   <td>hexists</td> 
   <td>判断一个key是否存在</td> 
  </tr> 
  <tr> 
   <td>hkeys</td> 
   <td>获取所有的key</td> 
  </tr> 
  <tr> 
   <td>hvals</td> 
   <td>获取所有的value</td> 
  </tr> 
  <tr> 
   <td>hmset</td> 
   <td>设置多个key/value</td> 
  </tr> 
  <tr> 
   <td>hmget</td> 
   <td>获取多个key的value</td> 
  </tr> 
  <tr> 
   <td>hsetnx</td> 
   <td>设置一个不存在的key的值</td> 
  </tr> 
  <tr> 
   <td>hincrby</td> 
   <td>为value的值进行加法运算</td> 
  </tr> 
  <tr> 
   <td>hincrbyfloat</td> 
   <td>为value的值进行加浮点类型值运算</td> 
  </tr> 
 </tbody> 
</table>

3.List（列表）

*  Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。

操作指令

<table> 
 <thead> 
  <tr> 
   <th><strong>命令</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>LINDEX</strong></td> 
   <td>通过索引获取列表中的元素 lindex lists 0</td> 
  </tr> 
  <tr> 
   <td><strong>LINSERT key BEFORE|AFTER</strong></td> 
   <td>在列表的元素前或者后插入元素</td> 
  </tr> 
  <tr> 
   <td><strong>LLEN</strong></td> 
   <td>获取列表长度</td> 
  </tr> 
  <tr> 
   <td><strong>LPOP</strong></td> 
   <td>移出并获取列表的第一个元素</td> 
  </tr> 
  <tr> 
   <td><strong>LPUSH</strong></td> 
   <td>将一个或多个值插入到列表头部</td> 
  </tr> 
  <tr> 
   <td><strong>LPUSHX</strong></td> 
   <td>将一个值插入到<strong>已存在</strong>的列表头部</td> 
  </tr> 
  <tr> 
   <td><strong>LRANGE</strong></td> 
   <td>获取列表指定范围内的元素 （0 -1）</td> 
  </tr> 
  <tr> 
   <td><strong>LREM</strong></td> 
   <td>移除列表重复元素</td> 
  </tr> 
  <tr> 
   <td><strong>LSET</strong></td> 
   <td>通过索引设置列表元素的值 ，但是索引必须存在，实质是根据索引修改值</td> 
  </tr> 
  <tr> 
   <td><strong>LTRIM</strong></td> 
   <td>对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除</td> 
  </tr> 
  <tr> 
   <td><strong>RPOP</strong></td> 
   <td>移除列表的最后一个元素，返回值为移除的元素</td> 
  </tr> 
  <tr> 
   <td><strong>RPOPLPUSH</strong></td> 
   <td>移除列表的最后一个元素，并将该元素添加到另一个列表并返回</td> 
  </tr> 
  <tr> 
   <td><strong>RPUSH</strong></td> 
   <td>在列表中添加一个或多个值</td> 
  </tr> 
  <tr> 
   <td><strong>RPUSHX</strong></td> 
   <td>为已存在的列表添加值</td> 
  </tr> 
 </tbody> 
</table>

4.Set（集合）

*  Redis 的 Set 是 string 类型的无序集合。
 *  集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。

操作指令：

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>sadd</td> 
   <td>为集合添加元素</td> 
  </tr> 
  <tr> 
   <td>smembers</td> 
   <td>显示集合中所有元素 （无序）</td> 
  </tr> 
  <tr> 
   <td>scard</td> 
   <td>返回集合中元素的个数</td> 
  </tr> 
  <tr> 
   <td>spop</td> 
   <td>随机返回一个元素，并将这个元素删除</td> 
  </tr> 
  <tr> 
   <td>smove</td> 
   <td>从一个集合向令一个集合中转移元素</td> 
  </tr> 
  <tr> 
   <td>srem</td> 
   <td>从集合中删除一个元素</td> 
  </tr> 
  <tr> 
   <td>sismember</td> 
   <td>判断集合中是否包含这个元素</td> 
  </tr> 
  <tr> 
   <td>srandmember</td> 
   <td>随机返回一个元素</td> 
  </tr> 
  <tr> 
   <td>sinter</td> 
   <td>求交集</td> 
  </tr> 
  <tr> 
   <td>sunion</td> 
   <td>求和集</td> 
  </tr> 
 </tbody> 
</table>

5.zset(sorted set：有序集合)

*  Redis zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。
 *  不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
 *  zset的成员是唯一的,但分数(score)却可以重复。

操作指令：

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>zadd</td> 
   <td>添加一个有序集合元素</td> 
  </tr> 
  <tr> 
   <td>zcard</td> 
   <td>返回集合中元素的个数</td> 
  </tr> 
  <tr> 
   <td>zrange升序 zrevrange降序</td> 
   <td>返回一个范围内的元素</td> 
  </tr> 
  <tr> 
   <td>zrangebyscore</td> 
   <td>按照分数查找一个范围内的元素</td> 
  </tr> 
  <tr> 
   <td>zrank</td> 
   <td>返回排名</td> 
  </tr> 
  <tr> 
   <td>zrevrank</td> 
   <td>倒叙排名</td> 
  </tr> 
  <tr> 
   <td>zscore</td> 
   <td>显示某个元素的分数</td> 
  </tr> 
  <tr> 
   <td>zrem</td> 
   <td>移除某个元素</td> 
  </tr> 
  <tr> 
   <td>zincrby</td> 
   <td>给某个特定元素加分</td> 
  </tr> 
 </tbody> 
</table>

#### **springboot操作Redis** ####

spring boot data redis中提供了RedisTemplate和StringRedisTemplate，其中StringRedisTemplate是Redistemplate的子类，两个方法基本一致，不同之处主要体现在操作的数据类型不同，RedisTemplate中的两个泛型都是Object，意味着存储的key和value都可以是一个对象，而StringRedisTemplate的两个泛型都是String，意味着StringRedisTemplate的key和value都只能是字符串。

引入依赖

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

#### **springboot 配置redis** ####

![8c40666907494a2ba676e025c6b24135.png][]

#### RedisTemplate及其相关方法 ####

1.RedisTemplate

Spring封装了RedisTemplate对象来进行对Redis的各种操作，它支持所有的Redis原生的api。RedisTemplate位于spring-data-redis包下。RedisTemplate提供了redis各种操作、异常处理及序列化，支持发布订阅。

2.Redis5种数据结构操作

*  redisTemplate.opsForValue(); //操作字符串
 *  redisTemplate.opsForHash(); //操作hash
 *  redisTemplate.opsForList(); //操作list
 *  redisTemplate.opsForSet(); //操作set
 *  redisTemplate.opsForZSet(); //操作有序set

或者：

*  redistempalate.boundValueOps
 *  redistempalate.boundSetOps
 *  redistempalate.boundListOps
 *  redistempalate.boundHashOps
 *  redistempalate.boundZSetOps

> opsForXXX和boundXXXOps的区别：XXX为value的类型，前者获取一个operator，但是没有指定操作的对象（key），可以在一个连接（事务）内操作多个key以及对应的value；后者获取了一个指定操作对象（key）的operator，在一个连接（事务）内只能操作这个key对应的value。

**SpringBootTest 实现Redis数据库增删改查**

/**
     * 使用RedisTemplate 操作Redis数据的不同数据类型
     */
    @SpringBootTest
    public class Springbootday03ApplicationTests {
        @Autowired
        private RedisTemplate<String, String> redisTemplate;
    
        /**
         * String 类型数据操作
         */
        @Test
        public void operateString() {
    
            //添加值
            redisTemplate.opsForValue().set("str", "strValue1");
    
            //添加值  判定是否存在 存在则不添加
            Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("str", "strAbsent");
            System.out.println("str设置成功:" + aBoolean);
    
            //获取值
            String str = redisTemplate.opsForValue().get("str");
            System.out.println("str = " + str);
    
            //更新值
            redisTemplate.opsForValue().set("str", "strValue2");
            str = redisTemplate.opsForValue().get("str");
            System.out.println("newStr = " + str);
    
            //删除值
            Boolean b = redisTemplate.delete("str");
            System.out.println("str删除成功：" + b);
    
        }
    
        /**
         * 操作string类型数据  设置过期时间
         */
        @Test
        public void operateString2() {
            redisTemplate.opsForValue().set("str", "strTimeout", 10, TimeUnit.SECONDS);
            //判定值是否存在 不存在则设置值 同时设置过期时间
            Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("str2", "strTimeoutAbsent", 20, TimeUnit.SECONDS);
            System.out.println("setIfAbsent:" + aBoolean);
        }
    
        /**
         * 操作hash类型数据
         */
        @Test
        public void operateHash() {
            //添加hash类型数据  key - value
            redisTemplate.opsForHash().put("hash", "username", "admin");
            //修改hash类型数据
            redisTemplate.opsForHash().put("hash", "username", "tom");
            redisTemplate.opsForHash().put("hash", "password", "123456");
    
            //添加hash类型数据  key - map
            HashMap<String, String> map = new HashMap<>();
            map.put("driverName", "com.mysql.jdbc.Driver");
            map.put("url", "jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC");
            redisTemplate.opsForHash().putAll("hash", map);
    
            //获取hash类型数据  entries
            Map<Object, Object> hash = redisTemplate.opsForHash().entries("hash");
            hash.forEach((key, value) -> {
                System.out.println(key + "::" + value);
            });
    
            //获取所有的key
            Set<Object> keys = redisTemplate.opsForHash().keys("hash");
            for (Object key : keys) {
                System.out.println("key:" + key);
            }
            //获取所有value
            List<Object> values = redisTemplate.opsForHash().values("hash");
            values.forEach(value -> System.out.println("value:" + value));
    
            //删除hash类型数据  删除一个  返回删除的个数
            Long delete = redisTemplate.opsForHash().delete("hash", "username");
            System.out.println("delete = " + delete);
    
            //删除hash类型数据  删除多个  返回删除的个数
            delete = redisTemplate.opsForHash().delete("hash", "username", "password", "driverName");
            System.out.println("delete = " + delete);
    
            //删除hash类型数据  删除所有
            Boolean delHash = redisTemplate.delete("hash");
            System.out.println("delHah:" + delHash);
    
        }
    
        /**
         * 操作List类型  有序 可重复
         */
        @Test
        public void operateList() {
    
            //左压栈
            // redisTemplate.opsForList().leftPush("list", "listValue1");
            // redisTemplate.opsForList().leftPush("list", "listValue1");
            // redisTemplate.opsForList().leftPush("list", "listValue2");
            // redisTemplate.opsForList().leftPush("list", "listValue3");
    
            //右压栈
            redisTemplate.opsForList().rightPush("list", "listValue0");
            redisTemplate.opsForList().rightPush("list", "listValue2");
            redisTemplate.opsForList().rightPush("list", "listValue0");
    
            //左出栈
            String list1 = redisTemplate.opsForList().leftPop("list");
            System.out.println("leftPop list1 = " + list1);
            //右出栈
            String list2 = redisTemplate.opsForList().rightPop("list");
            System.out.println("rightPop list2 = " + list2);
    
            //获取所有数据
            List<String> lists = redisTemplate.opsForList().range("list", 0, 		        redisTemplate.opsForList().size("list") - 1);
            lists.forEach(list -> System.out.println(list));
    
    
            //设置指定位置的数据
            redisTemplate.opsForList().set("list", 0, "listValue0");
            /**
             * 从存储在键中的列表中删除等于值的元素的第一个计数事件。
             * count> 0：删除等于从左到右移动的值的第一个元素；
             * count< 0：删除等于从右到左移动的值的第一个元素；
             * count = 0：删除等于value的所有元素。
             */
            Long remove = redisTemplate.opsForList().remove("list", -1, "listValue0");
            System.out.println("remove:" + remove);
    
            //删除指定key的list数据
            Boolean list = redisTemplate.delete("list");
            System.out.println("list集合删除成功:" + list);
        }
    
        /**
         * 操作Set类型  无序 不可重复
         */
        @Test
        public void operateSet() {
    
            //设置set值
            redisTemplate.opsForSet().add("set", "setValue0");
            redisTemplate.opsForSet().add("set", "setValue0");
            redisTemplate.opsForSet().add("set", "setValue1");
    
            //判定是否包含
            Boolean member = redisTemplate.opsForSet().isMember("set", "setValue0");
            System.out.println("isMember:" + member);
    
            //删除set中的值
            Long remove = redisTemplate.opsForSet().remove("set", "setValue0");
            System.out.println("remove = " + remove);
    
            //获取set类型值
            Set<String> set = redisTemplate.opsForSet().members("set");
            set.forEach(str -> {
                System.out.println("str = " + str);
            });
        }
    
        /**
         * 操作 ZSet  有序 不可重复
         */
        @Test
        public void operateZSet() {
            //存储值
            Boolean add = redisTemplate.opsForZSet().add("zset", "zsetValue0", 10);
            System.out.println("add = " + add);
            System.out.println("add = " + add);
            add = redisTemplate.opsForZSet().add("zset", "zsetValue2", 2);
            System.out.println("add = " + add);
            //获取值
            // Boolean zset = redisTemplate.delete("zset");
            // System.out.println("delete zset = " + zset);
        }
    }

**Redis工具类的封装**

/**
     * Redis 工具类
     * @author mosin
     * date 2021/11/30
     * @version 1.0
     */
    @Component
    public final class RedisUtil {
    
        private RedisUtil(){};
        @Autowired
        private RedisTemplate<String,String> redisTemplate;
    
        //设置值
        public void  setValue(String key,String value){
            redisTemplate.opsForValue().set(key, value);
        }
        // 设置值 同时设置有效时间
        public void setValue(String key, String value, Long timeOut, TimeUnit timeUnit){
            redisTemplate.opsForValue().setIfAbsent(key, value, timeOut, timeUnit);
        }
    
        //设置值 没有则设置 有则不设置
        public void  setNx(String key,String value){
            redisTemplate.opsForValue().setIfAbsent(key, value);
        }
    
        //设置值 没有则设置 同时设置有效时间 有则不设置
        public void  setNx(String key,String value,long timeOut,TimeUnit timeUnit){
            redisTemplate.opsForValue().setIfAbsent(key, value,timeOut,timeUnit);
        }
    
        //删除值
        public boolean del(String key){
            return redisTemplate.delete(key);
        }
        
         //获取值
        public String getValue(String key){
            return  redisTemplate.opsForValue().get(key);
        }
    }

**业务实践**（redis存储token，实现非法请求拦截）

1.编写拦截器 ![8d43a8be9a6548c7abb313146ae7d0fb.png][]

2.配置拦截器 ![387a9423664d4d84a6edd633715c1d61.png][]

3.编写统一返回数据格式类 ![62c256fce3a74fed8f24df801b79359d.png][]

4.编写控制器

@Controller
    @RequestMapping("/user")
    public class UserController {
        @Autowired
        private UserService userService;
        @Autowired
        private RedisUtil redisUtil;
        @ResponseBody
        @RequestMapping("/login")
        public Object login(User user) throws JsonProcessingException {
            User usr = User.builder().id(1).name("admin").password("123456").build();
            //获取token  放入redis
            String token = UUID.randomUUID().toString().replace("-", "");
            //将user 转为json格式放入 redis
            ObjectMapper objectMapper = new ObjectMapper();
            String s1 = objectMapper.writeValueAsString(usr);
            //将 token 和用户信息存入 redis
            redisUtil.setValue(token, s1, 2L, TimeUnit.MINUTES);
            //将token 存入map集合返回
            HashMap<String, String> map = new HashMap<>();
            map.put("token", token);
            return map;
        }
    
        @ResponseBody
        @RequestMapping("/register")
        public Object register(User user){
            HashMap<String, String> map = new HashMap<>();
            map.put("msg", "ok");
            return map;
        }
    
        @ResponseBody
        @RequestMapping("/add")
        public Object add(User user){
            HashMap<String, String> map = new HashMap<>();
            map.put("msg", "ok");
            return map;
        }
    }

5.编写业务类和Mapper接口

6.使用postman接口测试工具测试接口

### springBoot实现上传下载 ###

1.编写控制器

/**
     * 文件上传下载控制类
     * @author mosin
     * date 2021/12/1
     * @version 1.0
     */
    @Controller
    @RequestMapping("/file")
    public class FileController {
    
        @RequestMapping("/toupload")
        public String toUpload(){ //跳转上传页
            return "upload";
        }
    
        @RequestMapping("/upload")
        public Object fileUpload(MultipartFile file, Model model){
            if( !file.isEmpty()){
                String originalFilename = file.getOriginalFilename();
                String uuid = UUID.randomUUID().toString().replace("-", "");
                String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
                String fileName = uuid+suffix;
                File f = new File("D:\\upload",fileName);
                try {
                    file.transferTo(f);
                    model.addAttribute("downloadName", fileName);
                    model.addAttribute("originalFilename", originalFilename);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return "download";
        }
    
        @RequestMapping("/download")
        @ResponseBody
        public Object fileDownLoad(String fileName, HttpServletResponse response){
            HashMap<String, String> map = new HashMap<>();
            try {
                FileInputStream fis= new FileInputStream(new File("D:\\upload", fileName));
                //设置以附件形式输出
               response.setHeader("Content-disposition", "attachment; filename="+fileName);
                //获取输出流
                ServletOutputStream outputStream = response.getOutputStream();
                //org.springframework.util.FileCopyUtils  工具类
                FileCopyUtils.copy(fis, outputStream);
                map.put("msg", "上传成功!");
            } catch (Exception e) {
                e.printStackTrace();
                map.put("msg", "上传失败!");
            }
            return map ;
        }
    }

2.编写上传页面 ![c10238720b6e4c828680d2b6a5b4e210.png][]

3.编写下载页面 ![29336ae73459494e9665be78fd672a74.png][]

**设置上传文件大小限制** ![ee8fbf12067d46e6af3becb2aff81b33.png][]

#### RedisTemplate及其相关方法 ####

1.RedisTemplate

2.Redis5种数据结构操作

或者：

*  redistempalate.boundValueOps
 *  redistempalate.boundSetOps
 *  redistempalate.boundListOps
 *  redistempalate.boundHashOps
 *  redistempalate.boundZSetOps

**SpringBootTest 实现Redis数据库增删改查**

**Redis工具类的封装**

**业务实践**（redis存储token，实现非法请求拦截）

1.编写拦截器

@Component
    public class AdminInterceptor implements HandlerInterceptor {
        @Autowired
        private RedisUtil redisUtil;
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            System.out.println("拦截器以拦截请求");
            //从请求头中获取token  验证用户是否登录
            String token = request.getHeader("token");
            System.out.println(token);
            String tokenValue = redisUtil.getValue(token);
            System.out.println("tokenValue = " + tokenValue);
            if(tokenValue!=null){ //用户已登录 放行请求
                return  true;
            }else{//重定向到登录页面
                response.sendRedirect(request.getContextPath()+"/login.jsp");
                return false;
            }
        }
    }

2.配置拦截器 ![66740ae3b6c541e1a39cfbad47817dd8.png][]

3.编写统一返回数据格式类 ![f7d5cef62eda4764b43358f763391e03.png][]

4.编写控制器

5.编写业务类和Mapper接口

6.使用postman接口测试工具测试接口

### springBoot实现上传下载 ###

1.编写控制器

2.编写上传页面

![53b423454a1f4f9e8fe0d4bcbaad5eee.png][]

3.编写下载页面 ![cb12960e847b408e8302b76fc72f91e9.png][]

**设置上传文件大小限制**

![16d1534afab241c59a1ac38c81edea73.png][]

### springBoot CORS（跨域资源共享） ###

CORS是一个W3C标准，全称是"跨域资源共享"（Cross-origin resource sharing）。它允许浏览器向跨源服务器，发出[XMLHttpRequest][]请求，从而克服了AJAX只能同源使用的限制。

**什么是同源策略？** 同源策略是浏览器的一个安全功能，不同源的客户端脚本在没有明确授权的情况下，不能读写对方资源。所以a.com下的js脚本采用ajax读取b.com里面的文件数据是会报错的。

先来说说什么是源 • 源（origin）就是协议、域名和端口号。 若地址里面的协议、域名和端口号均相同则属于同源。 以下是相对于 `http:// www.a.com/test/index.html` 的同源检测 `http://www.a.com/dir/page.html` \----成功 `http://www.child.a.com/test/index.html` \----失败，域名不同 `https://www.a.com/test/index.html` \----失败，协议不同 `http://www.a.com:8080/test/index.html` \----失败，端口号不同

**哪些操作不受同源限制**

1.script

2.link

3.img

4.form

5.a

**哪些操作受同源的限制**

1.ajax

**解决方案：**

1.局部解决跨域

*  使用注解@CrossOrigin（局部跨域）

2.全局解决跨域

*  配置类解决跨域（全局跨域）

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.cors.CorsConfiguration;
    import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
    import org.springframework.web.filter.CorsFilter;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @Configuration
    public class CorsConfig {
        private CorsConfiguration buildConfig() {
            CorsConfiguration corsConfiguration = new CorsConfiguration();
            corsConfiguration.setAllowCredentials(true); //sessionid 多次访问一致
            // 允许访问的客户端域名
            List<String> allowedOriginPatterns = new ArrayList<>();
            allowedOriginPatterns.add("*");
            corsConfiguration.setAllowedOriginPatterns(allowedOriginPatterns);
            corsConfiguration.addAllowedHeader("*"); // 允许任何头
            corsConfiguration.addAllowedMethod("*"); // 允许任何方法（post、get等）
            return corsConfiguration;
        }
        @Bean
        public CorsFilter corsFilter() {
            UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
            source.registerCorsConfiguration("/**", buildConfig()); // 对接口配置跨域设置
            return new CorsFilter(source);
        }
    }
    
    
    方式2：
        
    @Configuration
    public class MyWebMvcConfig implements WebMvcConfigurer {
        @Override
        public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/**")
                    .allowedOrigins("*")
                    .allowedMethods("*")
                    .allowedHeaders("*");
        }
    }

### springBoot聚合工程 ###

**多模块聚合工程：按照MVC的思想，将应用分成三层web、service、mapper/dao这三个主要模块，在实际的开发过程中可能会根据实际的业务将聚合工程分成如下的形式:**

1.  common：通用工具类模块，专门用于项目中使用的一些工具类。
2.  entity：实体类模块，专门存放实体类对象，例如：DTO、BO、AO、VO等等对象。
3.  mapper：dao接口模块，专门存放操作数据库的dao接口。
4.  service：业务逻辑模块，专门进行业务逻辑的处理。
5.  web：控制器模块，用于页面请求控制模块。

**搭建聚合工程步骤如下：**

**（1）IDEA创建maven工程**

通过IDEA创建一个maven的quickstart类型项目，然后删除里面的src目录，保留pom.xml文件即可，如下图所示

![ec15fbff0b0b485ea671039304e5ce54.png][]

**（2）修改pom依赖，修改父工程项目中的pom.xml文件，添加【springboot】依赖。**

![261c256fa7614cdc9197af6d5c508e8d.png][]

**（3）创建common子模块** ![b364764f10524987ad4716d15f8803e9.png][]

在弹出界面中，选择【quickstart】类型的项目，然后下一步，填入子工程信息即可 ![c0a96b08a8234fa789382c844aed5efa.png][]

在子工程中，删除多余的【test】目录和【App】启动类，修改pom文件，删除多余内容，添加父工程依赖 ![12f20a853b2346d9ae963571def97cc1.png][]

按照以上步骤完成后续子模块的创建，web模块可创建一个webapp工程，形成如下的目录结构 ![da10b3a655fe4d4ca4c57fe3da7534bb.png][]

**统一依赖管理**

通过前面的步骤，我们已经将父工程和子工程都搭建完成了，并且引入了【springboot】父工程依赖。这里，我们为了方便管理每个子工程的依赖，以及其他第三方依赖，我们可以选择在父工程中的【pom】文件中，统一的定义依赖版本。

![b3b6d664122f4c48833dfffa5bc81457.png][]

在子工程【-web】的pom文件中，添加【web】依赖，并且创建【Application】启动类。 ![0b755f84bfc44dbdb1b8b63ca5ef90bf.png][]

创建【Application】启动类。 ![2ca1832ce33e457e86ccfe47e88f99d8.png][]

创建【src/main/resources】目录，新增【application.yml】配置文件 ![70ba1360108e439c8cf0108a463b1d4d.png][]

创建【HelloController】测试类 ![49eab54a6b614e01a1a233d44c64816f.png][]

启动项目，打开浏览器，访问测试路径 ![86b22d2a564743e38e00640884ec2beb.png][]

到这里，SpringBoot聚合项目已经创建好了，并且能够启动访问了。上面几个子工程虽然创建好了，但是每个子工程之间并没有依赖关系，现在我们就将这几个子工程进行依赖关联。

web----->service（---->表示依赖）

service----->mapper，app-common

mapper----->entity

依次给每个子工程添加上面的依赖即可

#### 今天的分享就到此结束了 ####

#### **创作不易点赞评论互关三连** ####

![c7a579659984427c951f24021bdb4be8.gif][]

[Releases _ tporadowski_redis _ GitHub]: https://github.com/tporadowski/redis/releases
[dfa1b6c7882c46929533c48754c8f03a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/34165bbd606f4f8cb1df88b7df5bbc3d.png
[e4ee4286ae3f44478c5e3f6897e6bdf9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/052b3b44d8ff453fa7d0abeb4fbb07f8.png
[b64dc2d3e90c45059c31d5c5725d9c74.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/2863903afb704839ab3077888578d52b.png
[bf244834246a4c0f9086dab923256b18.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/c38c9af9708c4e5f96554416f46bc78b.png
[09271d5b0b9543b1a761d4bed538eda6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/8759aae5bf0643c6b5ecc04208a4d78e.png
[8c40666907494a2ba676e025c6b24135.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/dbd741e3237248efb3b6c7dfc777270f.png
[8d43a8be9a6548c7abb313146ae7d0fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/03010a161dcc4e3eb25716e758c4bff9.png
[387a9423664d4d84a6edd633715c1d61.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/c2f1bbbdafda472ebd8e2efb8f5351e1.png
[62c256fce3a74fed8f24df801b79359d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/21b3a45a4adc40d891c21b6ddf1f8987.png
[c10238720b6e4c828680d2b6a5b4e210.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/a22212af2c7042e5afdbaf3150657da8.png
[29336ae73459494e9665be78fd672a74.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/5dd4f5d6fc894721ae0a5dde23b0d190.png
[ee8fbf12067d46e6af3becb2aff81b33.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/331be2ae8ceb4f3d9db521f278dbda06.png
[66740ae3b6c541e1a39cfbad47817dd8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/71b1f875d0034e9389d8ae7251ec8fd6.png
[f7d5cef62eda4764b43358f763391e03.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/30cdf34a94e34b2da5de4833e03522ce.png
[53b423454a1f4f9e8fe0d4bcbaad5eee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/d8ba41bd0f5c460ab7bfd683e5aa0779.png
[cb12960e847b408e8302b76fc72f91e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/c8fac5dafb184c129c1b28100a68773a.png
[16d1534afab241c59a1ac38c81edea73.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/3f54b3020fd1401e9a892fe82b3dba1c.png
[XMLHttpRequest]: https://www.ruanyifeng.com/blog/2012/09/xmlhttprequest_level_2.html
[ec15fbff0b0b485ea671039304e5ce54.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/44bcd3c9d51f4b949dcb32402fa988c2.png
[261c256fa7614cdc9197af6d5c508e8d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/63f536e7aa9f4f71a5b153031da4f1a3.png
[b364764f10524987ad4716d15f8803e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/8cf44ddfb6e34bf7b99dfd19589418fb.png
[c0a96b08a8234fa789382c844aed5efa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/f0df970b8552407e8f38dd9d7cf1b654.png
[12f20a853b2346d9ae963571def97cc1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/33195a3538514e398f1e2134b771f644.png
[da10b3a655fe4d4ca4c57fe3da7534bb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/ad1e229d7d0e4bb39d7a68709c087f5e.png
[b3b6d664122f4c48833dfffa5bc81457.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/76e9a7cf82984ada801ec3468f23e2ec.png
[0b755f84bfc44dbdb1b8b63ca5ef90bf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/2e76c80bbfef414e96bf5b17c6c600a6.png
[2ca1832ce33e457e86ccfe47e88f99d8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/255e726e2edd4f5883968f59b6ab088e.png
[70ba1360108e439c8cf0108a463b1d4d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/642d3f00c46248b5a51b51c409010de3.png
[49eab54a6b614e01a1a233d44c64816f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/88bc5892073340bcb6d82d1e77a1a7c4.png
[86b22d2a564743e38e00640884ec2beb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/bd57c4d2aa7c4d70847db973a0d81ade.png
[c7a579659984427c951f24021bdb4be8.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/fdc72c1918be4ed2ac765d2b25da1b88.png