第6章 数据同步解决方案-canal

角色：数据监控同步组。后端开发人员。

学习目标

• 能够完成数据监控微服务的开发
• 能够完成首页广告缓存更新的功能
• 能够完成商品上架索引库导入数据功能，能够画出流程图和说出实现思路
• 能够完成商品下架索引库删除数据功能，能够画出流程图和说出实现思路

1. canal

拓展：mysql 主备

1.1 canal简介

1. 背景：
   早期阿里巴巴因为杭州和美国双机房部署，存在跨机房同步的业务需求，实现方式主要是基于业务 trigger 获取增量变更。从 2010 年开始，业务逐步尝试数据库日志解析获取增量变更进行同步，由此衍生出了大量的数据库增量订阅和消费业务。
   原理：
   一、MySQL主备复制原理: 拓展资料（mysql主从备份原理）
   binlog关键
   
   

   • MySQL master 将数据变更写入二进制日志( binary log, 其中记录叫做二进制日志事件binary log events，可以通过 show binlog events 进行查看) binlog

• MySQL slave 将 master 的 binary log events 拷贝到它的中继日志(relay log)

  • MySQL slave 重放 relay log 中事件，将数据变更反映它自己的数据

  • 1. canal模拟mysql slave的交互协议，伪装自己为mysql slave，向mysql master发送dump协议
• 1. mysql master收到dump请求，开始推送binary log给slave(也就是canal)
  • 1. canal解析binary log对象(原始为byte流)

https://github.com/alibaba/canal/wiki/QuickStart

1.2 环境部署

1.2.1 mysql开启binlog模式

（1）查看当前mysql是否开启binlog模式。

SHOW VARIABLES LIKE '%log_bin%'

如果log_bin的值为OFF是未开启，为ON是已开启。

（2）修改/etc/my.cnf 需要开启binlog模式。

[mysqld]
log-bin=mysql-bin
binlog-format=ROW
server_id=1

修改完成之后，重启mysqld的服务。

(3) 进入mysql

mysql -h localhost -u root -p

（4）创建账号 用于测试使用

使用root账号创建用户并授予权限

create user canal@'%' IDENTIFIED by 'canal';
GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT,SUPER ON *.* TO 'canal'@'%';
FLUSH PRIVILEGES;

1.2.2 canal服务端安装配置

（1）下载地址canal

https://github.com/alibaba/canal/releases/tag/canal-1.0.24

（2）下载之后 上传到linux系统中，解压缩到指定的目录/usr/local/canal

解压缩之后的目录结构如下：

（3）修改 exmaple下的实例配置

vi conf/example/instance.properties

修改如图所示的几个参数。

（3）指定读取位置

进入mysql中执行下面语句查看binlog所在位置

mysql> show master status;
显示如下:
+------------------+----------+--------------+------------------+-------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+------------------+----------+--------------+------------------+-------------------+
| mysql-bin.000001 |      120 |              |                  |                   |
+------------------+----------+--------------+------------------+-------------------+
1 row in set (0.00 sec)

如果file中binlog文件不为 mysql-bin.000001 可以重置mysql

mysql> reset master;

查看canal配置文件

vim /usr/local/canal/conf/example/meta.dat

找到对应的binlog信息更改一致即可

"journalName":"mysql-bin.000001","position":120,"

注意：如果不一致，可能导致以下错误

2019-06-17 19:35:20.918 [New I/O server worker #1-2] ERROR c.a.otter.canal.server.netty.handler.SessionHandler - something goes wrong with channel:[id: 0x7f2e9be3, /192.168.200.56:52225 => /192.168.200.128:11111], exception=java.io.IOException: Connection reset by peer

（4）启动服务：

[root@localhost canal]# ./bin/startup.sh

（5）查看日志：

cat /usr/local/canal/logs/canal/canal.log

这样就表示启动成功了。

1.3 数据监控微服务

当用户执行数据库的操作的时候，binlog 日志会被canal捕获到，并解析出数据。我们就可以将解析出来的数据进行相应的逻辑处理。

我们这里使用的一个开源的项目，它实现了springboot与canal的集成。比原生的canal更加优雅。

https://github.com/chenqian56131/spring-boot-starter-canal

使用前需要将starter-canal安装到本地仓库。

我们可以参照它提供的canal-test，进行代码实现。

1.3.1 微服务搭建

（1）创建工程模块ydles_canal，pom引入依赖

        <!--canal相关-->
        <dependency>
            <groupId>com.xpand</groupId>
            <artifactId>starter-canal</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <!--rabbitMq相关-->
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit</artifactId>
        </dependency>

（2）创建包com.ydles.canal ，包下创建启动类

@EnableCanalClient //标注为canal客户端
@SpringBootApplication
public class CanalApplication {
    public static void main(String[] args) {
        SpringApplication.run(CanalApplication.class,args);
    }
}

（3）添加配置文件application.properties

canal.client.instances.example.host=192.168.200.128
canal.client.instances.example.port=11111
canal.client.instances.example.batchSize=1000
spring.rabbitmq.host=192.168.200.128

（4）创建com.ydles.canal.listener包，包下创建类

/**
 * @Created by IT李老师
 * 公主号 “IT李哥交朋友”
 * 个人微 itlils
 */
@CanalEventListener //这个类是canal的监听类
public class BusinessListener {
    /**
     *
     * @param eventType 改变 insert update delete
     * @param rowData
     */
    @ListenPoint(schema = "ydles_business",table = "tb_ad")
    public void adUpdate(CanalEntry.EventType eventType,CanalEntry.RowData rowData){
        System.out.println("EventType:"+eventType);
        //改变之前 这一行数据
        List<CanalEntry.Column> beforeColumnsList = rowData.getBeforeColumnsList();
        for (CanalEntry.Column column : beforeColumnsList) {
            System.out.println("改变之前，列名字："+column.getName()+"列值："+column.getValue());
        }
        System.out.println("======================================");
        //改变之后 这一行数据
        rowData.getAfterColumnsList().forEach(c->System.out.println("改变之后，列名字："+c.getName()+"列值："+c.getValue()));
    }
}

测试：启动数据监控微服务，修改ydles_business的tb_ad表，观察控制台输出。

2. 首页广告缓存更新

2.1 需求分析

当tb_ad（广告）表的数据发生变化时，更新redis中的广告数据。

2.2 实现思路

需求：双11来了，广告要变了！如何更新

http://192.168.200.128/ad_update?position=web_index_lb

想一下：怎么实现，微服务拆分。微服务之间如何通讯：rabbitmq。

方案：

（1）数据监控微服务，监控tb_ad表，当发生增删改操作时，提取position值（广告位置key）， 发送到rabbitmq

（2）运营微服务从rabbitmq中提取消息，通过OkHttpClient调用ad_update来实现对广告缓存数据的更新。

http://192.168.200.128/ad_update?position=web_index_lb

2.3 代码实现

2.3.1 发送消息到mq

（1）在rabbitmq管理后台创建队列 ad_update_queue ，用于接收广告更新通知

（2）引入rabbitmq起步依赖

<dependency>
    <groupId>org.springframework.amqp</groupId>
    <artifactId>spring-rabbit</artifactId>
</dependency>

（3）配置文件application.properties 添加内容

spring.rabbitmq.host=192.168.200.128

（4）新增rabbitMQ配置类 com.ydles.canal.config

@Configuration
public class RabbitMQConfig {
    //定义队列名称
    public static final String AD_UPDATE_QUEUE="ad_update_queue";
    //声明队列
    @Bean
    public Queue queue(){
        return new Queue(AD_UPDATE_QUEUE);
    }
}

（4）修改BusinessListener类

@CanalEventListener //声明当前的类是canal的监听类
public class BusinessListener {
    @Autowired
    RabbitTemplate rabbitTemplate;
    /**
 *
 * @param eventType 当前操作数据库的类型
 * @param rowData 当前操作数据库的数据
 */
@ListenPoint(schema = "ydles_business",table = "tb_ad")
public void adUpdate(CanalEntry.EventType eventType,CanalEntry.RowData rowData){
    System.out.println("广告表数据发生改变");
    //        rowData.getBeforeColumnsList().forEach((c)-> System.out.println("改变前的数据："+c.getName()+"::"+c.getValue()));
//        System.out.println("========================================");
//        rowData.getAfterColumnsList().forEach((c)-> System.out.println("改变后的数据："+c.getName()+"::"+c.getValue()));
for (CanalEntry.Column column : rowData.getAfterColumnsList()) {
        if(column.getName().equals("position")){
            System.out.println("发送数据到mq"+column.getValue());
            //发送消息
            rabbitTemplate.convertAndSend("", RabbitMQConfig.AD_UPDATE_QUEQU, column.getValue());
        }
    }
}
}

（5）测试：

重启canal服务

打开 http://192.168.200.128:15672/ 观察mq

修改数据库一条数据，查看程序输出、mq

2.3.2 从mq中提取消息执行更新

ydles_service_business工程

（1）pom.xml引入依赖

    <!-- mq依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <!-- 远程调用依赖 -->
    <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>3.9.0</version>
    </dependency>

（2）在spring节点下添加rabbitmq配置

  rabbitmq:
    host: 192.168.200.128

（3）com.ydles.business.listener下添加监听类

需求：发送http://192.168.200.128/ad_update?position=web_index_lb

@Component
public class AdListener {
    @Autowired
    RestTemplate restTemplate;
    @RabbitListener(queues = "ad_update_queue")
    public void reveiveMsg(String position) {
        System.out.println("接受到了广告消息，位置:" + position);
        //发请求 http://192.168.200.128/ad_update?position=web_index_lb
        String url = "http://192.168.200.128/ad_update?position=" + position;
        restTemplate.getForObject(url, Map.class);
        ////1,创建okHttpClient对象
        //OkHttpClient okHttpClient = new OkHttpClient();
        ////2,创建一个Request
        //String url = "http://192.168.200.128/ad_update?position=" + position;
        //final Request request = new Request.Builder()
        //        .url(url)
        //        .build();
        ////3,新建一个call对象
        //Call call = okHttpClient.newCall(request);
        ////4，请求加入调度，这里是异步Get请求回调
        //call.enqueue(new Callback() {
        //    //失败了怎么样
        //    @Override
        //    public void onFailure(Call call, IOException e) {
        //        System.out.println("发送请求失败");
        //    }
        //
        //    //成功了应该怎么样
        //    @Override
        //    public void onResponse(Call call, Response response) throws IOException {
        //        System.out.println("发送请求成功"+response.message());
        //    }
        //});
    }
}

（7）测试，启动eureka和business微服务，观察控制台输出和数据同步效果。

拓展：java 发送请求 三个原生客户端

okhttp

httpclient

URLconnection

3. 商品上架索引库导入数据

3.1 需求分析

商品上架将商品的sku列表导入或更新索引库。

3.2 实现思路

（1）商品上架（spu.is_marketable 0变为1） —>canal监控—>mq发送spuId。

（2）在rabbitmq管理后台创建商品上架交换机（fanout订阅发布模式）。为什么？

1. 导入索引库。
2. 详情页面静态化。

（3）spuId—>搜索服务—>feign商品服务获取skulList—>放入Es索引库。

3.3 代码实现

3.3.1 发送消息到mq

（1）在rabbitmq后台创建交换器goods_up_exchange（类型为fanout），创建队列search_add_queue绑定交换器goods_up_exchange,更新rabbitmq配置类

回顾：rabbitMq五种工作模式。

/**
 * @Created by IT李老师
 * 公主号 “IT李哥交朋友”
 * 个人微 itlils
 */
@Configuration
public class RabbitMQConfig {
    //定义队列名称
    public static final String AD_UPDATE_QUEUE="ad_update_queue";
    @Bean
    public Queue queue(){
        return new Queue(AD_UPDATE_QUEUE,true);
    }
    //上架交换机名称
    public static final String GOODS_UP_EXCHANGE = "goods_up_exchange";
    //定义上架队列名称
    public static final String SEARCH_ADD_QUEUE = "search_add_queue";
    //定义上架队列
    @Bean(SEARCH_ADD_QUEUE)
    public Queue SEARCH_ADD_QUEUE(){
        return new Queue(SEARCH_ADD_QUEUE);
    }
    //定义上架交换机
    @Bean(GOODS_UP_EXCHANGE)
    public Exchange GOODS_UP_EXCHANGE(){
        return ExchangeBuilder.fanoutExchange(GOODS_UP_EXCHANGE).durable(true)
                .build();
    }
    //上架队列和上架交换机绑定关系构建
    @Bean
    public Binding GOODS_UP_EXCHANGE_SEARCH_ADD_QUEUE(
            @Qualifier(SEARCH_ADD_QUEUE)Queue queue
            ,@Qualifier(GOODS_UP_EXCHANGE)Exchange exchange ){
        return BindingBuilder.bind(queue).to(exchange).with("").noargs();
    }
}

（2）数据监控微服务新增com.ydles.canal.listener.SpuListener，添加以下代码：

/**
 * @Created by IT李老师
 * 公主号 “IT李哥交朋友”
 * 个人微 itlils
 */
@CanalEventListener //这个类是canal的监听类
public class SpuListener {
    @Autowired
    RabbitTemplate rabbitTemplate;
    @ListenPoint(schema = "ydles_goods",table = "tb_spu")
    public void goodsUp(CanalEntry.EventType eventType, CanalEntry.RowData rowData){
        System.out.println("监听到了spu数据变了："+eventType);
        //isMarketable 0->1
        //改变之前的数据 --->map  {id:123,name:prada}
        Map<String, String> oldMap=new HashMap<>();
        rowData.getBeforeColumnsList().forEach(column -> oldMap.put(column.getName(), column.getValue()));
        //改变之后的数据 --->map  {id:123,name:prada}
        Map<String, String> newMap=new HashMap<>();
        rowData.getAfterColumnsList().forEach(column -> newMap.put(column.getName(), column.getValue()));
        if (oldMap.get("is_marketable").equals("0")&& newMap.get("is_marketable").equals("1")){
            //mq发spuId
            String spuId = newMap.get("id");
            System.out.println("商品上架了，往mq发消息"+spuId);
            rabbitTemplate.convertAndSend(RabbitMQConfig.GOODS_UP_EXCHANGE,"",spuId);
        }
    }
}

测试：修改一条数据，查看mq中消息。

3.3.2 索引库环境准备

我们提供的虚拟机镜像中已经包含了elasticsearch的相关docker镜像

3.3.3 创建索引结构

新建ydles_service_search_api模块,并添加索引库实体类

(1) 添加依赖

        <!--公共包-->
        <dependency>
            <groupId>com.ydles</groupId>
            <artifactId>ydles_common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--spring boot 与es 结合包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>

(2) 创建实体类com.ydles.search.pojo

@Document(indexName = "skuinfo", type = "docs")
public class SkuInfo implements Serializable {
    //商品id，同时也是商品编号
    @Id
    @Field(index = true, store = true, type = FieldType.Keyword)
    private Long id;
    //SKU名称
    @Field(index = true, store = true, type = FieldType.Text, analyzer = "ik_smart")
    private String name;
    //商品价格，单位为：元
    @Field(index = true, store = true, type = FieldType.Double)
    private Long price;
    //库存数量
    @Field(index = true, store = true, type = FieldType.Integer)
    private Integer num;
    //商品图片
    @Field(index = false, store = true, type = FieldType.Text)
    private String image;
    //商品状态，1-正常，2-下架，3-删除
    @Field(index = true, store = true, type = FieldType.Keyword)
    private String status;
    //创建时间
    private Date createTime;
    //更新时间
    private Date updateTime;
    //是否默认
    @Field(index = true, store = true, type = FieldType.Keyword)
    private String isDefault;
    //SPUID
    @Field(index = true, store = true, type = FieldType.Long)
    private Long spuId;
    //类目ID
    @Field(index = true, store = true, type = FieldType.Long)
    private Long categoryId;
    //类目名称
    @Field(index = true, store = true, type = FieldType.Keyword)
    private String categoryName;
    //品牌名称
    @Field(index = true, store = true, type = FieldType.Keyword)
    private String brandName;
    //规格
    private String spec;
    //规格参数
    private Map<String, Object> specMap;
    //getter & setter略
}

3.3.4 搜索微服务搭建

（1）创建ydles_service_search模块，pom.xml引入依赖

        <!--公共包-->
        <dependency>
            <groupId>com.ydles</groupId>
            <artifactId>ydles_common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--注册中心-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!--spring boot 与es 结合包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
        <!--商品实体类-->
        <dependency>
            <groupId>com.ydles</groupId>
            <artifactId>ydles_service_goods_api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--搜索实体类-->
        <dependency>
            <groupId>com.ydles</groupId>
            <artifactId>ydles_service_search_api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--rabbitmq依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

（2）ydles_service_search的application.yml

server:
  port: 9009
spring:
  application:
    name: search
  rabbitmq:
    host: 192.168.200.128
  redis:
    host: 192.168.200.128
  main:
    allow-bean-definition-overriding: true #当遇到同样名字的时候，是否允许覆盖注册
  data:
    elasticsearch:
      cluster-name: elasticsearch
      cluster-nodes: 192.168.200.128:9300
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:6868/eureka
  instance:
    prefer-ip-address: true
feign:
  hystrix:
    enabled: true
  client:
    config:
      default:   #配置全局的feign的调用超时时间  如果 有指定的服务配置 默认的配置不会生效
        connectTimeout: 600000 # 指定的是 消费者 连接服务提供者的连接超时时间 是否能连接  单位是毫秒
        readTimeout: 600000  # 指定的是调用服务提供者的 服务 的超时时间（）  单位是毫秒
#hystrix 配置
hystrix:
  command:
    default:
      execution:
        timeout:
          #如果enabled设置为false，则请求超时交给ribbon控制
          enabled: false
        isolation:
          strategy: SEMAPHORE

（3）创建com.ydles.search包，包下创建SearchApplication

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages = {"com.ydles.goods.feign"})
public class SearchApplication {
public static void main(String[] args) {
    SpringApplication.run(SearchApplication.class,args);
}
}

(4) 将rabbitmq配置类放入该模块下

@Configuration
public class RabbitMQConfig {
    //上架交换机名称
    public static final String GOODS_UP_EXCHANGE = "goods_up_exchange";
    //定义队列名称
public static final String AD_UPDATE_QUEQU = "ad_update_quequ";
//定义上架队列名称
public static final String SEARCH_ADD_QUEUE = "search_add_queue";
//声明队列
@Bean(AD_UPDATE_QUEQU)
public Queue queue() {
    return new Queue(AD_UPDATE_QUEQU);
}
//声明上架队列
@Bean(SEARCH_ADD_QUEUE)
public Queue SEARCH_ADD_QUEUE() {
    return new Queue(SEARCH_ADD_QUEUE);
}
//声明上架交换机
@Bean(GOODS_UP_EXCHANGE)
public Exchange GOODS_UP_EXCHANGE() {
    return ExchangeBuilder.fanoutExchange(GOODS_UP_EXCHANGE).durable(true).build();
}
// 队列和交换机绑定
@Bean
public Binding GOODS_UP_EXCHANGE_BINDING(
        @Qualifier(SEARCH_ADD_QUEUE) Queue queue,
        @Qualifier(GOODS_UP_EXCHANGE) Exchange exchange) {
    return BindingBuilder.bind(queue).to(exchange).with("").noargs();
}
}

3.3.5 商品服务查询商品信息

(1) SkuController新增方法

@GetMapping("/spu/{spuId}")
public List<Sku> findSkuListBySpuId(@PathVariable("spuId") String spuId){
    Map<String,Object> searchMap =new HashMap<>();
    //搜索全部，传来的spuId为all
    if(!"all".equals(spuId)){
        //spuId作为条件传入搜索列表
        searchMap.put("spuId", spuId);
    }
    //审核通过的
    searchMap.put("status", "1");
    List<Sku> skuList = skuService.findList(searchMap);
    return  skuList;
}

(2) ydles_service_goods_api新增common依赖

<dependencies>
  <dependency>
    <groupId>com.ydles</groupId>
    <artifactId>ydles_common</artifactId>
    <version>1.0-SNAPSHOT</version>
  </dependency>
</dependencies>

(3) 定义skuFegin接口

@FeignClient(name = "goods")
public interface SkuFeign {
    //根据spuId查询skuList
    @GetMapping("/sku/spu/{spuId}")
    public List<Sku> findSkuListBySpuId(@PathVariable("spuId")String spuId);
}

4测试 http://localhost:9001/sku/spu/1205332629172256768

3.3.6 搜索微服务批量导入数据逻辑

(1) 创建 com.ydles.search.dao包,并新增ESManagerMapper接口

public interface ESManagerMapper extends ElasticsearchRepository<SkuInfo,Long> {}

（2）创建 com.ydles.search.service包，包下创建接口EsManagerService

/**
 * @Created by IT李老师
 * 公主号 “IT李哥交朋友”
 * 个人微 itlils
 */
public interface EsManagerService {
    //1创建索引库，映射
    public void createIndexAndMapping();
    //2 现有所有sku导入es
    public void importData();
    //3 根据spuId,将他的skuList导入es
    public void importDataBySpuId();
}

（2）创建com.ydles.search.service.impl包，包下创建服务实现类

Template:帮助我们创建连接，关闭连接。类比rabbitTemplate redisTemplate jdbcTemplate

@Service
public class EsManagerServiceImpl implements EsManagerService {
    @Autowired
    ElasticsearchTemplate elasticsearchTemplate;
    @Autowired
    SkuFeign skuFeign;
    @Autowired
    ESManagerMapper esManagerMapper;
    //1创建索引库，映射
    @Override
    public void createIndexAndMapping() {
        //创建索引
        elasticsearchTemplate.createIndex(SkuInfo.class);
        //创建映射
        elasticsearchTemplate.putMapping(SkuInfo.class);
    }
    //2 现有所有sku导入es
    @Override
    public void importData() {
        //1 查到现有所有sku
        List<Sku> skuList = skuFeign.findSkuListBySpuId("all");
        System.out.println("查询出的skulist多少："+skuList.size());
        //2导入es
        List<SkuInfo> skuinfoList = new ArrayList<>();
        for (Sku sku : skuList) {
            String skuStr = JSON.toJSONString(sku); //{id:12,name:asda}
            SkuInfo skuInfo = JSON.parseObject(skuStr, SkuInfo.class);
            //需求 Sku.spec string ------>SkuInfo.specMap Map
            Map map = JSON.parseObject(sku.getSpec(), Map.class);
            skuInfo.setSpecMap(map);
            skuinfoList.add(skuInfo);
        }
        esManagerMapper.saveAll(skuinfoList);
    }
    @Override
    public void importDataBySpuId() {
    }
}

(3) 创建com.ydles.search.controller.定义ESManagerController

/**
 * @Created by IT李老师
 * 公主号 “IT李哥交朋友”
 * 个人微 itlils
 */
@RestController
@RequestMapping("/manager")
public class ESManagerController {
    @Autowired
    EsManagerService esManagerService;
    @GetMapping("/create")
    public Result create(){
        esManagerService.createIndexAndMapping();
        return new Result(true, StatusCode.OK,"创建索引库成功");
    }
    @GetMapping("/importData")
    public Result importData(){
        esManagerService.importData();
        return new Result(true, StatusCode.OK,"导入数据成功");
    }
}

测试：

1head插件查看es中索引状态为空

2启动搜索服务

3postman测试 http://localhost:9009/manager/create

4结果 es中添加skuinfo索引

5postman测试 http://localhost:9009/manager/importData

6结果 es中skuinfo索引添加了数据

3.3.7 接收mq消息执行导入

梳理逻辑：canal监听到某个spu上架，发送到mq之后，搜索服务接受消息，将此spu对应的sku查出来，放到es索引库。

ydles_service_search工程创建com.ydles.search.listener包，包下创建类

/**
 * @Created by IT李老师
 * 公主号 “IT李哥交朋友”
 * 个人微 itlils
 */
@Component
public class GoodUpListener {
    @Autowired
    EsManagerService esManagerService;
    @RabbitListener(queues = RabbitMQConfig.SEARCH_ADD_QUEUE)
    public void recieveMsg(String spuId){
        System.out.println("监听到了商品上架了！："+spuId);
        esManagerService.importDataBySpuId(spuId);
    }
}

3.3.8 测试

1启动canal、search等微服务

2将数据库中spu一条数据由下架改为上架

3search输出数据

4索引库中数据添加

4. 商品下架索引库删除数据

4.1 需求分析

商品下架后将商品从索引库中移除。

4.2 实现思路

与商品上架的实现思路非常类似。

（1）在数据监控微服务中监控tb_spu表的数据，当tb_spu发生更改且is_marketable为0时，表示商品下架，将spu的id发送到rabbitmq。

（2）在rabbitmq管理后台创建商品下架交换器（fanout）。使用分列模式的交换器是考虑商品下架会有很多种逻辑需要处理，索引库删除数据只是其中一项，另外还有删除商品详细页等操作。

（3）搜索微服务从rabbitmq的的队列中提取spu的id，通过调用elasticsearch的高级restAPI 将相关的sku列表从索引库删除。

4.3 代码实现

根据上边讲解的实现思路完成商品下架索引库删除数据的功能

4.3.1 创建交换器与队列

完成商品下架交换器的创建，队列的创建与绑定，将spuId发送消息到mq

商品下架交换器：goods_down_exchange

队列名称： search_delete_queue

绑定 search_delete_queue到goods_down_exchange

 //下架交换机名称
    public static final String GOODS_DOWN_EXCHANGE = "goods_down_exchange";
    //定义下架队列名称
    public static final String SEARCH_DEL_QUEUE = "search_del_queue";
    //定义下架队列
    @Bean(SEARCH_DEL_QUEUE)
    public Queue SEARCH_DEL_QUEUE(){
        return new Queue(SEARCH_DEL_QUEUE);
    }
    //定义下架交换机
    @Bean(GOODS_DOWN_EXCHANGE)
    public Exchange GOODS_DOWN_EXCHANGE(){
        return ExchangeBuilder.fanoutExchange(GOODS_DOWN_EXCHANGE).durable(true)
                .build();
    }
    //下架队列和下架交换机绑定关系构建
    @Bean
    public Binding GOODS_DOWN_EXCHANGE_SEARCH_DEL_QUEUE(
            @Qualifier(SEARCH_DEL_QUEUE)Queue queue
            ,@Qualifier(GOODS_DOWN_EXCHANGE)Exchange exchange ){
        return BindingBuilder.bind(queue).to(exchange).with("").noargs();
    }

2将RabbitMQConfig 复制到搜索服务

4.3.2 canal监听下架

修改ydles_canal的SpuListener的spuUpdate方法，添加以下代码

//获取最新下架的商品 1->0
if ("1".equals(oldData.get("is_marketable")) && "0".equals(newData.get("is_marketable"))){
    //将商品的spuid发送到mq
    rabbitTemplate.convertAndSend(RabbitMQConfig.GOODS_DOWN_EXCHANGE,"",newData.get("id"));
}

4.3.3 根据spuId删除索引数据

编写业务逻辑，实现根据spuId删除索引库数据的方法。

（1）ESManagerService新增方法定义

//根据souid删除es索引库中相关的sku数据
void delDataBySpuId(String spuId);

（2）ESManagerServiceImpl实现方法

@Override
public void delDataBySpuId(String spuId) {
    List<Sku> skuList = skuFeign.findSkuListBySpuId(spuId);
    if (skuList == null || skuList.size()<=0){
        throw new RuntimeException("当前没有数据被查询到,无法导入索引库");
    }
    for (Sku sku : skuList) {
        esManagerMapper.deleteById(Long.parseLong(sku.getId()));
    }
}

4.3.4 接收mq消息，执行索引库删除

从rabbitmq中提取消息，调动根据spuId删除索引库数据的方法 ydles_service_search新增监听类

@Component
public class GoodsDelListener {
    @Autowired
    private ESManagerService esManagerService;
    @RabbitListener(queues = RabbitMQConfig.SEARCH_DEL_QUEUE)
    public void receiveMessage(String spuId){
        System.out.println("删除索引库监听类,接收到的spuId:  "+spuId);
        //调用业务层完成索引库数据删除
        esManagerService.delDataBySpuId(spuId);
    }
}

测试：

1重启canal、搜索服务

2修改数据库中一条数据，将上架状态改为架

3观察canal应用输出

4观察es输出

总结：

1canal

mysql 主从复制 binlog

canal伪装slave

代码

2广告更新

3商品上架 同步到es库

4商品下架 es库删除

知识点：boot cloud(feign) rabbitmq(5种工作模式) es

第7章 商品搜索-elastaicSearch

角色：搜索后端组 search-service

前置内容：2天elasticsearch入门 倒排索引 全文检索

1课程目标

• 根据搜索关键字查询
• 条件筛选
• 规格过滤
• 价格区间搜索
• 分页查询
• 排序查询
• 高亮查询

2搭建框架

2.1关键字查询-构建搜索条件

需求：day01页面原型-》search.html

1搜索服务 com.ydles.search.service

public interface SearchService {
    //按照查询条件进行数据查询
    Map search(Map<String,String> searchMap);
}

2com.ydles.search.service.impl

@Service
public class SearchServiceImpl implements SearchService {
@Autowired
ElasticsearchTemplate elasticsearchTemplate;
@Override
public Map search(Map<String, String> searchMap) {
    //构建查询
    if(searchMap!=null){
         //  条件构建对象
        NativeSearchQueryBuilder nativeSearchQueryBuilder=new NativeSearchQueryBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //关键字查询
        if(StringUtils.isNotEmpty(searchMap.get("keywords"))){
            boolQueryBuilder.must(QueryBuilders.matchQuery("name", searchMap.get("keywords")).operator(Operator.AND));
        }
        nativeSearchQueryBuilder.withQuery(boolQueryBuilder);
        //开启查询
        /**
         * 条件构建对象
         * 查询实体类
         * 查询结果对象
         */
        AggregatedPage<SkuInfo> resultInfo = elasticsearchTemplate.queryForPage(nativeSearchQueryBuilder.build(), SkuInfo.class, new SearchResultMapper() {
            @Override
            public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
                            return null;
            }
        });
    }
    return null;
}
}

2.2封装查询结果

完善com.ydles.search.service.impl

@Service
public class SearchServiceImpl implements SearchService {
@Autowired
ElasticsearchTemplate elasticsearchTemplate;
@Override
public Map search(Map<String, String> searchMap) {
    //结果map
    Map<String,Object> resultMap=new HashMap<>();
    //构建查询
    if(searchMap!=null){
         //  条件构建对象
        NativeSearchQueryBuilder nativeSearchQueryBuilder=new NativeSearchQueryBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //关键字查询
        if(StringUtils.isNotEmpty(searchMap.get("keywords"))){
            boolQueryBuilder.must(QueryBuilders.matchQuery("name", searchMap.get("keywords")).operator(Operator.AND));
        }
        nativeSearchQueryBuilder.withQuery(boolQueryBuilder);
        //开启查询
        /**
         * 条件构建对象
         * 查询实体类
         * 查询结果对象
         */
        //封装查询结果
        AggregatedPage<SkuInfo> resultInfo = elasticsearchTemplate.queryForPage(nativeSearchQueryBuilder.build(), SkuInfo.class, new SearchResultMapper() {
            @Override
            public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
                // 查询结果操作
                List<T> list=new ArrayList<>();
                // 获取结果
                SearchHits hits = searchResponse.getHits();
                if (hits!=null){
                    for (SearchHit hit : hits) {
                        // hit对象转为skuinfo
                        SkuInfo skuInfo = JSON.parseObject(hit.getSourceAsString(), SkuInfo.class);
                        list.add((T) skuInfo);
                    }
                }
                //构建返回对象
                return new AggregatedPageImpl<>(list,pageable,hits.getTotalHits(),searchResponse.getAggregations());
            }
        });
                // 封装最终返回结果
        //总记录数
        resultMap.put("total", resultInfo.getTotalElements());
        //总页数
        resultMap.put("totalPages",resultInfo.getTotalPages());
        //数据集合
        resultMap.put("rows", resultInfo.getContent());
    }
    return resultMap;
}
}

2.3表现层定义

1 com.ydles.search.controller

@RestController
@RequestMapping("/search")
public class SearchController {
    @Autowired
    SearchService searchService;
    @GetMapping
public  Map search(@RequestParam Map<String,String> searchMap){
    //特殊符号处理
    this.handleSearchMap(searchMap);
    Map searchResult = searchService.search(searchMap);
    return searchResult;
}
private void handleSearchMap(Map<String, String> searchMap) {
    Set<Map.Entry<String, String>> entries = searchMap.entrySet();
    for (Map.Entry<String, String> entry : entries) {
        if (entry.getKey().startsWith("spec_")){
            searchMap.put(entry.getKey(), entry.getValue().replace("+", "%2B"));
        }
    }
}
}

2.4测试

postman测试 http://localhost:9009/search?keywords=包包

结果：默认分页 每页10条

3各种查询

3.1条件查询需求

3.2品牌过滤查询

需求：search.ydles.com/search?keywords=PRADA包包&brand=prada

1完善 SearchServiceImpl

//按照品牌查询       
if(StringUtils.isNotEmpty(searchMap.get("brand"))){         
    boolQueryBuilder.filter(QueryBuilders.termQuery("brandName", searchMap.get("brand")));
}

测试 http://localhost:9009/search?keywords=包包&brand=PRADA

http://localhost:9009/search?keywords=包包2019秋季限量版&brand=PRADA

3.3品牌聚合查询

需求：查看静态页面，品牌的显示要根据搜索结果不同展现。

1完善 SearchServiceImpl

//按照品牌聚合
String skuBrand="skuBrand";        nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuBrand).field("brandName"));
//封装品牌分组结果
StringTerms brandTerms = (StringTerms) resultInfo.getAggregation(skuBrand);
List<String> brandList = brandTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
resultMap.put("brandList", brandList);

测试： http://localhost:9009/search?keywords=包包

3.4按照规格过滤

需求：

（1）前端发来规格查询：

 http://localhost:9009/search?keywords=包包&spec_颜色=黑色&spec_二手程度=崭新出厂

（2）后台接到数据后，可以根据前缀spec_来区分是否是规格，如果以 spec_xxx 开始的数据 则为规格数据，需要根据指定规格找信息。

（3）

上图是规格的索引存储格式，真实数据在 “specMap.二手程度.keyword” 中，所以找数据 也是按照如下格式去找。

1完善 SearchServiceImpl

//按照规格过滤查询
        for (String key : searchMap.keySet()) {
            if(key.startsWith("spec_")){
                String value = searchMap.get(key).replace("%2B", "+");                boolQueryBuilder.filter(QueryBuilders.termQuery("specMap."+key.substring(5)+".keyword", value));
            }
        }

测试： http://localhost:9009/search?keywords=包包&spec_颜色=黑色

3.5按照规格聚合

1完善 SearchServiceImpl

//按照规格聚合
String skuSpec="skuSpec";        nativeSearchQueryBuilder.addAggregation(AggregationBuilders.terms(skuSpec).field("spec.keyword"));
//封装规格分组结果
StringTerms specTerms = (StringTerms) resultInfo.getAggregation(skuSpec);
List<String> specList = specTerms.getBuckets().stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
resultMap.put("specList", specList);

测试： http://localhost:9009/search?keywords=包包

text 类型 不能进行聚合和排序

keyword 类型 能进行聚合和排序

3.6价格区间查询

price=0-5000 price=30000

需求：价格区间查询，每次需要将价格传入到后台，前端传入后台的价格大概是 price=0‐500 或者 price=500‐1000 依次类推，最后一个是 price=3000 ,后台可以根据-分割，如果分割 得到的结果最多有2个，第1个表示 x<price ，第2个表示 price<=y。

1完善 SearchServiceImpl

            //价格区间查询  price=0-5000     price=30000
            if(StringUtils.isNotEmpty(searchMap.get("price"))){
                String price = searchMap.get("price");
                String[] split = price.split("-");
                //代码优化 codeReview
                RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("price").gte(split[0]);
                if(split.length==2){
                    //price=0-5000
                    rangeQueryBuilder.lte(split[1]);
                }//else {
                    //price=30000
                //}
                boolQueryBuilder.filter(rangeQueryBuilder);
            }

测试： http://localhost:9009/search?keywords=包包&price=0-500

3.7分页

需求：http://localhost:9009/search?keywords=包包&pageNum=1&pageSize=30

没有带分页参数，你得给我默认查询第一页，每页30条数据。

es:

1完善 SearchServiceImpl

        //分页查询
        String pageNum = searchMap.get("pageNum");
        String pageSize = searchMap.get("pageSize");
        if(StringUtils.isEmpty(pageNum)){
            pageNum="1";
        }
        if(StringUtils.isEmpty(pageSize)){
            pageSize="30";
        }
        nativeSearchQueryBuilder.withPageable(PageRequest.of(Integer.parseInt(pageNum)-1, Integer.parseInt(pageSize)));
        // 当前页
        resultMap.put("pageNum", pageNum);

测试： http://localhost:9009/search?keywords=包包&pageNum=5&pageSize=20

3.8排序

• 排序这里总共有根据价格排序、根据评价排序、根据新品排序、根据销量排序，排序要 想实现非常简单，只需要告知排序的域以及排序方式即可实现。

• 价格排序：只需要根据价格高低排序即可，降序价格高->低，升序价格低->高
  评价排序：评价分为好评、中评、差评，可以在数据库中设计3个列，用来记录好评、中 评、差评的量，每次排序的时候，好评的比例来排序，当然还要有

• 条数限制，评价条数 需要超过N条。

• 新品排序：直接根据商品的发布时间或者更新时间排序。

• 销量排序：销量排序除了销售数量外，还应该要有时间段限制。
  需求：http://localhost:9009/search?keywords=包包&sortField=price&sortRule=Desc
  
  1完善 SearchServiceImpl

      //排序
      //1当前域2升序降序
      if (StringUtils.isNotEmpty(searchMap.get("sortField")) && StringUtils.isNotEmpty(searchMap.get("sortRule"))) {
          if ("ASC".equals(searchMap.get("sortRule"))) {
              //升序
              nativeSearchQueryBuilder.withSort(SortBuilders.fieldSort(searchMap.get("sortField")).order(SortOrder.ASC));
          } else {
              //降序
           nativeSearchQueryBuilder.withSort(SortBuilders.fieldSort(searchMap.get("sortField")).order(SortOrder.DESC));
          }
      }

测试： http://localhost:9009/search?keywords=包包&pageSize=1000&sortField=price&sortRule=Desc

3.9高亮介绍

需求：京东搜索电脑

什么是高亮：搜索结果文字样式不同于其他。

<font class="skcolor_ljg">包包</font>

实现步骤：

1.指定高亮字段：name字段。关键词前后加标签。

2.将高亮字段提取，替换高亮字段:name。

3.10高亮实现

//1设置高亮域
HighlightBuilder.Field field = new HighlightBuilder.Field("name");
//前缀
field.preTags("<span style='color:red'>");
//后缀
field.postTags("</span>");      
nativeSearchQueryBuilder.withHighlightFields(field);
//2获取高亮字段
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
if (highlightFields != null&&highlightFields.size()>0) {                               skuInfo.setName(highlightFields.get("name").getFragments()[0].toString());
}

测试： http://localhost:9009/search?keywords=包包

总结 搜索后台开发工程师

1 estemplate.queryForPage(构建搜索条件，实体类，结果映射)

2各种查询

第8章 Thymeleaf

角色： 前端 展现到前台。

学习目标

• Thymeleaf的介绍
• Thymeleaf的入门
• Thymeleaf的语法及标签
• 搜索页面渲染
• 商品详情页静态化功能实现

1.Thymeleaf介绍

1动态页面：

html+java

通过执行asp、php、jsp和.net等程序生成客户端网页代码的网页。通常可以通过网站后台管理系统对网站的内容进行更新管理。发布新闻，发布公司产品，交流互动，博客，网上调查等，这都是动态网站的一些功能。也是我们常见的。 常见的扩展名有：.asp、php、jsp、cgi和aspx 等。 注意：动态页面的“动态”是网站与客户端用户互动的意思，而非网页上有动画的就是动态页面。

A．交互性好。

B．动态网页的信息都需要从数据库中读取，每打开一个一面就需要去获取一次数据库，如果访问人数很多，也就会对服务器增加很大的荷载，从而影响这个网站的运行速度。

2静态页面：

最早的时候，网站内容是通过在主机空间中放置大量的静态网页实现的。为了方便对这些分散在不同目录的静态网页的管理，（一般是通过FTP)，象frontpage/dreamweaver这样软件甚至直接提供了向主页空间以FTP方式直接访问文件的功能。以静态网页为主的网站最大的困难在于对网页的管理，在这种框架里，网页框架和网页中的内容混杂在一起，很大程度地加大了内容管理的难度。为了减轻这种管理的成本，发展出了一系列的技术，甚至连css本身，原本也是针对这种乱七八糟的网页维护而设计的，目的就是把网页表达的框架和内容本身抽象分离出来。

A．静态网页的内容稳定，页面加载速度快。

B．静态网页的没有数据库支持，在网站制作和维护方面的工作量较大。

C．静态网页的交互性差，有很大的局限性。

3为什么需要动态页面静态化：

1. 搜索引擎的优化

尽管搜索机器人有点讨厌，各个网站不但不会再象从前一样把它封起来，反而热情无比地搞SEO，所谓的面向搜索引擎的优化，其中就包括访问地址的改写，令动态网页看上去是静态网页，以便更多更大量地被搜索引擎收录，从而最大限度地提高自已的内容被目标接收的机会。但是，在完全以动态技术开发的网站，转眼中要求变换成静态网页提供，同时，无论如何，动态网页的内容管理功能也是必须保留的；就如同一辆飞驶的奔驰忽然要求180度转弯，要付出的成本代价是非常大的，是否真的值得，也确实让人怀疑。

1. 提高程序性能 10w/s

很多大型网站，进去的时候看它很复杂的页面，但是加载也没有耗费多长时间，除了其它必要原因以外，静态化也是其中必需考虑的技术之一。

先于用户获取资源或数据库数据进而通过静态化处理，生成静态页面，所有人都访问这一个静态页面，而静态化处理的页面本身的访问速度要较动态页面快很多倍，因此程序性能会有大大的提升。

静态化在页面上的体现为：访问速度加快，用户体验性明显提升；在后台体现为：访问脱离数据库，减轻了数据库访问压力。

模板+数据=文本

thymeleaf是一个XML/XHTML/HTML5模板引擎，可用于Web与非Web环境中的应用开发。它是一个开源的Java库，基于Apache License 2.0许可，由Daniel Fernández创建，该作者还是Java加密库Jasypt的作者。

Thymeleaf提供了一个用于整合Spring MVC的可选模块，在应用开发中，你可以使用Thymeleaf来完全代替JSP或其他模板引擎，如Velocity、FreeMarker等。Thymeleaf的主要目标在于提供一种可被浏览器正确显示的、格式良好的模板创建方式，因此也可以用作静态建模。你可以使用它创建经过验证的XML与HTML模板。相对于编写逻辑或代码，开发者只需将标签属性添加到模板中即可。接下来，这些标签属性就会在DOM（文档对象模型）上执行预先制定好的逻辑。

它的特点便是：开箱即用，Thymeleaf允许您处理六种模板，每种模板称为模板模式：

• XML
• 有效的XML
• XHTML
• 有效的XHTML
• HTML5
• 旧版HTML5

所有这些模式都指的是格式良好的XML文件，但Legacy HTML5模式除外，它允许您处理HTML5文件，其中包含独立（非关闭）标记，没有值的标记属性或不在引号之间写入的标记属性。为了在这种特定模式下处理文件，Thymeleaf将首先执行转换，将您的文件转换为格式良好的XML文件，这些文件仍然是完全有效的HTML5（实际上是创建HTML5代码的推荐方法）1。

另请注意，验证仅适用于XML和XHTML模板。

然而，这些并不是Thymeleaf可以处理的唯一模板类型，并且用户始终能够通过指定在此模式下解析模板的方法和编写结果的方式来定义他/她自己的模式。这样，任何可以建模为DOM树（无论是否为XML）的东西都可以被Thymeleaf有效地作为模板处理。

4Thymeleaf介绍

1概念：XML/XHTML/HTML5模板引擎。

2其他模板引擎：Velocity、FreeMarker、jsp

3为什么使用它：springboot内置支持

4特点：开箱即用，Thymeleaf允许您处理六种模板，每种模板称为模板模式：

• XML
• 有效的XML
• XHTML
• 有效的XHTML
• HTML5
• 旧版HTML5

2.Springboot整合thymeleaf

使用springboot 来集成使用Thymeleaf可以大大减少单纯使用thymleaf的代码量，所以我们接下来使用springboot集成使用thymeleaf.

实现的步骤为：

• 创建一个sprinboot项目
• 添加thymeleaf的起步依赖
• 添加spring web的起步依赖
• 编写html 使用thymleaf的语法获取变量对应后台传递的值
• 编写controller 设置变量的值到model中

(1)创建工程

创建一个独立的工程springboot-thymeleaf,该工程为案例工程，不需要放到ydles工程中。

pom.xml依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.ydles</groupId>
    <artifactId>springboot-thymeleaf</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
    </parent>
    <dependencies>
        <!--web起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--thymeleaf配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
    </dependencies>
</project>

(2)创建包com.ydles.thymeleaf.并创建启动类ThymeleafApplication

@SpringBootApplication
public class ThymeleafApplication {
    public static void main(String[] args) {
        SpringApplication.run(ThymeleafApplication.class,args);
    }
}

(3)创建application.yml

设置thymeleaf的缓存设置，设置为false。默认加缓存的，用于测试。

spring:
  thymeleaf:
    cache: false

(4)控制层

创建controller用于测试后台 设置数据到model中。

创建com.ydles.controller.TestController，代码如下：

@Controller
@RequestMapping("/test")
public class TestController {
    /***
     * 访问/test/hello  跳转到demo1页面
     * @param model
     * @return
     */
    @RequestMapping("/hello")
    public String hello(Model model){
        model.addAttribute("hello","hello welcome");
        return "demo";
    }
}

(2)创建html

在resources中创建templates目录，在templates目录创建 demo.html,代码如下：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Thymeleaf的入门</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
</head>
<body>
<!--输出hello数据-->
<p th:text="${hello}"></p>
</body>
</html>

解释：

html xmlns:th="http://www.thymeleaf.org":这句声明使用thymeleaf标签

(5)测试

启动系统，并在浏览器访问

http://localhost:8080/test/hello

3 Thymeleaf基本语法

(1)th:action

定义后台控制器路径，类似标签的action属性。

例如：

<form th:action="@{/demo/test}">
    <input th:type="text" th:name="id">
    <button>提交</button>
</form>

action

public String test(Model model,String id){    
    System.out.println(id);
}

(2)th:each

对象遍历，功能类似jstl中的标签。

创建com.ydles.model.User,代码如下：

public class User {
private Integer id;
private String name;
private String address;
getter and settrt
}

Controller添加数据

    List<User> userList=new ArrayList<>();
    userList.add(new User(1, "a", "bj"));
    userList.add(new User(2, "b", "tj"));
    userList.add(new User(3, "c", "nj"));
    model.addAttribute("userList", userList);

demo.html

<table>
    <tr>
        <td>下标</td>
        <td>编号</td>
        <td>姓名</td>
        <td>住址</td>
    </tr>
    <tr th:each="user,userStat:${userList}">
        <td th:text="${userStat.index}"></td>
        <td th:text="${user.id}"></td>
        <td th:text="${user.name}"></td>
        <td th:text="${user.address}"></td>
    </tr>
</table>

测试效果

(3) map取值

1action

    Map<String,Object> dataMap=new HashMap<>();
    dataMap.put("No", "123");
    dataMap.put("address", "bj");
    model.addAttribute("dataMap", dataMap);

2 demo.html

<div th:each="map,mapStat:${dataMap}">
    <div th:text="${map}"></div>
    key:<span th:text="${mapStat.current.key}"></span><br>
    value:<span th:text="${mapStat.current.value}"></span><br>
    ====================================
</div>

3测试 启动工程 访问 http://localhost:8080/demo/hello

测试效果

(4)数组遍历

1action

String[] names={"张三","李四","王五"};
model.addAttribute("names",names );

2demo.html

<div th:each="nm,nmStat:${names}">
    <span th:text="${nmStat.count}"></span><br>
    <span th:text="${nm}"></span><br>
    ====================================
</div>

3测试 启动工程 访问 http://localhost:8080/demo/test

测试效果

(5)Date输出

1action

model.addAttribute("now", new Date());

2demo.html

<div>    
    <span th:text="${#dates.format(now,'yyyy-MM-dd hh:mm:ss')}"></span>
</div>

测试效果

(6)th:if条件

1action

model.addAttribute("age", 15);

2demo.html

<div>    
    <span th:if="${(age>=18)}">终于成年了</span>
</div>

测试效果

(7)th:fragment 模块声明与页面包含

1 新建footer.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>fragment</title>
</head>
<body>
<div id="C" th:fragment="copy">
    关于我们<br/>
</div>
</body>
</html>