/**
 * 微信公众号属性配置
 *
 * @author rxliuli
 */
@ConfigurationProperties(prefix = "custom.wx.mp")
public class WxMpPropertiesConfig {
    private String appId;
    private String secret;
    private String token;
    private String aesKey;
    // getter() and setter()
}

/**
 * 微信公众号主要的配置类
 *
 * @author rxliuli
 */
@Configuration
@EnableConfigurationProperties(WxMpPropertiesConfig.class)
public class WxMpMainConfig {
    private final WxMpPropertiesConfig wxMpPropertiesConfig;

    /**
     * 微信公众号的服务对象
     * 用户调用微信的各种 API, 例如获取 access_token
     */
    private WxMpService wxMpService;

    @Autowired
    public WxMpMainConfig(WxMpPropertiesConfig wxMpPropertiesConfig) {
        this.wxMpPropertiesConfig = wxMpPropertiesConfig;
    }

    /**
     * 初始化路由列表和微信服务 api 对象
     */
    @PostConstruct
    public void init() {
        //配置微信 api 对象的策略（目前在内存中）
        final WxMpInMemoryConfigStorage storage = new WxMpInMemoryConfigStorage();
        storage.setAppId(wxMpPropertiesConfig.getAppId());
        storage.setSecret(wxMpPropertiesConfig.getSecret());
        storage.setAesKey(wxMpPropertiesConfig.getAesKey());
        storage.setToken(wxMpPropertiesConfig.getToken());
        //设置策略到服务对象中
        wxMpService = new WxMpServiceImpl();
        wxMpService.setWxMpConfigStorage(storage);
    }

    @Bean
    public WxMpService wxMpService() {
        return wxMpService;
    }
}

/**
 * 微信服务窗口 api
 *
 * @author rxliuli
 */
@RestController
@RequestMapping("/wx/portal")
public class WxMpPortalApi {
    private final WxMpService wxMpService;

    @Autowired
    public WxMpPortalApi(WxMpService wxMpService) {
        this.wxMpService = wxMpService;
    }

    /**
     * 微信认证当前服务可用
     *
     * @param signature 微信加密签名，signature 结合了开发者填写的 token 参数和请求中的 timestamp 参数、nonce 参数
     * @param timestamp 时间戳
     * @param nonce     随机数
     * @param echostr   成功后回传的随机字符串
     * @return {@code echostr}
     */
    @GetMapping
    public String authGet(
            String signature,
            String timestamp,
            String nonce,
            String echostr
    ) {
        if (StringUtils.isAnyEmpty(signature, timestamp, nonce, echostr)) {
            throw new IllegalArgumentException("请求非法参数!");
        }
        if (wxMpService.checkSignature(timestamp, nonce, signature)) {
            return echostr;
        }
        return "非法请求";
    }
}

/**
 * 微信服务窗口 api
 *
 * @author rxliuli
 */
@RestController
@RequestMapping("/wx/portal")
public class WxMpPortalApi {
    private final Logger log = LoggerFactory.getLogger(getClass());

    private final WxMpService wxMpService;
    private final WxMpMessageRouter router;

    @Autowired
    public WxMpPortalApi(WxMpService wxMpService, WxMpMessageRouter router) {
        this.wxMpService = wxMpService;
        this.router = router;
    }

    /**
     * 微信认证当前服务可用
     *
     * @param signature 微信加密签名，signature 结合了开发者填写的 token 参数和请求中的 timestamp 参数、nonce 参数
     * @param timestamp 时间戳
     * @param nonce     随机数
     * @param echostr   成功后回传的随机字符串
     * @return {@code echostr}
     */
    @GetMapping
    public String authGet(
            String signature,
            String timestamp,
            String nonce,
            String echostr
    ) {
        if (StringUtils.isAnyEmpty(signature, timestamp, nonce, echostr)) {
            throw new IllegalArgumentException("请求非法参数!");
        }
        if (wxMpService.checkSignature(timestamp, nonce, signature)) {
            return echostr;
        }
        return "非法请求";
    }

    /**
     * 对所有来自微信服务器的消息进行预处理
     *
     * @param requestBody 请求体（xml 格式）
     * @return 明文消息
     */
    @PostMapping
    public String authPost(
            @RequestBody String requestBody,
            @RequestParam("signature") String signature,
            @RequestParam("timestamp") String timestamp,
            @RequestParam("nonce") String nonce,
            @RequestParam(name = "encrypt_type", required = false) String encType,
            @RequestParam(name = "msg_signature", required = false) String msgSignature
    ) throws JsonProcessingException {
        if (!wxMpService.checkSignature(timestamp, nonce, signature)) {
            throw new IllegalArgumentException("非法请求, 并非微信发来的");
        }

        WxMpXmlMessage inMessage = null;
        if (encType == null) {
            //明文传输
            inMessage = WxMpXmlMessage.fromXml(requestBody);
        } else if ("aes".equals(encType)) {
            //aes 加密
            inMessage = WxMpXmlMessage.fromEncryptedXml(requestBody, wxMpService.getWxMpConfigStorage(), timestamp, nonce, msgSignature);
        }
        WxMpXmlOutMessage outMessage = router.route(inMessage);
        log.info("客户端发送的消息: {}", new ObjectMapper().writeValueAsString(outMessage));
        return outMessage == null ? "" : outMessage.toXml();
    }
}

/**
 * 基础微信消息处理器
 *
 * @author rxliuli
 */
public abstract class BaseHandler implements WxMpMessageHandler {
    final Logger log = LoggerFactory.getLogger(getClass());

    /**
     * 默认空实现
     *
     * @param wxMessage      微信的消息
     * @param context        上下文环境(用于在 handler 中传递信息)
     * @param wxMpService    微信 api 服务
     * @param sessionManager 会话管理
     * @return xml 格式的消息, 异步可返回 null
     */
    @Override
    public WxMpXmlOutMessage handle(WxMpXmlMessage wxMessage, Map<String, Object> context, WxMpService wxMpService, WxSessionManager sessionManager) {
        return null;
    }
}

/**
 * 用户发送消息的处理器
 *
 * @author rxliuli
 */
@Component
public class MsgHandler extends BaseHandler {
    @Override
    public WxMpXmlOutMessage handle(WxMpXmlMessage wxMessage, Map<String, Object> context, WxMpService wxMpService, WxSessionManager sessionManager) {
        log.info("接收到消息: {}", wxMessage.getMsg());
        final String content = "您发送的消息为: " + wxMessage.getContent();
        return WxMpXmlOutMessage.TEXT().content(content)
                .fromUser(wxMessage.getToUser())
                .toUser(wxMessage.getFromUser())
                .build();
    }
}

/**
 * 微信公众号主要的配置类
 *
 * @author rxliuli
 */
@Configuration
@EnableConfigurationProperties(WxMpPropertiesConfig.class)
public class WxMpMainConfig {
    private final WxMpPropertiesConfig wxMpPropertiesConfig;
    private final MsgHandler msgHandler;
    /**
     * 微信公众号监听管理路由映射表
     * 其实就是监听用户在公众号的操作罢了, 比如点击了某个菜单, 发送了一些消息
     */
    private WxMpMessageRouter wxMpMessageRouter;
    /**
     * 微信公众号的服务对象
     * 用户调用微信的各种 API, 例如获取 access_token
     */
    private WxMpService wxMpService;

    @Autowired
    public WxMpMainConfig(WxMpPropertiesConfig wxMpPropertiesConfig, MsgHandler msgHandler) {
        this.wxMpPropertiesConfig = wxMpPropertiesConfig;
        this.msgHandler = msgHandler;
    }

    /**
     * 初始化路由列表和微信服务 api 对象
     */
    @PostConstruct
    public void init() {
        //配置微信 api 对象的策略（目前在内存中）
        final WxMpInMemoryConfigStorage storage = new WxMpInMemoryConfigStorage();
        storage.setAppId(wxMpPropertiesConfig.getAppId());
        storage.setSecret(wxMpPropertiesConfig.getSecret());
        storage.setAesKey(wxMpPropertiesConfig.getAesKey());
        storage.setToken(wxMpPropertiesConfig.getToken());
        //设置策略到服务对象中
        wxMpService = new WxMpServiceImpl();
        wxMpService.setWxMpConfigStorage(storage);
        //添加路由
        wxMpMessageRouter = this.newRouter(wxMpService);
    }

    /**
     * 根据微信 api 服务对象创建一个微信监听路由
     *
     * @param wxMpService 微信 api 服务
     * @return 微信监听路由对象
     */
    private WxMpMessageRouter newRouter(WxMpService wxMpService) {
        WxMpMessageRouter router = new WxMpMessageRouter(wxMpService);
        //发送消息(默认)
        router.rule().async(false).handler(this.msgHandler).end();
        return router;
    }

    @Bean
    public WxMpService wxMpService() {
        return wxMpService;
    }

    @Bean
    public WxMpMessageRouter wxMpMessageRouter() {
        return wxMpMessageRouter;
    }
}

/**
 * 微信公众号菜单
 *
 * @author rxliuli
 */
@RestController
@RequestMapping("/wx/menu/")
public class WxMpMenuApi extends WxMpBaseApi {
    /**
     * 创建一个默认的菜单
     *
     * @return 菜单 id
     */
    @GetMapping("create")
    public String createDefault() throws WxErrorException {
        final WxMenu wxMenu = new WxMenu();
        final WxMenuButton buttonLeft = new WxMenuButton();
        buttonLeft.setType(WxConsts.MenuButtonType.CLICK);
        buttonLeft.setName("点击");
        buttonLeft.setKey(IdWorker.getIdStr());

        final WxMenuButton buttonRight = new WxMenuButton();
        buttonRight.setType(WxConsts.MenuButtonType.VIEW);
        buttonRight.setName("链接");
        buttonRight.setUrl("https://blog.rxliuli.com");
        buttonRight.setKey(IdWorker.getIdStr());
        wxMenu.getButtons().add(buttonLeft);
        wxMenu.getButtons().add(buttonRight);
        return wxMpService.getMenuService().menuCreate(wxMenu);
    }
}

/**
 * 用于测试的字符串工具类
 *
 * @author rxliuli
 */
public class StringUtil {
    /**
     * 判断是否为空
     *
     * @param string 要进行判断的字符串
     * @return 是否为 null 或者空字符串
     */
    public static boolean isEmpty(String string) {
        return string == null || string.isEmpty();

    }

    /**
     * 判断是否为空
     *
     * @param string 要进行判断的字符串
     * @return 是否为 null 或者空字符串
     */
    public static boolean isNotEmpty(String string) {
        return !isEmpty(string);
    }

    /**
     * 判断是否有字符串为空
     *
     * @param strings 要进行判断的一个或多个字符串
     * @return 是否有 null 或者空字符串
     */
    public static boolean isAnyEmpty(String... strings) {
        return Arrays.stream(strings)
                .anyMatch(StringUtil::isEmpty);
    }

    /**
     * 判断字符串是否全部为空
     *
     * @param strings 要进行判断的一个或多个字符串
     * @return 是否全部为 null 或者空字符串
     */
    public static boolean isAllEmpty(String... strings) {
        return Arrays.stream(strings)
                .allMatch(StringUtil::isEmpty);
    }
}

/**
 * @author rxliuli
 */
public class StringUtilTest {
    private String strNull = null;
    private String strEmpty = "";
    private String strSome = "str";

    @Test
    public void isEmpty() {
        //测试 null
        assertThat(StringUtil.isEmpty(strNull))
                .isTrue();
        //测试 empty
        assertThat(StringUtil.isEmpty(strEmpty))
                .isTrue();
        //测试 some
        assertThat(StringUtil.isEmpty(strSome))
                .isFalse();
    }

    @Test
    public void isNotEmpty() {
        //测试 null
        assertThat(StringUtil.isNotEmpty(strNull))
                .isFalse();
        //测试 empty
        assertThat(StringUtil.isNotEmpty(strEmpty))
                .isFalse();
        //测试 some
        assertThat(StringUtil.isNotEmpty(strSome))
                .isTrue();
    }

    @Test
    public void isAnyEmpty() {
        assertThat(StringUtil.isAnyEmpty(strNull, strEmpty, strSome))
                .isTrue();
        assertThat(StringUtil.isAnyEmpty())
                .isFalse();
    }

    @Test
    public void isAllEmpty() {
        assertThat(StringUtil.isAllEmpty(strNull, strEmpty, strSome))
                .isFalse();
        assertThat(StringUtil.isAnyEmpty(strNull, strEmpty))
                .isTrue();
    }
}

/**
 * @author rxliuli
 */
public class User implements Serializable {
    private Integer id;
    private String name;
    private Boolean sex;
    private Integer age;

    public User() {
    }

    public User(String name, Boolean sex, Integer age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public User(Integer id, String name, Boolean sex, Integer age) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    //getter() and setter()
}

/**
 * @author rxliuli
 */
@Repository
public class UserDao {
    private final RowMapper<User> userRowMapper = (rs, rowNum) -> new User(
            rs.getInt("id"),
            rs.getString("name"),
            rs.getBoolean("sex"),
            rs.getInt("age")
    );
    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 根据 id 获取一个对象
     *
     * @param id id
     * @return 根据 id 查询到的对象，如果没有查到则为 null
     */
    public User get(Integer id) {
        return jdbcTemplate.queryForObject("select * from user where id = ?", userRowMapper, id);
    }

    /**
     * 查询全部用户
     *
     * @return 全部用户列表
     */
    public List<User> listForAll() {
        return jdbcTemplate.query("select * from user", userRowMapper);
    }

    /**
     * 根据 id 删除用户
     *
     * @param id 用户 id
     * @return 受影响行数
     */
    public int deleteById(Integer id) {
        return jdbcTemplate.update("delete from user where id = ?", id);
    }
}

/**
 * {@code @SpringBootTest} 和 {@code @RunWith(SpringRunner.class)} 是必须的，这里貌似一直有人误会需要使用 {@code @RunWith(SpringJUnit4ClassRunner.class)}，但其实并不需要了
 * 下面的 {@code @Transactional} 和 {@code @Rollback}则是开启事务控制以及自动回滚
 *
 * @author rxliuli
 */
@SpringBootTest
@RunWith(SpringRunner.class)
@Transactional
@Rollback
public class UserDaoTest {
    @Autowired
    private UserDao userDao;

    @Test
    public void get() {
        int id = 1;
        User result = userDao.get(id);
        //断言 id 和 get id 相同
        assertThat(result)
                .extracting(User::getId)
                .contains(id);
    }

    @Test
    public void listForAll() {
        List<User> userList = userDao.listForAll();
        //断言不为空
        assertThat(userList)
                .isNotEmpty();
    }

    @Test
    public void deleteById() {
        int result = userDao.deleteById(1);
        assertThat(result)
                .isGreaterThan(0);
    }
}

/**
 * @author rxliuli
 */
@SpringBootTest
@RunWith(SpringRunner.class)
@Transactional
@Rollback
public class UserControllerUnitTest {
    @Autowired
    private UserController userController;
    /**
     * 用于测试 API 的模拟请求对象
     */
    private MockMvc mockMvc;

    @Before
    public void before() {
        //模拟一个 Mvc 测试环境，获取一个 MockMvc 实例
        mockMvc = MockMvcBuilders.standaloneSetup(userController)
                .build();
    }

    @Test
    public void testGet() throws Exception {
        //测试能够正常获取
        Integer id = 1;
        mockMvc.perform(
                //发起 get 请求
                get("/user/" + id)
        )
                //断言请求的状态是成功的(200)
                .andExpect(status().isOk())
                //断言返回对象的 id 和请求的 id 相同
                .andExpect(jsonPath("$.id").value(id));
    }

    @Test
    public void listForAll() throws Exception {
        //测试正常获取
        mockMvc.perform(
                //发起 post 请求
                post("/user/listForAll")
        )
                //断言请求状态
                .andExpect(status().isOk())
                //断言返回结果是数组
                .andExpect(jsonPath("$").isArray())
                //断言返回数组不是空的
                .andExpect(jsonPath("$").isNotEmpty());
    }
}

/**
 * @author rxliuli
 */
@SpringBootTest
@RunWith(SpringRunner.class)
@Transactional
@Rollback
public class UserControllerIntegratedTest {
    @Autowired
    private WebApplicationContext context;
    /**
     * 用于测试 API 的模拟请求对象
     */
    private MockMvc mockMvc;

    @Before
    public void before() {
        //这里把整个 WebApplicationContext 上下文都丢进去了，所以可以测试所有的 Controller
        mockMvc = MockMvcBuilders.webAppContextSetup(context)
                .build();
    }

    @Test
    public void testGet() throws Exception {
        //测试能够正常获取
        Integer id = 1;
        mockMvc.perform(
                //发起 get 请求
                get("/user/" + id)
        )
                //断言请求的状态是成功的(200)
                .andExpect(status().isOk())
                //断言返回对象的 id 和请求的 id 相同
                .andExpect(jsonPath("$.id").value(id));
    }

    @Test
    public void listForAll() throws Exception {
        //测试正常获取
        mockMvc.perform(
                //发起 post 请求
                post("/user/listForAll")
        )
                //断言请求状态
                .andExpect(status().isOk())
                //断言返回结果是数组
                .andExpect(jsonPath("$").isArray())
                //断言返回数组不是空的
                .andExpect(jsonPath("$").isNotEmpty());
    }
}

//获取当前的日期
final LocalDate now = LocalDate.now();
//toString 一下日期
//会得到 yyyy-MM-dd 格式
System.out.println("现在：" + now);
//1 天后的日期
final LocalDate localDatePlusDayOne = now.plusDays(1);
System.out.println("一天后：" + localDatePlusDayOne);
//一天前的日期
final LocalDate localDateMinusDayOne = now.minusDays(1);
System.out.println("一天前：" + localDateMinusDayOne);
//比较两个日期/时间的大小
final int nowEvenBigger = now.compareTo(localDatePlusDayOne);
System.out.println("当前时间更大么？" + nowEvenBigger);
//获取指定单位的日期（年/月/日/星期）
//获取当前月的时间
final int dayOfMonth = now.getDayOfMonth();
System.out.println("当前月的天数：" + dayOfMonth);
//更加通用获取方式
//使用枚举类 ChronoField
final int dayOfMonthForChronoField = now.get(ChronoField.DAY_OF_MONTH);
System.out.println("当前月的天数（通过 get() 获取）：" + dayOfMonthForChronoField);
//比较两个日期的差值
final long between = ChronoUnit.DAYS.between(now, localDatePlusDayOne);
System.out.println(between);

//获得当前时间
final LocalTime now = LocalTime.now();
//默认格式 hh:mm:ss.SSS
System.out.println("现在：" + now);
//一个小时后的时间
final LocalTime localTimePlusHourOne = now.plusHours(1);
System.out.println("一小时后：" + localTimePlusHourOne);
//一分钟前的时间
final LocalTime localTimeMinusMinuteOne = now.minusMinutes(1);
System.out.println(localTimeMinusMinuteOne);
//比较时间大小（实现了 Comparable 接口）
final int nowEvenBigger = now.compareTo(localTimeMinusMinuteOne);
System.out.println("当前时间更大么？" + nowEvenBigger);
//获取指定单位的时间
//当前小时数
final int hour = now.getHour();
System.out.println("当前时间的小时数：" + hour);
//使用枚举类 ChronoField 获取
final int hourOfDay = now.get(ChronoField.HOUR_OF_DAY);
System.out.println("当前时间的小时数（通过 get() 获取）：" + hourOfDay);
//比较两个日期的差值
final long between = ChronoUnit.HOURS.between(now, localTimePlusHourOne);
System.out.println(between);

//当前日期时间
final LocalDateTime now = LocalDateTime.now();
//默认格式 yyyy-MM-ddThh:mm:ss.SSS
System.out.println("现在：" + now);
//一个小时后的时间
final LocalDateTime localTimePlusHourOne = now.plusHours(1);
System.out.println("一小时后：" + localTimePlusHourOne);
//一分钟前的时间
final LocalDateTime localTimeMinusMinuteOne = now.minusMinutes(1);
System.out.println(localTimeMinusMinuteOne);
//比较时间大小（实现了 Comparable 接口）
final int nowEvenBigger = now.compareTo(localTimeMinusMinuteOne);
System.out.println("当前时间更大么？" + nowEvenBigger);
//获取指定单位的时间
//当前小时数
final int hour = now.getHour();
System.out.println("当前时间的小时数：" + hour);
//使用枚举类 ChronoField 获取
final int hourOfDay = now.get(ChronoField.HOUR_OF_DAY);
System.out.println("当前时间的小时数（通过 get() 获取）：" + hourOfDay);
//比较两个日期的差值
final long between = ChronoUnit.HOURS.between(now, localTimePlusHourOne);
System.out.println(between);
//获取一天的开始和结束
final LocalDateTime start = LocalDateTime.of(yesterday, LocalTime.MIN);
final LocalDateTime end = LocalDateTime.of(yesterday, LocalTime.MAX);
System.out.println(start);
System.out.println(end);

//获取日期/时间对象
final LocalDate localDate = now.toLocalDate();
final LocalTime localTime = now.toLocalTime();
System.out.println("当前日期：" + localDate);
System.out.println("当前时间：" + localTime);

//当前偏移的日期时间
final OffsetDateTime now = OffsetDateTime.now();
System.out.println(now);
//其实个人感觉就是多了一个时区
//获取到时区
ZoneId zone = now.toZonedDateTime().getZone();
System.out.println(zone);
//转换时区
ZonedDateTime zonedDateTime = now.atZoneSameInstant(ZoneId.of("+00:00"));
System.out.println(zonedDateTime);
//其他基本操作和上面的差不多，就不啰嗦啦

final LocalDateTime now = LocalDateTime.now();
//获取上个星期
final LocalDateTime lastWeek = now.minus(1, ChronoUnit.WEEKS);
//获取下个月
final LocalDateTime nextMonth = now.plus(1, ChronoUnit.MONTHS);
//获取当前是今年的第几个星期
final int weekValue = now.get(ChronoField.ALIGNED_WEEK_OF_YEAR);
//获取这周星期一的时间
final LocalDateTime nowOfMonday = now.with(DayOfWeek.MONDAY);
final LocalDateTime nowOfMonday2 = now.with(ChronoField.DAY_OF_WEEK, 1);
System.out.println(
    "lastWeek: " + lastWeek
        + "\nnextMonth: " + nextMonth
        + "\nweekValue: " + weekValue
        + "\nnowOfMonday: " + nowOfMonday
        + "\nnowOfMonday2: " + nowOfMonday2
);

final LocalDate now = LocalDate.now();
final LocalDate localTimePlusMonthOne = now.plusDays(1);
//计算相差的时间
final Period betweenForDay = Period.between(now, localTimePlusMonthOne);
//获取相差的天数
System.out.println("相差的天数：" + betweenForDay.getDays());
//使用 get() 方法获取通用的相差的天数
System.out.println("相差的天数(使用 get() 获取)：" + betweenForDay.get(ChronoUnit.DAYS));
//对相差的日期减去一天并判断是否为 0
System.out.println("相差的日期减去 1 天是不是就相同了呢？" + betweenForDay.minusDays(1).isZero());

final LocalDateTime now = LocalDateTime.now();
final LocalDateTime localDateTimeForPlusHourOne = now.plusHours(1);
//计算两个时间的差值
final Duration between = Duration.between(now, localDateTimeForPlusHourOne);
//默认格式是 PT 时间 单位
System.out.println("相差的时间：" + between);
//获取日期
final long betweenSeconds = between.getSeconds();
System.out.println("相差的时间（/秒）：" + betweenSeconds);
//根据指定单位获取相差时间的大小
final long betweenSecondsForGet = between.get(ChronoUnit.SECONDS);
System.out.println("相差的时间（/秒）：" + betweenSecondsForGet);
//转换成毫秒
System.out.println("相差的时间（/毫秒）：" + between.toMillis());
//获取相差时间支持的单位列表（其实感觉上没太大意义）
final List<TemporalUnit> temporalUnitList = between.getUnits();
System.out.println("相差的时间列表：" + temporalUnitList);
//在创建一个时间差
final Duration betweenForMinutes = Duration.between(now, now.minusMinutes(100));
//判断两个时间差哪个更大
System.out.println("between 的时间差更大么？" + between.compareTo(betweenForMinutes));
//获取绝对值
System.out.println("相差的绝对时间：" + betweenForMinutes.abs());

final LocalDateTime now = LocalDateTime.now();
final ChronoField hourOfDay = ChronoField.HOUR_OF_DAY;
System.out.println(hourOfDay);
//获取当前小时数
final long nowForHours = hourOfDay.getFrom(now);
System.out.println("当前时间的小时数：" + nowForHours);
//获取到指定单位的时间大小
final int hoursForGet = now.get(ChronoField.HOUR_OF_DAY);
System.out.println("当前时间的小时数（get()）：" + hoursForGet);
//获取到特定单位的时间对比对象 Duration
final TemporalUnit baseUnit = hourOfDay.getBaseUnit();
System.out.println(baseUnit);

//获取一个小时数
final ChronoUnit chronoUnit = ChronoUnit.MILLIS;
System.out.println(chronoUnit);
//获取两个时间的差值毫秒数
final LocalDateTime now = LocalDateTime.now();
final LocalDateTime localDateTimePlusHourOne = now.plusHours(1);
final long betweenForMillis = chronoUnit.between(now, localDateTimePlusHourOne);
System.out.println("相差的毫秒数：" + betweenForMillis);
//根据指定的单位修改时间也需要使用这个
final LocalDateTime localDateTimePlusMinuteOne = now.plus(1, ChronoUnit.MINUTES);
System.out.println("一分钟后的时间：" + localDateTimePlusMinuteOne);

//获取一个标准 iso 日期时间格式化对象
final DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_DATE_TIME;
System.out.println(dateTimeFormatter);
//格式化日期时间
final LocalDateTime now = LocalDateTime.now();
System.out.println("当前日期时间：" + dateTimeFormatter.format(now));
//根据自定义的格式格式化时间
final DateTimeFormatter customDateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 hh时mm分ss秒");
System.out.println(customDateTimeFormatter.format(now));

final LocalDateTime now = LocalDateTime.now();
//转换为 Instant（包括时区）
final Instant instant = now.toInstant(ZoneOffset.UTC);
System.out.println(instant);
//转换为 Date
final Date date = Date.from(instant);
System.out.println("当前时间：" + date);
//转换为 Instant
final Instant dateToInstant = date.toInstant();
System.out.println("两次转换后的时间还是相同的吧？" + dateToInstant.equals(instant));
//转换为 LocalDateTime
final ZoneId zoneId = ZoneId.systemDefault();
final LocalDateTime toLocalDateTime = LocalDateTime.ofInstant(dateToInstant, zoneId);
System.out.println("转换后的日期时间：" + toLocalDateTime);

/**
  * 提供一个全局可用的序列化 Bean
  */
public static final ObjectMapper OM = new ObjectMapper()
        //Date 对象的格式
        .setDateFormat(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"))
        //禁止序列化值为 null 的属性
        .setSerializationInclusion(JsonInclude.Include.NON_NULL)
        //禁止序列化时间为时间戳
        .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
        .registerModules(
                //注册 Jsr310（Java8 的时间兼容模块）
                new JavaTimeModule(),
                //序列化 Long 为 String
                new SimpleModule()
                        //大数字直接序列化为 String
                        .addSerializer(Long.class, ToStringSerializer.instance)
                        .addSerializer(Long.TYPE, ToStringSerializer.instance)
                        .addSerializer(long.class, ToStringSerializer.instance)
                        .addSerializer(BigInteger.class, ToStringSerializer.instance)
                        //大浮点数直接序列化为 String
                        .addSerializer(BigDecimal.class, new JsonSerializer<BigDecimal>() {
                            @Override
                            public void serialize(BigDecimal value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                                gen.writeString(value.setScale(10, BigDecimal.ROUND_HALF_UP).toPlainString());
                            }
                        })
        )
        //JSON 序列化移除 transient 修饰的 Page 无关紧要的返回属性(Mybatis Plus)
        .configure(MapperFeature.PROPAGATE_TRANSIENT_MARKER, true);