Spring Boot2 教程合集

给大家整理了几个开源免费的 Spring Boot + Vue 学习资料

2019-11-20T09:52:13+00:00

最近抽空在整理前面的文章案例啥的，顺便把手上的几个 Spring Boot + Vue 的学习资料推荐给各位小伙伴。这些案例有知识点的讲解，也有项目实战，正在做这一块的小伙伴们可以收藏下。

案例学习

javaboy-video-samples

项目地址：https://github.com/lenve/javaboy-video-samples

这个是松哥录制的 Spring Boot2 系列视频教程的案例，视频是加密的，但是案例从一开始就是开源的，这个可以毫无保留的共享给大家，案例可以说是非常全面，这个仓库会随着视频的录制而继续完善。

javaboy-code-samples

项目地址：https://github.com/lenve/javaboy-code-samples

这个是我平时公众号上文章的案例，因为公众号的文章大部分都是以 Spring Boot + Vue 前后端分离开发为主，所以这些文章也是这一方面的，不同于上面的那个仓库，这里的每个案例都有对应的文章进行讲解，这个仓库中的内容会随着公众号文章的增加而继续增加：

spring-boot-vue-samples

项目地址：https://github.com/lenve/spring-boot-vue-samples

这个是松哥《Spring Boot + Vue 全栈开发实战》一书的官方案例，但是因为书里给出来的地址是一个百度云盘的地址，所以这个仓库很少受到小伙伴们的关注。不过这套案例的整理的不是很满意，另外这套案例也比较旧了，是去年的，所以建议小伙伴们关注第一个，里边的案例比较新，也比较整齐。

Spring Boot2

项目地址：http://springboot.javaboy.org

这个不是 GitHub 上的仓库，是松哥一系列 Spring Boot 相关文章的集合，我把它做成了电子书的形式，但是有两个不太满意的地方：一个是文章排版不太满意，另一个则是网站托管在国外服务器上，访问速度较慢，因此这个在线的电子书我最近也在整理，整理完成后，我会分享出来给大家免费下载，小伙伴们多多关注公众号上的消息哦。

awesome-github-vue

项目地址：https://github.com/opendigg/awesome-github-vue

这个不是松哥的仓库，这是我刚开始学习 Vue 的时候收藏的一个仓库，感觉非常棒，很多常用的 Vue 插件这里都有，不过稍微遗憾的是，这个仓库有两年没有更新了，不过对于刚刚开始接触 Vue 的小伙伴而言，这个仓库够用了。

项目

项目就不用多说了，V 部落和微人事。

微人事

项目地址：https://github.com/lenve/vhr

关于微人事我已经写过好多文章了，这里就不再赘述了，要告诉大家的一个好消息是，大概在 12 月，微人事会进行一次全面的版本升级，Spring Boot 切换到当前最新版，Vue 构建工具切换到 vue-cli3，而且还会引入消息中间件 RabbitMQ 等一些外部工具，进一步扩展微人事所涉及到的知识点。微人事项目最新体验地址：

http://vhr.itboyhub.com

当然，松哥之前也录过一个微人事部署视频，大家可以参考：

V 部落

项目地址：https://github.com/lenve/VBlog

V 部落没有微人事那么丰富的文档，但是比较简单，业务简单，用到的技术点也简单，不过好多小伙伴竟然反映部署不起来，以后我看时间抽空也可以录一个部署教程吧，V 部落目前最新的体验地址是：

http://vblog.itboyhub.com

最后再悄悄告诉大家，公众号后台回复 2TB 可以获取 2TB Java 学习资源下载地址哦。

2TB 学习资源

2019-11-12T08:35:27+00:00

今年 5 月份的时候，松哥发了一个视频资源库，当时和大家说，这个资源库会定期更新，后来却迟迟未更新，其实不是我没资源了，是因为当时的关键字是我一个一个在微信后台配置的，配置到后面发现，后台配置关键字有数量上限，没法继续配置了，所以这事就搁置下来了。

九月份松哥上线了自己的服务，和微信的后台对接起来，具体实现大家可以参考这两篇文章：

现在再配置关键字就没有限制了。于是最近抽空把资源更新了一波，废话不多说，大家在公众号【江南一点雨】后台回复相应的口令，就可以获取相应的视频下载地址。

Java 基础

资源名称	口令
Java 基础语法	javaboy4096
Java 面向对象	javaboy6148
JavaSE 飞机大战项目	javaboy2053
深入面向对象和数组	javaboy8200
Java 常用类详解	javaboy4105
Java 异常机制解析	javaboy6157
Java 集合与数据结构	javaboy2062
JavaIO 流全解析	javaboy8209
深入理解 Java 多线程	javaboy4114
Java 网络编程	javaboy6166
手动开发一个 Web 服务器	javaboy2071
深入理解 Java 注解+反射	javaboy8218
Java23 种设计模式	javaboy4123
学会 Java 正则表达式	javaboy6175
JDBC 详解	javaboy2080
独立开发 SORM 框架	javaboy8227
快人一步，Java10 新特性全解析	javaboy4132
Java 数据结构和算法	javaboy6184
深入理解 Java 虚拟机	javaboy2089
Java 解析XML文件	javaboy8236

数据库

资源名称	口令
Oracle 数据库安装及简单 SQL	javaboy4141
Oracle 账户管理及查询语句	javaboy6193
Oracle 中的函数	javaboy2098
Oracle 中的子查询	javaboy8245
Oracle 中常见的表操作	javaboy4150
Oracle 中的数据备份	javaboy6202
MySQL 基础	javaboy2107
PowerDesigner 教程	javaboy8254
JDBC 操作数据库	javaboy4159
MySQL 优化	javaboy6211
Oracle 高级课程	javaboy2116
数据库与 SQL 优化	javaboy6283
数据库集群与高并发	javaboy2188

Web 基础

资源名称	口令
HTML 入门教程	javaboy8263
CSS 教程	javaboy4168
JavaScript 视频教程	javaboy6220
jQuery 视频教程	javaboy2125
EasyUI 视频教程	javaboy8272
Servlet 基础	javaboy4177
Servlet 中的 Request 和 Response	javaboy6229
Servlet 请求转发与重定向	javaboy2134
Session 和 Cookie	javaboy8281
JSP 详解	javaboy4186
用户管理系统实战	javaboy6238
Ajax 详解	javaboy2143
EL 和 JSTL	javaboy8290
过滤器详解	javaboy4195
监听器详解	javaboy6247
KnockoutJS 实战视频	javaboy2152

Java 高级

资源名称	口令
IntelliJIDEA 视频教程	javaboy4285
Java 高并发秒杀方案	javaboy8299
Activiti 工作流实战解析	javaboy4204
Java 并发编程与高并发实战	javaboy6256
Linux 快速入门	javaboy2161
Maven 详解	javaboy8308
Git 应用详解	javaboy4213
Svn 入门教程	javaboy6265
高并发编程与线程池	javaboy2170
系统优化与 JVM 调优	javaboy8317
Java 编程规范	javaboy4222
AIO、BIO、NIO 详解	javaboy6274
Netty 高级视频教程	javaboy2179
ActiveMQ 消息中间详解	javaboy8326
单点登录视频教程	javaboy4231
Dubbo 详解	javaboy8335
Redis 全解析	javaboy4240
VSFTPD+NGINX 视频教程	javaboy6292
MyBatis 视频教程	javaboy2197
Spring4 视频教程	javaboy8344
SpringMVC 视频教程	javaboy4249
SSM 框架整合视频教程	javaboy6301
RBAC 权限控制视频教程	javaboy2206
Hibernate4 视频教程	javaboy8353
Jfinal 视频教程	javaboy4258
Shiro 视频教程	javaboy6310
Solr 视频教程	javaboy2215
Struts2 视频教程	javaboy8362
Nginx 视频教程	javaboy4267
Redis 缓存详解	javaboy6319
JVM 虚拟机优化	javaboy2224
Zookeeper 详解视频	javaboy8371
Linux 基本操作	javaboy6328
架构师面试攻略（文档）	javaboy2233
架构师面试攻略（视频）	javaboy8380
JUC 视频教程	javaboy6400
MySQL 高级教程	javaboy2305
Java 邮件开发教程	javaboy8452
Maven 实战视频	javaboy8443
自己 DIY 一个 Tomcat	javaboy4339

大前端

资源名称	口令
HTML5 新特性	javaboy4276
AngularJS 视频教程	javaboy6337
Grunt 视频教程	javaboy2242
Gulp 视频教程	javaboy8389
Webpack 视频教程	javaboy4294
Bootstrap 视频教程	javaboy6346
CSS3 视频教程	javaboy2251
ES6 视频教程	javaboy8398
HTML5 核心技术	javaboy4303
HTML5 实战	javaboy6355
HTML5 项目实战	javaboy2260
JS 模块化视频教程	javaboy8407
less 视频教程	javaboy4312
NodeJS 视频教程	javaboy6364
React 视频教程	javaboy2269
Zepto 视频教程	javaboy8416
HTML+CSS 实战视频	javaboy4321
JavaScript140 集	javaboy6373
jQuery 视频教程	javaboy2278
JavaScript 高级语法视频教程	javaboy8425
Vue 项目实战视频	javaboy4330
CSS3 特效实战	javaboy6382
HTML5 特效实战	javaboy2287
HTML5+Canvas 实现刮刮卡	javaboy8434
Gradle 从入门到精通	javaboy6391
mpvue 项目实战	javaboy2296
Vue 最新最全视频教程	javaboy4348

大数据

资源名称	口令
Linux 操作系统	javaboy4357
Linux 基本命令	javaboy6409
Linux 文件安装	javaboy2314
Shell 编程	javaboy8461
网络基础知识	javaboy4366
LVS 集群与高并发	javaboy6418
Nginx 和高并发	javaboy2323
keepalive 和单点故障	javaboy8470
HDFS 分布式文件系统	javaboy4375
mapreduce 分布式计算	javaboy6427
YARN 资源管理与任务调度	javaboy2332
mapreduce 计算案例	javaboy8479
HIVE 视频教程	javaboy4384
Hbase 数据库详解	javaboy6436
zookeeper 协同处理	javaboy2341
CDH 使用	javaboy8488
HUE 使用	javaboy4393
IMPALA 详解	javaboy6445
oozie 详解	javaboy2350
elasticsearch 详解	javaboy8497
Redis 内存数据	javaboy4402
Scala 入门	javaboy6454
Spark 详解	javaboy2359
Spark 高级	javaboy8506
Spark-Stream 流式计算	javaboy4411
Kafka 分布式消息队列	javaboy6463
STORM 流式计算框架	javaboy2368
Python 语言基础	javaboy8515
回归算法	javaboy4420
分类算法、决策树	javaboy6472
聚类算法、微博案例	javaboy2377
推荐算法	javaboy8524
大型电商日志分析（项目实战）	javaboy4429
智慧交通（项目实战）	javaboy6481
智能 App（项目实战）	javaboy2386

人工智能

资源名称	口令
人工智能入门	javaboy8533
线性回归深入与代码实现	javaboy4438
梯度下降算发实现	javaboy6490
逻辑回归详解和应用	javaboy2395
分类项目案例与神经网络算法	javaboy8542
多分类、决策树分类与随机森林分类	javaboy4447
分类评估与聚类	javaboy6499
密度聚类与谱聚类	javaboy2404
Tensorflow 安装并实现线性回归	javaboy8551
TensorFlow 深入、TensorFlow可视化	javaboy4456
DNN 深度神经网络手写图片识别	javaboy6508
TensorBoard 可视化	javaboy2413
卷积神经网络、CNN 识别图片	javaboy8560
卷积神经网络深入，AlexNet 模型实现	javaboy4465
Keras 深度学习框架	javaboy6517

分布式相关

资源名称	口令
ZooKeeper 简介	javaboy2422
ZooKeeper 安装	javaboy8569
ZooKeeper 基本数据模型	javaboy4474
基于 Linux 的 ZK 客户端命令	javaboy6526
选举模式和 ZK 集群安装	javaboy2431
JavaAPI 操作 ZK	javaboy8578
ApacheCurator 客户端	javaboy4483
Dubbo 入门到重构服务	javaboy6535
分布式锁	javaboy2440
Zookeeper 总结	javaboy8587

项目实战

资源名称	口令
OA 办公自动化项目1	javaboy4492
OA 办公自动化项目2	javaboy6544
OA 办公自动化项目3	javaboy2449
OA 办公自动化项目4	javaboy8596
备锋客户关系管理(CRM)系统	javaboy4501
百战客户关系管理系统	javaboy6553
宅急送项目	javaboy2458
高仿人人网项目	javaboy8605
Java 邮件开发项目	javaboy4510
在线支付实战视频	javaboy6562
俄罗斯方块游戏实战	javaboy2467
贪吃蛇视频教程	javaboy8614
交通灯管理系统	javaboy4519
银行业务调度系统实战	javaboy6571
供应链系统实战视频	javaboy2476
网上商城项目实战	javaboy8623
医药采购平台管理系统	javaboy4528
点餐系统实战	javaboy6580
杰信商贸 SSM 版	javaboy2485
国家税务协同平台项目	javaboy8632
javaWeb 聊天室	javaboy4537
网上书店	javaboy6589
手机进销存系统	javaboy2494
QQ 聊天器	javaboy8641
ERP 项目	javaboy4546
坦克大战	javaboy6598
五子棋游戏	javaboy2503
报名系统 Activity	javaboy8650
OA 供应链系统	javaboy4555
用户管理系统	javaboy6607
JavaWeb 图书商城	javaboy2512
VIP 商场	javaboy8659
企业招聘系统	javaboy4564
博客系统项目	javaboy6616
超级玛丽	javaboy2521
成绩管理系统	javaboy8668
个人理财系统	javaboy4573
人事管理系统	javaboy6625
JBPM 采购申请系统	javaboy2530
电子商务网站	javaboy8677
跨平台 App 开发	javaboy4582

文档资源

资源名称	口令
Docker 教程	docker
Redis 教程	redis
RocketMQ 教程	rocketmq
Java8 新特性文档	java8
设计模式教程	设计模式
网络协议教程	网络
netty 教程	netty
web 全栈指南	web全栈

好了，本次就先更新这么多，如果这里没有你想要的，也也可以留言说说你需要的资料，松哥会及时更新资源哦。 另外，大家在公众号后台回复资源，也可以获取本文电子版。

如果这些资源帮助到你了，欢迎转发给更多小伙伴哦。

还在用 Dockerfile 部署 Spring Boot？out 啦！试试谷歌的大杀器 Jib

2019-11-07T10:33:35+00:00

之前松哥和大家分享过一篇将 Spring Boot 项目部署到远程 Docker 上的文章：

一键部署 Spring Boot 到远程 Docker 容器

但是这种部署有一个问题，就是一个小小的 helloworld 构建成镜像之后，竟然都有 660 MB+，这就有点过分了；而且这种方式步骤繁琐，很多人看了头大。

因此松哥今天想再和大家聊一聊另外一种方案 Jib，这是谷歌开源的一个容器化运行方案，使用它我们将 Spring Boot 进行容器化部署只要两步：

第一步配置 Maven Plugin
第二步构建

我们一起来看看。

Jib

在之前那篇文章中，我们将 Spring Boot 项目进行容器化部署，要求开发人员要有一定的 Docker 技能作为支撑，然而在实际开发中，并非每个人都是 Docker 专家，或者说会用 Docker。

有鉴于此，Google 搞出来一个 Jib，使 Spring Boot 容器化部署变得更加简便，开发人员可以不需要任何 Docker 相关的技能，就能将 Spring Boot 项目构建成 Docker 中的镜像，而且还可以“顺便”将镜像 push 到 register 上，极大的简化了部署过程。

Jib 使用 Java 开发，使用也非常简单，可以作为 Maven 或者 Gradle 的插件直接集成到我们的项目中。它利用镜像分层和注册表缓存来实现快速、增量的构建。Jib 会自动读取项目的构建配置，代码组织到不同的层（依赖项、资源、类）中，然后它只会重新构建和推送发生变更的层。在项目进行快速迭代时，Jib 只将发生变更的层推送到 registers 来缩短构建时间。

好了，大致了解了 Jib 之后，接下来我们来看看 Jib 要怎么使用。

准备工作

Jib 可以直接将构建好的镜像 push 到 registers 上，如果公司有自己的私有镜像站的话，可以直接推送到私有镜像站上，本文我就将构建好的镜像推送到官方的 Docker Hub 上，因此需要大家提前准备一个 Docker Hub 的账号，账号大家可以直接去 Docker Hub 上面注册（https://hub.docker.com/），大家要是对 Docker Hub 这些东西不了解，可以在公众号后台回复 docker，获取松哥自制的 Docker 教程。

牛刀小试

首先我们来创建一个 Spring Boot 工程，创建时只需要添加一个 Web 依赖即可：

项目创建成功后，添加一个 HelloController 用来做测试：

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "hello jib";
    }
}

然后，在 pom.xml 中添加上 Jib 的插件，如下：

<plugin>
    <groupId>com.google.cloud.tools</groupId>
    <artifactId>jib-maven-plugin</artifactId>
    <version>1.7.0</version>
    <configuration>
        <from>
            <image>openjdk:alpine</image>
        </from>
        <to>
            <image>docker.io/wongsung/dockerjib</image>
            <tags>
                <tag>v1</tag>
            </tags>
            <auth>
                <username>wongsung</username>
                <password>你的密码</password>
            </auth>
        </to>
    </configuration>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>build</goal>
            </goals>
        </execution>
    </executions>
</plugin>

关于这段配置，我说如下几点：

首先就是版本号的问题，我这里使用的是 1.7.0 ，网上有的教程比较老，用的 0.x 的版本，老的版本在配置 Docker 认证的时候非常麻烦，所以版本这块建议大家使用当前最新版。
from 中的配置表示本镜像构建所基于的根镜像为 openjdk:alpine
to 中的配置表示本镜像构建完成后，要发布到哪里去，如果是发布到私有镜像站，就写自己私有镜像站的地址，如果是发布到 Docker Hub 上，就参考我这里的写法 docker.io/wongsung/dockerjib，其中 wongsung 表示你在 Docker Hub 上注册的用户名，dockerjib 表示你镜像的名字，可以随意取。
tags 中配置的是自己镜像的版本。
auth 中配置你在 Docker Hub 上的用户名/密码。
executions 节点中的就是常规配置了，我就不再多说了。

配置完成后，在命令行执行如下命令将当前下项目构建成一个 Docker 镜像并 push 到 Docker Hub：

mvn compile jib:build

构建完成后，我们在 Docker Hub 上就能看到自己的镜像了：

接下来，启动 Docker ，在 Docker 中执行如下命令拉取镜像下来并运行：

docker run -d --name mydockerjib -p 8080:8080 docker.io/wongsung/dockerjib:v1

启动成功后，我们在浏览器中就可以直接访问我们刚才的 Spring Boot 项目中的 hello 接口了：

是不是很方便？比我第一次给大家介绍的方案要方便很多。

注意

这种方式是将项目构建成镜像后并 push 到 registers 上，这种构建方式不需要你本地安装 Docker，如果你需要在本地运行镜像，那当然需要 Docker，单纯的构建是不需要 Docker 环境的。

本地构建

如果你电脑本地刚好安装了 Docker ，有 Docker 环境，那么也可以将项目构建成本地 Docker 的镜像，

首先我们来查看一下本地镜像：

可以看到只有 MySQL 镜像，然后我们执行如下命令构建本地镜像：

mvn compile jib:dockerBuild

看到如下构建日志信息表示构建成功：

构建完成后，我们再来看本地镜像：

可以都看到，已经构建成功了，接下来启动命令和上面一样，我就不重复展示了。

结语

容器的出现，让我们的 Java 程序比任何时候都接近“一次编写，到处运行”，Spring Boot 容器化部署也是越来越方便，后面有空松哥再和大家聊聊结合 jenkins 的用法，好了，本文的案例我已经上传到 GitHub：https://github.com/lenve/javaboy-code-samples，有问题欢迎留言讨论。

Spring Boot 开发微信公众号后台(二)

2019-10-31T10:32:24+00:00

hello 各位小伙伴，今天我们来继续学习如何通过 Spring Boot 开发微信公众号。还没阅读过上篇文章的小伙伴建议先看看上文，有助于理解本文：

Spring Boot 开发微信公众号后台

上篇文章中我们将微信服务器和我们自己的服务器对接起来了，并且在自己的服务器上也能收到微信服务器发来的消息，本文我们要看的就是如何给微信服务器回复消息。

消息分类

在讨论如何给微信服务器回复消息之前，我们需要先来了解下微信服务器发来的消息主要有哪些类型以及我们回复给微信的消息都有哪些类型。

在上文中大家了解到，微信发送来的 xml 消息中有一个 MsgType 字段，这个字段就是用来标记消息的类型。这个类型可以标记出这条消息是普通消息还是事件消息还是图文消息等。

普通消息主要是指：

文本消息
图片消息
语音消息
视频消息
小视频消息
地址位置消息
链接消息

不同的消息类型，对应不同的 MsgType，这里我还是以普通消息为例，如下：

消息类型	MsgType
文本消息	text
图片消息	image
语音消息	voice
视频消息	video
小视频消息	shortvideo
地址位置消息	location
链接消息	link

大家千万不要以为不同类型消息的格式是一样的，其实是不一样的，也就是说，MsgType 为 text 的消息和 MsgType 为 image 的消息，微信服务器发给我们的消息内容是不一样的，这样带来一个问题就是我无法使用一个 Bean 去接收不同类型的数据，因此这里我们一般使用 Map 接收即可。

这是消息的接收，除了消息的接收之外，还有一个消息的回复，我们回复的消息也有很多类型，可以回复普通消息，也可以回复图片消息，回复语音消息等，不同的回复消息我们可以进行相应的封装。因为不同的返回消息实例也是有一些共同的属性的，例如消息是谁发来的，发给谁，消息类型，消息 id 等，所以我们可以将这些共同的属性定义成一个父类，然后不同的消息再去继承这个父类。

返回消息类型定义

首先我们来定义一个公共的消息类型：

public class BaseMessage {
    private String ToUserName;
    private String FromUserName;
    private long CreateTime;
    private String MsgType;
    private long MsgId;
    //省略 getter/setter
}

在这里：

ToUserName 表示开发者的微信号
FromUserName 表示发送方账号（用户的 OpenID）
CreateTime 消息的创建时间
MsgType 表示消息的类型
MsgId 表示消息 id

这是我们的基本消息类型，就是说，我们返回给用户的消息，无论是什么类型的消息，都有这几个基本属性。然后在此基础上，我们再去扩展出文本消息、图片消息等。

我们来看下文本消息的定义：

public class TextMessage extends BaseMessage {
    private String Content;
    //省略 getter/setter
}

文本消息在前面消息的基础上多了一个 Content 属性，因此文本消息继承自 BaseMessage ，再额外添加一个 Content 属性即可。

其他的消息类型也是类似的定义，我就不一一列举了，至于其他消息的格式，大家可以参考微信开放文档（http://1t.click/aPXK）。

返回消息生成

消息类型的 Bean 定义完成之后，接下来就是将实体类生成 XML。

首先我们定义一个消息工具类，将常见的消息类型枚举出来：

/**
 * 返回消息类型：文本
 */
public static final String RESP_MESSAGE_TYPE_TEXT = "text";
/**
 * 返回消息类型：音乐
 */
public static final String RESP_MESSAGE_TYPE_MUSIC = "music";
/**
 * 返回消息类型：图文
 */
public static final String RESP_MESSAGE_TYPE_NEWS = "news";
/**
 * 返回消息类型：图片
 */
public static final String RESP_MESSAGE_TYPE_Image = "image";
/**
 * 返回消息类型：语音
 */
public static final String RESP_MESSAGE_TYPE_Voice = "voice";
/**
 * 返回消息类型：视频
 */
public static final String RESP_MESSAGE_TYPE_Video = "video";
/**
 * 请求消息类型：文本
 */
public static final String REQ_MESSAGE_TYPE_TEXT = "text";
/**
 * 请求消息类型：图片
 */
public static final String REQ_MESSAGE_TYPE_IMAGE = "image";
/**
 * 请求消息类型：链接
 */
public static final String REQ_MESSAGE_TYPE_LINK = "link";
/**
 * 请求消息类型：地理位置
 */
public static final String REQ_MESSAGE_TYPE_LOCATION = "location";
/**
 * 请求消息类型：音频
 */
public static final String REQ_MESSAGE_TYPE_VOICE = "voice";
/**
 * 请求消息类型：视频
 */
public static final String REQ_MESSAGE_TYPE_VIDEO = "video";
/**
 * 请求消息类型：推送
 */
public static final String REQ_MESSAGE_TYPE_EVENT = "event";
/**
 * 事件类型：subscribe(订阅)
 */
public static final String EVENT_TYPE_SUBSCRIBE = "subscribe";
/**
 * 事件类型：unsubscribe(取消订阅)
 */
public static final String EVENT_TYPE_UNSUBSCRIBE = "unsubscribe";
/**
 * 事件类型：CLICK(自定义菜单点击事件)
 */
public static final String EVENT_TYPE_CLICK = "CLICK";
/**
 * 事件类型：VIEW(自定义菜单 URl 视图)
 */
public static final String EVENT_TYPE_VIEW = "VIEW";
/**
 * 事件类型：LOCATION(上报地理位置事件)
 */
public static final String EVENT_TYPE_LOCATION = "LOCATION";
/**
 * 事件类型：LOCATION(上报地理位置事件)
 */
public static final String EVENT_TYPE_SCAN = "SCAN";

大家注意这里消息类型的定义，以 RESP 开头的表示返回的消息类型，以 REQ 表示微信服务器发来的消息类型。然后在这个工具类中再定义两个方法，用来将返回的对象转换成 XML：

public static String textMessageToXml(TextMessage textMessage) {
    xstream.alias("xml", textMessage.getClass());
    return xstream.toXML(textMessage);
}
private static XStream xstream = new XStream(new XppDriver() {
    public HierarchicalStreamWriter createWriter(Writer out) {
        return new PrettyPrintWriter(out) {
            boolean cdata = true;
            @SuppressWarnings("rawtypes")
            public void startNode(String name, Class clazz) {
                super.startNode(name, clazz);
            }
            protected void writeText(QuickWriter writer, String text) {
                if (cdata) {
                    writer.write("<![CDATA[");
                    writer.write(text);
                    writer.write("]]>");
                } else {
                    writer.write(text);
                }
            }
        };
    }
});

textMessageToXML 方法用来将 TextMessage 对象转成 XML 返回给微信服务器，类似的方法我们还需要定义 imageMessageToXml、voiceMessageToXml 等，不过定义的方式都基本类似，我就不一一列出来了。

返回消息分发

由于用户发来的消息可能存在多种情况，我们需要分类进行处理，这个就涉及到返回消息的分发问题。因此我在这里再定义一个返回消息分发的工具类，如下：

public class MessageDispatcher {
    public static String processMessage(Map<String, String> map) {
        String openid = map.get("FromUserName"); //用户 openid
        String mpid = map.get("ToUserName");   //公众号原始 ID
        if (map.get("MsgType").equals(MessageUtil.REQ_MESSAGE_TYPE_TEXT)) { 
            //普通文本消息
            TextMessage txtmsg = new TextMessage();
            txtmsg.setToUserName(openid);
            txtmsg.setFromUserName(mpid);
            txtmsg.setCreateTime(new Date().getTime());
            txtmsg.setMsgType(MessageUtil.RESP_MESSAGE_TYPE_TEXT);
            txtmsg.setContent("这是返回消息");
            return MessageUtil.textMessageToXml(txtmsg);
        }
        return null;
    }
    public String processEvent(Map<String, String> map) {
        //在这里处理事件
    }
}

这里我们还可以多加几个 elseif 去判断不同的消息类型，我这里因为只有普通文本消息，所以一个 if 就够用了。

在这里返回值我写死了，实际上这里需要根据微信服务端传来的 Content 去数据中查询，将查询结果返回，数据库查询这一套相信大家都能搞定，我这里就不重复介绍了。

最后在消息接收 Controller 中调用该方法，如下：

@PostMapping(value = "/verify_wx_token",produces = "application/xml;charset=utf-8")
public String handler(HttpServletRequest request, HttpServletResponse response) throws Exception {
    request.setCharacterEncoding("UTF-8");
    Map<String, String> map = MessageUtil.parseXml(request);
    String msgType = map.get("MsgType");
    if (MessageUtil.REQ_MESSAGE_TYPE_EVENT.equals(msgType)) {
        return messageDispatcher.processEvent(map);
    }else{
        return messageDispatcher.processMessage(map);
    }
}

在 Controller 中，我们首先判断消息是否是事件，如果是事件，进入到事件处理通道，如果不是事件，则进入到消息处理通道。

注意，这里需要配置一下返回消息的编码，否则可能会出现中文乱码。

如此之后，我们的服务器就可以给公众号返回消息了。

上篇文章发出后，有小伙伴问松哥这个会不会开源，我可以负责任的告诉大家，肯定会开源，这个系列截稿后，我把代码处理下就上传到 GitHub。

好了，本文我们就先说到这里。

Spring Boot 开发微信公众号后台

2019-10-29T10:32:07+00:00

Hello 各位小伙伴，松哥今天要和大家聊一个有意思的话题，就是使用 Spring Boot 开发微信公众号后台。

很多小伙伴可能注意到松哥的个人网站（http://www.javaboy.org）前一阵子上线了一个公众号内回复口令解锁网站文章的功能，还有之前就有的公众号内回复口令获取超 2TB 免费视频教程的功能（免费视频教程），这两个都是松哥基于 Spring Boot 来做的，最近松哥打算通过一个系列的文章，来向小伙伴们介绍下如何通过 Spring Boot 来开发公众号后台。

1. 缘起

今年 5 月份的时候，我想把我自己之前收集到的一些视频教程分享给公众号上的小伙伴，可是这些视频教程大太了，无法一次分享，单次分享分享链接立马就失效了，为了把这些视频分享给大家，我把视频拆分成了很多份，然后设置了不同的口令，小伙伴们在公众号后台通过回复口令就可以获取到这些视频，口令前前后后有 100 多个，我一个一个手动的在微信后台进行配置。这么搞工作量很大，前前后后大概花了三个晚上才把这些东西搞定。

于是我就在想，该写点代码了。

上个月买了服务器，也备案了，该有的都有了，于是就打算把这些资源用代码实现下，因为大学时候搞过公众号开发，倒也没什么难度，于是说干就干。

2. 实现思路

其实松哥这个回复口令获取视频链接的实现原理很简单，说白了，就是一个数据查询操作而已，回复的口令是查询关键字，回复的内容则是查询结果。这个原理很简单。

另一方面大家需要明白微信公众号后台开发消息发送的一个流程，大家看下面这张图：

这是大家在公众号后台回复关键字的情况。那么这个消息是怎么样一个传递流程呢？我们来看看下面这张图：

这张图，我给大家稍微解释下：

首先 javaboy4096 这个字符从公众号上发送到了微信服务器
接下来微信服务器会把 javaboy4096 转发到我自己的服务器上
我收到 javaboy4096 这个字符之后，就去数据库中查询，将查询的结果，按照腾讯要求的 XML 格式进行返回
微信服务器把从我的服务器收到的信息，再发回到微信上，于是小伙伴们就看到了返回结果了

大致的流程就是这个样子。

接下来我们就来看一下实现细节。

3. 公众号后台配置

开发的第一步，是微信服务器要验证我们自己的服务器是否有效。

首先我们登录微信公众平台官网后，在公众平台官网的 开发-基本设置 页面，勾选协议成为开发者，然后点击“修改配置”按钮，填写：

服务器地址（URL）
Token
EncodingAESKey

这里的 URL 配置好之后，我们需要针对这个 URL 开发两个接口，一个是 GET 请求的接口，这个接口用来做服务器有效性验证，另一个则是 POST 请求的接口，这个用来接收微信服务器发送来的消息。也就是说，微信服务器的消息都是通过 POST 请求发给我的。

Token 可由开发者可以任意填写，用作生成签名（该 Token 会和接口 URL 中包含的 Token 进行比对，从而验证安全性）。

EncodingAESKey 由开发者手动填写或随机生成，将用作消息体加解密密钥。

同时，开发者可选择消息加解密方式：明文模式、兼容模式和安全模式。明文模式就是我们自己的服务器收到微信服务器发来的消息是明文字符串，直接就可以读取并且解析，安全模式则是我们收到微信服务器发来的消息是加密的消息，需要我们手动解析后才能使用。

4. 开发

公众号后台配置完成后，接下来我们就可以写代码了。

4.1 服务器有效性校验

我们首先来创建一个普通的 Spring Boot 项目，创建时引入 spring-boot-starter-web 依赖，项目创建成功后，我们创建一个 Controller ，添加如下接口：

@GetMapping("/verify_wx_token")
public void login(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException {
    request.setCharacterEncoding("UTF-8");
    String signature = request.getParameter("signature");
    String timestamp = request.getParameter("timestamp");
    String nonce = request.getParameter("nonce");
    String echostr = request.getParameter("echostr");
    PrintWriter out = null;
    try {
        out = response.getWriter();
        if (CheckUtil.checkSignature(signature, timestamp, nonce)) {
            out.write(echostr);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        out.close();
    }
}

关于这段代码，我做如下解释：

首先通过 request.getParameter 方法获取到微信服务器发来的 signature、timestamp、nonce 以及 echostr 四个参数，这四个参数中：signature 表示微信加密签名，signature 结合了开发者填写的 token 参数和请求中的timestamp参数、nonce参数；timestamp 表示时间戳；nonce 表示随机数；echostr 则表示一个随机字符串。
开发者通过检验 signature 对请求进行校验，如果确认此次 GET 请求来自微信服务器，则原样返回 echostr 参数内容，则接入生效，成为开发者成功，否则接入失败。
具体的校验就是松哥这里的 CheckUtil.checkSignature 方法，在这个方法中，首先将token、timestamp、nonce 三个参数进行字典序排序，然后将三个参数字符串拼接成一个字符串进行 sha1 加密，最后开发者获得加密后的字符串可与 signature 对比，标识该请求来源于微信。

校验代码如下：

public class CheckUtil {
    private static final String token = "123456";
    public static boolean checkSignature(String signature, String timestamp, String nonce) {
        String[] str = new String[]{token, timestamp, nonce};
        //排序
        Arrays.sort(str);
        //拼接字符串
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < str.length; i++) {
            buffer.append(str[i]);
        }
        //进行sha1加密
        String temp = SHA1.encode(buffer.toString());
        //与微信提供的signature进行匹对
        return signature.equals(temp);
    }
}
public class SHA1 {
    private static final char[] HEX_DIGITS = {'0', '1', '2', '3', '4', '5',
            '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
    private static String getFormattedText(byte[] bytes) {
        int len = bytes.length;
        StringBuilder buf = new StringBuilder(len * 2);
        for (int j = 0; j < len; j++) {
            buf.append(HEX_DIGITS[(bytes[j] >> 4) & 0x0f]);
            buf.append(HEX_DIGITS[bytes[j] & 0x0f]);
        }
        return buf.toString();
    }
    public static String encode(String str) {
        if (str == null) {
            return null;
        }
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("SHA1");
            messageDigest.update(str.getBytes());
            return getFormattedText(messageDigest.digest());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

OK，完成之后，我们的校验接口就算是开发完成了。接下来就可以开发消息接收接口了。

4.2 消息接收接口

接下来我们来开发消息接收接口，消息接收接口和上面的服务器校验接口地址是一样的，都是我们一开始在公众号后台配置的地址。只不过消息接收接口是一个 POST 请求。

我在公众号后台配置的时候，消息加解密方式选择了明文模式，这样我在后台收到的消息直接就可以处理了。微信服务器给我发来的普通文本消息格式如下：

<xml>
  <ToUserName><![CDATA[toUser]]></ToUserName>
  <FromUserName><![CDATA[fromUser]]></FromUserName>
  <CreateTime>1348831860</CreateTime>
  <MsgType><![CDATA[text]]></MsgType>
  <Content><![CDATA[this is a test]]></Content>
  <MsgId>1234567890123456</MsgId>
</xml>

这些参数含义如下：

参数	描述
ToUserName	开发者微信号
FromUserName	发送方帐号（一个OpenID）
CreateTime	消息创建时间（整型）
MsgType	消息类型，文本为text
Content	文本消息内容
MsgId	消息id，64位整型

看到这里，大家心里大概就有数了，当我们收到微信服务器发来的消息之后，我们就进行 XML 解析，提取出来我们需要的信息，去做相关的查询操作，再将查到的结果返回给微信服务器。

这里我们先来个简单的，我们将收到的消息解析并打印出来：

@PostMapping("/verify_wx_token")
public void handler(HttpServletRequest request, HttpServletResponse response) throws Exception {
    request.setCharacterEncoding("UTF-8");
    response.setCharacterEncoding("UTF-8");
    PrintWriter out = response.getWriter();
    Map<String, String> parseXml = MessageUtil.parseXml(request);
    String msgType = parseXml.get("MsgType");
    String content = parseXml.get("Content");
    String fromusername = parseXml.get("FromUserName");
    String tousername = parseXml.get("ToUserName");
    System.out.println(msgType);
    System.out.println(content);
    System.out.println(fromusername);
    System.out.println(tousername);
}
public static Map<String, String> parseXml(HttpServletRequest request) throws Exception {
    Map<String, String> map = new HashMap<String, String>();
    InputStream inputStream = request.getInputStream();
    SAXReader reader = new SAXReader();
    Document document = reader.read(inputStream);
    Element root = document.getRootElement();
    List<Element> elementList = root.elements();
    for (Element e : elementList)
        map.put(e.getName(), e.getText());
    inputStream.close();
    inputStream = null;
    return map;
}

大家看到其实都是一些常规代码，没有什么难度。

做完这些之后，我们将项目打成 jar 包在服务器上部署启动。启动成功之后，确认微信的后台配置也没问题，我们就可以在公众号上发一条消息了，这样我们自己的服务端就会打印出来刚刚消息的信息。

好了，篇幅限制，今天就和大家先聊这么多，后面再聊不同消息类型的解析和消息的返回问题。

不知道小伙伴们看懂没？有问题欢迎留言讨论。

参考资料：微信开放文档

Spring Security 前后端分离登录，非法请求直接返回 JSON

2019-10-16T21:40:59+00:00

hello 各位小伙伴，国庆节终于过完啦，松哥也回来啦，今天开始咱们继续发干货！

关于 Spring Security，松哥之前发过多篇文章和大家聊聊这个安全框架的使用：

不过，今天要和小伙伴们聊一聊 Spring Security 中的另外一个问题，那就是在 Spring Security 中未获认证的请求默认会重定向到登录页，但是在前后端分离的登录中，这个默认行为则显得非常不合适，今天我们主要来看看如何实现未获认证的请求直接返回 JSON ，而不是重定向到登录页面。

前置知识

这里关于 Spring Security 的基本用法我就不再赘述了，如果小伙伴们不了解，可以参考上面的 6 篇文章。

大家知道，在自定义 Spring Security 配置的时候，有这样几个属性：

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
            .anyRequest().authenticated()
            .formLogin()
            .loginProcessingUrl("/doLogin")
            .loginPage("/login")
            //其他配置
            .permitAll()
            .and()
            .csrf().disable();
}

这里有两个比较重要的属性：

loginProcessingUrl：这个表示配置处理登录请求的接口地址，例如你是表单登录，那么 form 表单中 action 的值就是这里填的值。
loginPage：这个表示登录页的地址，例如当你访问一个需要登录后才能访问的资源时，系统就会自动给你通过重定向跳转到这个页面上来。

这种配置在前后端不分的登录中是没有问题的，在前后端分离的登录中，这种配置就有问题了。我举个简单的例子，例如我想访问 /hello 接口，但是这个接口需要登录之后才能访问，我现在没有登录就直接去访问这个接口了，那么系统会给我返回 302，让我去登录页面，在前后端分离中，我的后端一般是没有登录页面的，就是一个提示 JSON，例如下面这样：

@GetMapping("/login")
public RespBean login() {
    return RespBean.error("尚未登录，请登录!");
}

完整代码大家可以参考我的微人事项目。

也就是说，当我没有登录直接去访问 /hello 这个接口的时候，我会看到上面这段 JSON 字符串。在前后端分离开发中，这个看起来没问题（后端不再做页面跳转，无论发生什么都是返回 JSON）。但是问题就出在这里，系统默认的跳转是一个重定向，就是说当你访问 /hello 的时候，服务端会给浏览器返回 302，同时响应头中有一个 Location 字段，它的值为 http://localhost:8081/login ，也就是告诉浏览器你去访问 http://localhost:8081/login 地址吧。浏览器收到指令之后，就会直接去访问 http://localhost:8081/login 地址，如果此时是开发环境并且请求还是 Ajax 请求，就会发生跨域。因为前后端分离开发中，前端我们一般在 NodeJS 上启动，然后前端的所有请求通过 NodeJS 做请求转发，现在服务端直接把请求地址告诉浏览器了，浏览器就会直接去访问 http://localhost:8081/login 了，而不会做请求转发了，因此就发生了跨域问题。

解决方案

很明显，上面的问题我们不能用跨域的思路来解决，虽然这种方式看起来也能解决问题，但不是最佳方案。

如果我们的 Spring Security 在用户未获认证的时候去请求一个需要认证后才能请求的数据，此时不给用户重定向，而是直接就返回一个 JSON，告诉用户这个请求需要认证之后才能发起，就不会有上面的事情了。

这里就涉及到 Spring Security 中的一个接口 AuthenticationEntryPoint ，该接口有一个实现类：LoginUrlAuthenticationEntryPoint ，该类中有一个方法 commence，如下：

/**
 * Performs the redirect (or forward) to the login form URL.
 */
public void commence(HttpServletRequest request, HttpServletResponse response,
		AuthenticationException authException) {
	String redirectUrl = null;
	if (useForward) {
		if (forceHttps && "http".equals(request.getScheme())) {
			redirectUrl = buildHttpsRedirectUrlForRequest(request);
		}
		if (redirectUrl == null) {
			String loginForm = determineUrlToUseForThisRequest(request, response,
					authException);
			if (logger.isDebugEnabled()) {
				logger.debug("Server side forward to: " + loginForm);
			}
			RequestDispatcher dispatcher = request.getRequestDispatcher(loginForm);
			dispatcher.forward(request, response);
			return;
		}
	}
	else {
		redirectUrl = buildRedirectUrlToLoginPage(request, response, authException);
	}
	redirectStrategy.sendRedirect(request, response, redirectUrl);
}

首先我们从这个方法的注释中就可以看出，这个方法是用来决定到底是要重定向还是要 forward，通过 Debug 追踪，我们发现默认情况下 useForward 的值为 false，所以请求走进了重定向。

那么我们解决问题的思路很简单，直接重写这个方法，在方法中返回 JSON 即可，不再做重定向操作，具体配置如下：

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
            .anyRequest().authenticated()
            .formLogin()
            .loginProcessingUrl("/doLogin")
            .loginPage("/login")
            //其他配置
            .permitAll()
            .and()
            .csrf().disable().exceptionHandling()
                .authenticationEntryPoint(new AuthenticationEntryPoint() {
            @Override
            public void commence(HttpServletRequest req, HttpServletResponse resp, AuthenticationException authException) throws IOException, ServletException {
                resp.setContentType("application/json;charset=utf-8");
                PrintWriter out = resp.getWriter();
                RespBean respBean = RespBean.error("访问失败!");
                if (authException instanceof InsufficientAuthenticationException) {
                    respBean.setMsg("请求失败，请联系管理员!");
                }
                out.write(new ObjectMapper().writeValueAsString(respBean));
                out.flush();
                out.close();
            }
        });
}

在 Spring Security 的配置中加上自定义的 AuthenticationEntryPoint 处理方法，该方法中直接返回相应的 JSON 提示即可。这样，如果用户再去直接访问一个需要认证之后才可以访问的请求，就不会发生重定向操作了，服务端会直接给浏览器一个 JSON 提示，浏览器收到 JSON 之后，该干嘛干嘛。

结语

好了，一个小小的重定向问题和小伙伴们分享下，不知道大家有没有看懂呢？这也是我最近在重构微人事的时候遇到的问题。预计 11 月份，微人事的 Spring Boot 版本会升级到目前最新版，请小伙伴们留意哦。

Spring Boot 中自定义 SpringMVC 配置，到底继承谁？

2019-09-12T21:40:59+00:00

用过 Spring Boot 的小伙伴都知道，我们只需要在项目中引入 spring-boot-starter-web 依赖，SpringMVC 的一整套东西就会自动给我们配置好，但是，真实的项目环境比较复杂，系统自带的配置不一定满足我们的需求，往往我们还需要结合实际情况自定义配置。

自定义配置就有讲究了，由于 Spring Boot 的版本变迁，加上这一块本身就有几个不同写法，很多小伙伴在这里容易搞混，今天松哥就来和大家说一说这个问题。

概览

首先我们需要明确，跟自定义 SpringMVC 相关的类和注解主要有如下四个：

WebMvcConfigurerAdapter
WebMvcConfigurer
WebMvcConfigurationSupport
@EnableWebMvc

这四个中，除了第四个是注解，另外三个两个类一个接口，里边的方法看起来好像都类似，但是实际使用效果却大不相同，因此很多小伙伴容易搞混，今天松哥就来和大家聊一聊这个问题。

WebMvcConfigurerAdapter

我们先来看 WebMvcConfigurerAdapter，这个是在 Spring Boot 1.x 中我们自定义 SpringMVC 时继承的一个抽象类，这个抽象类本身是实现了 WebMvcConfigurer 接口，然后抽象类里边都是空方法，我们来看一下这个类的声明：

public abstract class WebMvcConfigurerAdapter implements WebMvcConfigurer {
    //各种 SpringMVC 配置的方法
}

再来看看这个类的注释：

/**
 * An implementation of {@link WebMvcConfigurer} with empty methods allowing
 * subclasses to override only the methods they're interested in.
 * @deprecated as of 5.0 {@link WebMvcConfigurer} has default methods (made
 * possible by a Java 8 baseline) and can be implemented directly without the
 * need for this adapter
 */

这段注释关于这个类说的很明白了。同时我们也看到，从 Spring5 开始，由于我们要使用 Java8，而 Java8 中的接口允许存在 default 方法，因此官方建议我们直接实现 WebMvcConfigurer 接口，而不是继承 WebMvcConfigurerAdapter 。

也就是说，在 Spring Boot 1.x 的时代，如果我们需要自定义 SpringMVC 配置，直接继承 WebMvcConfigurerAdapter 类即可。

WebMvcConfigurer

根据上一小节的解释，小伙伴们已经明白了，WebMvcConfigurer 是我们在 Spring Boot 2.x 中实现自定义配置的方案。

WebMvcConfigurer 是一个接口，接口中的方法和 WebMvcConfigurerAdapter 中定义的空方法其实一样，所以用法上来说，基本上没有差别，从 Spring Boot 1.x 切换到 Spring Boot 2.x ，只需要把继承类改成实现接口即可。

松哥在之前的案例中(40 篇原创干货，带你进入 Spring Boot 殿堂！)，凡是涉及到自定义 SpringMVC 配置的地方，也都是通过实现 WebMvcConfigurer 接口来完成的。

WebMvcConfigurationSupport

前面两个都好理解，还有一个 WebMvcConfigurationSupport ，这个又是干什么用的呢？

松哥之前有一篇文章中用过这个类，不知道小伙伴们有没有留意，就是下面这篇：

纯 Java 代码搭建 SSM 环境

这篇文章我放弃了 Spring 和 SpringMVC 的 xml 配置文件，转而用 Java 代替这两个 xml 配置。那么在这里我自定义 SpringMVC 配置的时候，就是通过继承 WebMvcConfigurationSupport 类来实现的。在 WebMvcConfigurationSupport 类中，提供了用 Java 配置 SpringMVC 所需要的所有方法。我们来看一下这个方法的摘要：

有一点眼熟，可能有小伙伴发现了，这里的方法其实和前面两个类中的方法基本是一样的。

在这里首先大家需要明确的是，WebMvcConfigurationSupport 类本身是没有问题的，我们自定义 SpringMVC 的配置是可以通过继承 WebMvcConfigurationSupport 来实现的。但是继承 WebMvcConfigurationSupport 这种操作我们一般只在 Java 配置的 SSM 项目中使用，Spring Boot 中基本上不会这么写，为什么呢？

小伙伴们知道，Spring Boot 中，SpringMVC 相关的自动化配置是在 WebMvcAutoConfiguration 配置类中实现的，那么我们来看看这个配置类的生效条件：

@Configuration
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
		ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {
}

我们从这个类的注解中可以看到，它的生效条件有一条，就是当不存在 WebMvcConfigurationSupport 的实例时，这个自动化配置才会生生效。因此，如果我们在 Spring Boot 中自定义 SpringMVC 配置时选择了继承 WebMvcConfigurationSupport，就会导致 Spring Boot 中 SpringMVC 的自动化配置失效。

Spring Boot 给我们提供了很多自动化配置，很多时候当我们修改这些配置的时候，并不是要全盘否定 Spring Boot 提供的自动化配置，我们可能只是针对某一个配置做出修改，其他的配置还是按照 Spring Boot 默认的自动化配置来，而继承 WebMvcConfigurationSupport 来实现对 SpringMVC 的配置会导致所有的 SpringMVC 自动化配置失效，因此，一般情况下我们不选择这种方案。

在 Java 搭建的 SSM 项目中(纯 Java 代码搭建 SSM 环境)，因为本身就没什么自动化配置，所以我们使用了继承 WebMvcConfigurationSupport。

@EnableWebMvc

最后还有一个 @EnableWebMvc 注解，这个注解很好理解，它的作用就是启用 WebMvcConfigurationSupport。我们来看看这个注解的定义：

/**
 * Adding this annotation to an {@code @Configuration} class imports the Spring MVC
 * configuration from {@link WebMvcConfigurationSupport}, e.g.:

可以看到，加了这个注解，就会自动导入 WebMvcConfigurationSupport，所以在 Spring Boot 中，我们也不建议使用 @EnableWebMvc 注解，因为它一样会导致 Spring Boot 中的 SpringMVC 自动化配置失效。

总结

不知道上面的解释小伙伴有没有看懂？我再简单总结一下：

Spring Boot 1.x 中，自定义 SpringMVC 配置可以通过继承 WebMvcConfigurerAdapter 来实现。
Spring Boot 2.x 中，自定义 SpringMVC 配置可以通过实现 WebMvcConfigurer 接口来完成。
如果在 Spring Boot 中使用继承 WebMvcConfigurationSupport 来实现自定义 SpringMVC 配置，或者在 Spring Boot 中使用了 @EnableWebMvc 注解，都会导致 Spring Boot 中默认的 SpringMVC 自动化配置失效。
在纯 Java 配置的 SSM 环境中，如果我们要自定义 SpringMVC 配置，有两种办法，第一种就是直接继承自 WebMvcConfigurationSupport 来完成 SpringMVC 配置，还有一种方案就是实现 WebMvcConfigurer 接口来完成自定义 SpringMVC 配置，如果使用第二种方式，则需要给 SpringMVC 的配置类上额外添加 @EnableWebMvc 注解，表示启用 WebMvcConfigurationSupport，这样配置才会生效。换句话说，在纯 Java 配置的 SSM 中，如果你需要自定义 SpringMVC 配置，你离不开 WebMvcConfigurationSupport ，所以在这种情况下建议通过继承 WebMvcConfigurationSupport 来实现自动化配置。

不知道小伙伴们有没有看懂呢？有问题欢迎留言讨论。

一键部署 Spring Boot 到远程 Docker 容器，就是这么秀！

2019-08-30T21:40:59+00:00

不知道各位小伙伴在生产环境都是怎么部署 Spring Boot 的，打成 jar 直接一键运行？打成 war 扔到 Tomcat 容器中运行？不过据松哥了解，容器化部署应该是目前的主流方案。

不同于传统的单体应用，微服务由于服务数量众多，在部署的时候出问题的可能性更大，这个时候，结合 Docker 来部署，就可以很好的解决这个问题，这也是目前使用较多的方案之一。

将 Spring Boot 项目打包到 Docker 容器中部署，有很多不同的方法，今天松哥主要来和大家聊一聊如何将 Spring Boot 项目一键打包到远程 Docker 容器，然后通过运行一个镜像的方式来启动一个 Spring Boot 项目。

至于其他的 Spring Boot 结合 Docker 的用法，大家不要着急，后续的文章，松哥会和大家慢慢的一一道来。

1.准备工作

1.1 准备 Docker

我这里以 CentOS7 为例来给大家演示。

首先需要在 CentOS7 上安装好 Docker，这个安装方式网上很多，我就不多说了，我自己去年写过一个 Docker 入门教程，大家可以在公众号后台回复 Docker 获取教程下载地址。

Docker 安装成功之后，我们首先需要修改 Docker 配置，开启允许远程访问 Docker 的功能，开启方式很简单，修改 /usr/lib/systemd/system/docker.service 文件，加入如下内容：

-H tcp://0.0.0.0:2375  -H unix:///var/run/docker.sock

如下图：

配置完成后，保存退出，然后重启 Docker：

systemctl daemon-reload    
service docker restart 

Docker 重启成功之后，Docker 的准备工作就算是 OK 了。

1.2 准备 IDEA

IDEA 上的准备工作，主要是安装一个 Docker 插件，点击 File->Settings->Plugins->Browse Repositories 如下：

点击右边绿色的 Install 按钮，完成安装，安装完成之后需要重启一下 IDEA。

IDEA 重启成功之后，我们依次打开 File->Settings->Build,Execution,Deployment->Docker ，然后配置一下 Docker 的远程连接地址：

配置一下 Docker 的地址，配置完成后，可以看到下面有一个 Connection successful 提示，这个表示 Docker 已经连接上了。

如此之后，我们的准备工作就算是 OK 了。

2.准备项目

接下来我们来创建一个简单的 Spring Boot 项目（只需要引入 spring-boot-starter-web 依赖即可），项目创建成功之后，我们再创建一个普通的 HelloDockerController，用来做测试，如下：

@RestController
public class HelloDockerController {
    @GetMapping("/hello")
    public String hello() {
        return "hello docker!";
    }
}

这是一个很简单的接口，无需多说。

3.配置 Dockerfile

接下来，在项目的根目录下，我创建一个 Dockerfile ，作为我镜像的构建文件，具体位置如下图：

文件内容如下：

FROM hub.c.163.com/library/java:latest
VOLUME /tmp
ADD target/docker-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

这里只有简单的四行，我说一下：

Spring Boot 项目的运行依赖 Java 环境，所以我自己的镜像基于 Java 镜像来构建。
考虑到 Docker 官方镜像下载较慢，我这里使用了网易提供的 Docker 镜像。
由于 Spring Boot 运行时需要 tmp 目录，这里数据卷配置一个 /tmp 目录出来。
将本地 target 目录中打包好的 .jar 文件复制一份新的到 /app.jar。
最后就是配置一下启动命令，由于我打包的 jar 已经成为 app.jar 了，所以启动命令也是启动 app.jar。

这是我们配置的一个简单的 Dockerfile。

4.配置 Maven 插件

接下来在 pom.xml 文件中，添加如下插件：

<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>1.2.0</version>
    <executions>
        <execution>
            <id>build-image</id>
            <phase>package</phase>
            <goals>
                <goal>build</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <dockerHost>http://192.168.66.131:2375</dockerHost>
        <imageName>javaboy/${project.artifactId}</imageName>
        <imageTags>
            <imageTag>${project.version}</imageTag>
        </imageTags>
        <forceTags>true</forceTags>
        <dockerDirectory>${project.basedir}</dockerDirectory>
        <resources>
            <resource>
                <targetPath>/</targetPath>
                <directory>${project.build.directory}</directory>
                <include>${project.build.finalName}.jar</include>
            </resource>
        </resources>
    </configuration>
</plugin>

这个插件的配置不难理解：

首先在 execution 节点中配置当执行 mvn package 的时候，顺便也执行一下 docker:build
然后在 configuration 中分别配置 Docker 的主机地址，镜像的名称，镜像的 tags，其中 dockerDirectory 表示指定 Dockerfile 的位置。
最后 resource 节点中再配置一下 jar 的位置和名称即可。

OK，做完这些我们就算大功告成了。

5.打包运行

接下来对项目进行打包，打包完成后，项目会自动构建成一个镜像，并且上传到 Docker 容器中，打包方式如下：

打包过程会稍微有一点旧，因为还包含了镜像的构建，特别是第一次打包，需要下载基础镜像，会更慢一些。

部分打包日志如下（项目构建过程）:

项目打包成功之后，我们就可以在 Docker 容器中看到我们刚刚打包成的镜像了，如下：

5.1 运行方式一

此时，我们可以直接在 Linux 上像创建普通容器一样创建这个镜像的容器，然后启动，执行如下命令即可：

docker run -d --name javaboy -p 8080:8080 javaboy/docker:0.0.1

启动成功之后，我们就可以访问容器中的接口了。

但是这种操作显然还是有点麻烦，结合我们一开始安装的 Docker 插件，这个运行步骤还可以做进一步的简化。

5.2 运行方式二

大家注意，此时我们的 IDEA 中多了一个选项，就是 docker，如下：

点击左边的绿色启动按钮，连接上 Docker 容器，连接成功之后，我们就可以看到目前 Docker 中的所有容器和镜像了，当然也包括我们刚刚创建的 Docker 镜像，如下：

此时，我们选中这个镜像，右键单击，即可基于此镜像创建出一个容器，如下图：

我们选择 Create container，然后填入容器的一些必要信息，配置一下容器名称，镜像 ID 会自动填上，暴露的端口使用 Specify 即可，然后写上端口的映射关系：

配置完成后，点击下方的 run 按钮，就可以开始运行了。运行日志如下：

注意，这个日志是在 Docker 的那个窗口里打印出来的。

项目运行成功之后，在浏览器输入远程服务器的地址，就可以访问了：

如此之后，我们的 Spring Boot 项目就算顺利发布到远程 Docker 容器中了。

好玩吗？试试！

本文案例我已经上传到 GitHub，小伙伴们可以参考：https://github.com/lenve/javaboy-code-samples

完结撒花！129 集 21 个小时，松哥自制的 Spring Boot2 系列视频教程杀青啦！

2019-08-26T21:40:59+00:00

松哥的 Spring Boot 教程分为几个阶段。

2016

松哥最早在 2016 年底的时候开始写 Spring Boot 系列的教程，记得当时在广州上班，年底那段时间在深圳出差，在深圳人生地不熟，下班回到酒店，就开始写博客，写 Spring Boot 教程。

我写的 Spring Boot 教程，不敢说是顶呱呱，但是我相信对大家来说绝对是有用的。我在 CSDN 上写了 400 多篇原创干货，其中访问量最高的几篇竟然都是 Spring Boot 相关的：

Spring Boot 火爆程度可见一斑。不过这些都是基于这是基于早期的 Spring Boot 版本写的（1.4.x）。

Spring Boot 也算是业界有名的版本帝，版本更新非常快，这也从侧面说明了 Spring Boot 发展速度之快。于是松哥的教程一直没有停。

2017

我在 2017 年推出了两个 Spring Boot + Vue 前后端分离项目。目前在 GitHub 上 star 数分别超过 8.8k 和 2.8k（公司倒闭 1 年了，而我当年的项目上了 GitHub 热榜）。

https://github.com/lenve/vhr
https://github.com/lenve/VBlog

为什么这两个项目这么火呢？我也分析过原因，单纯的 Spring Boot 并不难，单纯的 Vue 也不难，相对于 React 和 Angular ，Vue 算是最容易上手的前端框架了。但是要把前后端结合起来，这就有难度了，对前端工程师而言，数据库、Java、Redis 等等，都要花时间去学习，对后端工程师而言，前端的 ES6、webpack、前端工程化、Vue 等等也都要花时间去研究。

而我这两个开源项目，则打通了前后端，从一个 Java 工程师的角度，带领小伙伴既写后端接口，又写前端页面，快速实现一个常规的企业后台管理系统。

时代变了，单兵作战、快速迭代才有未来。从这个角度来讲，每个人都不应只专注于后端的 CRUD，我觉得这是这两个开源项目受欢迎的原因。

2018

2018 年，应清华社夏老师的邀请，出版了《Spring Boot + Vue 全栈开发实战》一书。把 Spring Boot 开发中的知识点做了一番仔细的整理，同时也在自己脑海中将 Spring Boot 教程体系化。

新书出版至今，已经加印多次，还被国内某一本大学选作教材（我的第一本书，被选作大学教材了！）。

加了很多读者的微信，也收到读者不少反馈。我发现一些很简单的知识点，大家照着书写还是有问题，虽然我也提供了很多配套案例，可是还是会收到不少小伙伴的求助，很多东西搞不定。

于是，继续出教程….

2019

时间到了 2019 年，Spring Boot 又经过了好几次版本变更，我自己也写了不少新版教程：

40 篇原创干货，带你进入 Spring Boot 殿堂！

还利用业余时间整理了一个电子书出来：

可以说，在 Spring Boot 布道的路上从未停止。

除了这些图文教程之外，松哥最近也抽时间录制了一套 Spring Boot 视频教程，这套教程分为两个阶段：

Spring Boot 精讲系列
Spring Boot + Vue 项目实战系列

目前第一阶段的视频已经录制完毕，共 129 集 21 个小时，全程高能无废话，可以说是满满的干货，大家可以看一下目录：

从 9 月份开始，我将开始录制第二阶段的内容，第二阶段我会手把手带领大家做一个 Spring Boot + Vue 的实战项目，具体的项目就是我在 GitHub 上的开源项目 vhr(https://github.com/lenve/vhr)，该项目目前已经超过 8.8k star。这个项目我会带领大家从头开始搭建 Spring Boot + Vue 前后端分离环境，权限设计，RESTful 接口设计等，预计两个月之内更新完毕。

看过我博客的小伙伴应该知道，我的博客的思路清晰，小伙伴按照我博客的思路都能够做出来效果，我的视频教程和博客的风格一致，一样也是思路清晰条理清楚，这不是我的自夸，有小伙伴的评价为证：

除了这两个视频之外，后期也会录制其他视频教程，目前确定的有 Cloud 和 Redis，其他的还在规划中，不过可以确定的是，每个月都会发布我自己录制的视频教程。

这些视频的录制，我花费了巨大的时间成本，很多时候我都是晚上十二点才到家，然后早上六点起来录视频,录到八点半，然后去上班：

晚上回到家，除了写博客，还要对录好的视频剪辑，去噪，这是一个细活：

巨大的时间付出，保证了视频的质量，当然也决定了这是一套付费视频。

我自己还在网上搜集了很多别人录制的视频，这些视频对我来说没有多大成本，都是网络上找的，因此我都免费送给大家了，在我公众号底部菜单里有免费视频，这些免费视频大家都可以领取，我不会拿这些随处可见的视频来卖钱。

如果大家想要试看视频，可以参考如下两篇文章：

欢迎大家加入星球，一起学习进步！现在直接扫码加入星球需要 199，这里我提供另外一个优惠的方式，大家可以加我微信，发红包只要 119，然后我手动拉你进星球。星球上每有一个课程完结的时候，就会提升一次价格，早点加入就是优势。同时为了保证加入星球的小伙伴的权益，我可以向大家保证，你在其他地方不会看到一模一样的免费的整套视频教程，因为这些视频都是我自己录制的，全部都是加密之后发布的，所以请大家放心。

感谢大家信任。

40 篇原创干货，带你进入 Spring Boot 殿堂！

2019-08-20T21:40:59+00:00

两个月前，松哥总结过一次已经完成的 Spring Boot 教程，当时感受到了小伙伴们巨大的热情。

两个月过去了，松哥的 Spring Boot 教程又更新了不少，为了方便小伙伴们查找，这里再给大家做一个索引参考。

需要再次说明的是，这一系列教程不是终点，而是一个起点，松哥后期还会不断完善这个教程，也会持续更新 Spring Boot 最新版本的教程，希望能帮到大家。教程索引如下：