• Springboot整合ShardingJdbc实现分库分表方案

    一、创建库表

    1、创建两个数据库

    1. CREATE SCHEMA `shard_db_0` DEFAULT CHARACTER SET utf8 ;
    2. CREATE SCHEMA `shard_db_1` DEFAULT CHARACTER SET utf8 ;

    2、在每个数据库各创建三个分表

    1. CREATE TABLE `tb_order_0` (
    2.   `order_id` bigint(20) NOT NULL,
    3.   `buyer_id` bigint(20) not null comment '买家ID',
    4.   `seller_id` bigint(20) not null comment '卖家ID',
    5.   `order_name` varchar(64) not NULL COMMENT '商品名称',
    6.   `price` decimal(10,2) DEFAULT NULL COMMENT '商品价格',
    7.   PRIMARY KEY (`order_id`)
    8. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    1. CREATE TABLE `tb_order_1` (
    2.   `order_id` bigint(20) NOT NULL,
    3.   `buyer_id` bigint(20) not null comment '买家ID',
    4.   `seller_id` bigint(20) not null comment '卖家ID',
    5.   `order_name` varchar(64) not NULL COMMENT '商品名称',
    6.   `price` decimal(10,2) DEFAULT NULL COMMENT '商品价格',
    7.   PRIMARY KEY (`order_id`)
    8. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    1. CREATE TABLE `tb_order_2` (
    2.   `order_id` bigint(20) NOT NULL,
    3.   `buyer_id` bigint(20) not null comment '买家ID',
    4.   `seller_id` bigint(20) not null comment '卖家ID',
    5.   `order_name` varchar(64) not NULL COMMENT '商品名称',
    6.   `price` decimal(10,2) DEFAULT NULL COMMENT '商品价格',
    7.   PRIMARY KEY (`order_id`)
    8. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

    2、创建工程

    1、引入maven依赖

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.     <modelVersion>4.0.0</modelVersion>
    5.     <parent>
    6.         <groupId>org.springframework.boot</groupId>
    7.         <artifactId>spring-boot-starter-parent</artifactId>
    8.         <version>3.3.1</version>
    9.         <relativePath/> <!-- lookup parent from repository -->
    10.     </parent>
    11.     <groupId>com.example</groupId>
    12.     <artifactId>sharding-sphere-demo</artifactId>
    13.     <version>0.0.1-SNAPSHOT</version>
    14.     <name>sharding-sphere-demo</name>
    15.     <description>sharding-sphere-demo</description>
    16.     <url/>
    17.     <licenses>
    18.         <license/>
    19.     </licenses>
    20.     <developers>
    21.         <developer/>
    22.     </developers>
    23.     <scm>
    24.         <connection/>
    25.         <developerConnection/>
    26.         <tag/>
    27.         <url/>
    28.     </scm>
    29.     <properties>
    30.         <java.version>17</java.version>
    31.     </properties>
    32.     <dependencies>
    33.         <dependency>
    34.             <groupId>org.springframework.boot</groupId>
    35.             <artifactId>spring-boot-starter-web</artifactId>
    36.         </dependency>
    37.  
    38.         <dependency>
    39.             <groupId>org.projectlombok</groupId>
    40.             <artifactId>lombok</artifactId>
    41.             <optional>true</optional>
    42.         </dependency>
    43.         <dependency>
    44.             <groupId>org.springframework.boot</groupId>
    45.             <artifactId>spring-boot-starter-test</artifactId>
    46.             <scope>test</scope>
    47.         </dependency>
    48.  
    49.         <dependency>
    50.             <groupId>mysql</groupId>
    51.             <artifactId>mysql-connector-java</artifactId>
    52.             <version>8.0.15</version>
    53.         </dependency>
    54.  
    55.         <!-- MyBatis-Plus -->
    56.         <dependency>
    57.             <groupId>com.baomidou</groupId>
    58.             <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
    59.             <version>3.5.7</version>
    60.         </dependency>
    61.  
    62.         <!-- https://mvnrepository.com/artifact/org.apache.shardingsphere/shardingsphere-jdbc-core-spring-boot-starter -->
    63.         <dependency>
    64.             <groupId>org.apache.shardingsphere</groupId>
    65.             <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
    66.             <version>5.2.1</version>
    67.         </dependency>
    68.  
    69.         <dependency>
    70.             <groupId>org.apache.commons</groupId>
    71.             <artifactId>commons-lang3</artifactId>
    72.         </dependency>
    73.  
    74.         <dependency>
    75.             <groupId>cn.hutool</groupId>
    76.             <artifactId>hutool-all</artifactId>
    77.             <version>5.3.1</version>
    78.         </dependency>
    79.  
    80.         <dependency>
    81.             <groupId>junit</groupId>
    82.             <artifactId>junit</artifactId>
    83.             <scope>test</scope>
    84.         </dependency>
    85.  
    86.     </dependencies>
    87.  
    88.     <build>
    89.         <plugins>
    90.             <plugin>
    91.                 <groupId>org.springframework.boot</groupId>
    92.                 <artifactId>spring-boot-maven-plugin</artifactId>
    93.                 <configuration>
    94.                     <excludes>
    95.                         <exclude>
    96.                             <groupId>org.projectlombok</groupId>
    97.                             <artifactId>lombok</artifactId>
    98.                         </exclude>
    99.                     </excludes>
    100.                 </configuration>
    101.             </plugin>
    102.         </plugins>
    103.     </build>
    104.  
    105. </project>

    2、创建po

    1. @Builder
    2. @Data
    3. @TableName("tb_buyer")
    4. public class TbBuyer {
    5.  
    6.     @TableId
    7.     private Long buyerId;
    8.     private String buyerName;
    9.     private Boolean sex;
    10.     private Integer age;
    11.  
    12. }
    1. @Builder
    2. @Data
    3. @TableName("tb_order")
    4. public class TbOrder {
    5.  
    6.     @TableId
    7.     private Long orderId;
    8.     private Long buyerId;
    9.     private Long sellerId;
    10.     private String orderName;
    11.     private BigDecimal price;
    12.  
    13. }
    1. @Builder
    2. @Data
    3. @TableName("tb_seller")
    4. public class TbSeller {
    5.  
    6.     @TableId
    7.     private Long sellerId;
    8.     private String sellerName;
    9.     private Boolean sex;
    10.     private Integer age;
    11.  
    12. }

    3、创建mapper

    1. package com.example.shardingsphere.mapper;
    2.  
    3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    4. import com.example.shardingsphere.po.TbBuyer;
    5. import org.apache.ibatis.annotations.Mapper;
    6.  
    7. @Mapper
    8. public interface TbBuyerMapper extends BaseMapper<TbBuyer> {
    9.     // 可以在这里定义自定义方法
    10. }
    1. package com.example.shardingsphere.mapper;
    2.  
    3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    4. import com.example.shardingsphere.po.TbOrder;
    5. import org.apache.ibatis.annotations.Mapper;
    6.  
    7. @Mapper
    8. public interface TbOrderMapper extends BaseMapper<TbOrder> {
    9.     // 可以在这里定义自定义方法
    10. }
    1. package com.example.shardingsphere.mapper;
    2.  
    3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    4. import com.example.shardingsphere.po.TbSeller;
    5. import org.apache.ibatis.annotations.Mapper;
    6.  
    7. @Mapper
    8. public interface TbSellerMapper extends BaseMapper<TbSeller> {
    9.     // 可以在这里定义自定义方法
    10. }

    4、创建controller控制器

    1. package com.example.shardingsphere.web;
    2.  
    3. import com.example.shardingsphere.mapper.TbBuyerMapper;
    4. import com.example.shardingsphere.mapper.TbOrderMapper;
    5. import com.example.shardingsphere.mapper.TbSellerMapper;
    6. import com.example.shardingsphere.po.TbOrder;
    7. import jakarta.annotation.Resource;
    8. import org.springframework.web.bind.annotation.GetMapping;
    9. import org.springframework.web.bind.annotation.PathVariable;
    10. import org.springframework.web.bind.annotation.RestController;
    11.  
    12. import java.util.HashMap;
    13. import java.util.Map;
    14.  
    15. @RestController
    16. public class OrderController {
    17.  
    18.     @Resource
    19.     private TbBuyerMapper tbBuyerMapper ;
    20.     @Resource
    21.     private TbSellerMapper tbSellerMapper ;
    22.     @Resource
    23.     private TbOrderMapper tbOrderMapper ;
    24.  
    25.     /**
    26.      * 查询订单详情
    27.      */
    28.     @GetMapping("/order/info/{orderId}")
    29.     public Map orderInfo (@PathVariable Long orderId){
    30.         Map orderMap = new HashMap<>() ;
    31.         TbOrder order = tbOrderMapper.selectById(orderId) ;
    32.         if (order != null){
    33.             orderMap.put("order",order) ;
    34.             orderMap.put("buyer",tbBuyerMapper.selectById(order.getBuyerId())) ;
    35.             orderMap.put("seller",tbSellerMapper.selectById(order.getSellerId())) ;
    36.         }
    37.         return orderMap ;
    38.     }
    39. }

    5、用到的工具类（雪花算法生成关联表主键ID，测试用，无特殊意义）

    1. package com.example.shardingsphere.provider;
    2.  
    3. import cn.hutool.core.lang.Snowflake;
    4. import cn.hutool.core.util.IdUtil;
    5. import cn.hutool.core.util.RandomUtil;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.apache.commons.lang3.StringUtils;
    8. import org.apache.commons.lang3.SystemUtils;
    9. import org.springframework.boot.ApplicationArguments;
    10. import org.springframework.boot.ApplicationRunner;
    11. import org.springframework.stereotype.Component;
    12.  
    13. import java.net.Inet4Address;
    14. import java.net.InetAddress;
    15. import java.net.UnknownHostException;
    16.  
    17. /**
    18.  * 雪花算法
    19.  *
    20.  */
    21. @Slf4j
    22. @Component
    23. public class SnowFlakeProvider implements ApplicationRunner {
    24.  
    25.     private long workerId;
    26.     private Snowflake snowFlake;
    27.     private long datacenterId;
    28.  
    29.     /**
    30.      * 初始化方法，用于在类实例化后进行必要的设置。
    31.      * 本方法主要用于确定WorkerId，这是一个在分布式系统中唯一标识当前节点的ID。
    32.      * 它通过获取本地主机名或IP并转换为long值来实现。
    33.      * 如果无法获取本地主机名或IP，或者转换过程中发生异常，将不设置workerId，可能导致后续ID生成失败。
    34.      */
    35.     @Override
    36.     public void run(ApplicationArguments args) throws Exception {
    37.         //初始化workId
    38.         initWorkId();
    39.  
    40.         initDataCenterId();
    41.  
    42.         //初始化SnowflakeID生成器
    43.         createSnowFlake(workerId, datacenterId);
    44.     }
    45.  
    46.     /**
    47.      * 根据IP Address 生成workId
    48.      *
    49.      * @return
    50.      */
    51.     private void initWorkId() {
    52.         try {
    53.             String hostAddress = Inet4Address.getLocalHost().getHostAddress();
    54.             log.info("hostAddress========={}", hostAddress);
    55.             int[] ints = StringUtils.toCodePoints(hostAddress);
    56.             int sums = 0;
    57.             for (int b : ints) {
    58.                 sums += b;
    59.             }
    60.             workerId= (long) (sums % 32);
    61.         } catch (UnknownHostException e) {
    62.             log.error("根据IP获取workId失败。", e);
    63.             // 如果获取失败，则使用随机数备用
    64.             workerId = RandomUtil.randomLong(0, 31);
    65.         }
    66.     }
    67.     /**
    68.      * 根据HostName 生成dataCenterId
    69.      * @return
    70.      */
    71.     private void initDataCenterId() {
    72.         String hostName = getHostName();
    73.         log.info("hostName========={}", hostName);
    74.         int[] ints = StringUtils.toCodePoints(hostName);
    75.         int sums = 0;
    76.         for (int i : ints) {
    77.             sums += i;
    78.         }
    79.         datacenterId = (long) (sums % 32);
    80.     }
    81.  
    82.     /**
    83.      * 获取 hostName
    84.      *   SystemUtils.getHostName() 在mac系统为空处理
    85.      * @return
    86.      */
    87.     public static String getHostName() {
    88.         //获取当前操作系统名称,例如:windows xp,linux 等
    89.         String osName = System.getProperty("os.name");
    90.         String hostName = null;
    91.         if(!StringUtils.startsWithIgnoreCase(osName,"mac")){
    92.             hostName = SystemUtils.getHostName();
    93.         }else{
    94.             try {
    95.                 hostName = InetAddress.getLocalHost().getHostName().toUpperCase();
    96.             } catch (UnknownHostException e) {
    97.                 hostName = "N/A";
    98.                 log.error("获取 hostName错误：", e);
    99.             }
    100.         }
    101.         return hostName;
    102.     }
    103.  
    104.     /**
    105.      * 初始化SnowflakeID生成器。
    106.      * 使用指定的workerId和datacenterId创建SnowflakeID生成器实例。如果创建失败，将抛出异常。
    107.      *
    108.      * @param workerId 工作节点ID，用于标识当前节点。
    109.      * @param datacenterId 数据中心ID，用于标识数据中心。
    110.      * @throws IllegalArgumentException 如果Snowflake实例创建失败，则抛出此异常。
    111.      * @throws RuntimeException 如果Snowflake实例创建过程中发生其他异常，则抛出此异常。
    112.      */
    113.     private Snowflake createSnowFlake(long workerId, long datacenterId) {
    114.         try {
    115.             this.snowFlake = IdUtil.createSnowflake(workerId, datacenterId);
    116.             // 参数合法性检查
    117.             if (null == snowFlake) {
    118.                 throw new IllegalArgumentException("Failed to create Snowflake instance. Check workerId and datacenterId.");
    119.             }
    120.             return snowFlake;
    121.         } catch (Exception e) {
    122.             log.error("创建Snowflake实例失败，异常：{}", e.getMessage());
    123.             throw new RuntimeException("Initialization failed for Snowflake ID generator.", e);
    124.         }
    125.     }
    126.  
    127.     /**
    128.      * 获取一个唯一的雪花ID。使用Snowflake算法生成ID，该算法由Twitter开源。
    129.      * 具体来说，这个方法调用了Snowflake实例的nextId方法来获取一个唯一的长整型ID。
    130.      * 使用synchronized关键字确保了这个方法在多线程环境下的线程安全，
    131.      * 保证了ID的生成不会因为并发而产生重复或错乱。
    132.      *
    133.      * @return 生成的唯一长整型ID。
    134.      */
    135.     public synchronized long snowflakeId() {
    136.         // 调用Snowflake实例的nextId方法获取唯一ID
    137.         return this.snowFlake.nextId();
    138.     }
    139.  
    140.     /**
    141.      * 生成基于Snowflake算法的唯一ID。
    142.      * 
    143.      * 使用Snowflake算法生成唯一的分布式ID。该算法由Twitter提出，通过组合时间戳、工作机器ID和序列号来生成全局唯一的ID。
    144.      * 具体结构如下：
    145.      * - 1位符号位，用于区分正负，由于ID只能是正数，所以这个位始终为0。
    146.      * - 41位时间戳，精确到毫秒，可以使用约69年。
    147.      * - 10位工作机器ID，可以部署在1024个节点，包括5位数据中心ID和5位工作机器ID。
    148.      * - 12位序列号，用于同一毫秒内生成的ID去重，每个节点每毫秒可以生成4096个ID。
    149.      * 
    150.      * 参数:
    151.      * workerId - 工作机器ID，用于标识不同的工作机器或进程。
    152.      * datacenterId - 数据中心ID，用于标识不同的数据中心。
    153.      * 
    154.      * 返回:
    155.      * 一个长整型的唯一ID，根据Snowflake算法生成。
    156.      */
    157.     public synchronized long snowflakeId(long workerId, long datacenterId) {
    158.         return createSnowFlake(workerId, datacenterId).nextId();
    159.     }
    160.  
    161. }

    6、测试用例

    1. package com.example.shardingsphere;
    2.  
    3. import cn.hutool.core.util.RandomUtil;
    4. import cn.hutool.json.JSONUtil;
    5. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    6. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    7. import com.example.shardingsphere.mapper.TbOrderMapper;
    8. import com.example.shardingsphere.po.TbOrder;
    9. import com.example.shardingsphere.provider.SnowFlakeProvider;
    10. import lombok.extern.slf4j.Slf4j;
    11. import org.junit.Assert;
    12. import org.junit.Test;
    13. import org.springframework.beans.factory.annotation.Autowired;
    14.  
    15. import java.math.BigDecimal;
    16. import java.util.ArrayList;
    17. import java.util.List;
    18.  
    19. @Slf4j
    20. public class ShardTest extends ShardingSphereDemoApplicationTests{
    21.  
    22.     @Autowired
    23.     private SnowFlakeProvider snowFlakeProvider;
    24.  
    25.     @Autowired
    26.     private TbOrderMapper tbOrderMapper ;
    27.  
    28.     /**
    29.      * 写入100条数据
    30.      */
    31.     @Test
    32.     public void testOrderInsert (){
    33.         List<TbOrder> list = new ArrayList<>();
    34.         for (int i=1 ; i<= 10 ; i++){
    35.             TbOrder order = TbOrder.builder()
    36. //                    .orderId(snowFlakeProvider.snowflakeId())
    37.                     .buyerId(snowFlakeProvider.snowflakeId())
    38.                     .sellerId(snowFlakeProvider.snowflakeId())
    39.                     .orderName("订单"+ RandomUtil.randomInt(6))
    40.                     .price(RandomUtil.randomBigDecimal().setScale(2, BigDecimal.ROUND_HALF_UP))
    41.                     .build();
    42.             list.add(order);
    43.         }
    44.         tbOrderMapper.insert(list);
    45.     }
    46.  
    47.     @Test
    48.     public void testOrderQuery (){
    49.         TbOrder order = tbOrderMapper.selectById(5) ;
    50.         Assert.assertNotNull(order);
    51.         log.info("查询结果："+ JSONUtil.toJsonStr(order));
    52.     }
    53.  
    54.     @Test
    55.     public void testOrderUpdate (){
    56.         TbOrder order = tbOrderMapper.selectById(3) ;
    57.         Assert.assertNotNull(order);
    58.         order.setBuyerId(1l);
    59.         order.setSellerId(3l);
    60.         int count = tbOrderMapper.updateById(order) ;
    61.         log.info("更新记录数："+count);
    62.     }
    63.  
    64.     @Test
    65.     public void testOrderPage (){
    66.         //分页参数
    67.         Page<TbOrder> rowPage = new Page<>(1, 2);
    68.         //queryWrapper组装查询where条件
    69.         LambdaQueryWrapper<TbOrder> queryWrapper = new LambdaQueryWrapper<>();
    70.         Page<TbOrder> page = tbOrderMapper.selectPage(rowPage, queryWrapper);
    71.         log.info("分页查询结果："+ JSONUtil.toJsonStr(page));
    72.     }
    73.  
    74. }

    7、yml配置

    1. server:
    2.   port: 8095
    3.  
    4. spring:
    5.   application:
    6.     name: dynamic-datasource-spring-boot-starter
    7.   shardingsphere:
    8.     mode:
    9.       type: Standalone
    10.       repository:
    11.         type: JDBC
    12.     database:
    13.       name: db0
    14.     # 数据源配置
    15.     datasource:
    16.       # 数据源名称，多数据源以逗号分隔
    17.       names: db0,db1
    18.       db0:
    19.         type: com.zaxxer.hikari.HikariDataSource
    20.         driver-class-name: com.mysql.cj.jdbc.Driver
    21.         jdbc-url: jdbc:mysql://xx:3306/shard_db_0?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
    22.         username: xx
    23.         password: xx
    24.       db1:
    25.         type: com.zaxxer.hikari.HikariDataSource
    26.         driver-class-name: com.mysql.cj.jdbc.Driver
    27.         jdbc-url: jdbc:mysql://xx:3306/shard_db_1?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
    28.         username: xx
    29.         password: xx
    30.     # 分片规则配置
    31.     rules:
    32.       sharding:
    33.         # 分片算法配置
    34.         sharding-algorithms:
    35.           database-inline:
    36.             # 分片算法类型
    37.             type: INLINE
    38.             props:
    39.               # 分片算法的行表达式（算法自行定义，此处为方便演示效果）
    40.               algorithm-expression: db${order_id % 2}
    41.           table-inline:
    42.             # 分片算法类型
    43.             type: INLINE
    44.             props:
    45.               # 分片算法的行表达式
    46.               algorithm-expression: tb_order_${order_id % 3}
    47.         tables:
    48.           # 逻辑表名称
    49.           tb_order:
    50.             # 行表达式标识符可以使用 ${...} 或 $->{...}，但前者与 Spring 本身的属性文件占位符冲突，因此在 Spring 环境中使用行表达式标识符建议使用 $->{...}
    51.             actual-data-nodes: db${0..1}.tb_order_${0..2}
    52.             # 分库策略
    53.             database-strategy:
    54.               standard:
    55.                 # 分片列名称
    56.                 sharding-column: order_id
    57.                 # 分片算法名称
    58.                 sharding-algorithm-name: database-inline
    59.             # 分表策略
    60.             table-strategy:
    61.               standard:
    62.                 # 分片列名称
    63.                 sharding-column: order_id
    64.                 # 分片算法名称
    65.                 sharding-algorithm-name: table-inline
    66.     # 属性配置
    67.     props:
    68.       # 展示修改以后的sql语句
    69.       sql-show: true
    70.  
    71. mybatis-plus:
    72.   type-aliases-package: com.example.dynamic.po
    73.   configuration:
    74.     map-underscore-to-camel-case: true
    75.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    76.   mapper-locations:
    77.     - classpath:/mapper/*.xml
    78.

    至此，一个支持分库分表的工程搭建完成。

    ########################################################

    关于搭建过程中遇到的问题（shardingsphere-jdbc-core-spring-boot-starter 5.2.1）

    1、Caused by: java.lang.NoSuchMethodError: org.yaml.snakeyaml.representer.Representer: method 'void ()' not found

    解答：该问题是由于版本问题导致的，是个兼容性问题。

    shardingsphere-jdbc-core-spring-boot-starter 5.2.1中使用snakeyaml版本1.33 spring-boot-starter-web使用snakeyaml版本2.2 2.2中删除了Representer和SafeRepresenter的无参构造器，因此导致了该异常。

     可通过降低boot版本号从而降低其中snakeyaml版本号解决，但由于snakeyaml 1.x版本有安全问题，而shardingsphere-jdbc-core-spring-boot-starter已是当前最高版本，因此可通过重新jar中bean新增无参构造器去覆盖jar bean去解决。

    com.main.java下新增目录org.yaml.snakeyaml.representer

    目录下新建bean

    1. //
    2. // Source code recreated from a .class file by IntelliJ IDEA
    3. // (powered by FernFlower decompiler)
    4. //
    5.  
    6. package org.yaml.snakeyaml.representer;
    7.  
    8. import java.util.ArrayList;
    9. import java.util.Arrays;
    10. import java.util.Collection;
    11. import java.util.Collections;
    12. import java.util.HashMap;
    13. import java.util.Iterator;
    14. import java.util.List;
    15. import java.util.Map;
    16. import java.util.Set;
    17. import org.yaml.snakeyaml.DumperOptions;
    18. import org.yaml.snakeyaml.TypeDescription;
    19. import org.yaml.snakeyaml.DumperOptions.FlowStyle;
    20. import org.yaml.snakeyaml.introspector.Property;
    21. import org.yaml.snakeyaml.introspector.PropertyUtils;
    22. import org.yaml.snakeyaml.nodes.MappingNode;
    23. import org.yaml.snakeyaml.nodes.Node;
    24. import org.yaml.snakeyaml.nodes.NodeId;
    25. import org.yaml.snakeyaml.nodes.NodeTuple;
    26. import org.yaml.snakeyaml.nodes.ScalarNode;
    27. import org.yaml.snakeyaml.nodes.SequenceNode;
    28. import org.yaml.snakeyaml.nodes.Tag;
    29.  
    30. public class Representer extends SafeRepresenter {
    31.     protected Map<Class<? extends Object>, TypeDescription> typeDefinitions = Collections.emptyMap();
    32.  
    33.     public Representer() {
    34.         this.representers.put(null, new RepresentJavaBean());
    35.     }
    36.  
    37.     public Representer(DumperOptions options) {
    38.         super(options);
    39.         this.representers.put(null, new RepresentJavaBean());
    40.     }
    41.  
    42.     public TypeDescription addTypeDescription(TypeDescription td) {
    43.         if (Collections.EMPTY_MAP == this.typeDefinitions) {
    44.             this.typeDefinitions = new HashMap();
    45.         }
    46.  
    47.         if (td.getTag() != null) {
    48.             this.addClassTag(td.getType(), td.getTag());
    49.         }
    50.  
    51.         td.setPropertyUtils(this.getPropertyUtils());
    52.         return (TypeDescription)this.typeDefinitions.put(td.getType(), td);
    53.     }
    54.  
    55.     public void setPropertyUtils(PropertyUtils propertyUtils) {
    56.         super.setPropertyUtils(propertyUtils);
    57.         Collection<TypeDescription> tds = this.typeDefinitions.values();
    58.         Iterator var3 = tds.iterator();
    59.  
    60.         while(var3.hasNext()) {
    61.             TypeDescription typeDescription = (TypeDescription)var3.next();
    62.             typeDescription.setPropertyUtils(propertyUtils);
    63.         }
    64.  
    65.     }
    66.  
    67.     protected MappingNode representJavaBean(Set<Property> properties, Object javaBean) {
    68.         List<NodeTuple> value = new ArrayList(properties.size());
    69.         Tag customTag = (Tag)this.classTags.get(javaBean.getClass());
    70.         Tag tag = customTag != null ? customTag : new Tag(javaBean.getClass());
    71.         MappingNode node = new MappingNode(tag, value, FlowStyle.AUTO);
    72.         this.representedObjects.put(javaBean, node);
    73.         DumperOptions.FlowStyle bestStyle = FlowStyle.FLOW;
    74.         Iterator var8 = properties.iterator();
    75.  
    76.         while(true) {
    77.             NodeTuple tuple;
    78.             do {
    79.                 if (!var8.hasNext()) {
    80.                     if (this.defaultFlowStyle != FlowStyle.AUTO) {
    81.                         node.setFlowStyle(this.defaultFlowStyle);
    82.                     } else {
    83.                         node.setFlowStyle(bestStyle);
    84.                     }
    85.  
    86.                     return node;
    87.                 }
    88.  
    89.                 Property property = (Property)var8.next();
    90.                 Object memberValue = property.get(javaBean);
    91.                 Tag customPropertyTag = memberValue == null ? null : (Tag)this.classTags.get(memberValue.getClass());
    92.                 tuple = this.representJavaBeanProperty(javaBean, property, memberValue, customPropertyTag);
    93.             } while(tuple == null);
    94.  
    95.             if (!((ScalarNode)tuple.getKeyNode()).isPlain()) {
    96.                 bestStyle = FlowStyle.BLOCK;
    97.             }
    98.  
    99.             Node nodeValue = tuple.getValueNode();
    100.             if (!(nodeValue instanceof ScalarNode) || !((ScalarNode)nodeValue).isPlain()) {
    101.                 bestStyle = FlowStyle.BLOCK;
    102.             }
    103.  
    104.             value.add(tuple);
    105.         }
    106.     }
    107.  
    108.     protected NodeTuple representJavaBeanProperty(Object javaBean, Property property, Object propertyValue, Tag customTag) {
    109.         ScalarNode nodeKey = (ScalarNode)this.representData(property.getName());
    110.         boolean hasAlias = this.representedObjects.containsKey(propertyValue);
    111.         Node nodeValue = this.representData(propertyValue);
    112.         if (propertyValue != null && !hasAlias) {
    113.             NodeId nodeId = nodeValue.getNodeId();
    114.             if (customTag == null) {
    115.                 if (nodeId == NodeId.scalar) {
    116.                     if (property.getType() != Enum.class && propertyValue instanceof Enum) {
    117.                         nodeValue.setTag(Tag.STR);
    118.                     }
    119.                 } else {
    120.                     if (nodeId == NodeId.mapping && property.getType() == propertyValue.getClass() && !(propertyValue instanceof Map) && !nodeValue.getTag().equals(Tag.SET)) {
    121.                         nodeValue.setTag(Tag.MAP);
    122.                     }
    123.  
    124.                     this.checkGlobalTag(property, nodeValue, propertyValue);
    125.                 }
    126.             }
    127.         }
    128.  
    129.         return new NodeTuple(nodeKey, nodeValue);
    130.     }
    131.  
    132.     protected void checkGlobalTag(Property property, Node node, Object object) {
    133.         if (!object.getClass().isArray() || !object.getClass().getComponentType().isPrimitive()) {
    134.             Class<?>[] arguments = property.getActualTypeArguments();
    135.             if (arguments != null) {
    136.                 Class t;
    137.                 Iterator iter;
    138.                 Iterator var9;
    139.                 if (node.getNodeId() == NodeId.sequence) {
    140.                     t = arguments[0];
    141.                     SequenceNode snode = (SequenceNode)node;
    142.                     Iterable<Object> memberList = Collections.emptyList();
    143.                     if (object.getClass().isArray()) {
    144.                         memberList = Arrays.asList((Object[])object);
    145.                     } else if (object instanceof Iterable) {
    146.                         memberList = (Iterable)object;
    147.                     }
    148.  
    149.                     iter = ((Iterable)memberList).iterator();
    150.                     if (iter.hasNext()) {
    151.                         var9 = snode.getValue().iterator();
    152.  
    153.                         while(var9.hasNext()) {
    154.                             Node childNode = (Node)var9.next();
    155.                             Object member = iter.next();
    156.                             if (member != null && t.equals(member.getClass()) && childNode.getNodeId() == NodeId.mapping) {
    157.                                 childNode.setTag(Tag.MAP);
    158.                             }
    159.                         }
    160.                     }
    161.                 } else if (object instanceof Set) {
    162.                     t = arguments[0];
    163.                     MappingNode mnode = (MappingNode)node;
    164.                     Iterator<NodeTuple> ite = mnode.getValue().iterator();
    165.                     Set<?> set = (Set)object;
    166.                     var9 = set.iterator();
    167.  
    168.                     while(var9.hasNext()) {
    169.                         Object member = var9.next();
    170.                         NodeTuple tuple = (NodeTuple)ite.next();
    171.                         Node keyNode = tuple.getKeyNode();
    172.                         if (t.equals(member.getClass()) && keyNode.getNodeId() == NodeId.mapping) {
    173.                             keyNode.setTag(Tag.MAP);
    174.                         }
    175.                     }
    176.                 } else if (object instanceof Map) {
    177.                     t = arguments[0];
    178.                     Class<?> valueType = arguments[1];
    179.                     MappingNode mnode = (MappingNode)node;
    180.                     iter = mnode.getValue().iterator();
    181.  
    182.                     while(iter.hasNext()) {
    183.                         NodeTuple tuple = (NodeTuple)iter.next();
    184.                         this.resetTag(t, tuple.getKeyNode());
    185.                         this.resetTag(valueType, tuple.getValueNode());
    186.                     }
    187.                 }
    188.             }
    189.  
    190.         }
    191.     }
    192.  
    193.     private void resetTag(Class<? extends Object> type, Node node) {
    194.         Tag tag = node.getTag();
    195.         if (tag.matches(type)) {
    196.             if (Enum.class.isAssignableFrom(type)) {
    197.                 node.setTag(Tag.STR);
    198.             } else {
    199.                 node.setTag(Tag.MAP);
    200.             }
    201.         }
    202.  
    203.     }
    204.  
    205.     protected Set<Property> getProperties(Class<? extends Object> type) {
    206.         return this.typeDefinitions.containsKey(type) ? ((TypeDescription)this.typeDefinitions.get(type)).getProperties() : this.getPropertyUtils().getProperties(type);
    207.     }
    208.  
    209.     protected class RepresentJavaBean implements Represent {
    210.         protected RepresentJavaBean() {
    211.         }
    212.  
    213.         public Node representData(Object data) {
    214.             return Representer.this.representJavaBean(Representer.this.getProperties(data.getClass()), data);
    215.         }
    216.     }
    217. }
    1. //
    2. // Source code recreated from a .class file by IntelliJ IDEA
    3. // (powered by FernFlower decompiler)
    4. //
    5.  
    6. package org.yaml.snakeyaml.representer;
    7.  
    8. import java.math.BigInteger;
    9. import java.nio.charset.StandardCharsets;
    10. import java.util.ArrayList;
    11. import java.util.Arrays;
    12. import java.util.Calendar;
    13. import java.util.Date;
    14. import java.util.HashMap;
    15. import java.util.Iterator;
    16. import java.util.LinkedHashMap;
    17. import java.util.List;
    18. import java.util.Map;
    19. import java.util.Set;
    20. import java.util.TimeZone;
    21. import java.util.UUID;
    22. import java.util.regex.Pattern;
    23. import org.yaml.snakeyaml.DumperOptions;
    24. import org.yaml.snakeyaml.DumperOptions.FlowStyle;
    25. import org.yaml.snakeyaml.DumperOptions.NonPrintableStyle;
    26. import org.yaml.snakeyaml.DumperOptions.ScalarStyle;
    27. import org.yaml.snakeyaml.error.YAMLException;
    28. import org.yaml.snakeyaml.external.biz.base64Coder.Base64Coder;
    29. import org.yaml.snakeyaml.nodes.Node;
    30. import org.yaml.snakeyaml.nodes.Tag;
    31. import org.yaml.snakeyaml.reader.StreamReader;
    32.  
    33. class SafeRepresenter extends BaseRepresenter {
    34.     protected Map<Class<? extends Object>, Tag> classTags;
    35.     protected TimeZone timeZone = null;
    36.     protected DumperOptions.NonPrintableStyle nonPrintableStyle;
    37.     private static final Pattern MULTILINE_PATTERN = Pattern.compile("\n|\u0085|\u2028|\u2029");
    38.  
    39.     public SafeRepresenter() {
    40.         this(new DumperOptions());
    41.     }
    42.  
    43.     public SafeRepresenter(DumperOptions options) {
    44.         if (options == null) {
    45.             throw new NullPointerException("DumperOptions must be provided.");
    46.         } else {
    47.             this.nullRepresenter = new RepresentNull();
    48.             this.representers.put(String.class, new RepresentString());
    49.             this.representers.put(Boolean.class, new RepresentBoolean());
    50.             this.representers.put(Character.class, new RepresentString());
    51.             this.representers.put(UUID.class, new RepresentUuid());
    52.             this.representers.put(byte[].class, new RepresentByteArray());
    53.             Represent primitiveArray = new RepresentPrimitiveArray();
    54.             this.representers.put(short[].class, primitiveArray);
    55.             this.representers.put(int[].class, primitiveArray);
    56.             this.representers.put(long[].class, primitiveArray);
    57.             this.representers.put(float[].class, primitiveArray);
    58.             this.representers.put(double[].class, primitiveArray);
    59.             this.representers.put(char[].class, primitiveArray);
    60.             this.representers.put(boolean[].class, primitiveArray);
    61.             this.multiRepresenters.put(Number.class, new RepresentNumber());
    62.             this.multiRepresenters.put(List.class, new RepresentList());
    63.             this.multiRepresenters.put(Map.class, new RepresentMap());
    64.             this.multiRepresenters.put(Set.class, new RepresentSet());
    65.             this.multiRepresenters.put(Iterator.class, new RepresentIterator());
    66.             this.multiRepresenters.put((new Object[0]).getClass(), new RepresentArray());
    67.             this.multiRepresenters.put(Date.class, new RepresentDate());
    68.             this.multiRepresenters.put(Enum.class, new RepresentEnum());
    69.             this.multiRepresenters.put(Calendar.class, new RepresentDate());
    70.             this.classTags = new HashMap();
    71.             this.nonPrintableStyle = options.getNonPrintableStyle();
    72.             this.setDefaultScalarStyle(options.getDefaultScalarStyle());
    73.             this.setDefaultFlowStyle(options.getDefaultFlowStyle());
    74.         }
    75.     }
    76.  
    77.     protected Tag getTag(Class<?> clazz, Tag defaultTag) {
    78.         return this.classTags.containsKey(clazz) ? (Tag)this.classTags.get(clazz) : defaultTag;
    79.     }
    80.  
    81.     public Tag addClassTag(Class<? extends Object> clazz, Tag tag) {
    82.         if (tag == null) {
    83.             throw new NullPointerException("Tag must be provided.");
    84.         } else {
    85.             return (Tag)this.classTags.put(clazz, tag);
    86.         }
    87.     }
    88.  
    89.     public TimeZone getTimeZone() {
    90.         return this.timeZone;
    91.     }
    92.  
    93.     public void setTimeZone(TimeZone timeZone) {
    94.         this.timeZone = timeZone;
    95.     }
    96.  
    97.     protected class RepresentUuid implements Represent {
    98.         protected RepresentUuid() {
    99.         }
    100.  
    101.         public Node representData(Object data) {
    102.             return SafeRepresenter.this.representScalar(SafeRepresenter.this.getTag(data.getClass(), new Tag(UUID.class)), data.toString());
    103.         }
    104.     }
    105.  
    106.     protected class RepresentByteArray implements Represent {
    107.         protected RepresentByteArray() {
    108.         }
    109.  
    110.         public Node representData(Object data) {
    111.             char[] binary = Base64Coder.encode((byte[])data);
    112.             return SafeRepresenter.this.representScalar(Tag.BINARY, String.valueOf(binary), ScalarStyle.LITERAL);
    113.         }
    114.     }
    115.  
    116.     protected class RepresentEnum implements Represent {
    117.         protected RepresentEnum() {
    118.         }
    119.  
    120.         public Node representData(Object data) {
    121.             Tag tag = new Tag(data.getClass());
    122.             return SafeRepresenter.this.representScalar(SafeRepresenter.this.getTag(data.getClass(), tag), ((Enum)data).name());
    123.         }
    124.     }
    125.  
    126.     protected class RepresentDate implements Represent {
    127.         protected RepresentDate() {
    128.         }
    129.  
    130.         public Node representData(Object data) {
    131.             Calendar calendar;
    132.             if (data instanceof Calendar) {
    133.                 calendar = (Calendar)data;
    134.             } else {
    135.                 calendar = Calendar.getInstance(SafeRepresenter.this.getTimeZone() == null ? TimeZone.getTimeZone("UTC") : SafeRepresenter.this.timeZone);
    136.                 calendar.setTime((Date)data);
    137.             }
    138.  
    139.             int years = calendar.get(1);
    140.             int months = calendar.get(2) + 1;
    141.             int days = calendar.get(5);
    142.             int hour24 = calendar.get(11);
    143.             int minutes = calendar.get(12);
    144.             int seconds = calendar.get(13);
    145.             int millis = calendar.get(14);
    146.             StringBuilder buffer = new StringBuilder(String.valueOf(years));
    147.  
    148.             while(buffer.length() < 4) {
    149.                 buffer.insert(0, "0");
    150.             }
    151.  
    152.             buffer.append("-");
    153.             if (months < 10) {
    154.                 buffer.append("0");
    155.             }
    156.  
    157.             buffer.append(months);
    158.             buffer.append("-");
    159.             if (days < 10) {
    160.                 buffer.append("0");
    161.             }
    162.  
    163.             buffer.append(days);
    164.             buffer.append("T");
    165.             if (hour24 < 10) {
    166.                 buffer.append("0");
    167.             }
    168.  
    169.             buffer.append(hour24);
    170.             buffer.append(":");
    171.             if (minutes < 10) {
    172.                 buffer.append("0");
    173.             }
    174.  
    175.             buffer.append(minutes);
    176.             buffer.append(":");
    177.             if (seconds < 10) {
    178.                 buffer.append("0");
    179.             }
    180.  
    181.             buffer.append(seconds);
    182.             if (millis > 0) {
    183.                 if (millis < 10) {
    184.                     buffer.append(".00");
    185.                 } else if (millis < 100) {
    186.                     buffer.append(".0");
    187.                 } else {
    188.                     buffer.append(".");
    189.                 }
    190.  
    191.                 buffer.append(millis);
    192.             }
    193.  
    194.             int gmtOffset = calendar.getTimeZone().getOffset(calendar.getTime().getTime());
    195.             if (gmtOffset == 0) {
    196.                 buffer.append('Z');
    197.             } else {
    198.                 if (gmtOffset < 0) {
    199.                     buffer.append('-');
    200.                     gmtOffset *= -1;
    201.                 } else {
    202.                     buffer.append('+');
    203.                 }
    204.  
    205.                 int minutesOffset = gmtOffset / '\uea60';
    206.                 int hoursOffset = minutesOffset / 60;
    207.                 int partOfHour = minutesOffset % 60;
    208.                 if (hoursOffset < 10) {
    209.                     buffer.append('0');
    210.                 }
    211.  
    212.                 buffer.append(hoursOffset);
    213.                 buffer.append(':');
    214.                 if (partOfHour < 10) {
    215.                     buffer.append('0');
    216.                 }
    217.  
    218.                 buffer.append(partOfHour);
    219.             }
    220.  
    221.             return SafeRepresenter.this.representScalar(SafeRepresenter.this.getTag(data.getClass(), Tag.TIMESTAMP), buffer.toString(), ScalarStyle.PLAIN);
    222.         }
    223.     }
    224.  
    225.     protected class RepresentSet implements Represent {
    226.         protected RepresentSet() {
    227.         }
    228.  
    229.         public Node representData(Object data) {
    230.             Map<Object, Object> value = new LinkedHashMap();
    231.             Set<Object> set = (Set)data;
    232.             Iterator var4 = set.iterator();
    233.  
    234.             while(var4.hasNext()) {
    235.                 Object key = var4.next();
    236.                 value.put(key, (Object)null);
    237.             }
    238.  
    239.             return SafeRepresenter.this.representMapping(SafeRepresenter.this.getTag(data.getClass(), Tag.SET), value, FlowStyle.AUTO);
    240.         }
    241.     }
    242.  
    243.     protected class RepresentMap implements Represent {
    244.         protected RepresentMap() {
    245.         }
    246.  
    247.         public Node representData(Object data) {
    248.             return SafeRepresenter.this.representMapping(SafeRepresenter.this.getTag(data.getClass(), Tag.MAP), (Map)data, FlowStyle.AUTO);
    249.         }
    250.     }
    251.  
    252.     protected class RepresentPrimitiveArray implements Represent {
    253.         protected RepresentPrimitiveArray() {
    254.         }
    255.  
    256.         public Node representData(Object data) {
    257.             Class<?> type = data.getClass().getComponentType();
    258.             if (Byte.TYPE == type) {
    259.                 return SafeRepresenter.this.representSequence(Tag.SEQ, this.asByteList(data), FlowStyle.AUTO);
    260.             } else if (Short.TYPE == type) {
    261.                 return SafeRepresenter.this.representSequence(Tag.SEQ, this.asShortList(data), FlowStyle.AUTO);
    262.             } else if (Integer.TYPE == type) {
    263.                 return SafeRepresenter.this.representSequence(Tag.SEQ, this.asIntList(data), FlowStyle.AUTO);
    264.             } else if (Long.TYPE == type) {
    265.                 return SafeRepresenter.this.representSequence(Tag.SEQ, this.asLongList(data), FlowStyle.AUTO);
    266.             } else if (Float.TYPE == type) {
    267.                 return SafeRepresenter.this.representSequence(Tag.SEQ, this.asFloatList(data), FlowStyle.AUTO);
    268.             } else if (Double.TYPE == type) {
    269.                 return SafeRepresenter.this.representSequence(Tag.SEQ, this.asDoubleList(data), FlowStyle.AUTO);
    270.             } else if (Character.TYPE == type) {
    271.                 return SafeRepresenter.this.representSequence(Tag.SEQ, this.asCharList(data), FlowStyle.AUTO);
    272.             } else if (Boolean.TYPE == type) {
    273.                 return SafeRepresenter.this.representSequence(Tag.SEQ, this.asBooleanList(data), FlowStyle.AUTO);
    274.             } else {
    275.                 throw new YAMLException("Unexpected primitive '" + type.getCanonicalName() + "'");
    276.             }
    277.         }
    278.  
    279.         private List<Byte> asByteList(Object in) {
    280.             byte[] array = (byte[])in;
    281.             List<Byte> list = new ArrayList(array.length);
    282.  
    283.             for(int i = 0; i < array.length; ++i) {
    284.                 list.add(array[i]);
    285.             }
    286.  
    287.             return list;
    288.         }
    289.  
    290.         private List<Short> asShortList(Object in) {
    291.             short[] array = (short[])in;
    292.             List<Short> list = new ArrayList(array.length);
    293.  
    294.             for(int i = 0; i < array.length; ++i) {
    295.                 list.add(array[i]);
    296.             }
    297.  
    298.             return list;
    299.         }
    300.  
    301.         private List<Integer> asIntList(Object in) {
    302.             int[] array = (int[])in;
    303.             List<Integer> list = new ArrayList(array.length);
    304.  
    305.             for(int i = 0; i < array.length; ++i) {
    306.                 list.add(array[i]);
    307.             }
    308.  
    309.             return list;
    310.         }
    311.  
    312.         private List<Long> asLongList(Object in) {
    313.             long[] array = (long[])in;
    314.             List<Long> list = new ArrayList(array.length);
    315.  
    316.             for(int i = 0; i < array.length; ++i) {
    317.                 list.add(array[i]);
    318.             }
    319.  
    320.             return list;
    321.         }
    322.  
    323.         private List<Float> asFloatList(Object in) {
    324.             float[] array = (float[])in;
    325.             List<Float> list = new ArrayList(array.length);
    326.  
    327.             for(int i = 0; i < array.length; ++i) {
    328.                 list.add(array[i]);
    329.             }
    330.  
    331.             return list;
    332.         }
    333.  
    334.         private List<Double> asDoubleList(Object in) {
    335.             double[] array = (double[])in;
    336.             List<Double> list = new ArrayList(array.length);
    337.  
    338.             for(int i = 0; i < array.length; ++i) {
    339.                 list.add(array[i]);
    340.             }
    341.  
    342.             return list;
    343.         }
    344.  
    345.         private List<Character> asCharList(Object in) {
    346.             char[] array = (char[])in;
    347.             List<Character> list = new ArrayList(array.length);
    348.  
    349.             for(int i = 0; i < array.length; ++i) {
    350.                 list.add(array[i]);
    351.             }
    352.  
    353.             return list;
    354.         }
    355.  
    356.         private List<Boolean> asBooleanList(Object in) {
    357.             boolean[] array = (boolean[])in;
    358.             List<Boolean> list = new ArrayList(array.length);
    359.  
    360.             for(int i = 0; i < array.length; ++i) {
    361.                 list.add(array[i]);
    362.             }
    363.  
    364.             return list;
    365.         }
    366.     }
    367.  
    368.     protected class RepresentArray implements Represent {
    369.         protected RepresentArray() {
    370.         }
    371.  
    372.         public Node representData(Object data) {
    373.             Object[] array = (Object[])data;
    374.             List<Object> list = Arrays.asList(array);
    375.             return SafeRepresenter.this.representSequence(Tag.SEQ, list, FlowStyle.AUTO);
    376.         }
    377.     }
    378.  
    379.     private static class IteratorWrapper implements Iterable<Object> {
    380.         private final Iterator<Object> iter;
    381.  
    382.         public IteratorWrapper(Iterator<Object> iter) {
    383.             this.iter = iter;
    384.         }
    385.  
    386.         public Iterator<Object> iterator() {
    387.             return this.iter;
    388.         }
    389.     }
    390.  
    391.     protected class RepresentIterator implements Represent {
    392.         protected RepresentIterator() {
    393.         }
    394.  
    395.         public Node representData(Object data) {
    396.             Iterator<Object> iter = (Iterator)data;
    397.             return SafeRepresenter.this.representSequence(SafeRepresenter.this.getTag(data.getClass(), Tag.SEQ), new IteratorWrapper(iter), FlowStyle.AUTO);
    398.         }
    399.     }
    400.  
    401.     protected class RepresentList implements Represent {
    402.         protected RepresentList() {
    403.         }
    404.  
    405.         public Node representData(Object data) {
    406.             return SafeRepresenter.this.representSequence(SafeRepresenter.this.getTag(data.getClass(), Tag.SEQ), (List)data, FlowStyle.AUTO);
    407.         }
    408.     }
    409.  
    410.     protected class RepresentNumber implements Represent {
    411.         protected RepresentNumber() {
    412.         }
    413.  
    414.         public Node representData(Object data) {
    415.             Tag tag;
    416.             String value;
    417.             if (!(data instanceof Byte) && !(data instanceof Short) && !(data instanceof Integer) && !(data instanceof Long) && !(data instanceof BigInteger)) {
    418.                 Number number = (Number)data;
    419.                 tag = Tag.FLOAT;
    420.                 if (number.equals(Double.NaN)) {
    421.                     value = ".NaN";
    422.                 } else if (number.equals(Double.POSITIVE_INFINITY)) {
    423.                     value = ".inf";
    424.                 } else if (number.equals(Double.NEGATIVE_INFINITY)) {
    425.                     value = "-.inf";
    426.                 } else {
    427.                     value = number.toString();
    428.                 }
    429.             } else {
    430.                 tag = Tag.INT;
    431.                 value = data.toString();
    432.             }
    433.  
    434.             return SafeRepresenter.this.representScalar(SafeRepresenter.this.getTag(data.getClass(), tag), value);
    435.         }
    436.     }
    437.  
    438.     protected class RepresentBoolean implements Represent {
    439.         protected RepresentBoolean() {
    440.         }
    441.  
    442.         public Node representData(Object data) {
    443.             String value;
    444.             if (Boolean.TRUE.equals(data)) {
    445.                 value = "true";
    446.             } else {
    447.                 value = "false";
    448.             }
    449.  
    450.             return SafeRepresenter.this.representScalar(Tag.BOOL, value);
    451.         }
    452.     }
    453.  
    454.     protected class RepresentString implements Represent {
    455.         protected RepresentString() {
    456.         }
    457.  
    458.         public Node representData(Object data) {
    459.             Tag tag = Tag.STR;
    460.             DumperOptions.ScalarStyle style = SafeRepresenter.this.defaultScalarStyle;
    461.             String value = data.toString();
    462.             if (SafeRepresenter.this.nonPrintableStyle == NonPrintableStyle.BINARY && !StreamReader.isPrintable(value)) {
    463.                 tag = Tag.BINARY;
    464.                 byte[] bytes = value.getBytes(StandardCharsets.UTF_8);
    465.                 String checkValue = new String(bytes, StandardCharsets.UTF_8);
    466.                 if (!checkValue.equals(value)) {
    467.                     throw new YAMLException("invalid string value has occurred");
    468.                 }
    469.  
    470.                 char[] binary = Base64Coder.encode(bytes);
    471.                 value = String.valueOf(binary);
    472.                 style = ScalarStyle.LITERAL;
    473.             }
    474.  
    475.             if (SafeRepresenter.this.defaultScalarStyle == ScalarStyle.PLAIN && SafeRepresenter.MULTILINE_PATTERN.matcher(value).find()) {
    476.                 style = ScalarStyle.LITERAL;
    477.             }
    478.  
    479.             return SafeRepresenter.this.representScalar(tag, value, style);
    480.         }
    481.     }
    482.  
    483.     protected class RepresentNull implements Represent {
    484.         protected RepresentNull() {
    485.         }
    486.  
    487.         public Node representData(Object data) {
    488.             return SafeRepresenter.this.representScalar(Tag.NULL, "null");
    489.         }
    490.     }
    491. }

  • 相关阅读:
    算法金 | 不愧是腾讯，问基础巨细节 。。。
    基于Matlab在以地球为中心的场景中模拟和跟踪航路飞机仿真（附源码）
    tiup dm deploy
    系统开发系列 之java反射以及应用
    【CANN训练营笔记】OrangePI AIPro 体验手写体识别模型训练与推理
    【spring】初识spring基础
    Linux中常用数据库管理系统之MariaDB
    springboot整合redis-sentinel哨兵模式集群(二)
    react状态管理工具redux的使用
    Android 内核加载fw通用方法分析
  • 原文地址：https://blog.csdn.net/weixin_39195030/article/details/140429674