第三章 - 图1

Demo3具体操作

项目创建-依赖导入

  1. 新建项目

  2. 选择Dependencies（依赖包）image.png

  3. 等待sts自动从阿里云下载相关依赖包image.png

基础环境搭建

  1. 数据准备
    1. 导入数据库文件（课表P51文件3-1的数据库表）至MySQL
    2. 直接登入MySQL（-uroot -p）
      1. 输入source （拖入文件至命令行窗口），或者复制3-1代码（如下） ```sql set character set utf8; drop database if exists springbootdata;

        创建数据库

        CREATE DATABASE springbootdata default character set utf8;

        选择使用数据库

        USE springbootdata;

        创建表t_article并插入相关数据

        DROP TABLE IF EXISTS t_article; CREATE TABLE t_article ( id int(20) NOT NULL AUTO_INCREMENT COMMENT ‘文章id’, title varchar(200) DEFAULT NULL COMMENT ‘文章标题’, content longtext COMMENT ‘文章内容’, PRIMARY KEY (id) ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8; set character set utf8; INSERT INTO t_article VALUES (‘1’, ‘Spring Boot基础入门’, ‘从入门到精通讲解…’); INSERT INTO t_article VALUES (‘2’, ‘Spring Cloud基础入门’, ‘从入门到精通讲解…’);

        创建表t_comment并插入相关数据

        DROP TABLE IF EXISTS t_comment; CREATE TABLE t_comment ( id int(20) NOT NULL AUTO_INCREMENT COMMENT ‘评论id’, content longtext COMMENT ‘评论内容’, author varchar(200) DEFAULT NULL COMMENT ‘评论作者’, a_id int(20) DEFAULT NULL COMMENT ‘关联的文章id’, PRIMARY KEY (id) ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8; set character set utf8; INSERT INTO t_comment VALUES (‘1’, ‘很全、很详细’, ‘狂奔的蜗牛’, ‘1’); INSERT INTO t_comment VALUES (‘2’, ‘赞一个’, ‘tom’, ‘1’); INSERT INTO t_comment VALUES (‘3’, ‘很详细’, ‘kitty’, ‘1’); INSERT INTO t_comment VALUES (‘4’, ‘很好，非常详细’, ‘张三’, ‘1’); INSERT INTO t_comment VALUES (‘5’, ‘很不错’, ‘张杨’, ‘2’);
  2.    3. 该springbootdata数据库创建了两个表t_article和t_comment。其中评论表t_comment的a_id与文章表t_article的主键id相互关联
  3. 2. 编写配置文件
  4.    1. 在application.properties配置文件中进行MySQL数据库连接配置编写（P52文件3-4，如下）
  5. ```properties
  6. # MySQL数据库连接配置 2-数据资源地址-mysql数据库：地址 3-数据库账号 4-数据库密码
  7. spring.datasource.url=jdbc:mysql://local:3306/springbootdata?serverTimezone=UTC
  8. spring.datasource.username=root
  9. spring.datasource.password=q271579262333
  1.   1. 若提示框显示编码问题——选择Save as UTF-8（中文编码）
  1. pom.xml文件中添加Druid数据源的依赖启动器（在maven仓库搜druid）(如下复制到pom.xml中) ```xml com.alibaba druid 1.2.8 
  2.    3. 上述依赖启动器内部已经初始化了一些运行参数，可在全局配置文件（application.properties）中自定义Druid的运行参数（P53文件3-5）
  3. ```properties
  4. #添加并配置第三方数据源Druid  初始大小-最小风险数10-最大连接数100
  5. spring.datasource.type = com.alibaba.druid.pool.DruidDataSource
  6. spring.datasource.initialSize = 20
  7. spring.datasource.minIdle = 10
  8. spring.datasource.maxActive = 100
  1. 在demo包下新建config的包，并在该包下创建一个自定义配置类DataSourceConfig，对Druid数据源属性值进行注入image.png ```java package com.example.demo.config;

import javax.sql.DataSource;

import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration;

import com.alibaba.druid.pool.DruidDataSource;

@Configuration //注入Configuratoin注解标注该类为配置类 public class DataSourceConfig { @Bean @ConfigurationProperties(prefix=”spring.datasource”) //将配置文件引入配置类 public DataSource getDruid() { return new DruidDataSource(); } }

  1. <a name="I5o1h"></a>
  2. #### SpringBoot整合JPA(P58)
  4. 1. 编写ORM实体类Discuss
  5.    1. demo包下新建entity包
  6.    2. entity包下新建Discuss类（实体类）
  7. ```java
  8. package com.example.demo.entity;
  10. import javax.persistence.Column;
  11. import javax.persistence.Entity;
  12. import javax.persistence.GeneratedValue;
  13. import javax.persistence.GenerationType;
  14. import javax.persistence.Id;
  16. @Entity(name = "t_comment")        //Entity标注该类为实体类，并且注释所对应的数据表表名。让JPA知道该类为PO，映射到数据库表里面
  17. public class Discuss {
  18.     @Id //Id注解表明这个属性对应表中的主键，
  19.     @GeneratedValue(strategy = GenerationType.IDENTITY)    //表示属性对应主键的生成策略，为IDENTITY，即主键自增。
  20.     private Integer id;
  21.     @Column(name = "content")    //@Column标注在属性上面，如果属性名和表中名字不一样，一定要用这个注解，可以自动对应相应字段
  22.     private String content;    //写String类型contend属性对应表中contend
  23.     @Column(name = "author")
  24.     private String author;    //写String类型author属性对应表中author
  25.     @Column(name = "a_id")    
  26.     private Integer aId;
  28.     //——————————————————————————id-get、set方法
  29.     public Integer getId() {
  30.         return id;
  31.     }
  32.     public void setId(Integer id) {
  33.         this.id = id;
  34.     }
  35.     //——————————————————————————content-get、set方法
  36.     public String getContent() {
  37.         return content;
  38.     }
  39.     public void setContent(String content) {
  40.         this.content = content;
  41.     //——————————————————————————author-get、set方法
  42.     }
  43.     public String getAuthor() {
  44.         return author;
  45.     }
  46.     public void setAuthor(String author) {
  47.         this.author = author;
  48.     }
  49.     //——————————————————————————aid-get、set方法
  50.     public Integer getaId() {
  51.         return aId;
  52.     }
  53.     public void setaId(Integer aId) {
  54.         this.aId = aId;
  55.     }
  56. }
  1. 编写Repository接口 ```java package com.example.demo.dao;

import java.util.List;

import org.springframework.data.domain.Pageable; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Modifying; import org.springframework.data.jpa.repository.Query; import org.springframework.stereotype.Repository; import org.springframework.transaction.annotation.Transactional;

import com.example.demo.entity.Discuss;

@Repository public interface DiscussRepository extends JpaRepository {
//↑↑↑↑针对JPA自定义Repository接口方法必须继承XXRepository接口，其中T-Discuss是自定义类，ID-Integer是主键的数据类型P60 public List findByAuthorNotNull(); //JPA支持的方法名关键字查询方式，查找author非空的Discuss信息

  1. @Query("SELECT c FROM t_comment c WHERE c.aId = ?1")    //Query队列注解（需要在jpa包导入）-引入一条SQL语句--
  2. public List<Discuss> getDiscussPaged(Integer aid,Pageable pageable);//以上方Query注解，通过文章分页ID查询Discuss信息
  4. @Query(value = "SELECT * FROM t_comment WHERE a_Id = ?1",nativeQuery = true)//nativeQuery（默认false）设为true，用于编写原生SQL语句
  5. public List<Discuss> getDiscussPaged2(Integer aid,Pageable pageable);
  7. @Transactional        //表示支持事务管理，针对数据变更操作，一定要添加该注解，否则异常
  8. @Modifying//注解——表示支持数据变更，进行数据变更操作必须添加该注解
  9. @Query("UPDATE t_comment c SET c.author = ?1 WHERE c.id = ?2")
  10. public int updateDiscuss(String author, Integer id);//使用上条@Query注解对应了SQL语句，进行数据更新
  12. @Transactional
  13. @Modifying
  14. @Query("UPDATE t_comment c WHERE c.id = ?1")
  15. public int deleteDiscuss(Integer id);        ////使用上条@Query注解对应了SQL语句，传入了对应参数id，连接数据库对应id的评论进行删除

}

  5. 编写DiscussController
  8. <a name="ICXff"></a>
  9. ### Demo302具体操作
  11. 1. 新建Spring Starter Project
  13. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/22384052/1648773504985-9a298013-de51-45d8-8c69-0001a36b8430.png#clientId=u3b1a1e0c-58e3-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=652&id=udfadf657&margin=%5Bobject%20Object%5D&name=image.png&originHeight=815&originWidth=1261&originalType=binary&ratio=1&rotation=0&showTitle=false&size=116398&status=done&style=none&taskId=ub82f54d9-3bf3-4c79-bd7d-2122a0f8c1e&title=&width=1008.8)
  15. 2. 选择最新Spring Boot版本，Lombok，Spring Web，MySQL Driver(用MySQL就一定要引入这个)
  17. 3. Windows——Preferences——Maven——选择自己安装的maven3.8.2
  18. 4. Windows——Preferences——Maven——User Setting——User Setting选择Maven路径里的pom.xml
  19. > 不然无法从阿里云的仓库下载东西
  21. 5. 放进MyBaits-Plus依赖器代码到pom.xml
  22. ```java
  23. <dependency> 
  24.     <groupId>com.baomidou</groupId> 
  25.     <artifactId>mybatis-plus</artifactId> 
  26. <version>3.5.1</version> </dependency>

  1. 百度搜Maven Repository（即Maven仓库）——搜Druid——Druid——在pom.xml里引入该引入数据库连接池

    1. <dependency>
    2.  <groupId>com.alibaba</groupId>
    3.  <artifactId>druid</artifactId>
    4.  <version>1.2.8</version>
    5. </dependency>


  2. 复制User Setting，路径里repository文件夹下是全部的jar包，如果出问题了可以全部删掉，它就会自动重新下载。

  3. 去编写全局配置文件——application.properties

    1. 打代码进行MySQL连接配置

      1. # MySQL数据库连接配置 行2-数据资源地址-mysql数据库：地址 行3-数据库账号 行4-数据库密码
      2. spring.datasource.url=jdbc:mysql://local:2741/springbootdata?serverTimezone=UTC
      3. spring.datasource.username=root
      4. spring.datasource.password=q271579262333

    2. 打代码进行Druid配置

      1. #添加并配置第三方数据源Druid(数据库连接池)  初始大小-最小风险数10-最大连接数100
      2. spring.datasource.type = com.alibaba.druid.pool.DruidDataSource
      3. spring.datasource.initialSize = 20
      4. spring.datasource.minIdle = 10
      5. spring.datasource.maxActive = 100

    3. 打代码进行配置

      1. # mbp开启控制台操作日志，方便调试
      2. mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
      3. # mbp所有映射实体默认的逻辑删除标记字段，请在对应的数据表中加入该字段，并且设置为int型，初始默认值为0
      4. mybatis-plus.global-config.db-config.logic-delete-field=deleted
      5. # 逻辑删除后的值
      6. mybatis-plus.global-config.db-config.logic-delete-value=1
      7. # 未逻辑删除的值
      8. mybatis-plus.global-config.db-config.logic-not-delete-value=0

  4. 数据准备

    1. 导入数据库文件至MySQL
      1. 直接登入MySQL（-uroot -p）
      2. 输入source （拖入文件至命令行窗口），或者复制代码（如下） ```sql

        设置字体为UTF-8格式

        set character set utf8;

        如果有名称为spingbootdata的数据库则将其删除

        drop database if exists springbootdata;

        创建数据库

        CREATE DATABASE springbootdata default character set utf8;

        选择使用数据库

        USE springbootdata;

        创建表t_article并插入相关数据

        DROP TABLE IF EXISTS t_article; CREATE TABLE t_article ( id int(20) NOT NULL AUTO_INCREMENT COMMENT ‘文章id’, title varchar(200) DEFAULT NULL COMMENT ‘文章标题’, content longtext COMMENT ‘文章内容’, PRIMARY KEY (id) ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8; set character set utf8; INSERT INTO t_article VALUES (‘1’, ‘Spring Boot基础入门’, ‘从入门到精通讲解…’); INSERT INTO t_article VALUES (‘2’, ‘Spring Cloud基础入门’, ‘从入门到精通讲解…’);

        创建表t_comment并插入相关数据

        DROP TABLE IF EXISTS t_comment; CREATE TABLE t_comment ( id int(20) NOT NULL AUTO_INCREMENT COMMENT ‘评论id’, content longtext COMMENT ‘评论内容’, author varchar(200) DEFAULT NULL COMMENT ‘评论作者’, a_id int(20) DEFAULT NULL COMMENT ‘关联的文章id’, deleted int(20) DEFAULT 0, PRIMARY KEY (id) ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8; set character set utf8; INSERT INTO t_comment VALUES (‘1’, ‘很全、很详细’, ‘狂奔的蜗牛’, ‘1’, ‘0’); INSERT INTO t_comment VALUES (‘2’, ‘赞一个’, ‘tom’, ‘1’, ‘0’); INSERT INTO t_comment VALUES (‘3’, ‘很详细’, ‘kitty’, ‘1’, ‘0’); INSERT INTO t_comment VALUES (‘4’, ‘很好，非常详细’, ‘张三’, ‘1’, ‘0’); INSERT INTO t_comment VALUES (‘5’, ‘很不错’, ‘张杨’, ‘2’, ‘0’);
  2. 10. 下载Lombok补丁——放到sts-目录打开，安装
  3. 11. 新建.entity(Package)
  4.    1. 新建Discuss类——编写实体类Discuss
  5. ```java
  6. package com.example.demo.entity;
  8. import com.baomidou.mybatisplus.annotation.TableField;
  9. import com.baomidou.mybatisplus.annotation.TableId;
  10. import com.baomidou.mybatisplus.annotation.TableName;
  12. import lombok.Data;
  14. //让MBP知道，这个类是PO，要映射到数据库表里面
  15. @Data
  16. @TableName("t_comment")
  17.     public class Discuss{
  19.     //@TableId("id")标注在类属性上表示某一个属性对应表中的主键
  20.     @TableId("id")
  21.     private Integer id;
  22.     @TableField("content")
  23.     private String content;
  24.     @TableField("author")
  25.     private String author;
  26.     @TableField("a_Id")
  27.     private Integer aId;
  28.     @TableField("deleted")
  29.     private Integer deleted;
  31.     public void setId(Integer id) {
  32.         this.id = id;
  33.     }
  34.     public Integer getId() {
  35.         return id;
  36.     }
  37.     public void setContent(String content) {
  38.         this.content = content;
  39.     }
  40.     public String getContent() {
  41.         return content;
  42.     }
  43.     public void setAuthor(String author) {
  44.         this.author = author;
  45.     }
  46.     public String getAuthor() {
  47.         return author;
  48.     }
  49.     public void setAid(Integer aId) {
  50.         this.aId = aId;
  51.     }
  52.     public Integer getAid() {
  53.         return aId;
  54.     }
  55.     public void setDeleted(Integer deleted) {
  56.         this.deleted = deleted;
  57.     }
  58.     public Integer getDeleted() {
  59.         return deleted;
  60.     }
  61. }
  1. 编写Mapper接口继承BaseMapper ```java package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.example.demo.entity.Discuss;

public interface DiscussMapper extends BaseMapper { }

//继承的BaseMapper里面已经有开发者设计好的增删查改的方法。

  2. 12. 让Spring Boot扫描到自己编写的Mapper接口
  3. - 两个方法
  4.    - 在项目的主程序启动类里添加：@MapperScan（“com.itheima.mapper”）//Mapper接口所在的包的位置，这个方法可以使Spring Boot扫描到所有Mapper接口
  5.    - 在每个Mapper接口上添加@Mapper
  6. 13. 编写Service接口和它的实现类
  7.    1. 建service包，包下建DiscussService接口
  8. ```java
  9. package com.example.demo.service;
  11. import java.util.List;
  13. import com.example.demo.entity.Discuss;
  15. public interface DiscussService {
  16.     public List<Discuss> findAllDiscuss();
  17.     public List<Discuss> findDiscussByContent();
  19. }
  1. package com.example.demo.service;
  3. import java.util.List;
  5. import org.springframework.beans.factory.annotation.Autowired;
  7. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  8. import com.example.demo.entity.Discuss;
  9. import com.example.demo.mapper.DiscussMapper;
  11. public class DiscussServiceImpl implements DiscussService{
  13.     //注入Mapper接口
  14.     @Autowired
  15.     DiscussMapper discussMapper;
  16.     @Override
  17.     public List<Discuss> findAllDiscuss(){
  18.         //构造一个SQL语句对象
  19.         QueryWrapper<Discuss> qWrapper = new QueryWrapper<>();
  20.         //直接操作数据库查询所有记录
  21.         return discussMapper.selectList(qWrapper);
  22.     }
  23.     @Override
  24.     public List<Discuss> findDiscussByContent(String content) {
  25.         QueryWrapper<Discuss>qWrapper = new QueryWrapper<>();
  26.         //构造一个含有like语句的SQL语句对象
  27.         qWrapper.like("content", content);
  28.         //按条件查询记录
  29.         return discussMapper.selectList(qWrapper);
  30.     }
  32. }
  1. DiscussMapper
  2. BaseMapper
  3. QueryMapper
  4. DiscussController

@Slf4j
@RestController

Demo303具体操作

Redis安装

  1. 直接安装到C盘（不要中文路径）
  2. 检测是否安装
    1. cmd
    2. redis-cli回车
    3. 出现本机地址；端口
    4. 如果无法启动该命令（可能是系统名字为中文；环境变量没有配置）
    5. Path环境配置image.png
      1. 如果修改了还是不行
        1. cmd
        2. 拖入Redis安装目录下的redis-cli.exe文件到cmd命令行回车
      2. image.png
  3. 其他命令
    1. keys *——查看有的键值对
      1. 无数据则显示——empty list or set
  4. 新建Spring Starter Project项目
    1. 依赖包dependencies选择
      1. Spring Data JPA
      2. Spring Data Redis(Access+Driver)
      3. Spring Web
      4. Lombok
      5. MySQL Driver
    2. image.png
  5. 新建domain包，包下编写
    1. 实体类Person ```java package com.example.demo.domain;

import java.util.List; import org.springframework.data.annotation.Id; import org.springframework.data.redis.core.RedisHash; import org.springframework.data.redis.core.index.Indexed;

import lombok.Data; import lombok.experimental.SuperBuilder; @SuperBuilder @Data //Data注解可省略getset方法和toString @RedisHash(“persons”) //用于指定操作实体类对象在Redis数据库中的存储空间 public class Person { @Id //用于标识实体类主键，在Redis里默认生成字符串形式的HashKey private String id; @Indexed //在Redis里生成二级索引 private String firstname; @Indexed private String lastname; private Address address; private List familyList; public Person() { } }

  2.    2. 实体类Address
  3. ```java
  4. package com.example.demo.domain;
  6. import org.springframework.data.redis.core.index.Indexed;
  7. import lombok.Data;
  8. import lombok.experimental.SuperBuilder;
  10. @SuperBuilder
  11. @Data    //Data注解可省略getset方法和toString
  12. public class Address {
  13.     @Indexed
  14.     private String city;
  15.     @Indexed
  16.     private String country;
  18.     public Address() {
  19.     }
  20. }
  1. 实体类Family ```java package com.example.demo.domain;

import org.springframework.data.redis.core.index.Indexed; import lombok.Data; import lombok.experimental.SuperBuilder;

@SuperBuilder @Data public class Family { @Indexed private String type; @Indexed private String username; public Family() {
} }

  2. 6. 新建Repository包，包下编写
  3.    1. PersonRepository接口
  4. ```java
  5. package com.example.demo.repository;
  7. import java.util.List;
  9. import org.springframework.data.domain.Page;
  10. import org.springframework.data.domain.Pageable;
  11. import org.springframework.data.repository.CrudRepository;
  13. import com.example.demo.domain.Person;
  15. public interface PersonRepository extends CrudRepository<Person, String>{
  16.     List<Person> findByLastname(String lastname);
  18.     Page<Person> findPersonByLastname(String lastname, Pageable page);
  20.     List<Person> findByFirstnameAndLastname(String firstname, String lastname);
  22.     List<Person> findByAddress_City(String city);
  24.     List<Person> findByFamilyList_Username(String username);
  26. }
  1. 配置application.properties
    ```properties

    Redis 服务器地址

    spring.redis.host = 127.0.0.1

    Redis 服务器连接端口

    spring.redis.port = 6379

    Redis 服务器连接密码(默认为空)

    spring.redis.password=

MySQL数据库连接配置 2-数据资源地址-mysql数据库：地址 3-数据库账号 4-数据库密码

spring.datasource.url=jdbc:mysql://local:2741/springbootdata?serverTimezone=UTC spring.datasource.username=root spring.datasource.password=

添加并配置第三方数据源Druid(数据库连接池) 初始大小-最小风险数10-最大连接数100

spring.datasource.type = com.alibaba.druid.pool.DruidDataSource spring.datasource.initialSize = 20 spring.datasource.minIdle = 10 spring.datasource.maxActive = 100

  2. 8. 新建Controller类，包下编写
  3.    1. PersonController类——用于对外暴露访问入口做查询
  4.       1. 该类后面接着编写Init方法——用于Controller初始化数据，将数据存入Redis
  5. ```properties
  6. package com.example.demo.Controller;
  8. import java.util.ArrayList;
  9. import java.util.List;
  11. import javax.annotation.PostConstruct;
  13. import org.springframework.beans.factory.annotation.Autowired;
  14. import org.springframework.web.bind.annotation.GetMapping;
  15. import org.springframework.web.bind.annotation.RequestMapping;
  16. import org.springframework.web.bind.annotation.RequestParam;
  17. import org.springframework.web.bind.annotation.RestController;
  19. import com.example.demo.domain.Address;
  20. import com.example.demo.domain.Family;
  21. import com.example.demo.domain.Person;
  22. import com.example.demo.repository.PersonRepository;
  24. import lombok.extern.slf4j.Slf4j;
  26. @RestController
  27. @RequestMapping("/person")
  28. @Slf4j
  29. public class PersonController {
  30.     @Autowired
  31.     private PersonRepository personRepository;
  32.     @GetMapping("/find")
  33.     public List<Person>
  34.     findPersonByLastName(@RequestParam("lastname") String lastname){
  35.         List<Person> persons = personRepository.findByLastname(lastname);
  36.         log.info("从缓存查询到{}",persons);
  37.         return persons;
  38.     }
  40.     @PostConstruct
  41.     private void init() {
  42.         //清理缓存
  43.         personRepository.deleteAll();
  44.         //创建新缓存
  45.         Address address = Address.builder().city("canton").country("china").build();
  46.         Family family = Family.builder().username("z").type("g").build();
  47.         List<Family> families = new ArrayList<>();
  48.         families.add(family);
  49.         Person person = Person.builder().address(address).familyList(families).firstname("r").lastname("z").id("50").build();
  50.         Person result = personRepository.save(person);
  51.         log.info("{}已经保存到redis",result.toString());
  52.     }
  53. }
  1. 复制测试类重命名RedisTests ```properties package com.example.demo;

import java.util.ArrayList; import java.util.List; import org.springframework.test.context.junit4.SpringRunner; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest;

import com.example.demo.domain.Address; import com.example.demo.domain.Family; import com.example.demo.domain.Person; import com.example.demo.repository.PersonRepository;

@RunWith(SpringRunner.class) @SpringBootTest class RedisTests { @Autowired private PersonRepository repository; @Test public void savePerson() { Person person = Person.builder().lastname(“张”).firstname(“有才”).build(); Person person2 = Person.builder().lastname(“James”).firstname(“Harden”).build(); //创建并添加住址信息 Address address = Address.builder().city(“北京”).country(“China”).build(); person.setAddress(address); //创建并添加家庭成员 List list = new ArrayList<>(); Family dad = Family.builder().type(“父亲”).username(“张良”).build(); Family mon = Family.builder().type(“母亲”).username(“李香君”).build(); list.add(dad); list.add(mon); person.setFamilyList(list); //向Redis数据库添加数据 Person save = repository.save(person); Person save2 = repository.save(person2); System.out.println(save); System.out.println(save2); } @Test public void selectPerson() { List list = repository.findByAddress_City(“北京”); System.out.println(list); } @Test public void updatePerson() { Person person = repository.findByFirstnameAndLastname(“张”, “有才”).get(0); person.setLastname(“小明”); Person update = repository.save(person); System.out.println(update); } @Test public void deletePerson() { Person person = repository.findByFirstnameAndLastname(“张”, “小明”).get(0); repository.delete(person); } //void contextLoads() {}

}

```