愿景：”让编程不再难学，让技术与生活更加有趣”

更多架构课程请访问 xdclass.net

第一章 小滴课堂-海量数据处理商用短链平台大课介绍

第1集 海量数据处理商用短链平台大课介绍

简介：海量数据处理商用短链平台大课介绍

• 课程核心介绍

• 目标岗位能力说明

• 适合人员

第2集 商用短链平台技术栈介绍和观看形式-更新周期

简介：商用短链平台技术栈介绍和观看形式-更新周期

第3集 海量数据处理商用短链平台项目核心亮点《上》

简介：海量数据处理商用短链平台项目亮点《上》

第4集 海量数据处理商用短链平台项目核心亮点《下》

简介：海量数据处理商用短链平台项目亮点《下》

第5集 大课解决的问题和跳槽职业发展规划

简介：大课解决的问题和跳槽职业发展规划

第6集 大课疑惑解答+学习准备

简介：大课疑惑解答+学习准备

愿景：”让编程不再难学，让技术与生活更加有趣”

更多架构课程请访问 xdclass.net

第二章 不在其位要谋其政，技术Leader能力模型提升

第1集 互联网大厂里 技术Leader的能力模型-不单写代码

简介：职级的能力模型，不要只顾自己的一亩三分地

• 前言先说

  • 可能同学到现在都不知道【商用短链平台】是什么，没关系，后续讲完前面几章我们就开始了
  • 前面几章是讲 产品方法论，就是技术Leader需要掌握的内容

  • 不管你是否校招、社招、工作5到10年的人

    • 不要说【二当家小D】瞎扯淡！！！不讲技术只讲虚幻的
    • 我需要给大家打个强心剂！！！！
    • 大课软硬技能都有，但是层级高的或者野心大的，就必须学

• 【不画大饼】看我们课程不会让你成为CTO、阿里P7、P8

  • 课程让你成为CTO、阿里P7、P8的助力器，
  • 我很鼓励团队的人进行充电，不管是线上还是线下

  • 始终相信

    • 量变->质变，没量变的人，是不可能有质变的
    • 光输出不输入，你觉得能成长多少

• 浅谈Leader的好处和坏处

  • 当leader好处

    • 待遇高、股票、奖金
    • 接触面、圈子广
    • 软技能多方面提升

  • 当leader坏处

    • 多数是晚上才能安心写代码
    • 背负团队KPI：技术+业务
    • 操心事多

• 你上司为啥是你上司？（也就是大家需要提升的方向，并非一朝一夕，而是先有意识，然后不断积累）

  • 能力模型

• 多个能力汇总起来就是商业化产品构建能力,负责业务产品线一号位的能力

  • 帮企业找到新的盈利方向
  • 商业模式(外) × 发展空间(外) × 核心壁垒(内) × 企业文化(内)

• 接下去重点教大家《产品+运营》这块的能力，然后为啥需要这能力，就不会觉得虚幻了

  • 掌握这些能力的好处多多！！！！！

  • 如果选一个好的公司，进公司如何转岗去一个好的部门-》发现能力

  • 知道未来1~3年哪些方向好，万一站在风口上是吧，薪资待遇、股票期权

    • 蚂蚁的一个同事：虽然是P7，但是第一批员工，如果蚂蚁上市-据说是整层楼最有钱的了

  • 避免进入错的方向：公司倒闭、裁员、发不出工资

  • 技术Leader的必备能力

    • 公司技术产品的研发，比如算法平台、DevOps平台、规则引擎等

第2集 技术人的产品运营能力提升-竞品分析

简介：竞品分析-入职-提升-运营能力

• 什么是竞品分析

  • 竞品：竞争对手的产品，叫竞品
  • 分析：对这些收集的竞品加以分析，从而对自己的产品设计产生帮助

• 为什么要做竞品分析

  • 熟悉产品

  • 利用现有的商业模式去改进

    • 抖音、视频号
    • 拼多多、淘宝特价版（明星部门重要性-同事转岗去特价版，年终奖20个月+，然后晋升绿色通道）

• 谁去做？

  • 产品
  • 运营
  • 技术leader

• 为啥是技术leader去做？

  • C端产品文档，这个基本就不用技术去做了

  • 但是大厂里面都是做C端的吗？

    • BI后台
    • 自动化测试平台
    • APP应用配置中心
    • 性能分析平台
    • 看下阿里云产品线：https://www.aliyun.com/product/list

第3集 跳出自己的技术思维模型-上司给你团队安排任务

简介：跳出自己的技术思维模型-上司给你团队安排任务

• 目标

  • 跳出自己的技术思维模型，去分析产品需求背后的合理性和必要性
  • 让自己更快理解业务需求，从而进行开发
  • 看需求文档
  • 写需求文档

• 说说我的情况

  • 产品经理：常规进行操作，技术负责开发
  • 老板开会：探讨新业务、然后就是技术负责人进行分析
  • 团队的产品经理：P7产品专家，技术出身，然后转产品

  • 沟通起来特别轻松

    • 数据埋点、AB测试、流量模型、扩容、性能
    • 偶尔还能帮技术定位问题、看监控等

• 大老板阿里CEO张勇在20年内部也发话了

  • 阿里未来的产品经理都是技术出身

    • 技术：研发能力强
    • 产品：思维能力强
    • 技术+产品：知道解决方案、研发工时、技术合理性、数据能力、分析能力

  • 多数例子

    • 百度：李彦宏
    • 腾讯：马化腾
    • 微信：张小龙
    • 字节：张一鸣
    • 360：周鸿祎
    • 阿里：马云（但是对技术是最看重的）
    • Facebook：扎克伯格
    • 微软：比尔盖茨

• 大气的老板：想做个短链平台，赋能公司业务，然后开启商业化对外出售

  • 让你写-知道怎么写不
• 小滴短链商用平台需求文档地址： https://zhuanlan.zhihu.com/p/428514067

愿景：”让编程不再难学，让技术与生活更加有趣”

更多架构课程请访问 xdclass.net

第三章 商用短链平台介绍和技术Leader常用方法论介绍

第1集 商用短链平台业务介绍+需求背景说明

简介： 短链平台业务介绍+需求背景说明

• 什么是短链平台，应用场景有哪些

• 短链长啥样？

• 业务背景：为啥需要短链？

  • 公司电商产品推广、业务活动页、广告落地页 缺少实时【数据反馈和渠道效果分析】

  • 老项目业务推广【没人维护，无法做埋点】需要统计效果

    • 例子 https://tongji.baidu.com/web/demo/overview/index?siteId=16847648

• APP和营销活动发送营销短信链接过长，【浪费短信发送费用】

• 国内【反垄断后】微信、抖音、淘宝 流量互通，很多知识付费公司需要做 私域流量、社群运营
• 可以对外做产品输出，实现商业化能力增加公司营收
• 积累终端数据和人群数据，为公司未来产品人群做策略助力

• 更多。。。。

  • 盈利点

• 用户按量付费，根据流量包选择付费购买对应的套餐

• 不同流量包权益不一样

  • 每天可以创建的短链次数不一样
  • 流量包使用时间限制、支持流量包叠加
  • 注册用户每天有一定免费使用次数，但是不能查看数据
    • 短链平台产品目标

• 满足公司现有业务的营销推广需求、数据分析和拉新促活能力

• 对外进行付费商用，支持企业私有化部署
• 首年日活用户： 10万
• 首年日新增短链数据：10万*50 = 500万
• 年新增用户数：50万/1年
• 年营收目标: 10万付费用户 * 客单价200元 = 2千万
• 新增短链：50条/用户每日
• 年私有化部署用户数：1K用户 * 3万/单价 = 3千万

• 上面需求背景、产品目标是怎么来的？为啥能想到这些？有没风险？有没遗漏的内容？

  • 这个就是做事、思考 的方法论！！！
  • 接下去几集重点要掌握（不要求一次性彻底掌握， 但是要有大概的认知，然后边学边实践，这个才能成长）

第2集 为什么需要学方法论 避免无章法做事和跳槽面试

简介： 避免无章法管理和做事，为什么需要学方法论

• 方法论：通俗来说就是【做事套路，解决问题的方法（手段/途径/工具）】 喜欢学术性的介绍可以百度更多的

• 你是否被问过类似这些 方法论技术面试题（考查你的逻辑思维是否清晰）

  • 线上接口响应慢，你会怎么定位问题

    • 监控统计问题、机房问题、某个节点问题、服务器带宽问题、CPU内存问题、网关问题、业务逻辑问题、并发量问题、数据库问题

  • sql查询耗时久，你会怎么排查优化

  • java应用发生了OOM，你会怎么排查问题

  • 订单支付成功率下滑严重，你会怎么排查问题

  • RabbitMQ和RocketMQ技术选型，你会怎么选，考虑哪些因素

• 为什么要学方法论，常见的有哪些是必备的

  • 新业务规划（PEST）

    • 上线被下架 （K12教育、互联网金融）

  • 运营推广（AARRR）

    • 不被产品牵着走，但是也不盲目

  • SWOT态势分析法

    • 个人成长、技术解决方案

  • 团队管理（SMART）

    • 合适的人合适的事
    • 工作量分配
  • 跳槽面试（逻辑考查）

第3集 公司行业前景分析-PEST方法论-选择大于努力

简介： 公司行业前景分析-PEST方法论-选择大于努力

• PEST方法论

  • 指的是政治（Political）、经济（Economic）、社会（Social）和技术（Technological）

    • 政治环境主要是看我们的国家现在是否鼓励相关的业务
    • 经济环境又可以分为宏观经济和微观经济，包括居民消费水平、产业结构
    • 社会环境则是说跟社会的风俗习惯是否吻合
    • 技术环境当然就是说的我们的技术实力（ASML光刻机）

• 案例：BAT区块链大牛找你开发特币交易平台app

  • P 国家出台了相关政策、法律法规监管
  • E 大家有闲钱，现在人居可支配收入高
  • S 人口规模大，生活方式改变，投资理财越来越多
  • T 团队已有对应的技术，行业领先，移动互联网成熟

• 案例延伸

  • 互联网金融贷款产品 p2p

  • 高中在线辅导产品

  • 初中同学找你开发电商平台-对标淘宝、拼多多

• 聪明的人做聪明的事，避免自己入坑

  • 行业选择错：白忙活几年，领域专家也吃亏

  • 公司裁员、倒闭发不出工资：白干几个月，辛苦大半年，一夜回到解放前

  • 大厂也一样：字节、阿里、腾讯、京东等

第4集 技术Leader必备方法论-用户增长的数据分析模型AARRR

简介： 技术Leader必备方法论-用户增长的数据分析模型AARRR

• 什么是AARRR用户增长模型

  • AARRR是Acquisition、Activation、Retention、Revenue、Referral 五个单词的缩写，对应用户生命周期中的5个重要环节。
  • 通俗来说就是一个产品从0~1到100的方法论
  • 指引产品运营在不同的产品运营阶段，思考哪些关键节点，更好各个节点的指标数据

• AARRR详细解释

  • 获取：新用户首单免费/低价(瑞幸、拼多多)、厂商预装(手机)、买量投放
  • 激活：app推送、短信推送、产品价值激活
  • 留存：签到、活动短信推送、平台价值提供
  • 收益：平台广告、电商变现、付费会员、融资、软件服务
  • 传播：好友助力、分享抽奖、兄弟砍我一刀

第5集 技术Leader必备方法论-SWOT态势分析法-个人能力与技术解决方案

简介： 技术Leader必备方法论-SWOT态势分析法-个人能力与技术解决方案

• 什么是SWOT态势分析

  • 官方：用来确定企业自身的竞争优势、劣势、外部市场的机会和威胁，从而将公司的战略与公司内部资源、外部环境有机地结合起来的一种科学的分析方法

  • 4个单词的缩写 优势=strength、劣势=weakness、机会=opportunity、威胁=threats

    • 优势和弱势是内部环境的分析，机会和威胁是对于外部环境的分析

``` 外部的机会正好是你的优势，赶紧利用起来

外部的机会但是你的劣势，需要改进

自身具有优势但外部存在威胁，就需要时刻思考、保持警惕

是威胁又是你的劣势，就规避并消除

![](img/image-20211103125244799.png#alt=image-20211103125244799)
   - 
案例应用场景
      - 
个人做技术Leader能力分析（工作3年，高级java，技术能力不错，项目组长刚离职）
         - 
优势：技术不错、对公司业务熟悉（个人内部）
         - 
劣势：项目管理能力不足、PPT汇报能力不足（个人内部）
         - 
机会:  独立负责的项目把控、直接和领导汇报，成为管理层（个人外部）
         - 
威胁：项目的规范机制没有建立、项目的核心难点没有攻破、加班比较多（个人外部）
      - 
技术解决方案分析（团队熟悉RabbitMQ，新来的组长熟悉RocketMQ，技术选型思考）
         - 优势：RabbitMQ团队多人用过、AMQP跨语言、模型API丰富（团队内部）
         - 劣势：阅读过源码的人过少, Erlang开发，二次修改不容易，项目组长对这个不熟悉（团队内部）
         - 机会：项目可以快速上线，减少采坑（团队外部）
         - 威胁：未来可能有更强大的MQ产品出现或公司改动架构（团队外部）
- 
总结：根据SWOT进行充分分析，然后进行取舍选择，考虑更全面（对比没用这个分析你会怎么选择）
<a name="66f08107"></a>
#### 第6集  技术Leader必备方法论SMART衡量需求、工作的利器
**简介：  技术Leader必备方法论SMART衡量需求、工作的利器**
- 
什么是SMART方法论
   - 
源于国外管理大师的《管理的实践》
   - 
是为了利于员工更加明确高效地工作，更是为了管理者将来对员工实施绩效考核提供了考核目标和考核标准，使考核更加科学化、规范化
   - 
是5个单词的缩写
      - SMART原则【目标管理、设置】
      - Specific：目标要具体
      - Measurable：目标成果要可衡量（量化）
      - Attainable：目标要可实现，避免过高/过低
      - Relevant：与其他目标有一定的相关性
      - Time bound：目标必须有明确的期限
   - 
意义：在制定工作目标或者任务目标时，考虑一下目标与计划是不是SMART化的。只有具备SMART化的计划才是具有良好可实施性的，也才能指导保证计划得以实现
   - 
案例
      - 短链平台项目组成员，每天需要开晨会-并记录 ( 周一 早上团队开周会，每个人列出本周事项安排)
![](img/image-20211103132853684.png#alt=image-20211103132853684)
      - 张三的周报如下
         - 周三前完成短链平台数据库设计并输出相关sql文件（SMART）
         - 周四前完成短链平台整体架构搭建和工作任务拆分并评审完成（SMART）
         - 周二完成短链微服务开发工作 (SM RT)
         - 开发账号微服务 (S)
         - 解决老项目的bug ( )
         - 周二完成优化电商项目里面的下单接口RT响应时间，把500ms优化到200ms响应（SMART）
![](https://file.xdclass.net/note/2020/javaweb/%E5%9B%BE%E7%89%87/logo.png#alt=logo) **愿景："让编程不再难学，让技术与生活更加有趣"  **
**更多架构课程请访问 xdclass.net**
<a name="8324eb53"></a>
### 第四章 商用短链平台-功能需求介绍和微服务拆分讲解
<a name="1952de4d"></a>
#### 第1集 学以致用-商用短链平台需求文档拆分和总结
**简介：学以致用-短链平台实战需求文档拆分和总结**
- 看了前面的方法论和拓展知识，我们再来巩固下需求文档和功能
   - 小滴短链商用平台需求文档地址： [https://zhuanlan.zhihu.com/p/428514067](https://zhuanlan.zhihu.com/p/428514067)
<a name="0ee11249"></a>
#### 第2集 商用短链平台-微服务拆分和技术栈版本说明
**简介：海量数据处理商用短链平台-微服务拆分和技术栈版本说明**
- 
Maven聚合工程拆分
   - dcloud-common
      - 公共依赖包
   - dcloud-app
      - Flink+Kafka实时计算
   - dcloud-account
      - 账号+流量包微服务
   - dcloud-data
      - 数据可视化微服务
   - dcloud-gateway
      - 业务网关
   - dcloud-link
      - 短链微服务
   - dcloud-shop
      - 流量包商品+支付微服务
- 
微服务技术栈+前置中间件版本说明
   - JDK11
   - SpringBoot 2.5.5
   - SpringCloud 2020.0.4
   - AlibabaCloud 2021.1
   - Sharding-JDBC 4.1.1
   - Mysql 8.0
   - Nacos 2.0.2
   - Redis 6.2.4
   - RabbitQM 3.8.15
   - Kafka : wurstmeister/kafka:2.13-2.7.0
      - 为啥有RabbitMQ还要有Kafka（单机写入TPS约在百万条/秒，最大的优点，就是吞吐量高）
      - 一个是业务MQ、一个大数据流式处理的MQ，建议分开
   - 还有更多的中间件用的时候再安装
<a name="b3e4db94"></a>
#### 第3集 商用短链平台-业务架构图讲解
**简介：商用短链平台-业务架构图讲解**
- 整体业务应用架构图
![](img/image-20211105080403794.png#alt=image-20211105080403794)
- 各个微服务模块解析
![](img/image-20211104151551376.png#alt=image-20211104151551376)
![](https://file.xdclass.net/note/2020/javaweb/%E5%9B%BE%E7%89%87/logo.png#alt=logo) **愿景："让编程不再难学，让技术与生活更加有趣"  **
**更多架构课程请访问 xdclass.net**
<a name="07197cf7"></a>
### 第五章 阿里云Linux服务器选配和常用中间件环境安装
<a name="3a663876"></a>
#### 第1集 云服务器配置和搭建Docker相关讲解
**简介：云服务器配置和搭建Docker环境讲解**
- 
云服务器购买
   - 
厂商
      - 
阿里云：[https://www.aliyun.com/](https://www.aliyun.com/)
      - 
腾讯云：[https://cloud.tencent.com/](https://cloud.tencent.com/)
      - 
亚马逊云：[https://aws.amazon.com/](https://aws.amazon.com/)
      - 
腾讯云新用户折扣地址
         - [https://cloud.tencent.com/act/cps/redirect?redirect=1575&cps_key=3cb5dbec53a023baba788acac8d11871&from=console](https://cloud.tencent.com/act/cps/redirect?redirect=1575&cps_key=3cb5dbec53a023baba788acac8d11871&from=console)
      - 
阿里云新用户地址（如果地址失效，联系我或者客服即可，买2核8g或者16g以上，如果资金允许-买3年）
         - [https://www.aliyun.com/minisite/goods?userCode=r5saexap&share_source=copy_link](https://www.aliyun.com/minisite/goods?userCode=r5saexap&share_source=copy_link)
- 
服务器说明

阿里云-服务器根据情况买1~2台就行, 建议买2核8g以上可以1年或者3年长久，建议大课群里3人组队，每人买1台就够用的了，组合起来就是3台了，大家学习时间基本是错开的，然后MQ、mysql、nacos 约定好命名空间，就不会冲突的

也可以自己账号买1台长久使用，然后结尾部署的时候使用按量付费的形式就行购买多节点则省钱

PS:建议用新用户注册比如家人的（手机号、身份证、设备），购买成功后可以换绑手机号

- 环境问题说明
   - 务必使用CentOS 7 以上版本，64位系统，不要在Windows系统操作！！！！推荐是CentOS 7.8
   - 带宽可以选择固定带宽1M~5M都行，或者按量付费（带宽过小，后续Jenkins构建推送镜像比较慢）
   - 避免使用本地用虚拟机（后续部署很多中间件+本地多个微服务开发会很卡，且容易采坑）
      - 谁都不能保证每个人-硬件组成-系统版本-虚拟机软件版本都一样
      - 出现问题，大家结合报错日志搜索博文解决
      - 少数同学 -Win7、Win8、Win10、Mac、虚拟机等等，可能存在兼容问题
- 记得重置密码和配置网络安全组相关操作，我这边就不多说了
![](https://file.xdclass.net/note/2021/redis/img/image-20210405121007100.png#alt=image-20210405121007100)
- Docker安装

按照依赖

yum install -y yum-utils device-mapper-persistent-data lvm2

配置yum源（比较慢,不用）

yum-config-manager —add-repo https://download.docker.com/linux/centos/docker-ce.repo

配置yum源 使用国内的

yum-config-manager —add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

查看版本

yum list docker-ce —showduplicates | sort -r

1. 安装docker

yum -y install docker-ce-20.10.10-3.el7

2. 查看docker版本

docker -v

3. 启动docker

systemctl start docker

4. 查看docker 启动状态

systemctl status docker

检查安装结果。 docker info

启动使用Docker systemctl start docker #运行Docker守护进程 systemctl stop docker #停止Docker守护进程 systemctl restart docker #重启Docker守护进程

docker ps查看容器 docker stop 容器id

修改镜像仓库 vim /etc/docker/daemon.json

改为下面内容，然后重启docker

{ “debug”:true,”experimental”:true, “registry-mirrors”:[“https://pb5bklzr.mirror.aliyuncs.com","https://hub-mirror.c.163.com","https://docker.mirrors.ustc.edu.cn“] }

查看信息

docker info

注意：不使用1.13.1版本，该版本在jenkins使用docker命令时会说找不到配置文件！

<a name="45ca822b"></a>
#### 第2集 云服务器基础设施安装之Mysql8.0+Redis6.X安装
**简介：云服务器基础设施安装之Mysql8.0+Redis6.X安装**
- Mysql8.0安装

安装mysql8,让容器使用宿主机的时间，容器时间与宿主机时间同步

docker run \ -p 3306:3306 \ -e MYSQL_ROOT_PASSWORD=root \ -v /home/data/mysql/data:/var/lib/mysql:rw \ -v /etc/localtime:/etc/localtime:ro \ —name root \ —restart=always \ -d mysql:8.0

Mysql工具连接测试

连接数配置

show variables like ‘%max_connections%’; set GLOBAL max_connections=5000; set GLOBAL mysqlx_max_connections=5000;

- Redis6安装

docker run -itd —name my_redis1 -p 6379:6379 -v /mydata/redis/data:/data redis:6.2.4 —requirepass root

进入容器的redis docker exec -it 容器id redis-cli

工具测试连接

<a name="83e46b0e"></a>
#### 第3集 云服务器基础设施安装之Nacos2.x+Mysql8配置持久化-避坑
**简介：云服务器基础设施安装之Nacos2.x+Mysql8配置持久化-避坑**
- 
Nacos持久化SQL数据脚本
   - 第5章第3集资料里面
   - 默认登录
      - 账户nacos
      - 密码 nacos
- 
Nacos2.x安装（生产环境让运维人员配置网络，不暴露公网）
   - 配置中心需要加认证信息才可以访问

开源版本的 Nacos server 配置中，不会对客户端鉴权，即任何能访问 Nacos server 的用户，都可以直接获取 Nacos 中存储的配置，假如一个黑客攻进了企业内网，就能获取所有的业务配置，这样肯定会有安全隐患。

比如请求 http://112.74.55.160:8848/nacos/v1/cs/configs?dataId=dcloud-account-service-dev.yaml&group=DEFAULT_GROUP

需要先开启 Nacos server 的鉴权,在 Nacos server 上修改 application.properties 中的 nacos.core.auth.enabled 值为 true 即可

```
docker run -d \
-e NACOS_AUTH_ENABLE=true \
-e MODE=standalone \
-e JVM_XMS=128m \
-e JVM_XMX=128m \
-e JVM_XMN=128m \
-p 8848:8848 \
-e SPRING_DATASOURCE_PLATFORM=mysql \
-e MYSQL_SERVICE_HOST=192.168.200.204 \
-e MYSQL_SERVICE_PORT=3306 \
-e MYSQL_SERVICE_USER=root \
-e MYSQL_SERVICE_PASSWORD=root \
-e MYSQL_SERVICE_DB_NAME=nacos_config \
-e MYSQL_SERVICE_DB_PARAM='characterEncoding=utf8&connectTimeout=10000&socketTimeout=30000&autoReconnect=true&useSSL=false' \
--restart=always \
--privileged=true \
-v /home/data/nacos/logs:/home/nacos/logs \
--name nacos \
nacos/nacos-server:2.0.2

第4集 云服务器基础设施安装之RabbitMQ安装

简介：云服务器基础设施安装之RabbitMQ安装

• RabbitMQ安装

docker run -d  --name xd_rabbit -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=password -p 15672:15672 -p 5672:5672 rabbitmq:3.8.15-management
#网络安全组记得开放端口
4369 erlang 发现口
5672 client 端通信口
15672 管理界面 ui 端口
25672 server 间内部通信口
访问管理界面
ip:15672

愿景：”让编程不再难学，让技术与生活更加有趣”

更多架构课程请访问 xdclass.net

第六章 短链平台项目创建+git代码管理+开发分层规范讲解

第1集 短链平台实战-Maven聚合工程创建微服务项目

简介：Maven聚合工程创建微服务项目实战

• Maven聚合工程拆分

  • dcloud-common

    • 公共依赖包

  • dcloud-app

    • Flink+Kafka实时计算

  • dcloud-account

    • 账号+流量包微服务

  • dcloud-data

    • 数据可视化微服务

  • dcloud-gateway

    • 业务网关

  • dcloud-link

    • 短链微服务

  • dcloud-shop

    • 流量包商品+支付微服务

• 创建项目(记得删除聚合工程src目录)

• 添加依赖

    <properties>
        <!--JDK版本，如果是jdk8则这里是 1.8-->
        <java.version>11</java.version>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <spring.boot.version>2.5.5</spring.boot.version>
        <spring.cloud.version>2020.0.4</spring.cloud.version>
        <alibaba.cloud.version>2021.1</alibaba.cloud.version>
        <mybatisplus.boot.starter.version>3.4.0</mybatisplus.boot.starter.version>
        <lombok.version>1.18.16</lombok.version>
        <commons.lang3.version>3.9</commons.lang3.version>
        <commons.codec.version>1.15</commons.codec.version>
        <xxl-job.version>2.3.0</xxl-job.version>
        <aliyun.oss.version>3.10.2</aliyun.oss.version>
        <captcha.version>1.1.0</captcha.version>
        <docker.image.prefix>dcloud</docker.image.prefix>
        <redission.version>3.10.1</redission.version>
        <jwt.version>0.7.0</jwt.version>
        <sharding-jdbc.version>4.1.1</sharding-jdbc.version>
        <!--跳过单元测试-->
        <skipTests>true</skipTests>
        <junit.version>4.12</junit.version>
        <druid.version>1.1.16</druid.version>
    </properties>
    <!--锁定版本-->
    <dependencyManagement>
        <dependencies>
            <!--https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-dependencies/2.3.3.RELEASE-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring.boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies/Hoxton.SR8-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring.cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-alibaba-dependencies/2.2.1.RELEASE-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${alibaba.cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--mybatis plus和springboot整合-->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatisplus.boot.starter.version}</version>
            </dependency>
            <!--https://mvnrepository.com/artifact/org.projectlombok/lombok/1.18.16-->
            <!--scope=provided，说明它只在编译阶段生效，不需要打入包中, Lombok在编译期将带Lombok注解的Java文件正确编译为完整的Class文件-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <!--<scope>provided</scope>-->
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>${commons.lang3.version}</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->
            <!--用于加密-->
            <dependency>
                <groupId>commons-codec</groupId>
                <artifactId>commons-codec</artifactId>
                <version>${commons.codec.version}</version>
            </dependency>
            <!--验证码kaptcha依赖包-->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>kaptcha-spring-boot-starter</artifactId>
                <version>${captcha.version}</version>
            </dependency>
            <!--阿里云oss-->
            <dependency>
                <groupId>com.aliyun.oss</groupId>
                <artifactId>aliyun-sdk-oss</artifactId>
                <version>${aliyun.oss.version}</version>
            </dependency>
            <!-- JWT相关 -->
            <dependency>
                <groupId>io.jsonwebtoken</groupId>
                <artifactId>jjwt</artifactId>
                <version>${jwt.version}</version>
            </dependency>
            <!--分布式锁-->
            <dependency>
                <groupId>org.redisson</groupId>
                <artifactId>redisson</artifactId>
                <version>${redission.version}</version>
            </dependency>
             <!--https://mvnrepository.com/artifact/org.apache.shardingsphere/sharding-jdbc-spring-boot-starter-->
            <dependency>
                <groupId>org.apache.shardingsphere</groupId>
                <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
                <version>${sharding-jdbc.version}</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/com.xuxueli/xxl-job-core -->
            <dependency>
                <groupId>com.xuxueli</groupId>
                <artifactId>xxl-job-core</artifactId>
                <version>${xxl-job.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <!-- 代码库 -->
    <repositories>
        <repository>
            <id>maven-ali</id>
            <url>http://maven.aliyun.com/nexus/content/groups/public//</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
                <updatePolicy>always</updatePolicy>
                <checksumPolicy>fail</checksumPolicy>
            </snapshots>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
    <!--module不用添加打包版本信息-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <skip>true</skip>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring.boot.version}</version>
                <configuration>
                    <fork>true</fork>
                    <addResources>true</addResources>
                </configuration>
            </plugin>
        </plugins>
    </build>

第2集 Gitee仓库介绍和项目纳入版本管理+ignore文件配置

简介：开源中国Gitee仓库-介绍和项目纳入版本管理+ignore文件配置置

• Git介绍

  • 是一个版本管理工具, 其作用就是可以让你更好的管理你的程序，比如你原来提交过的内容，以后虽然修改了，但是通过git这个工具，可以把你原来提交的内容重现出来，这样对于你后来才意识到的一些错误的更改，可以进行还原

• 基于git协议的代码仓库

  • github 全球最大同性交友社区
  • gitee 开源中国
  • gitlab 开源的git仓库平台，阿里等大厂就是基于这个搭建
  • codeup 阿里云上的免费git仓库

• gitee仓库地址

  • https://gitee.com/

• 大课项目必须用git吗？

  • 如果是因为不会git，而不用则不行，因为这个是互联网公司必备的
  • 可以看联系客服看小滴课堂 git+gitlab专题视频

• 本地安装文档

  • https://www.runoob.com/git/git-install-setup.html
  • https://git-scm.com/book/zh/v2/起步-安装-Git

• 大课项目加入git管理（是公钥设置，不是秘钥设置）

  • 本地生成公钥 ssh-keygen -t rsa -C “794666918@qq.com“

    • 生成公钥文档：https://gitee.com/help/articles/4181
    • 设置公钥文档：https://gitee.com/help/articles/4191#article-header0
  • 进入项目目录

• 配置gitignore文件

  • 根目录创建文件 .gitignore

# Compiled class file
*.class
# Log file
*.log
# BlueJ files
*.ctxt
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar
.DS_Store
.idea
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*

第3集 阿里编码规范里面Manager分层介绍-和开发规范说明

简介：阿里编码规范里面Manager分层介绍-专用名词和POJO实体类约定

• 开发人员：张三、李四、王五

• 一定要避免单点故障

  • 一个微服务起码两个人熟悉：一个是主程一个是技术leader ,推荐是团队里面两个开发人员
• N方库说明

一方库: 本工程内部子项目模块依赖的库(jar 包)。
二方库: 公司内部发布到中央仓库，可供公司内部其它应用依赖的库(jar包)。
三方库: 公司之外的开源库(jar 包)。

• POJO实体类

POJO(Plain Ordinary Java Object): 在手册中，POJO 专指只有 setter / getter / toString的简单类，包括DO/DTO/BO/VO等, 禁止命名成xxxPOJO

• 各个层级约束规范

A) Service/DAO层方法命名规约
    1) 获取单个对象的方法用get做前缀。
    2) 获取多个对象的方法用list做前缀，复数形式结尾如:listObjects。 
    3) 获取统计值的方法用count做前缀。
    4) 插入的方法用save/insert做前缀。
    5) 删除的方法用remove/delete做前缀。
    6) 修改的方法用update做前缀。
B) 领域模型命名规约
  1) 数据对象:xxxDO，xxx即为数据表名。
  2) 一般数据传输对象:xxxDTO，xxx为业务领域相关的名称，项目里面也用VO。 
  3) 展示对象:xxxVO，也就是响应给前端的实体包装类。
  4) 接收前端json对象请求的命名为 XXXRequest

• Manager分层说明 通用业务处理层，它有如下特征

  • 对第三方平台封装的层，预处理返回结果及转化异常信息
  • 对Service层通用能力的下沉，如缓存方案、中间件通用处理;
  • 与DAO层交互，对多个DAO的组合复用。

·

• 更多开发规范，可以参考阿里巴巴编码手册（资料里面有 第6章第3集资料里面）

  • 有兴趣的同学也可以安装IDEA编码扫描插件，不过前期可以先不用开启，会影响电脑卡顿和强迫症

第4集【重要】dcloud-common通用模块配置使用实战和新版改动

简介：短链平台dcloud-common通用模块配置使用实战

• pom文件配置

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--项目中添加 spring-boot-starter-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--数据库连接-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--mybatis plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
        </dependency>
        <!--单元测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!--redis客户端-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <!--用于加密-->
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
        </dependency>
        <!-- JWT相关 -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
        </dependency>
        <!--redisson分布式锁-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
        </dependency>
<!--Hoxton.M2版本之后不再使用Ribbon而是使用spring-cloud-loadbalancer，所以不引入spring-cloud-loadbalancer会报错，所以加入spring-cloud-loadbalancer依赖 并且在nacos中排除ribbon依赖，不然loadbalancer无效 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
        </dependency>
        <!--配置中心， 留坑，后续用的时候再讲-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <!--Feign远程调用-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!--限流依赖-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>
        <!--限流持久化到nacos-->
        <dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-datasource-nacos</artifactId>
        </dependency>
        <!--Springboot项目整合spring-kafka依赖包配置-->
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>
        <!--引入AMQP-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <!--spring cache依赖包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.xuxueli/xxl-job-core -->
        <!--分布式调度-->
        <dependency>
            <groupId>com.xuxueli</groupId>
            <artifactId>xxl-job-core</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>

第5集 统一接口响应协议-响应工具类封装

简介：统一接口响应协议和响应工具类封装

• 统一业务状态码 BizCodeEnum开发

  • 状态码定义约束，共6位数，前三位代表服务，后3位代表接口
  • 比如 商品服务210

/**
 * 小滴课堂,愿景：让技术不再难学
 *
 * @Description 状态码定义约束，共6位数，前三位代表服务，后3位代表接口
 *  比如 商品服务210,购物车是220、用户服务230，403代表权限
 *
 **/
public enum BizCodeEnum {
    /**
     * 短链分组
     */
    GROUP_REPEAT(23001,"分组名重复"),
    GROUP_OPER_FAIL(23503,"分组名操作失败"),
    GROUP_NOT_EXIST(23404,"分组不存在"),
    /**
     *验证码
     */
    CODE_TO_ERROR(240001,"接收号码不合规"),
    CODE_LIMITED(240002,"验证码发送过快"),
    CODE_ERROR(240003,"验证码错误"),
    CODE_CAPTCHA_ERROR(240101,"图形验证码错误"),
    /**
     * 账号
     */
    ACCOUNT_REPEAT(250001,"账号已经存在"),
    ACCOUNT_UNREGISTER(250002,"账号不存在"),
    ACCOUNT_PWD_ERROR(250003,"账号或者密码错误"),
    ACCOUNT_UNLOGIN(250004,"账号未登录"),
    /**
     * 短链
     */
    SHORT_LINK_NOT_EXIST(260404,"短链不存在"),
    /**
     * 订单
     */
    ORDER_CONFIRM_PRICE_FAIL(280002,"创建订单-验价失败"),
    ORDER_CONFIRM_REPEAT(280008,"订单恶意-重复提交"),
    ORDER_CONFIRM_TOKEN_EQUAL_FAIL(280009,"订单令牌缺少"),
    ORDER_CONFIRM_NOT_EXIST(280010,"订单不存在"),
    /**
     * 支付
     */
    PAY_ORDER_FAIL(300001,"创建支付订单失败"),
    PAY_ORDER_CALLBACK_SIGN_FAIL(300002,"支付订单回调验证签失败"),
    PAY_ORDER_CALLBACK_NOT_SUCCESS(300003,"支付宝回调更新订单失败"),
    PAY_ORDER_NOT_EXIST(300005,"订单不存在"),
    PAY_ORDER_STATE_ERROR(300006,"订单状态不正常"),
    PAY_ORDER_PAY_TIMEOUT(300007,"订单支付超时"),
    /**
     * 流控操作
     */
    CONTROL_FLOW(500101,"限流控制"),
    CONTROL_DEGRADE(500201,"降级控制"),
    CONTROL_AUTH(500301,"认证控制"),
    /**
     * 流量包操作
     */
    TRAFFIC_FREE_NOT_EXIST(600101,"免费流量包不存在，联系客服"),
    TRAFFIC_REDUCE_FAIL(600102,"流量不足，扣减失败"),
    TRAFFIC_EXCEPTION(600103,"流量包数据异常,用户无流量包"),
    /**
     * 通用操作码
     */
    OPS_REPEAT(110001,"重复操作"),
    OPS_NETWORK_ADDRESS_ERROR(110002,"网络地址错误"),
    /**
     * 文件相关
     */
    FILE_UPLOAD_USER_IMG_FAIL(700101,"用户头像文件上传失败");
    @Getter
    private String message;
    @Getter
    private int code;
    private BizCodeEnum(int code, String message){
        this.code = code;
        this.message = message;
    }
}

• 接口统一协议 JsonData工具类开发

@Data
@AllArgsConstructor
@NoArgsConstructor
public class JsonData {
    /**
     * 状态码 0 表示成功
     */
    private Integer code;
    /**
     * 数据
     */
    private Object data;
    /**
     * 描述
     */
    private String msg;
    /**
     *  获取远程调用数据
     *  注意事项：
     *      支持多单词下划线专驼峰（序列化和反序列化）
     *
     *
     * @param typeReference
     * @param <T>
     * @return
     */
    public <T> T getData(TypeReference<T> typeReference){
        return JSON.parseObject(JSON.toJSONString(data),typeReference);
    }
    /**
     * 成功，不传入数据
     * @return
     */
    public static JsonData buildSuccess() {
        return new JsonData(0, null, null);
    }
    /**
     *  成功，传入数据
     * @param data
     * @return
     */
    public static JsonData buildSuccess(Object data) {
        return new JsonData(0, data, null);
    }
    /**
     * 失败，传入描述信息
     * @param msg
     * @return
     */
    public static JsonData buildError(String msg) {
        return new JsonData(-1, null, msg);
    }
    /**
     * 自定义状态码和错误信息
     * @param code
     * @param msg
     * @return
     */
    public static JsonData buildCodeAndMsg(int code, String msg) {
        return new JsonData(code, null, msg);
    }
    /**
     * 传入枚举，返回信息
     * @param codeEnum
     * @return
     */
    public static JsonData buildResult(BizCodeEnum codeEnum){
        return JsonData.buildCodeAndMsg(codeEnum.getCode(),codeEnum.getMessage());
    }
}

第6集 微服务自定义全局异常+处理器handler开发

简介：自定义全局异常+处理器开发

• 自定义全局异常

/**
 * 全局异常处理
 */
@Data
public class BizException extends RuntimeException {
    private Integer code;
    private String msg;
    public BizException(Integer code, String message) {
        super(message);
        this.code = code;
        this.msg = message;
    }
    public BizException(BizCodeEnum bizCodeEnum) {
        super(bizCodeEnum.getMsg());
        this.code = bizCodeEnum.getCode();
        this.msg = bizCodeEnum.getMsg();
    }
}

• 自定义异常处理器

@ControllerAdvice
@Slf4j
public class ExceptionHandle {
    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public JsonData handle(Exception e) {
        if (e instanceof BizException) {
            BizException bizException = (BizException) e;
            log.info("[业务异常]{}", e);
            return JsonData.buildError(bizException.getMsg(), bizException.getCode());
        } else {
            log.info("[系统异常]{}", e);
            return JsonData.buildError("全局异常，未知错误");
        }
    }
}

第7集 common通用工具和时间格式化工具类讲解

简介：common通用工具和时间格式化工具类讲解

• 时间格式化工具类封装

public class TimeUtil {
    /**
     * 默认日期格式
     */
    private static final String DEFAULT_PATTERN = "yyyy-MM-dd HH:mm:ss";
    /**
     * 默认日期格式
     */
    private static final DateTimeFormatter DEFAULT_DATE_TIME_FORMATTER  = DateTimeFormatter.ofPattern(DEFAULT_PATTERN);
    private static final  ZoneId DEFAULT_ZONE_ID = ZoneId.systemDefault();
    /**
     * LocalDateTime 转 字符串，指定日期格式
     * @param time
     * @param pattern
     * @return
     */
    public static String format(LocalDateTime localDateTime,String pattern){
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        String timeStr = formatter.format(localDateTime.atZone(DEFAULT_ZONE_ID));
        return timeStr;
    }
    /**
     * Date 转 字符串, 指定日期格式
     * @param time
     * @param pattern
     * @return
     */
    public static String format(Date time,String pattern){
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        String timeStr = formatter.format(time.toInstant().atZone(DEFAULT_ZONE_ID));
        return timeStr;
    }
    /**
     *  Date 转 字符串，默认日期格式
     * @param time
     * @return
     */
    public static String format(Date time){
        String timeStr = DEFAULT_DATE_TIME_FORMATTER.format(time.toInstant().atZone(DEFAULT_ZONE_ID));
        return timeStr;
    }
    /**
     * timestamp 转 字符串，默认日期格式
     *
     * @param time
     * @return
     */
    public static String format(long timestamp) {
        String timeStr = DEFAULT_DATE_TIME_FORMATTER.format(new Date(timestamp).toInstant().atZone(DEFAULT_ZONE_ID));
        return timeStr;
    }
    /**
     * 字符串 转 Date
     *
     * @param time
     * @return
     */
    public static Date strToDate(String time) {
        LocalDateTime localDateTime = LocalDateTime.parse(time, DEFAULT_DATE_TIME_FORMATTER);
        return Date.from(localDateTime.atZone(DEFAULT_ZONE_ID).toInstant());
    }
    /**
     * 获取当天剩余的秒数,用于流量包过期配置
     * @param currentDate
     * @return
     */
    public static Integer getRemainSecondsOneDay(Date currentDate) {
        LocalDateTime midnight = LocalDateTime.ofInstant(currentDate.toInstant(),
                ZoneId.systemDefault()).plusDays(1).withHour(0).withMinute(0)
                .withSecond(0).withNano(0);
        LocalDateTime currentDateTime = LocalDateTime.ofInstant(currentDate.toInstant(),
                ZoneId.systemDefault());
        long seconds = ChronoUnit.SECONDS.between(currentDateTime, midnight);
        return (int) seconds;
    }
}

• Json序列化工具类封装

public class JsonUtil {
    private static final ObjectMapper mapper = new ObjectMapper();
    static {
        //设置可用单引号
        mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
        //序列化的时候序列对象的所有属性
        mapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
        //反序列化的时候如果多了其他属性,不抛出异常
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        //如果是空对象的时候,不抛异常
        mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        //取消时间的转化格式,默认是时间戳,可以取消,同时需要设置要表现的时间格式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    }
    /**
     * 对象转为Json字符串
     * @param data
     * @return
     */
    public static String obj2Json(Object obj) {
        String jsonStr = null;
        try {
            jsonStr = mapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return jsonStr;
    }
    /**
     * json字符串转为对象
     * @param str
     * @param valueType
     * @return
     */
    public static <T> T json2Obj(String jsonStr, Class<T> beanType) {
        T obj = null;
        try {
            obj = mapper.readValue(jsonStr, beanType);
        } catch (Exception e){
            e.printStackTrace();
        }
        return obj;
    }
    /**
     * json数据转换成pojo对象list
     * @param jsonData
     * @param beanType
     * @return
     */
    public static <T> List<T> json2List(String jsonData, Class<T> beanType) {
        JavaType javaType = mapper.getTypeFactory().constructParametricType(List.class, beanType);
        try {
            List<T> list = mapper.readValue(jsonData, javaType);
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 对象转为byte数组
     * @param data
     * @return
     */
    public static byte[] obj2Bytes(Object obj) {
        byte[] byteArr = null;
        try {
            byteArr = mapper.writeValueAsBytes(obj);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return byteArr;
    }
    /**
     * byte数组转为对象
     * @param byteArr
     * @param valueType
     * @return
     */
    public static <T> T bytes2Obj(byte[] byteArr, Class<T> beanType) {
        T obj = null;
        try {
            obj = mapper.readValue(byteArr, beanType);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }
}

• common工具大集合

@Slf4j
public class CommonUtil {
    /**
     * 获取ip
     *
     * @param request
     * @return
     */
    public static String getIpAddr(HttpServletRequest request) {
        String ipAddress = null;
        try {
            ipAddress = request.getHeader("x-forwarded-for");
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("WL-Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getRemoteAddr();
                if (ipAddress.equals("127.0.0.1")) {
                    // 根据网卡取本机配置的IP
                    InetAddress inet = null;
                    try {
                        inet = InetAddress.getLocalHost();
                    } catch (UnknownHostException e) {
                        e.printStackTrace();
                    }
                    ipAddress = inet.getHostAddress();
                }
            }
            // 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
            if (ipAddress != null && ipAddress.length() > 15) {
                // "***.***.***.***".length()
                // = 15
                if (ipAddress.indexOf(",") > 0) {
                    ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
                }
            }
        } catch (Exception e) {
            ipAddress = "";
        }
        return ipAddress;
    }
    /**
     * 获取全部请求头
     * @param request
     * @return
     */
    public static Map<String, String> getAllRequestHeader(HttpServletRequest request){
        Enumeration<String> headerNames = request.getHeaderNames();
        Map<String, String> map = new HashMap<>();
        while (headerNames.hasMoreElements()) {
            String key = (String)headerNames.nextElement();
            //根据名称获取请求头的值
            String value = request.getHeader(key);
            map.put(key,value);
        }
        return map;
    }
    /**
     * MD5加密
     *
     * @param data
     * @return
     */
    public static String MD5(String data) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] array = md.digest(data.getBytes("UTF-8"));
            StringBuilder sb = new StringBuilder();
            for (byte item : array) {
                sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
            }
            return sb.toString().toUpperCase();
        } catch (Exception exception) {
        }
        return null;
    }
    /**
     * 获取验证码随机数
     *
     * @param length
     * @return
     */
    public static String getRandomCode(int length) {
        String sources = "0123456789";
        Random random = new Random();
        StringBuilder sb = new StringBuilder();
        for (int j = 0; j < length; j++) {
            sb.append(sources.charAt(random.nextInt(9)));
        }
        return sb.toString();
    }
    /**
     * 获取当前时间戳
     *
     * @return
     */
    public static long getCurrentTimestamp() {
        return System.currentTimeMillis();
    }
    /**
     * 生成uuid
     *
     * @return
     */
    public static String generateUUID() {
        return UUID.randomUUID().toString().replaceAll("-", "").substring(0, 32);
    }
    /**
     * 获取随机长度的串
     *
     * @param length
     * @return
     */
    private static final String ALL_CHAR_NUM = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
    public static String getStringNumRandom(int length) {
        //生成随机数字和字母,
        Random random = new Random();
        StringBuilder saltString = new StringBuilder(length);
        for (int i = 1; i <= length; ++i) {
            saltString.append(ALL_CHAR_NUM.charAt(random.nextInt(ALL_CHAR_NUM.length())));
        }
        return saltString.toString();
    }
    /**
     * 响应json数据给前端
     *
     * @param response
     * @param obj
     */
    public static void sendJsonMessage(HttpServletResponse response, Object obj) {
        response.setContentType("application/json; charset=utf-8");
        try (PrintWriter writer = response.getWriter()) {
            writer.print(JsonUtil.obj2Json(obj));
            response.flushBuffer();
        } catch (IOException e) {
            log.warn("响应json数据给前端异常:{}",e);
        }
    }
}