SpringBoot学习系列笔记

SpringBoot 微框架 = spring（工厂）用来管理项目对象创建项目中对象 + springmvc（控制器）controller

spring工厂创建对象的2种形式：

基于配置文件形式创建对象

spring.xml
```
  	2. 基于注解方式创建对象
```
@Component 作用：就是在工厂中创建对象

@Controller: 创建控制器注解

@Service: 创建业务层注解

@Repository: 创建dao层注解

SpringBoot 创建对象：

a. 使用原始spring框架中注解创建对象 【只能创建单个对象】

@Component 作用：就是在工厂中创建对象

@Controller: 创建控制器注解

@Service: 创建业务层注解

@Repository: 创建dao层注解

b. 使用配置方式创建对象【可以创建多个对象】

@Configuration : 代表这是一个工厂的配置类相当于spring.xml配置文件；修饰范围：用在类上；

作用：代表这个类是一个springboot中配置类

@Bean注解：用来在工厂中创建这个@Bean注解标识的对象；

默认使用@Bean创建对象在工厂中唯一标识方法名称

修改在工厂中对象标识可以在使用@Bean(“工厂中名字”)指定一个名字

@Configuration
public class BeansConfig(){
    @Bean
    public User user(){
        return new User();
    }
}

spring框架中属性注入：

SET 注入灵活构造注入自动注入

引用类型属性注入：

@Autowired: spring框架默认根据类型注入

@Resources：javaEE 规范默认根据名称注入 / 自动根据类型注入

一般用在成员变量上或者成员变量的set方法上

八种基本类型 + 日期类型+ String类型(前面几个都是用的value标签) + 数组类型(array标签) + 集合类型属性注入(set,list,map)：

@Value("XX")
private string name //注解方式标注value

SpringBoot 升级版属性注入：

@Value注解

@Autowired注解

@Resource注解

@Value注入方式

    @Value("${name}")
    private String name;
    @Value("${age}")
    private Integer age;
    @Value("${price}")
    private Double price;
    @Value("${bir}")
    private Date bir;
    @Value("${sex}")
    private Boolean sex;
    @Value("${array}")
    private Integer[] array;
    @Value("#{${map}}")
    private Map<string,string> map;

    @RequestMapping("inject")
    public String inject(){
        System.out.println("inject ok");
        System.out.println("my name is "+name+" sex: "+sex+",age:"+age+",bir:"+bir+" and my pockets $"+price);
        for (int i = 0; i < array.length; i++) {
            System.out.println(" -- "+array[i]);
        }
        System.out.println("Map 遍历");
        map.forEach((key,value)-> System.out.println(key+"->"+value));
        return "inject ok";
    }

# 声明注入值
name: 小明
age: 23
price: 12.5
sex: true
bir: 2021/02/20 00:00:52   # 注意日期格式为  yyyy/mm/dd  HH:MM:ss
array: 85,75,98            #注入数组时候，多个元素用“，”隔开
list: 45,87,46             #注入数组时候，多个元素用“，”隔开
map: "{'aa':'小胡','bb':'小妮'}"    #注入map集合可以使用json形式进行注入   注意：使用@Value注入时必须加入“#{${属性}}”进行注入

对象注入【#重要#】

根据@ConfigurationProperties构建注入元数据

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-configuration-processor</artifactid>
    <!--代表这个依赖不会被传递-->
    <optional>true</optional>
</dependency>

//修饰范围用在类上    作用：用来指定前缀的属性  注入到当前对象中属性名一致的属性中
//注意：使用这个注解为属性一次性赋值   必须为属性提供SET方法
@ConfigurationProperties(value = "orders")
public class InjectionController {

    private String name;
    private Integer age;
    private Boolean sex;
    private Date bir;

    @RequestMapping("inject")
    public String inject(){
        System.out.println("inject ok");
        System.out.println(name+age+sex+bir);
        return "";
    }


    public void setName(String name) {
        this.name = name;
    }
    ....

#声明对象方式注入
orders:
  name: 小明
  age: 12
  sex: true
  bir: 2021/02/20 00:00:52

JSP模板集成

引入依赖：

        <!--c标签库-->
        <dependency>
            <groupid>jstl</groupid>
            <artifactid>jstl</artifactid>
            <version>1.2</version>
        </dependency>
        <!--让Tomcat具有解析jsp功能-->
        <dependency>
            <groupid>org.apache.tomcat.embed</groupid>
            <artifactid>tomcat-embed-jasper</artifactid>
        </dependency>

# application.yml文件 中配置jsp视图前缀和后缀    解析结果：前缀+ controller返回值 +后缀
spring:  
  mvc:    
    view:      
      prefix: /      
      suffix: .jsp      
    jsp:      
      init-parameters:        
        development: true   #开启jsp页面开发模式  作用修改jsp页面无须重启SpringBoot应用

SpringBoot整合mybatis

引入依赖（spring-boot-stater-web、mysql驱动、druid数据源、mybatis-spring-boot-stater）

书写配置过程

a. 开启注解扫描(省略)；

b. 创建数据源

指定数据源类型
指定数据库的驱动
指定url
指定username，password

c.创建SqlSessionFactory

指定mapper配置文件位置
指定实体所在包（起别名）

d. 创建DAO

指定DAO接口所在包

e. 创建事务管理器开启注解时事务生效(省略)

f. 测试

建表
开发实体类
开发DAO接口
开发Mapper配置文件
开发Service接口
开发ServiceImpl实现类
测试ServiceImpl

#application.yml 添加mybatis配置
spring:  
  datasource:   
    type: com.alibaba.druid.pool.DruidDataSource    
    driver-class-name: com.mysql.jdbc.Driver    
    url: jdbc:mysql://localhost:3306/spbdemo?characterEncoding=UTF-8    
    username: root    
    password: root
mybatis:      
  mapper-locations: classpath:com/eric/*.xml  #指定mapper配置文件位置  
  type-aliases-package: com.eric.entity       # 指定实体类的包名

// 在入口类上添加注解，用于创建DAO，指定DAO所在包@SpringBootApplication
@MapperScan(value = "com.eric.dao")  //修饰范围：用在类上  作用：用来扫描dao接口所在包，同时将所有dao接口在工厂中创建
public class SpringBootDay2Application {    
    public static void main(String[] args) {
      SpringApplication.run(SpringBootDay2Application.class, args);    
    }
}

本地测试

引入结合junit 和 springboot 依赖

启动springboot应用

@SpringBootTest

修饰范围：类上；作用：在这个类实例化过程中启动springboot应用

@SpringBootTest
class xxxxxxxTests {    
   @Autowired    
   private SGService service;    
   @Test    
   void contextLoads() {        
     service.findAll().forEach(studentsGrade ->System.out.println(studentsGrade.getName()));    
   }

}




# devtools热部署工具的使用

1. 引入依赖

```xml
      <dependency>            
         <groupid>org.springframework.boot</groupid>            
         <artifactid>spring-boot-devtools</artifactid>       
         <!--optional:该依赖是否可以传递 true 不能传递 只能当前项目-->            
         <optional>true</optional>        
      </dependency>

设置idea中支持自动编译（只设置一次）

idea开启自动编译

日志处理

日志的级别

logging:  
  level:    
  root: info   #调整全局日志展示位
debug    com.eric.dao: info # 输出指定包的日志    org.springframework: info  
  file:    
    name: run.log  # 指定生成日志文件名称    
    path: ./       # 将日志文件生成当前目录（当前项目的目录中）

开发网页端验证码模块

导入VerifyCodeUtils.java文件
开发用户模块功能——验证码

举例EMS项目开发流程

详细设计
1. 详细设计省略

编码缓解

技术选型：springboot + mybatis + jsp + mysql

环境搭建： springboot + jsp + mybatis

  <!--web-->
  <dependency>
      <groupid>org.springframework.boot</groupid>
      <artifactid>spring-boot-starter-web</artifactid>
  </dependency>        
  <!--test-->
  <dependency>
      <groupid>org.springframework.boot</groupid>
      <artifactid>spring-boot-starter-test</artifactid>
      <scope>test</scope>
  </dependency>        
  <!--c标签库-->
  <dependency>
      <groupid>jstl</groupid>
      <artifactid>jstl</artifactid>
      <version>1.2</version>
  </dependency>        
  <!--让Tomcat具有解析jsp功能-->
  <dependency>
      <groupid>org.apache.tomcat.embed</groupid>
      <artifactid>tomcat-embed-jasper</artifactid>
  </dependency>        <!--mysql-->
  <dependency>
      <groupid>mysql</groupid>
      <artifactid>mysql-connector-java</artifactid>
  </dependency>        <!--druid-->
  <dependency>
      <groupid>com.alibaba</groupid>
      <artifactid>druid</artifactid>
      <version>1.2.6</version>
  </dependency>        <!--mybatis-->
  <dependency>
      <groupid>org.mybatis.spring.boot</groupid>
      <artifactid>mybatis-spring-boot-starter</artifactid>
      <version>2.2.0</version>
  </dependency>        <!--devtools-->
  <dependency>
      <groupid>org.springframework.boot</groupid>
      <artifactid>spring-boot-devtools</artifactid>            
      <!--optional:该依赖是否可以传递 true 不能传递 只能当前项目-->
      <optional>true</optional>
  </dependency>

项目名字： ems-jsp
功能实现

用户模块功能实现

验证码生成功能实现:

生成随机字符
放入session

生成图片并响应

    /*
    * 生成验证码
    * */
    @RequestMapping("generateImageCode")
    public void generateImageCode(HttpSession session, HttpServletResponse response)
            throws IOException {
        String code = VerifyCodeUtils.generateVerifyCode(4); //生成4位随机字符
        session.setAttribute("code",code); //放入session

        response.setContentType("image/png");
        ServletOutputStream os = response.getOutputStream();
        VerifyCodeUtils.outputImage(70,35,os,code); //生成图片并响应用户
    }

用户注册功能实现:

根据用户输入验证码比较session中验证码是否一致
如果一致完成注册，如果不一致直接返回错误

完成注册向数据库中保存当前的用户信息

a.保存信息之前判断当前用户名是否存在如果存在直接返回错误

b.如果当前用户名不存在保存用户信息保存用户信息给密码进行加密处理

    /*
    *用户注册
    * */
    @RequestMapping("register")
    public String register(User user, String code,HttpSession session)
            throws UnsupportedEncodingException {
        try {
            //比较验证码是否一致
            String sessionCode = (String) session.getAttribute("code");
            if (!sessionCode.equals(code))
                throw new RuntimeException("验证码输入错误");
            //注册用户
            userService.register(user);
        }catch (RuntimeException e){
            e.printStackTrace();
            return "redirect:/register.jsp?msg="+
                    URLEncoder.encode(e.getMessage(),"UTF-8"); //地址重定向，并返回msg数据
        }
        return "redirect:/login.jsp"; // 地址重定向
    }

用户登录功能实现:

根据用户输入用户名去数据库中查询是否存在改用户名
如果存在，判断密码是否一致如果不存在，用户名输入错误
判断密码根据数据库加密密码与对接收密码进行md5加密之后比较

保存用户登录标记到session中

    /*
    * 用户登录
    * */
    @RequestMapping("/login")
    public String login(String name, String password, HttpSession session)
            throws UnsupportedEncodingException {
        try{
            /*去数据库中查询是否存在该用户名*/
            User user = userService.login(name,password);
            /*保存用户登录标记到session中*/
            session.setAttribute("user",user);
        }catch (Exception e){
            e.printStackTrace();
            return "redirect:/login.jsp?msg="+URLEncoder.encode(e.getMessage(),"UTF-8");
        }
        return "redirect:/employee/list";
    }

员工模块功能实现

员工列表

在数据库中查询所有员工信息

在页面中进行展示

    @RequestMapping("list")
    public String listEmployee(HttpServletRequest request, Model model){
        List<Employee> employeeList = employeeService.findAll();
        employeeList.forEach(employee -> System.out.println(employee));
        request.setAttribute("employee",employeeList);
        // model.addAttribute("employee",employeeList);  //功能同上request
        return "emplist";
    }

    <c:forEach items="${requestScope.employee}" var="emp" varStatus="stu">

        <tr
                <c:if test="${stu.index%2!=0}">
                    class="row1"
                </c:if>
                <c:if test="${stu.index%2==0}">
                    class="row2"
                </c:if>
        >
            <td>${emp.id}</td>
            <td>${emp.name}</td>
                <%--性别格式化输出--%>
            <td>${emp.gender? '男':'女'}</td>
                <%--日期格式化输出--%>
            <td><fmt:formatDate value="${emp.birthday}" pattern="yyyy-MM-dd"/></td>
            <td>${emp.salary}</td>
            <td>
                <a href="javascript:;" onclick="deleteEmployee()">删除</a>
                <script>
                    function deleteEmployee() {
                        if (window.confirm("是否删除？")) {
                            location.href = '${pageContext.request.contextPath}/employee/delete?id=${emp.id}';
                        }
                    }
                </script>
                <a href="${pageContext.request.contextPath}/employee/detail?id=${emp.id}">更新</a>
            </td>
        </tr>
    </c:forEach>

添加员工

在员工controller中开发一个添加方法
接收员工信息
将员工信息保存到数据库

跳转到员工列表展示数据

    @RequestMapping("addemp")
    public String addEmployee(Employee employee){
        employeeService.save(employee);
        return "redirect:/employee/list";
    }

更新员工
1. 上半步数据回显:
  1. 点击更新链接传递当前更新员工id到controller
  2. 在controller中根据id查询员工信息
  3. 将查询到的员工信息保存到作用域
  4. 跳转到更新页面展示修改员工信息
2. 下半步：
  1. 获取更新之后员工信息
  2. 更新数据库
```
    @RequestMapping("upemp")
    public String updateEmp(Employee employee){
        employeeService.update(employee);
        return "redirect:/employee/list";
    }
```

删除员工信息：

点击删除根据id去数据库中删除指定员工信息

删除成功之后跳转到列表页面

    @RequestMapping("delete")
    public String deleteEmp(Integer id){
        employeeService.delete(id);
        return "redirect:/employee/list";
    }

项目开发中的小tips

作用域：

request：一次请求【以当前请求有效】

session：整个会话【整个会话未结束有效】

application：应用级作用域【只有一个，所有用户共享，保存在内存中】

//根据用户名查询数据库是否存在该用户
if (!ObjectUtils.isEmpty(userDB)) throw new RuntimeException("用户名已存在");
        //注册之前给明文加密
String passwordSecret = DigestUtils.md5DigestAsHex(user.getPassword().getBytes(StandardCharsets.UTF_8));
//实体数据库返回值重新赋值
user.setPassword(passwordSecret);

Controller接收参数的变量名，要与HTML元素的name一致

AOP面向切面编程步骤

文件上传下载

上传

下载

拦截器

RestFulAPI

接口开发-前后端分离

添加状态码后的代码

CORS跨域资源共享

局部解决跨域
@CrossOrigin:这个注解用在Controller类上，代表解决类中所有方法允许其他域中资源共享访问
全局解决跨域
新建一个配置类

Jasypt加密

加入依赖


        <!--jasypt-->
        <dependency>
            <groupId>com.github.ulisesbocchio</groupId>
            <artifactId>jasypt-spring-boot-starter</artifactId>
            <version>3.0.4</version>
        </dependency>

将秘钥作为参数，动态传递

Redis学习

启动redis

redis-server.exe redis.windows.conf
redis-cli.exe -h 127.0.0.1 -p 6379

redis客户端显示中文

./ redis-cli -p 端口号 --raw

操作Key相关指令

常用操作命令

命令	说明
set	设置一个key/value
get	根据key获得对应的value
mset	一次设置多个key value
mget	一次获得多个key的value
getset	获得原始key值，同时设置新值
strlen	获得对应key存储value的长度
append	为对应key 的value追加内容
getrange索引0开始	截取value的内容
setex	设置一个key存活的有效期
psetex	设置一个key存活的有效期
setnx	存在不做任何操作，不存在就添加
msetnx原子操作(只要有一个存在，就不做任何操作)	可以同时设置多个key，只要有一个存在都不保存
decr	进行数值类型的-1操作
decrby	根据提供的数据进行减法操作
lncr	进行数值类型的+1操作
incrby	根据提供的数据进行加法操作
lncrbyfloat	根据提供的数据加入浮点数

List类型

常用操作指令

命令	说明
lpush	将某个值加入到一个key列表头部
lpushx	同lpush，但是必须要保证这个key存在
rpush	将摸一个值加入到一个key列表末尾
rpushx	同rpush，但是必须要保证这个key存在
lpop	返回个移除列表的第一个元素
rpop	返回个移除列表的第一个元素
lrange 0 -1	获取某个下标区间内的元素
llen	获取列表元素个数
lset	设置某个指定索引的值（索引必须存在）
lindex	获取某各指定索引位置的元素
lrem	删除重复元素
ltrim	保留列表中特定区间内的元素
linsert	在某一个元素之前，之后插入新元素

Set类型

常用命令

命令	说明
sadd	为集合添加元素
smembers	无序显示集合中所有元素
scard	返回集合中元素的个数
spop	随机返回一个元素并将元素并在集合中删除
smove	从一个集合中向另一个集合移动元素
srem	从集合中删除一个元素
sismember	判断一个集合中是否含有这个元素
srandmember	随机返回元素
sdiff	去掉第一个集合中其他集合含有的相同元素
sinter	求交集
sunion	求合集

ZSet类型

特点：可排序的set集合

命令	说明
zadd	添加一个有序集合元素
zcard	返回集合的元素个数
zrange升序zrevrage降序	返回一个范围内的元素
zrangebyscore	按照分数查找一个范围内的元素
zrank	返回排名
zrevrank	倒序排名
zscore	显示某一个元素的分数
zrem	移除某一个元素
zincrby	给某个特定元素加分

Hash类型

特点：value是一个map结构，存在key value， key是无序的

Hash类型的value值是嵌套的map数据类型

命令	说明
hset	设置一个key/value对
hget	获得一个key对应的value
hgetall	获得所有的key/value对
hdel	删除某一个key/value对
hexists	判断一个key是否存在
hkeys	获得所有的key
hvals	获得所有的value
hmset	设置对个key/value
hmget	获得多个key/value
hsetnx	设置一个不存在的key的值
hincrby	为value进行加法运算
hincrbyfloat	为value加入浮点值

开启redis远程连接

注意：默认redis服务器是没有开启远程连接，也就是默认拒绝所有远程客户端连接

修改配置开启远程连接

vim redis.conf 中修改如下配置

bind 0.0.0.0 #允许一切客户端连接

修改配置之后重启redis服务

./redis-server ../redis.conf #注意一定要加载配置文件启动

redis持久化操作

客户端方式：BGSAVE和SAVE指令

服务器配置自动触发

AOF持久化

特点：通过追加日志文件实现持久化操作

开启AOP持久

修改appendonly yes 开启持久化

修改appendfilename “appendonly.aof” 指定生成文件名称

日志追加频率

说明：每秒执行一次同步显式的将多个写命令同步到磁盘

解释：未来间隔安全和写入性能，用户可以考虑使用everysec选项，让redis每秒一次的频率对AOF文件进行同步；redis每秒同步一次AOF文件时性能和不使用任何持久化特性时的性能相差无几，而通过每秒同步一次AOF文件，redis可以保证，即使系统崩溃，用户最多丢失一秒之内产生的数据。、

修改同步频率

AOF文件重写

执行BGWRITEAOF命令不会阻塞redis服务

使用java对redis的操作

1.1 Java操作key相关指令

    //测试key操作相关
    @Test
    public void testKey(){
        //del指令
        jedis.del("list");
        //exists指令
        jedis.exists("maps");
        //expire
        jedis.expire("zets1",1000);
        //查找所有符合给定模式pattern的key
        jedis.keys("*");
        //当前数据库的key，移动到指定数据库db中
        jedis.move("name",0);
        //.....
    }

1.2 Java操作redis常用命令

    //测试常用操作命令相关
    @Test
    public void testKey(){
        //获得对应key存储value的长度
        jedis.strlen("maps");
        //截取value的内容
        jedis.getrange("name",0,-1);
        //.....
    }

1.3 Java操作list相关指令

    //测试list操作命令相关
    @Test
    public void testKey(){
        //删除重复元素
        jedis.lrem("list",2,"xiaoming");
        //获取列表元素个数]
        jedis.llen("list");
        jedis.linsert("list", ListPosition.BEFORE,"Eric","Machael");
        //.....
    }

1.4 Java操作Set相关指令

    //测试Set操作命令相关
    @Test
    public void testKey(){
        //为集合添加元素
        jedis.sadd("Eric","Siri","Alpha");
        //无序显示集合中所有元素 
        jedis.smembers("set2");
        //.....
    }

1.5 Java操作ZSet相关指令

    //测试Set操作命令相关
    @Test
    public void testKey(){
        //添加一个有序集合元素
        jedis.zadd("zset1",2,"eric");
        //返回集合的元素个数
        jedis.zcard("zset1");
        //.....
    }

1.6 Java操作Hash相关指令

//测试Hash操作命令相关
@Test
public void testKey(){
    //设置一个不存在的key的值
    Map<String, String> map = new HashMap<>();
    map.put("name","Sina");
    map.put("age","23");
    jedis.hsetnx("hash","name","Micheal");
    jedis.hmset("hash",map);
    //.....
}

springBoot整合Redis

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

##注意:使用RedisTemplate默认是将对象序列化到Redis中，所以放入的对象必须实现对象序列化接口【需要序列化的对象，对象类实现Serializable类，就可以了】

引入依赖

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

配置 application.yml 文件

spring.refis.port=6379

spring.redis.host=127.0.0.1

spring.redis.database=0

基于StringRedisTemplate的Redis操作

key相关操作

@Autowired
private StringRedisTemplate stringRedisTemplate; // 基于String  key value都是字符串
@Test
public void testKey(){
    Boolean hasKey = stringRedisTemplate.hasKey("name");//判断是否存在key
    DataType type = stringRedisTemplate.type("name");//key类型
    Set<String> keys = stringRedisTemplate.keys("*");//查询所有key
    ........
}

List相关操作

@Autowired
private StringRedisTemplate stringRedisTemplate; // 基于String  key value都是字符串
@Test
public void testList(){
    List<String> list = new ArrayList<>();
    list.add("Eric");
    list.add("Siri");
    stringRedisTemplate.opsForList().leftPushAll("list",list);//放入多个元素
    List<String> lists = stringRedisTemplate.opsForList().range("list", 0, -1);
    ........
}

Set相关操作

@Autowired
private StringRedisTemplate stringRedisTemplate; // 基于String  key value都是字符串
@Test
public void testSet(){
    /*为集合添加元素*/
    stringRedisTemplate.opsForSet().add("set1","eric1","siri","Micheal2");
    /*无序显示集合中所有元素*/
    Set<String> set = stringRedisTemplate.opsForSet().members("set");
    /*求交集*/
    Set<String> intersect = stringRedisTemplate.opsForSet().intersect("set", "set1");
}

ZSet相关操作

@Autowired
private StringRedisTemplate stringRedisTemplate; // 基于String  key value都是字符串
@Test
public void testZSet(){
    stringRedisTemplate.opsForZSet().add("zset","eric",19);//添加元素
    Set<ZSetOperations.TypedTuple<String>> zset = stringRedisTemplate.opsForZSet().
            rangeWithScores("zset", 0, -1);//指定范围返回值和权值
    zset.forEach(zsets-> System.out.println(zsets.getValue()+zsets.getScore()));
}

Hash相关操作

@Autowired
private StringRedisTemplate stringRedisTemplate; // 基于String  key value都是字符串
@Test
public void testHash(){
    Map<String, String> hash = new HashMap<>();
    hash.put("name","Eric");
    hash.put("age","23");
    stringRedisTemplate.opsForHash().putAll("hash",hash);//添加hash元素
    List<Object> hash1 = stringRedisTemplate.opsForHash().
            multiGet("hash",Arrays.asList("name","age"));//获取多个key的value
}

基于RedisTemplate的Redis的操作

@Autowired
public RedisTemplate redisTemplate;
/*
* redisTemplate 对象中，key和value的序列化都是JdkSerializer
*         key：String
*         value：Object
*         修改默认key序列化方案：key   StringRedisSerializer
* */
@Test
public void testRedisTemplate(){
    //修改key序列化方案    String类型序列
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    //修改Hash key 序列化方案
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());

    User user = new User();
    user.setId(UUID.randomUUID().toString());
    user.setUsername("Eric");
    user.setRealname("tangtang");
    
    redisTemplate.opsForValue().set("user",user);// redis进行设置，对象需要经过序列化
    User user1 = (User) redisTemplate.opsForValue().get("user");

    redisTemplate.opsForList().leftPush("list",user);
    redisTemplate.opsForSet().add("set",user);
    redisTemplate.opsForZSet().add("zset",user,10);
    redisTemplate.opsForHash().put("hash","name",user);
}

</string,></zsetoperations.typedtuple</string,></string,string>

posted @ 2021-09-30 17:57 二十八畫生阅读(60) 评论(0) 收藏举报

刷新页面返回顶部

二十八畫生