ramostear.comramostear.com 谭朝红的技术分享博客

格言 编程是一门技术,也是一门艺术 !

正确甄别API & REST API & RESTful API & Web Service之间的差异与联系

正确甄别API & REST API & RESTful API & Web Service之间的差异与联系

​ 看到API你会想起什么?是接口、第三方调用、还是API文档?初看你可能会觉得这太熟悉了,这不是系统开发日常系列吗?但你仔细想一想,你会发现API的概念在你脑海里是如此的模糊。如何你通过搜索引擎检索API,你会看到类似这样的信息:API——Application Programming Interface(应用程序编程接口),这太抽象了。接下来,我将结合在开发中总结的一些经验,以通俗的方式聊聊API、REST API、RESTful API以及Web Service这四者之间的联系与区别。

1、API 与 REST API

​ 什么是API?这里引述维基百科给出的定义:应用程序接口(英语:Application Programming Interface,缩写:API;又称为应用编程接口)是软件系统不同组成部分衔接的约定。这个对API的定义太过于广泛和抽象,而通俗的讲,API是一段应用程序与另一段应用程序相互“交流”的方式(协议)。在Web应用程开发中,API是我们通过网络进行数据检索的一种主要方式,API文档将告知你检索数据的URL列表、查询参数、请求方式以及响应状态,其目的是降低Web应用程序开发难度,共享两个应用程序之间的数据(文本、音频、视频、图片等),而屏蔽其内部复杂的实现细节。

​ REST是Representational State Transfer的缩写,直译过来就是:表述状态的转移。REST API是一组关于如何构建Web应用程序API的架构规则、标准或指导,或者说REST API是遵循API原则的一种架构风格。REST是专门针对Web应用程序而设计的,其目的在于降低开发的复杂度,提高系统的可伸缩性。下面是设计REST风格的系统架构时需要满足或者遵循的一些基本条件和原则:

  • 1、在REST架构中,Web中所有的事物(文本、音频、视频、图片、链接)都可以被统一的抽象为资源(resource)
  • 2、在REST架构中,每一个资源都有与之对应的唯一资源标识符(resource identifier),当资源的状态发生改变时,资源标识符不会发生改变
  • 3、在REST架构中,所有的操作都是无状态的。REST架构遵循CRUD原则,所有的资源都可以通过GET、POST、PUT和DELETE这四种行为完成对应的操作。
  • 4、可缓存(可选项),在REST架构中需要缓存来有效的处理大批量的请求
  • 5、接口一致

​ 现在,了解了API和REST API的基本概念,那这两者之间有什么异同?如果按照数学上集合的概念来解释API与REST API之间的联系与区别,API是REST API的超集,REST API 是API的子集;所有的REST API都是API,但不是所有的API都是REST API。更通俗的解释是:所有的男人都是人,但不是所有的人都是男人。

2、REST API 与RESTful API

​ 在第一小节中,了解了什么是REST API,接下来聊聊REST API与RESTful API之间的异同。很多初学者很容易将这两者等同起来,认为RESTful API就是REST API,这可能是单纯的从字面上去理解了,当你深入的去了解两者的本质后,你会发现其实不然。REST API是Web API设计的一种规范或者指导原则,而RESTful API则是这中架构设计原则或者规范的一种具体实现方式。也就是说,RESTful API是REST API的非正式实现方式,因为实现REST API的方式有很多,RESTful API只是其中一种,且没有完全满足REST API的所有设计原则,每个开发者在实现REST 架构时的则重点都会有差别。

​ 很多初学者容易将REST API与RESTful API两者的概念搞混淆,我想可能只是看字面意思,而没有关注它们本身的含义(就像认识中文字一样,有边读边,无边读中间,断章取义了)。这就好比很多人会把变性人等同于女人,变性人可能五官的表象看起来和女人一样,但变性人不能生育,它只是满足了定义一个女性的大多数条件(实现),但本质上不是女人。

​ 接下来,通过一个简单的例子以加深对REST API和RESTful API的理解。下面将给出一个执行CURD操作的RESTful API设计案例:

说明:resource代指某种资源的名称,可以时student(学生)、teacher(老师)、book(书籍)等等,通常使用名词来表示;{id}则代指某种资源的唯一标识符(resource identifier)

下面是一个具体的小例子,以学生管理为例,设计学生管理的API。学生资源包括ID,姓名和所学课程信息,学生资源信息如下:

​ 现在,我们需要将学生数据保存到数据库,然后执行查询、修改和删除学生数据的操作。学生管理API的使用者调用的API如下:

​ 前面的内容说到,API共享数据资源,而屏蔽内部实现,API的使用者(客户端)关注的是资源(读懂数据),并不需要了解API内部构造;API的提供者(服务端)只关注自己的内部实现,而不关系API使用者(客户端)的状态。为了加深对这一概念的理解,下面给出学生管理API的内部实现示例:

说明:

示例代码是基于Spring MVC进行实现的。

除了上述的内容之外,你还可以通过提供键值对的方式对查询数据进行过滤,如获取所有的学生数据时,只想获取性别为女性的学生数据,则可以通过这样的方式来完成:

[GET] http://www.example.com/students?gender=female

Tip:如果API拥有对数据过滤的功能,对应服务端的API实现代码也需要做调整。

​ 在前面的内容中,我们提到RESTful API是REST API的非正式实现方式或规范。为什么这么说呢?因为在RESTful API的设计中,我们完全可以通过GET的方式完成CURD操作,也可以通过DELETE行为来创建资源,通过POST行为来修改资源,它的实现方式并不严谨或者说并没有严格按照REST API提出的约束条件来进行。所以说RESTful API是REST API的非正式实现方式

3、REST与Web Service

3-1、什么是Web Service?

​ 如万维网联盟(W3C)所述,Web Service提供了在各种平台和/或框架上运行的不同软件应用程序之间可以进行互操作的标准方法。Web Service的特点是具有良好的互操作性和可扩展性,以及由于使用XML而可以对程序处理过程进行描述。它们可以以松散耦合的方式组合不同的服务以实现复杂的操作。提供简单服务的程序可以通过相互交互,以提供复杂的增值服务。

​ 两个Web Service之间主要通过HTTP网络协议进行通信,如我们熟知的SOA(面向服务的体系架构),主要依赖于XML-RPC和SOAP(Simple Object Access Protocol,即简单对象访问协议)。

Tip:千万不要将SOA(面向服务体系架构)和SOAP(简单对象访问协议)搞混,前者是一种架构设计形式,后者是一种数据交换协议。

​ 简单的一个示例:假设一个Web Service A提供允许其他应用程序通过URL获取用户信息的功能:[GET] http://www.abc.com/{id}。id是用户的唯一标识符,请求此URL将获得用户信息。现在假设浏览器、手机、桌面应用程序的用户都要获取服务A提供的用户信息,这三者只需要请求服务A提供的URL地址,并输入用户id信息即可。至于者三个不同客户端的实现方式(编程语言)是什么与服务A 没有任何关系,只要能够解析出服务A返回的XML文档即可。这样,应用程序之间交换数据就可以不用依赖于具体的语言和环境。这就好比不同国家不同语言的人,只要能够知晓对方语言的语法结构,两个人就可以进行交流。

3-2、Web Service的优点

​ 使用Web Service有如下的几个优点:

  • 1、互操作性:Web Service允许应用程序之间进行通信,交换数据和共享服务。
  • 2、可用性:Web Service的功能可以从简单的信息查找到复杂的算法计算。
  • 3、可重用性:Web Service之间可以相互组合,以提供更为复杂的服务,由于其互操作性的特点,可以轻松的在其他的服务中重用Web Service组件,提高了服务的重用率。
  • 4、易于部署:Web Service可以部署在基于Internet标准的容器中,如Apache、Axis2等,以提供HTTP或者WSDL(网络服务定义语言)驱动的服务。
  • 5、成本低:Web Service是通过打包成Web服务组件进行部署,从而降低了使用的成本。

3-3、Web Service的类型

​ 目前,Web Service主要有两大流派:

  • 1、基于SOAP的Web Service : SOAP(简单对象访问协议)是一种基于XML的协议,用以访问Web Service。其接口以机器可处理的格式进行描述,称为WSDL(Web服务定义语言)文档。通过使用标准的的XML文档来描述Web Service,在XML文件中,会详细记录接口的信息,如消息的格式、传输协议以及交互的位置等信息。
  • 2、基于REST的Web Service :REST(Representational State Transfer)是一种软件架构,它使用JSON来描述数据格式,最重要的是HTTP传输协议对REST来说是非必须的。

3-4、REST与SOAP的区别和联系

​ 下面,通过一张表格来对比REST与SOAP之间的异同:

总结

如上所述,我们了解了什么是API,什么是REST API,什么是RESTful API以及Web Service的相关概念。API代表应用程序编程接口,是一种较为宽泛的定义或者说是一种协议,作为软件程序之间相互通信的接口而存在。REST API是API的一个子集,所有的REST API都是API;RESTful API是对REST API架构风格的一种非正式实现方式。API与Web Service都是服务提供者和服务消费者之间的通信手段。最后,为了能够快速的识别API与Web Service之间的差异,将这两种手段的不同之处整理成对照表如下:

鱼与熊掌得兼:Hibernate与Mybatis共存

鱼与熊掌得兼:Hibernate与Mybatis共存

鱼与熊掌得兼:Hibernate与Mybatis共存

很长一段时间,网上有很多关于Hibernate与Mybatis孰优孰劣的争论,两个阵营的人谁也不能说服谁,每个人的理由都很有道理。今天,我分享的主题是:在一个项目中同时使用Hibernate和Mybatis两个ORM框架。

​ 作为一个开发者,没有必要花费过多的时间去证明技术无用论,当你开始指责某个框架垃圾,另外一个框架最好时,隐性的暴露出你对某个框架没有深入的研究,无知的指责对于技术的提升没有任何的帮助。框架本身没有对错一说,只有适合和更适合项目的选择。任何框架都有自身的能力范围,就拿Hibernate和Mybatis这两个ORM框架来说,Hibernate封装了很多有用的API给开发者,降低了操作数据库的难度和复杂度,同时也减少了模板代码的数量,但Hibernate留给开发者可操作的空间相对Mybatis少了很多;Mybatis框架使用起来很灵活,开发者可以自定义查询语句,但增加了模板代码的数量,看起来没有Hibernate那么便捷。两种框架在便捷与灵活两个指标上做出了取舍与妥协,这不能说是框架的错。对于一个框架而言,需要有自身专注的领域和设计愿景,不可能面面俱到。

​ 使用任何一种技术框架,都需要贴合现实的业务需求以及自身的技术能力。当你还没有深入的去了解一门技术或者当前业务需求无法与框架契合时,不要盲目的批判框架的好坏。今天,我不再去对比Hibernate与Mybatis两者之间的优劣,而是给出一个比较中庸的放方案,将两个ORM框架同时整合在一个项目中。

一、准备开发环境

​ 如果你想成功运行本文中的源代码,需要满足一下的几个条件:

  • 1、JDK : JDK 1.8.x及以上版本
  • 2、Maven : Maven 3.x或更高版本
  • 3、Git:版本控制工具,选择一个你喜欢的
  • 4、IDE : 选择你比较喜欢的一个代码编辑器,如STS、IntelliJ IDEA。笔者使用的是IntelliJ IDEA
  • 5、Databases : 选择一个你熟练使用的数据库系统。笔者在本文中使用的是MySQL 5.1.x版本的数据库系统

如需获取本次分享内容的源代码进调试,可以到文章末尾找到源代码仓库连接

二、搭建项目

2-1、引入依赖

​ 为了快速构建项目,笔者采用Spring Boot来构建项目,同时使用加入Spring Data JPA和Mybatis两个ORM框架的依赖包。在此需要特别说明,Hibernate是一个JPA标准的实现,尔Spring Data JPA是一个JPA数据访问抽象,通过Spring Data JPA,可以轻松使用Hibernate框架。

​ 你可以通过Spring Initializer来初始化项目,也可以通过IDEA自带的Spring Initializer功能构建项目,项目构建完成之后,pom.xml文件中的配置如下(包含但不限于文中给出的依赖项):

2-2、定义实体类-User.java

​ 为了演示同时使用Hibernate和Mybatis操作数据库,需要提供一个实体类User.java,代码如下所示:

说明:

在本次演示的项目中,使用到了Lombok插件,它可以让开发者减少模板代码的书写,提高开发速度。@Data注解可以自动生成类属性的getter、setter和toString方法。@NoArgsConstructor会自动为类生成无参构造函数,@AllArgsConstructor则会生成带全部属性的构造函数。

2-3、定义数据持久化接口

​ 在本次课程中,将使用Spring Data JPA来完成写操作,如新增、修改、删除;使用Mybatis来完成读操作,如根据用户ID查询、查询所有的用户等。Spring Data JPA和MyBatis的持久化接口都位于com.ramostear.hm.orm包下,Spring Data JPA的持久化接口相对比较简单,之间继承JpaRepository类即可,代码如下:

说明:因为JPA只负责写操作,所以直接继承并使用JpaRepository提供的API即可,不需要额外的定义其他的接口方法。

​ 下面是Mybatis的映射接口,定义了两个方法:根据ID查询用户信息和查询所有的用户信息。代码如下所示:

说明:

此接口需要注意的地方是@Component@Mapper注解,@Component注解标注此接口后,Spring会自动扫描并配置此类;@Mapper注解是把这个mapper的DAO交由Spring进行管理。

定义完Mybatis 映射接口后,需要提供一个进行数据库查询的xml配置文件。该文件位于resources/mapper文件夹中,UserMapper.xml完整代码如下:

2-4、定义UserService

​ 在UserService接口中,提供三个方法:保存用户信息、根据ID查询用户、查询所有的用户。UserService接口代码如下:

在UserService接口的实现类中,需要同时注入UserRepository和UserMapper两个依赖。我们使用构造函数的方式来注入这两个依赖。代码如下:

说明:

@Transactional注解用于设置每个方法的事务控制方式。@Service注解声明该类是一个服务提供类,且设置了该类被Spring初始化时Bean对象的名称为“userService”。

2-5、定义控制器

​ 最后,提供一个控制器,用于处理客户端的相关请求。在控制器中,提供了三个请求处理方法,分别处理客户端新增用户、根据ID查询用户和查询所有用户的请求。控制器代码如下:

说明:

在本次教程中,为了编码IDEA报警告,所有的依赖注入都采用构造函数的方式注入相关的依赖。

三、配置Hibernate和Mybatis

​ 网络上有很多关于在Spring Boot项目中配置Hibernate和Mybatis的教程,但同时配置Hibernate和Mybatis的文章很少,有一些是通过Java代码的方式对这两个ORM框架进行配置,采用的是多数据源的方法来整合两个框架。其实整合这两个框架没有想象中的那么难,只需要在application.yml或者application.properties配置文件中加入几行代码,就可以完成两个框架的整合。以application.yml配置文件为例,配置代码如下:

是不是很简单,并为没有太多复杂的配置,这是一种较为简单的整合方式。Hibernate和Mybatis共用一个数据源,如果是JPA的忠实粉丝,现在想要使用Mybatis,只需要额外加入mybatis的配置即可。

四、测试

​ 通过以上的几个步骤,整个项目已经搭建完毕,接下来将使用Postman测试工具对Controller的三个方法进行测试,验证两个ORM框架在同一个项目中是否能共存。

​ 首先测试 POST http://localhost/users ,验证Hibernate是否能够成功将用户信息持久化。打开Postman工具,在地址栏输入http://localhost/users请求地址,请求方式选择POST,在Body栏输入如下的信息:

{
    "username":"谭朝红",
    "alias":"ramostear",
    "age":28
}

点击“Send”按钮发送请求,观察服务端响应信息,测试结果如下图所示:

可以看到,服务端成功返回用户信息,且用户ID=3。接下来,我们请求 GET http://localhost/users/3 ,验证Mybatis是否能够成功查询出用户信息,测试结果如下:

通过测试,服务端成功返回了用户ID=3的用户信息:

{
  "id": 3,
  "username": "谭朝红",
  "alias": "ramostear",
  "age": 28
}

由此证明,在同一个项目中,Hibernate和Mybatis均能正常工作,整合方案有效,解决了在同一项目中Hibernate与Mybatis共存的问题。

五、总结

​ 本次课程验证了同时使用Hibernate和Mybatis两个ORM框架的方案可行,且采用了一种比较简单的方式来整合两个框架,摒弃了多数据源的复杂配置,快速实现两个框架并用的需求。

​ 在一个项目中同时使用两个ORM框架有没有实际的意义呢?我的答案是肯定的。同时使用两个ORM框架,两者之间可以相互弥补自身的不足,以达到灵活性和便捷性同时兼顾,另外一方面,在单独使用Mybatis时,开发者需要手动或者借助其他的工具生成数据库表信息,而采用本文的整合方案,Mybatis可以借助JPA自动生成数据库表的能力,从而简化使用Mybatis的步骤。最后,对于一些读多于写的系统,完全可以将这两个框架同时使用,写操作少的模块,可以使用Spring Data JPA快速完成相关功能的实现,对于读操作部分,则可以利用Mybatis来优化查询语句。两者之间的优势互补,能进一步的提升开发效率和系统性能。

本次分享内容的源代码仓库地址:

https://github.com/ramostear/orm-hm.git

5个Spring Event奇技淫巧,你GET到了吗?

5个Spring Event奇技淫巧,你GET到了吗?

5个Spring Event奇技淫巧,你GET到了吗?

前言:

谈到事件,接触过前端或GUI编程(JavaScript,Swing)的同学应该有较深刻印象。如事件源、事件的监听、回调等概念应该耳熟能详。而在Web应用程序中则很少用到事件。但在Web应用程序中,也可以轻松实现面向事件的编程。

1、为什么需要面向事件编程

​ 在本文中,将基于Spring框架来谈谈关于面向事件编程的5个奇技淫巧。在开始主要内容之前,先了解一下为什么需要面向事件编程。首先看一个生活中的一个场景来帮助我们快速的了解面向事件编程所带来的好处。以客户到银行柜台取现为例,在较早以前,银行柜台取现需要一个接一个的排长龙等待柜台业务员处理取现业务,在此期间,客户不能离开队伍去做其他的事情,否则需要重新排队。这好比常规的面向过程的编程,需要依次执行每条逻辑语句,直到所有的语句都执行完毕,方法才返回结果。现在,银行柜台取现多了一台叫号机,需要办理取现业务的客户先通过叫号机领取一张业务号,如果等待人数过多的时候,客户可以先处理自身的事情,直到柜台叫到自己的号时,才到柜台办理取现业务。这就是一个典型(不太严谨)面向事件的处理过程。首先,客户通过叫号机注册一个取现的事件,此时的叫号机,相当于事件发布器(事件注册中心),客户相当于事件源,当柜台收到有客户需要取现的消息时,就会广播提示客户办理取现业务,柜台就相当于一个事件监听器。

​ 如上所述,面向事件的编程(也称作事件驱动编程)是基于对消息信号的反应的编程。面向事件编程需要满三个条件:

  • 1、事件源:消息的源头,如点击一个按钮、访问某个页面、新增一条数据等。
  • 2、事件注册中心:事件注册中心用于存储和发布事件。
  • 3、事件监听器:用于接收特定的消息,并作出对应的反应。

下面通过一张图更为直观的了解面向事件编程的基本原理:

图 1-1 事件处理机制

2、Spring Events

​ Spring Events 是Spring Framework的一部分,但在应用程序中并不经常使用,甚至被忽略。然而,Spring的Application拥有强大的事件发布并注册事件监听器的能力,它拥有一套完整的事件发布与处理机制。Spring 4.1开始引入@EventListener注解来监听具体类型的事件,它的出现,消除了使用Spring定义一个事件监听器的复杂操作。仅仅通过一个简单的注解,就可以完成一个监听器的定义,你不需要额外的进行其他的配置;这简直太棒了。在Spring Framework中,事件的发布是由ApplicationContext提供的,如果想完成一个完整的面向事件(也称为事件驱动编程)编程,你需要遵循以下三个基本的原则:

  • 1、定义一个事件,且扩展ApplicationEvent
  • 2、事件发布者应该注入一个ApplicationEventPublisher对象
  • 3、监听器实现ApplicationListener接口或者使用@EventListener注解

在开始介绍面向事件编程的具体实施细节之前,先通过一张类图了解一下Spring的事件机制设计类图:

图 2-1 Spring Event 类图

​ 通过类图,先快速对Spring Event事件类图做一个简单的介绍:

  • 1、ApplicationEventPublisher是Spring的事件发布接口,所有的事件都是通过该接口提供的publishEvent方法发布事件的。
  • 2、ApplicationEventMulticaster是Spring事件广播器,它将提供一个SimpleApplicationEventMulticaster实现类,如果没有提供任何可用的自定义广播器,Spring将采用默认的广播规则。
  • 3、ApplicationListener是Spring事件监听接口,所有的事件监听器都需要实现此接口,并通过onApplicationEvent方法处理具体的逻辑。
  • 4、在Spring Framework中,ApplicationContext本身就具备监听器的能力,我们也可以通过ApplicationContext发布先关的事件。

​ 通过分析,可以看到:当一个事件通过ApplicationEventPublisher发布出去之后,ApplicationEventMulticaster广播器就会开始工作,它将去ApplicationContext中寻找对应的事件监听器(ApplicationListener),并执行对应监听器中的onApplicationEvent方法,从而完成事件监听的全部逻辑。

3、自定义Spring Event

​ 本次内容将使用Spring Boot 2.1.5快速搭建所需要的环境。首先将演示如何自定义一个事件,并监听该事件且对监听到的事件做出反应。

​ 我们将使用IntelliJ IDEA创建一个Web项目,并在pom.xml文件中添加如下的依赖:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ramostear</groupId>
    <artifactId>spring-boot-event</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-boot-event</name>
    <description>Demo project for Spring events</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

说明:

这将是一个完整的演示Spring Event事件处理机制的项目,因为期间需要演示事务管理的特性,所以加入了MySql数据库依赖。

​ 本次的内容将依据这样一个场景展开:当成功添加一条用户信息后,将发送一条邮件到用户的邮箱账户。首先,需要定义两个实体,用户实体和邮件详情实体。具体代码如下:

接下来是邮件详情实体类:

持久化类通过扩展JPA的JpaRepository类快速获得CRUD能力。用户持久化类和邮件详情持久化类分别如下:

UserRepository.java

package com.ramostear.repository;

import com.ramostear.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * Created by Ramostear on 2019/5/31 0031.
 */
public interface UserRepository extends JpaRepository<User,Long> {
}

EmailDetailRepository.java

package com.ramostear.repository;

import com.ramostear.domain.EmailDetail;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * Created by Ramostear on 2019/5/31 0031.
 */
public interface EmailDetailRepository extends JpaRepository<EmailDetail,Long> {
}

接下来,将定义一个用户业务接口,提供创建和查找用户两个方法,代码如下:

package com.ramostear.service;

import com.ramostear.domain.User;

/**
 * Created by Ramostear on 2019/5/31 0031.
 */
public interface UserService {

    User created(User user);


    User findOne(Long id);
}

基本的环境已经准备就绪,现在开始定义定义第一个事件类:SendEmailEvent.java,其代码如下所示

如之前所述,自定义事件需要扩展ApplicationEvent类,并提供自己的实现细节。这里的事件需要为其提供一个用户ID,在接下来的监听器中,通过此ID来甄别具体的用户,并发送邮件。

接下来,我们将使用@EventListener注解实现一个事件监听器,其源码如下:

说明:

在此类中,我们注入了EmailDetailRepository和UserRepository两个依赖项,并使用@EventListener注解对sendEmail方法进行了标注。在方法中,使用了Thread.sleep(1000*3)让程序休眠3秒,以模拟发送邮件时所耗费的时间。@Slf4j注解是Lombok提供的快速使用Logger的一个快捷方式。@Component注解用于标注此类是一个普通的组件,将被Spring自动扫描并管理。

​ 准备好了事件源以及事件监听器,现在来看看如何发布一个事件。发布事件将在用户业务实现类中进行操作。UserServiceImpl.java类的实现细节如下:

​ 如前面章节所讲,如果使用Spring发布一个事件,需要在具体的类中注入一个ApplicationEventPublisher对象。在用户业务实现类中,通过构造函数的方式注入ApplicationEventPublisher对象和UserRepository持久化对象。在created(User user)方法中,当成功保存用户数据后,通过发布一个SendEmailEvent事件,将邮件发送给用户的邮箱。与此同时,我们记录了程序执行完所耗费的事件,在下一小节中我们将使用到这个数据。

​ 最后,我们定义一个控制器,提供一个处理添加用户请求的方法,验证发送邮件事件是否被监听器成功监听。控制器代码如下:

启动项目,并使用PostMan工具对POST /users API进行测试:

图 3-1 Postman测试结果

经测试,成功返回了用户信息,且耗时3530ms。我们在看看控制台的日志信息:

图 3-2 日志记录信息

​ 至此,第一个基于Spring Event的面向事件的编程案例完成。在这个案例中,虽然我们解决了事件的发送和监听的编码实现问题,但可能会有同学会想,这样子的处理方式和将发布事件的代码替换成直接调用邮件持久化类保存邮件信息没有任何区别,如同一开始说的案例,虽然有叫号机叫号,解决排队的问题,但等待的时间依旧没有改变,这和直接排队在时间耗费上没有根本的变化。那么针对这样一个问题,我们在接下来的内容中将讲解如何实现异步事件。异步事件就好比你现在从普通储蓄客户变成了VIP会员,你可以不去银行柜台叫号,而是通过电话或者其他手段预约一个时间去办理业务,银行客户经理会给你预留相应的时间,当预约时间到达之后,你才去银行柜台办理业务。

4、Spring 异步事件

​ 在该小节的基础上,将原有的事件改造成异步事件,以节省客户端等待服务端响应的时间。使用Spring实现异步事件有两种方式,第一种方式是使用@Async注解对监听器进行标注,这是最为简单的一种实现方式;第二种是通过配置类对Spring的事件广播器进行配置,设置Multicaster对异步操作的支持,此方法比第一种方法稍微复杂一些,但可以拥有对事件广播器更多的控制权。接下来,将分别介绍这两种实现方式。

4-1、使用@Async注解实现异步事件

​ 在现有的工程中,我们需要对两个类进行改造。第一处改造是在项目主类上加入@EnableAsync注解,开启对异步操作的支持。代码如下:

package com.ramostear;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

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

第二步是改造监听器,在原来的方法上加入@Async注解,其余部分保持不变,代码如下:

    @Async
    @EventListener
    public void sendEmail(SendEmailEvent event){
       ...
    }

通过上述两个步骤,我们就将Spring默认的同步事件改造为异步事件。重新启动项目,依旧使用Postman对接口POST /users进行测试,结果如下:

图 4-1 @Async异步事件

通过上图我们可以看到,服务端成功返回用户信息,注意观察,从客户端发起请求到服务端响应结束总共耗时480ms,而在第一个案例中,请求和响应的总耗时为3530ms。最后我们再来看看控制台的日志信息,确定一下数据库是否成功保存用户邮件:

图 4-2 @Async异步事件控制台日志信息

通过上述的测试结果,我们可以看到,异步事件已经生效,在相同的环境下,同样的业务请求,使用同步事件和异步事件,服务端响应时间存在巨大的差异。同步事件耗时3530ms,异步事件耗时480ms,这就是异步事件带来的巨大优势。

4-2 、使用配置文件开启对异步事件的支持

​ 在4-1中,我们学会了如何使用@Async定义异步事件,那本小节将展示另外一种方式获取对异步事件的支持。首先需要定义一个配置类,该类用于配置SimpleApplicationEventMulticaster类对于异步事件的支持。其源码如下:

package com.ramostear.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ApplicationEventMulticaster;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.core.task.SimpleAsyncTaskExecutor;

/**
 * Created by Ramostear on 2019/5/31 0031.
 */
@Configuration
public class AsyncSpringEventConfig {

    @Bean(name = "applicationEventMulticaster")
    public ApplicationEventMulticaster applicationEventMulticaster(){
        SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();
        multicaster.setTaskExecutor(new SimpleAsyncTaskExecutor());
        return multicaster;
    }
}

​ 在此配置文件中,applicationEventMulticaster方法将返回一个SimpleApplicationEventMulticaster对象。在返回此事件发布器之前,我们为此事件发布器设置了一个任务执行器:SimpleAsyncTaskExecutor,当应用程序中有新的异步事件时,将会调用此异步任务执行器的submitListenable(Callable task)方法,发布异步事件任务,并选择相应的监听器处理事件。定义好配置类后,还需要将主类中的@EnableAsync和监听器中的@Async两个注解注释掉,其余部分保持不变。最后重启项目,并测试API接口。

图 4-3 异步事件发布器配置测试

如图4-3所示,测试成功返回用户信息,其请求和响应总耗时为492ms。通过配置的方式开启Spring对异步事件的支持已生效。

5、事件过滤

​ 如果我们想对用户事件进行限制,某一部分满足条件的用户才发送邮件,可以使用condition属性来指定限制的条件。这就好比银行柜台提供的VIP预约取现业务,它分不同等级的VIP,只有达到某个条件时,才享有预约服务。在原来的基础上,我们做如下的改动,当用户ID大于5时,才发送邮件给用户。代码如下:

    @EventListener(condition = "#event.userId > 5")
    public void sendEmail(SendEmailEvent event){
       ...
    }

现在,数据库中用户ID最大为3,我们先添加两个用数据,看邮件详情表是否会新增数据。启动项目,测试API接口:

图 5-1 条件过滤测试一

服务端成功返回结果,用户ID=4,现在看看数据库是否有用户邮件数据被添加:

图 5-2 数据库查询结果一

从查询结果可以看到,并未给ID=4的用户发送邮件。控制台也只输出了插入用户数据的SQL语句:

Hibernate: 
    insert 
    into
        t_user
        (email, first_name, last_name) 
    values
        (?, ?, ?)
2019-06-03 06:14:19.334  INFO 4652 --- [p-nio-80-exec-2] c.r.service.impl.UserServiceImpl         : total times :58

接下来我们再新增两条用户数据,观察当用户ID=6时,是否会为用户发送邮件。图5-3是当用户ID=6时,数据库的查询结果以及控制台的输出:

图 5-3 数据库查询结果二

此时,控制台的输出信息如下所示:

图 5-4 控制台日志信息

由此可以看出,我们的事件过滤条件已生效。

6、事务处理

​ 现在,Spring Event的相关使用技巧以及介绍了大部分,最后让我们来考虑这样一个问题,如果在保存用户的时候发生错误,事件将会怎么样?在监听器处理事件时,保存用户的事务还未提交会怎么样?按照常规的逻辑,当用户持久化事务未提交,或者保存过程中发生异常时,不应该给用户发送邮件。试想一下,如果本次案例的场景是发生在用户注册的业务中,如果用户尚未注册成功,就给用户发送一封邮件,那是多么尴尬的事情。这就涉及到事件的事务控制。在Spring中,可以使用@TransactionalEventListener注解对监听器进行标注,一旦使用此注解,被标注的方法将被纳入到事务管理的范围。此注解是@EventListener的扩展,它允许你将事件的监听绑定到某个事务阶段。可以通过phase属性对事务阶段进行设置。下面是phase可设置的所有事务阶段:

  • 1、AFTER_COMMIT(默认值),用于在事务成功完成后出发事件
  • 2、AFTER_ROLLBACK,用于事务回滚是出发事件
  • 3、AFTER_COMPLETION,用于事务完成后出发事件(AFTER_COMMIT和AFTER_ROLLBACK的一种模糊表述)
  • 4、BEFORE_COMMIT,用于事务提交前出发事件

最后给出一个简单的示例:

    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT,condition = "#event.userId >=5")
    public void sendEmail(SendEmailEvent event){
        Optional<User> optional = userRepository.findById(event.getUserId());
        if(optional.isPresent()){
            User user = optional.get();
            log.info("User Detail:{ id:{},firstName:{},email:{}",user.getId(),user.getFirstName(),user.getEmail());
            try {
                Thread.sleep(1000*3);
            } catch (InterruptedException e) {
                log.error(e.getLocalizedMessage());
            }
            emailDetailRepository.save(EmailDetail.builder().
                    userId(user.getId()).
                    email(user.getEmail()).
                    sendTime(new Date()).
                    build());
            log.info("User email already send.");
        }
    }

其余代码保持不变。

总结

以上就是关于Spring Event的5个实用技巧,如果你想了解更多细节内容,我已将全部源码上传至Github仓库,你可以通过此链接获取全部源码。如有问题,请在文章最后给我留言。

WebMvcConfigurerAdapter被弃用后的两个选择

WebMvcConfigurerAdapter被弃用后的两个选择

WebMvcConfigurerAdapter类型被弃用后的选择

1. 介绍

在本文中,将介绍将spring 4.xx(或者更低)版本升级到Spring 5.xx以及将Spring Boot 1.xx版本升级到Spring Boot 2.xx版本后会报的一个严重警告:“Warning:The type WebMvcConfigurerAdapter is deprecated.” ,以及快速的分析产生这个严重警告的原因和处理办法。

2. 出现警告的原因

如果我们使用Spring 5.xx(或者Spring Boot 2.xx)版本来构建或者升级应用程序,在配置WebMvc时,则会出现此警告,这是因为在早期的Spring版本中,如果要配置Web应用程序,可以通过扩展WebMvcConfigurerAdapter类快熟实现配置,大致代码如下:

package com.ramostear.page;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.PathMatchConfigurer;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

/**
 * Spring 4(或者Spring Boot 1.x)版本配置Web应用程序示例
 * @author ramostear
 * @create-time 2019/4/18 0018-1:38
 */
@Configuration
public class OldMvcConfig extends WebMvcConfigurerAdapter{

    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        super.configurePathMatch(configurer);
        configurer.setUseSuffixPatternMatch(false);
    }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/**")
                .addResourceLocations("classpath:/static/")
                .addResourceLocations("classpath:/META-INF/resources/")
                .addResourceLocations("classpath:/public/")
                .addResourceLocations("classpath:/resources/");
        super.addResourceHandlers(registry);
    }
}

WebMvcConfigurerAdapter 是一个实现了WebMvcConfigurer 接口的抽象类,并提供了全部方法的空实现,我们可以在其子类中覆盖这些方法,以实现我们自己的配置,如视图解析器,拦截器和跨域支持等…,由于Java的版本更新,在Java 8中,可以使用default关键词为接口添加默认的方法,Spring在升级的过程中也同步支持了Java 8中这一新特性。下面是在Java 8 中给接口定义一个默认方法的简单实现:

public interface MyInterface{

    default void sayHello(){
        //...
    }

    void sayName(){}

    String writeName(){}

    //...
}

3. 解决方案

如前面所述,从Spring 5开始,WebMvcConfigure接口包含了WebMvcConfigurerAdapter类中所有方法的默认实现,因此WebMvcConfigurerAdapter这个适配器就被打入冷宫了,下面是WebMvcConfigurerAdapter类部分源码示例:

/**
 * An implementation of {@link WebMvcConfigurer} with empty methods allowing
 * subclasses to override only the methods they're interested in.
 *
 * @author Rossen Stoyanchev
 * @since 3.1
 * @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
 */
@Deprecated
public abstract class WebMvcConfigurerAdapter implements WebMvcConfigurer {

    /**
     * {@inheritDoc}
     * <p>This implementation is empty.
     */
    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
    }

    /**
     * {@inheritDoc}
     * <p>This implementation is empty.
     */
    @Override
    public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
    }

    ...
}

趣味提示:我们可以通过实现WebMvcConfigure接口中的方法来配置Web应用程序,而不需要让WebMvcConfigurerAdapter这个中间商 赚差价。

如此这般,我们找到了一个消除警告的方法:直接实现WebMvcConfigurer接口。在我们准备与WebMvcConfigurer打交道之前,先看看此接口的基本情况:

public interface WebMvcConfigurer {

    default void configurePathMatch(PathMatchConfigurer configurer) {
    }

    /**
     * Configure content negotiation options.
     */
    default void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
    }

    /**
     * Configure asynchronous request handling options.
     */
    default void configureAsyncSupport(AsyncSupportConfigurer configurer) {
    }

   ...
}

现在,我们就可以动手配置Web应用程序了,大致的代码如下:

/**
 * Spring 5 (或者Spring Boot 2.x)版本配置Web应用程序示例
 * @author ramostear
 * @create-time 2019/4/18 0018-1:40
 */
@Configuration
public class MvcConfigure implements WebMvcConfigurer{

    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        configurer.setUseSuffixPatternMatch(false);
    }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/**")
                .addResourceLocations("classpath:/static/")
                .addResourceLocations("classpath:/public/")
                .addResourceLocations("classpath:/resources/");
    }
}

就这样简单地将警告消除了,将原来的继承WebMvcConfigurerAdapter类改为实现WebMvcConfigurer接口,其余的地方都没有变化。但有一点需要注意,如果你是升级旧有的应用程序,需要将方法中对super()的调用代码清除。

至此,我们的程序又可以愉快的玩耍了。那么,除了消除中间商 赚差价的方式来规避警告外,还有没有其他的途径呢?答案当然是肯定的。我们除了消除中间商从WebMvcConfigurer中获得配置Web应用程序的途径外,还可以直接从WebMvcConfigurationSupport这个配置“供应商“的手中获取配置途径。WebMvcConfigurationSupport是一个提供了以Java编程方式来配置Web应用程序的配置主类,所以我们可以从这个配置供应商的手中获取Web应用程序的配置方式。方法很简单,只需要扩展此类并重写对应的方法即可。和上面的方式一样,我们先看看此类的内部大致结构:

public class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {
    ...
    /**
     * Provide access to the shared handler interceptors used to configure
     * {@link HandlerMapping} instances with.
     * <p>This method cannot be overridden; use {@link #addInterceptors} instead.
     */
    protected final Object[] getInterceptors() {
        ...
    }

    /**
     * Return a handler mapping ordered at Integer.MAX_VALUE-1 with mapped
     * resource handlers. To configure resource handling, override
     * {@link #addResourceHandlers}.
     */
    @Bean
    @Nullable
    public HandlerMapping resourceHandlerMapping() {
        ...
        handlerMapping.setPathMatcher(mvcPathMatcher());
        handlerMapping.setUrlPathHelper(mvcUrlPathHelper());
        handlerMapping.setInterceptors(getInterceptors());
        handlerMapping.setCorsConfigurations(getCorsConfigurations());
        return handlerMapping;
    }
}

是不是看到很熟悉的东西,有拦截器,静态资源映射等等…,现在我们只需要扩展此类并重写其中的方法,就可以配置我们的Web应用程序(还需要使用@Configuration对扩展类进行注释),示例代码如下:

/**
 * 消除警告的第二种配置选择
 * @author ramostear
 * @create-time 2019/4/7 0007-4:10
 */
@Configuration
public class MvcConfig extends WebMvcConfigurationSupport {

    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        super.configurePathMatch(configurer);
        configurer.setUseSuffixPatternMatch(false);
    }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/**")
                .addResourceLocations("classpath:/static/")
                .addResourceLocations("classpath:/META-INF/resources/")
                .addResourceLocations("classpath:/public/")
                .addResourceLocations("classpath:/resources/");
        super.addResourceHandlers(registry);
    }
}

4. 结束语

在本文中,通过快速的梳理,给出了两种不同的方案来消除由于升级Spring(或者Spring Boot)版本所带来的WebMvcConfigurerAdapter类被弃用的严重警告。本次技术分享到这里就结束了,感谢你耐心的阅读。如果你在遇到同样问题时还有更好的解决方案,可以在下方的评论区给我留言。

基于Base64编/解码算法的Spring Boot文件上传技术解析

基于Base64编/解码算法的Spring Boot文件上传技术解析

导读

文件上传时Web应用最为常见的功能之一,传统的文件上传需要定制一个特殊的form表单来上传文件,以上传图片为例,常规的做法是先上传图片,然后回传图片地址,最后在使用图片。这无疑会带来一个严重的问题:如果在接下来使用图片的过程中web请求中断了或者其他原因导致请求关闭,那么在服务器上就会遗留下未被使用的脏数据,还需要通过其他的方式进行清理。我将这种设计模式称之为“粗犷型经济”模式,不管市场(业务)是否消费,先生产(上传)了再说,最后会导致资源的极度浪费。而本次分享要谈的是另外一种设计模式,我称之为“节约型经济”模式,将生产活动(上传)以“责任承包”制度承包(下方)给具体的业务,采用Base64解码算法的方式,通过二进制文本同步传输到业务方法,最后将文件解码存储,以达到节约资源的效果。

基本术语

1. Base64编码

Base64编码是从二进制到字符的过程,可用于在HTTP环境下传递较长的标识信息。例如,在Java Persistence系统Hibernate中,就采用Base64来将一个较长的唯一标识符(一般为128-bit的UUID)编码成一个字符串,用作HTTP表单和HTTP GET URL中的参数。在其他的应用场景中,也常常需要把二进制数据编码为合适放在URL(包括隐藏表单域)中的形式。此时,采用Base64编码具有不可读性,需要解码后才能阅读。

2. 文件上传

文件上传就是将信息从个人计算机(本地计算机)传送到中央服务器(远程计算机)系统上,让网络上的其他用户可以进行访问。文件上传又分为Web上传和FTP上传,前者直接通过点击网页上的连接即可操作,后者需要专门的FTP工具进行操作。

案例解析

以添加文章的需求为一个案例,一篇文章需要有ID,标题,封面,简介,正文等信息。针对文章封面的设置,通常的做法是在添加文章的页面中通过异步的方式先将图片上传至服务器,然后回传图片存储地址(URL或者URI)绑定到一个隐藏域中和一个用于预览的IMG节点上。此时,文章主体信息是没有提交到服务器的,但与文章相关的图片已经先于文章到达了服务器,这就好比你想要去洗手间放翔,结果翔还没有出来,先从嘴里呕吐了一些东东。虽然看起来都是一个“异化”过程,但总觉得让人“恶心”。原本放完翔(提交请求)冲一下马桶(提交事务)就完事了,你现在还需要额外的擦拭一下地上的呕吐物(清理垃圾文件)。

基于上述的一个应用背景,提出了采用Base64编/解码的方式同步上传文件,让文章的图片随文章主体信息一起到达服务端,如果在请求的过程中服务意外终止,那么在服务器上也不会产生任何脏数据。需求和出发点就聊这么多,接下来进入本次分享的正题,看看如何实现同步上传文件的功能。

功能实现

1. 解码器

我们需要定义一个解码器对前端传入的二进制的图片数据进行解码,对于前端如何将图片文件采用Base64算法编码,在接下来的内容当中单独介绍。此时解码器的做用主要是获取Base64编码的二进制文本中header信息(编码方式)和文件类型信息。然后对数据域进行解码。完成解码工作后,再讲字节码转换成我们熟悉的MultipartFile类型对象。解码器的实现代码如下:

package com.ramostear.jfast.common.utils;

import org.springframework.web.multipart.MultipartFile;

import java.io.*;

/**
 * @author ramostear|谭朝红
 * @create-time 2019/3/19 0019-23:54
 * @modify by :
 * @since:
 */
public class Base64Decoder implements MultipartFile{

    private final byte[] IMAGE;

    private final String HEADER;

    private Base64Decoder(byte[]image,String header){
        this.IMAGE = image;
        this.HEADER = header;
    }

    public static MultipartFile multipartFile(byte[]image,String header){
        return new Base64Decoder(image,header);
    }

    @Override
    public String getName() {
        return System.currentTimeMillis()+Math.random()+"."+HEADER.split("/")[1];
    }

    @Override
    public String getOriginalFilename() {
        return System.currentTimeMillis()+(int)Math.random()*10000+"."+HEADER.split("/")[1];
    }

    @Override
    public String getContentType() {
        return HEADER.split(":")[1];
    }

    @Override
    public boolean isEmpty() {
        return IMAGE == null || IMAGE.length == 0;
    }

    @Override
    public long getSize() {
        return IMAGE.length;
    }

    @Override
    public byte[] getBytes() throws IOException {
        return IMAGE;
    }

    @Override
    public InputStream getInputStream() throws IOException {
        return new ByteArrayInputStream(IMAGE);
    }

    @Override
    public void transferTo(File file) throws IOException, IllegalStateException {
        new FileOutputStream(file).write(IMAGE);
    }
}

2. 转换器

现在,需要定义一个转换器,将前端传入的图片字符信息转换成Base64编码的字节数组,然后调用解码器获得最终的MultipartFile类型对象。转换器的实现比较简单,器代码如下:

package com.ramostear.jfast.common.utils;

import org.springframework.web.multipart.MultipartFile;

import java.util.Base64;

/**
 * @author ramostear|谭朝红
 * @create-time 2019/3/20 0020-0:00
 * @modify by :
 * @since:
 */
public class Base64Converter {

    public static MultipartFile converter(String source){
        String [] charArray = source.split(",");
        Base64.Decoder decoder = Base64.getDecoder();
        byte[] bytes = new byte[0];
        bytes = decoder.decode(charArray[1]);
        for (int i=0;i<bytes.length;i++){
            if(bytes[i]<0){
                bytes[i]+=256;
            }
        }
        return Base64Decoder.multipartFile(bytes,charArray[0]);
    }
}

重点介绍一下转换器的方法:

首先我们先看看基于Base64算法编码后的图片二进制字符的格式:

data:image/png;base64,iVBOR....Px1yGQ9EOFXNAAAAAE1FTkSuQmcc

因此,先通过“,”分割字符串,拿到数据的头部信息data:image/png;base64 ,再将数据的主体部分通过Base64进行转码,获得一个byte数组,最后调用解码器的解码方法获取MultipartFile对象。

3. 前端的Base64编码

后端的核心逻辑已经完成,接下来将介绍前端如何将一张图片采用Base64算法进行编码。

    1. 首先,需要有一个添加文章的form表单,同时将图片域设置为隐藏状态,提供一个图片预览的dom节点和一个浏览本地图片的input输入框,表单的核心代码如下:
    ...
     <form action="/articles" method="POST">
         ...
         <div class="file-preview">
              <div class="file-upload-zone">
                    <div class="file-upload-zone-title">Upload & preview img here …</div>
              </div>
         </div>
         <div class="clearfix"></div>
         <input type="hidden" name="cover" id="cover"/>
         <div class="input-group-btn">
             <button class="btn btn-blue" type="button" id="upload-btn">
                 <i class="fa fa-folder-open"></i>
                 <input id="upload-cover" name="upload-cover" multiple="multiple"
                        onchange="fileChange(this)" type="file"
                        accept="image/*"/>
             </button>
         </div>
         ...
    </form>
    ...
    
    1. 然后是定义一个fileChange方法来处理文件编码的工作,代码如下:
    function fileChange(obj){
            try{
                var file = obj.files[0];
                var reader = new FileReader();
                var fileName="";
                if(typeof(fileName) != "undefined"){
                    fileName = $(obj).val().split("\\").pop();
                }
                reader.onload = function(){
                    var img = new Image();
                    img.src = reader.result;
                    img.onload = function(){
                        var w = img.width,h = img.height;
                        var canvas = document.createElement("canvas");
                        var ctx = canvas.getContext("2d");
                        $(canvas).attr({
                            width:w,
                            height:h
                        });
                        ctx.drawImage(img,0,0,w,h);
                        var base64 = canvas.toDataURL("image/png",0.5);
                        var result = {
                            url:window.URL.createObjectURL(file),
                            base64:base64,
                            clearBase64:base64.substr(base64.indexOf(',')+1),
                          suffix:base64.substring(base64.indexOf(',')+1,base64.indexOf(';'))
                        };
                        $(".file-upload-zone-title").hide();
                        $(".file-upload-zone").empty();
                        $("#cover").val(result.base64);
                        $("<img src=\""+result.base64+"\" class=\"img img-responsive center-block\">").appendTo(".file-upload-zone");
                        $(".file-upload-zone").trigger("create");
                        $(".file-name").val(fileName);
                    }
                }
                reader.readAsDataURL(obj.files[0]);
            }catch(e){
                layer.msg("error");
            }
        };
    

关于这段代码的核心逻辑,其实与后端的解码过程刚好相反,这里不再赘述。

到现在,通过Base64编码方式同步上传文件的核心功能已经完成,在接下来的内容中,使用Spring Boot 2.0快速的演示本次分享的内容。

添加文章服务组件#文件上传

1. 添加文章的服务组件

接一开始的需求背景,图片信息属于文章对象的一个属性值,所以处理文件上传的逻辑后置到service中,在本次测试代码中,最终的文件存储采用的是七牛云的CDN服务,关于CDN部分的代码不进行展开,可以上传到本地,两者操作的对象都是MultipartFile,关于如何存储不是本次分享的重点。文章服务组件主要代码如下:

package com.ramostear.jfast.domain.service.impl;

import com.ramostear.jfast.common.ext.Translate;
import com.ramostear.jfast.domain.repo.ArticleRepo;
import com.ramostear.jfast.domain.service.ArticleService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
 * @author ramostear|谭朝红
 * @create-time 2019/3/19 0019-23:37
 * @modify by :
 * @since:
 */
@Service(value = "articleService")
@Transactional(readOnly = true)
public class ArticleServiceImpl implements ArticleService {
    @Autowired
    private ArticleRepo articleRepo;

    @Override
    @Transactional
    public void save(ArticleVo vo) {
        Article article = Translate.toArticle(vo);
        articleRepo.save(article);
    }

在ArticleService服务组件中,涉及到一个Translate类,它的作用主要是讲前端传输过来的ValueObject映射到POJO类中,同时将文件存储的逻辑也封装进去了,主要代码如下:

package com.ramostear.jfast.common.ext;

import com.ramostear.jfast.common.factory.CdnFactory;
import com.ramostear.jfast.common.factory.cdn.CdnRepository;
import com.ramostear.jfast.common.utils.Base64Converter;
import com.ramostear.jfast.domain.model.Article;
import com.ramostear.jfast.domain.vo.ArticleVo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.web.multipart.MultipartFile;

import java.util.Date;

/**
 * @author ramostear|谭朝红
 * @create-time 2019/3/18 0018-3:39
 * @modify by :
 * @since:
 */
public class Translate {

    private static CdnRepository cdnRepo = CdnFactory.builder(CdnFactory.CdnType.Qiniu);

    public static Article toArticle(ArticleVo vo){
        Article article = new Article();
        BeanUtils.copyProperties(vo,article);
        if(StringUtils.isNotBlank(vo.getCover())){
            MultipartFile file = Base64Converter.converter(vo.getCover());
            article.setCover(cdnRepo.save(file));
        }
        return article;
    }
}

此处由于使用的是七牛云的CDN服务,所以通过一个CND的工厂类获取一个CND仓储实例,用于将文件写入到仓储中,并回传一个文件访问地址。除了上述的方法,还可以调用file.transferTo()方法将文件写入到本地(应用服务器)磁盘中。

这里的CND工厂类实现细节由于篇幅原因不再展开。需要了解更多关于CDN SDK使用方法,可以在文章末尾给我留言。

2. 文章控制器

最后,定义一个控制器,提供给前端添加文章时进行调用,文章控制器主要工作是获得前端传入的文章信息,然后调用文章服务组件,完成添加文章工作。核心代码如下:

package com.ramostear.jfast.domain.controller;

@RestController
public class ArticleController{
    @Autowired
    ArticleService articleService;

    @Postmapping(value="/articles")
    public ResponseEntity<Object> createArticle(@RequestBody ArticleVo vo){
        try{
            articleService.save(vo);
            return new ResponseEntity<>("已经成功将文字写入数据库",HttpStatus.CREATED);
        }catch(Exception e){
            return new ResponseEntity<>(e.getMessage(),HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

}

结束语

本次分享只给出了核心部位的实现,其中涉及到的如CDN、HTML、JS等的知识没有展开,如果给你带来了困惑,可以在评论区给我留言,我们再一起讨论。再次感谢大家赏光拜读,谢谢~~~

使用Ehcache三步搞定Spring Boot 缓存?

使用Ehcache三步搞定Spring Boot 缓存?

三步搞定Spring Boot 缓存

本次内容主要介绍基于Ehcache 3.0来快速实现Spring Boot应用程序的数据缓存功能。在Spring Boot应用程序中,我们可以通过Spring Caching来快速搞定数据缓存。接下来我们将介绍如何在三步之内搞定Spring Boot缓存。

1. 创建一个Spring Boot工程并添加Maven依赖

你所创建的Spring Boot应用程序的maven依赖文件至少应该是下面的样子:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ramostear</groupId>
    <artifactId>cache</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>cache</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.ehcache</groupId>
            <artifactId>ehcache</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.cache</groupId>
            <artifactId>cache-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

依赖说明:

  • spring-boot-starter-cache为Spring Boot应用程序提供缓存支持
  • ehcache提供了Ehcache的缓存实现
  • cache-api 提供了基于JSR-107的缓存规范

2. 配置Ehcache缓存

现在,需要告诉Spring Boot去哪里找缓存配置文件,这需要在Spring Boot配置文件中进行设置:

spring.cache.jcache.config=classpath:ehcache.xml

然后使用@EnableCaching注解开启Spring Boot应用程序缓存功能,你可以在应用主类中进行操作:

package com.ramostear.cache;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class CacheApplication {

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

接下来,需要创建一个ehcache的配置文件,该文件放置在类路径下,如resources目录下:

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.ehcache.org/v3"
        xmlns:jsr107="http://www.ehcache.org/v3/jsr107"
        xsi:schemaLocation="
            http://www.ehcache.org/v3 http://www.ehcache.org/schema/ehcache-core-3.0.xsd
            http://www.ehcache.org/v3/jsr107 http://www.ehcache.org/schema/ehcache-107-ext-3.0.xsd">
    <service>
        <jsr107:defaults enable-statistics="true"/>
    </service>

    <cache alias="person">
        <key-type>java.lang.Long</key-type>
        <value-type>com.ramostear.cache.entity.Person</value-type>
        <expiry>
            <ttl unit="minutes">1</ttl>
        </expiry>
        <listeners>
            <listener>
                <class>com.ramostear.cache.config.PersonCacheEventLogger</class>
                <event-firing-mode>ASYNCHRONOUS</event-firing-mode>
                <event-ordering-mode>UNORDERED</event-ordering-mode>
                <events-to-fire-on>CREATED</events-to-fire-on>
                <events-to-fire-on>UPDATED</events-to-fire-on>
                <events-to-fire-on>EXPIRED</events-to-fire-on>
                <events-to-fire-on>REMOVED</events-to-fire-on>
                <events-to-fire-on>EVICTED</events-to-fire-on>
            </listener>
        </listeners>
        <resources>
                <heap unit="entries">2000</heap>
                <offheap unit="MB">100</offheap>
        </resources>
    </cache>
</config>

最后,还需要定义个缓存事件监听器,用于记录系统操作缓存数据的情况,最快的方法是实现CacheEventListener接口:

package com.ramostear.cache.config;

import org.ehcache.event.CacheEvent;
import org.ehcache.event.CacheEventListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author ramostear
 * @create-time 2019/4/7 0007-0:48
 * @modify by :
 * @since:
 */
public class PersonCacheEventLogger implements CacheEventListener<Object,Object>{

    private static final Logger logger = LoggerFactory.getLogger(PersonCacheEventLogger.class);

    @Override
    public void onEvent(CacheEvent cacheEvent) {
        logger.info("person caching event {} {} {} {}",
                cacheEvent.getType(),
                cacheEvent.getKey(),
                cacheEvent.getOldValue(),
                cacheEvent.getNewValue());
    }
}

3. 使用@Cacheable注解对方法进行注释

要让Spring Boot能够缓存我们的数据,还需要使用@Cacheable注解对业务方法进行注释,告诉Spring Boot该方法中产生的数据需要加入到缓存中:

package com.ramostear.cache.service;

import com.ramostear.cache.entity.Person;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

/**
 * @author ramostear
 * @create-time 2019/4/7 0007-0:51
 * @modify by :
 * @since:
 */
@Service(value = "personService")
public class PersonService {

    @Cacheable(cacheNames = "person",key = "#id")
    public Person getPerson(Long id){
        Person person = new Person(id,"ramostear","ramostear@163.com");
        return person;
    }
}

通过以上三个步骤,我们就完成了Spring Boot的缓存功能。接下来,我们将测试一下缓存的实际情况。

4. 缓存测试

为了测试我们的应用程序,创建一个简单的Restful端点,它将调用PersonService返回一个Person对象:

package com.ramostear.cache.controller;

import com.ramostear.cache.entity.Person;
import com.ramostear.cache.service.PersonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


/**
 * @author ramostear
 * @create-time 2019/4/7 0007-0:54
 * @modify by :
 * @since:
 */
@RestController
@RequestMapping("/persons")
public class PersonController {

    @Autowired
    private PersonService personService;

    @GetMapping("/{id}")
    public ResponseEntity<Person> person(@PathVariable(value = "id") Long id){
        return new ResponseEntity<>(personService.getPerson(id), HttpStatus.OK);
    }
}

Person是一个简单的POJO类:

package com.ramostear.cache.entity;


import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import java.io.Serializable;

/**
 * @author ramostear
 * @create-time 2019/4/7 0007-0:45
 * @modify by :
 * @since:
 */
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class Person implements Serializable{

    private Long id;

    private String username;

    private String email;
}

以上准备工作都完成后,让我们编译并运行应用程序。项目成功启动后,使用浏览器打开:http://localhost:8080/persons/1 ,你将在浏览器页面中看到如下的信息:

{"id":1,"username":"ramostear","email":"ramostear@163.com"}

此时在观察控制台输出的日志信息:

2019-04-07 01:08:01.001  INFO 6704 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 5 ms
2019-04-07 01:08:01.054  INFO 6704 --- [e [_default_]-0] c.r.cache.config.PersonCacheEventLogger  : person caching event CREATED 1 null com.ramostear.cache.entity.Person@ba8a729

由于我们是第一次请求API,没有任何缓存数据。因此,Ehcache创建了一条缓存数据,可以通过CREATED看一了解到。

我们在ehcache.xml文件中将缓存过期时间设置成了1分钟(1),因此在一分钟之内我们刷新浏览器,不会看到有新的日志输出,一分钟之后,缓存过期,我们再次刷新浏览器,将看到如下的日志输出:

2019-04-07 01:09:28.612  INFO 6704 --- [e [_default_]-1] c.r.cache.config.PersonCacheEventLogger  : person caching event EXPIRED 1 com.ramostear.cache.entity.Person@a9f3c57 null
2019-04-07 01:09:28.612  INFO 6704 --- [e [_default_]-1] c.r.cache.config.PersonCacheEventLogger  : person caching event CREATED 1 null com.ramostear.cache.entity.Person@416900ce

第一条日志提示缓存已经过期,第二条日志提示Ehcache重新创建了一条缓存数据。

结束语

在本次案例中,通过简单的三个步骤,讲解了基于Ehcache的Spring Boot应用程序缓存实现。文章内容重在缓存实现的基本步骤与方法,简化了具体的业务代码,有兴趣的朋友可以自行扩展,期间遇到问题也可以随时与我联系。

使用Spring Boot 2.0 十分钟构建Web应用程序

使用Spring Boot 2.0 十分钟构建Web应用程序

Spring Boot 2.0 :快速构建Web应用程序

1. 简介

Spring Boot 节约了我们对Spring Framework的学习和使用成本,它能够让我们以更短的时间,更高的效率去构建一个Web应用程序。本教程是Spring Boot 2.0系列教程的一个开端,我将在此文章中介绍一些Spring Boot 2.0的核心配置、前端应用、快速数据操作以及异常处理。

2. 配置

首先,我们使用Spring Initializr为我们的项目构建出基本的工程目录结构。

生成的项目将依赖于spring-boot-starter-parent:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.3.RELEASE</version>
    <relativePath/>
</parent>

一开始的项目依赖关系很简单,pom文件中添加的核心依赖如下:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
</dependency>

大多数的Spring库都可以通过简单的配置相关的starters导入到我们的项目中。

3. 应用程序配置

接下来,我们将为我们的应用程序配置一个简单的主类(主类的配置Spring Initializer已经为我们完成):

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

说明:@SpringBootApplication 是一个组合注解,它等同于@Configuration@EnableAutoConfiguration@ComponentScan 三个注解的组合使用

最后,我们在定义一个简单的application.properties文件,设置一个简单的属性和值:

server.port = 8888

server.port = 8888 将把Spring Boot 设置的服务器端口从默认的8080更改为8888;其他属性的设置可参考Spring Boot 属性设置

4. MVC视图

在本次教程中,我们将使用Thymeleaf作为前端的模板,你也可以使用诸如Freemarker等其他的模板引擎。

首先,我们需要在pom文件中添加Thymeleaf的依赖,将spring-boot-starter-thymeleaf依赖项添加到pom.xml中:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

通过上述配置,Thymeleaf已经引入到项目中,我们只需要在application.properties中简单的配置即可使用它:

spring.thymeleaf.cache = false
spring.thymeleaf.enabled = true
spring.thymeleaf.prefix = classpath:/templates/
spring.thymeleaf.suffix = .html
spring.application.name = Building Web Application base on Spring Boot 2.0

接下来,我们将定义一个简单的控制器和一个前端页面,主页控制器如下:

@Controller
public class HomeController{
    @Value("${spring.application.name}")
    String appName;

    @GetMapping("/")
    public String home(Model model){
        model.addAttribute("appName",appName);
        return "home";
    }
}

最后,创建一个home.html页面:

<html>
    <head>
        <title>Home Page</title>
    </head>
    <body>
        <h1>
            Spring Boot 2.0 Tutorial
        </h1>
        <p>
            Server message: <span th:text="${appName}">default appName</span>
        </p>
    </body>
</html>

5. 应用安全

接下来,我们将使用Spring Security为我们的应用程序增加安全访问控制,首先是添加相关的依赖项:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

一旦我们导入并开启了Spirng Security,Spring Security将使用默认的httpBasic或者formLogin策略对我们的应用程序进行安全检查。也就是说默认情况下,我们应用中的所有端点都将被Spring Security进行安全保护,因此,我们需要通过扩展Spring Security的WebSecurityConfigurerAdapter类来自定义我们自己的自定义安全控制配置项:

@Configuration
@EnableWebSecurity
public class MySecurityConfiguration extends WebSecurityConfigurerAdapter{
    @Override
    protected void configure(HttpSecurity http) throws Exception{
        http.authorizeRequests()
            .anyRequest()
            .permitAll()
            .and.csrf().disabled();
    }
}

通过上述的配置,在我们的应用中,所有端点的访问将不受任何限制。

Spring Security的内容不仅仅只是文中提到的这些,更多的内容可自行研究

6. 持久化

首先,让我们从定义数据模型开始,数据模型是持久化操作的基础。一个简单的用户实体:

@Entity
public class User{
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;

    @Column(nullable = false,unique = true)
    private String username;

    @Column(nullable = false)
    private String address;
}

接下来,我们使用Spring Data来定义用户的存储库:

public interface UserRepository extends CrudRepository<User,Long>{
    List<User> findByUsername(String username);
}

最后,我们需要配置我们的持久化类:

@EnableJpaRepositories("com.ramostear.persistence.repo")
@EntityScan("com.ramostear.persistence.model")
@SpringBootApplication
public class Application{
    ...
}

相关注解说明:

为了快速的演示项目,我们使用了H2内存数据库,以减少项目在运行过程中所依赖的外部系统。一旦我们引入了H2的依赖项,Spring Boot会自动检测并设置我们的持久化关系,我们只需要在application.xml中配置数据源属性:

spring.datasource.driver-class-name = org.h2.Driver
spring.datasource.url = jdbc:h2:mem:bootapp;DB_CLOSE_DELAY=-1
spring.datasource.username = sa
spring.datasource.password =

7. Web层和控制器

在本小节中,我们将定义一个简单的控制器 —UserController来完成Web层的操作。我们将实现基本的CRUD操作,并通过REST 的方式来暴露User相关资源:

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserRepository userRepository;

    @GetMapping
    public Iterable<User> findAll(){
        return userRepository.findAll();
    }

    @GetMapping("/username/{username}")
    public List<User> findByUsername(@PathVariable(name = "username")String username){
        return userRepository.findAllByUsername(username);
    }

    @GetMapping("/{id}")
    public User findOne(@PathVariable Long id){
        return userRepository.findById(id)
                .orElseThrow(UserNotFoundException::new);
    }


    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public User create(@RequestBody User user){
        User u = userRepository.save(user);
        return u;
    }

    @DeleteMapping("/{id}")
    public void delete(@PathVariable Long id){
        userRepository.findById(id)
                .orElseThrow(UserNotFoundException::new);
        userRepository.deleteById(id);
    }

    @PutMapping("/{id}")
    public User updateUser(@RequestBody User user,@PathVariable Long id){
        if(!id.equals(user.getId())){
            throw new UserIdMismatchException();
        }
        userRepository.findById(id)
                .orElseThrow(UserNotFoundException::new);
        return userRepository.save(user);
    }
}

鉴于文章篇幅问题,我们不再去定义前端页面,而是使用@RestController注解,将控制器定义为一个API控制器。这里的@RestController相当于@Controller@ResponseBody两个注解的组合。

8 . 异常处理

现在,Web应用的核心功能已经准备就绪,接下来我们将使用@ControllerAdvice注解来集中处理应用中可能出现的异常信息。

首先,我们需要定义一个自定义的异常类:

public class UserNotFoundException extends RuntimeException{
    public UserNotFoundException(String message,Throwable cause){
        super(message,cause);
    }
    ....
}

然后,使用@ControllerAdvice定义我们的异常信息统一处理类:

@ControllerAdvice
public RestExceptionHandler extends ResponseEntityExceptionHandler{

    @ExceptionHandler({UserNotFoundException.class})
    protected ResponseEntity<Object> handleNotFound(Exception ex,WebRequest request){
        return handleExceptionInternal(ex,"User not found",
                                       new HttpHeaders(),
                                       HttpStatus.NOT_FOUND,request);
    }

    @ExceptionHandler({UserIdMIsmatchException.class,
                      ConstraintViolationException.class,
                      DataIntegrityViolationException.class})
    public ResponseEntity<Object> handleBadRequest(Exception ex,WebRequest request){
        return handleExceptionInternal(ex,ex.getLocalizedMessage(),
                                      new HttpHeaders(),HttpStatus.BAD_REQUEST,request);
    }
}

默认情况下,Spring Boot 已提供了错误信息页面映射。我们也可以自定义一个error.html页面来定义其视图:

<html>
    <head>
        <title>Error Page</title>
    </head>
    <body>
        <h1>
            Error infomation !
        </h1>
        <b>
            [<span th:text="${status}">status</span>]
            <span th:text="${error}">error</span>
        </b>
        <p th:text="${message}">
            message
        </p>
    </body>
</html>

与设置Spring Boot中其他属性一样,我们可以在application.properties文件中覆盖默认的映射路径:

server.error.path = /error

9 . 应用测试

最后,我们将对我们定义的用户访问接口进行测试。我们将使用@SpringBootTest注解来加载应用程序的上下文:

@RunWith(SpringRunner.class)
@SpringBootTest(classes = {Application.class},webEnvironment = WebEnvironment.DEFINED_PORT)
public class UserAPITest{
    private static final String API_ROOT_URL = "http://localhost:8888/api/users";

     private User createRandomUser(){
        final User user = new User();
        user.setUsername(RandomStringUtils.randomAlphabetic(10));
        user.setAddress(RandomStringUtils.randomAlphabetic(15));
        return user;
    }

    private String  createUserAsUri(User user){
        final Response response = RestAssured.given()
                .contentType(MediaType.APPLICATION_JSON_VALUE)
                .body(user)
                .post(API_ROOT_URL);
        return API_ROOT_URL+"/"+response.jsonPath().get("id");
    }

}

首先,我们通过不同使用不同条件来查找用户:

@Test
    public void whenGetAllUsers_thenOk(){
        final Response response = RestAssured.get(API_ROOT_URL);
        Assert.assertEquals(HttpStatus.OK.value(),response.getStatusCode());
    }

    @Test
    public void whenGetUsersByUsername_thenOk(){
        final User user = createRandomUser();
        createUserAsUri(user);
        final Response response = RestAssured.get(API_ROOT_URL+"/username/"+user.getUsername());
        Assert.assertEquals(HttpStatus.OK.value(),response.getStatusCode());
       Assert.assertTrue(response.as(List.class).size() >0);
    }

    @Test
    public void whenGetCreatedUserById_thenOk(){
        final User user = createRandomUser();
        final String location = createUserAsUri(user);
        System.out.println(location);
        final Response response = RestAssured.get(location);
        Assert.assertEquals(HttpStatus.OK.value(),response.getStatusCode());
        Assert.assertEquals(user.getUsername(),response.jsonPath().get("username"));
    }

    @Test
    public void whenGetNotExistUserById_thenNotFound(){
        final Response response = RestAssured.get(API_ROOT_URL+"/"+RandomStringUtils.randomNumeric(4));
        Assert.assertEquals(HttpStatus.NOT_FOUND.value(),response.getStatusCode());
    }

接下来,我们尝试测试新增一个用户:

    @Test
     public void whenCreateNewUser_thenCreated(){
        final User user = createRandomUser();
        final Response response = RestAssured.given()
                .contentType(MediaType.APPLICATION_JSON_VALUE)
                .body(user)
                .post(API_ROOT_URL);
                Assert.assertEquals(HttpStatus.CREATED.value(),
                            response.getStatusCode());
    }

    @Test
    public void whenInvalidUserByUsernameNull_thenError(){
        final User user = createRandomUser();
        user.setUsername(null);
        final Response response = RestAssured.given()
                .contentType(MediaType.APPLICATION_JSON_VALUE)
                .body(user)
                .put(API_ROOT_URL);
                    Assert.assertEquals(HttpStatus.METHOD_NOT_ALLOWED.value(),
                                    response.getStatusCode());
    }

然后尝试更新一个用户的信息:

@Test
    public void whenUpdateCreatedUser_thenUpdated(){
        final User user = createRandomUser();
        final String location = createUserAsUri(user);
        user.setId(Long.parseLong(location.split("api/users/")[1]));
        user.setUsername("newUsername");
        Response response = RestAssured.given()
                .contentType(MediaType.APPLICATION_JSON_VALUE)
                .body(user)
                .put(location);
        Assert.assertEquals(HttpStatus.OK.value(),response.getStatusCode());
        response = RestAssured.get(location);
        Assert.assertEquals(HttpStatus.OK.value(),response.getStatusCode());
        Assert.assertEquals("newUsername",response.jsonPath().get("username"));
    }

最后,我们试着去移除一个用户:

@Test
public void whenDeleteCreatedUser_thenOk(){
    final User user = createRandomUser();
    final String location = createUserAsUri(user);
    Response response = RestAssured.delete(location);
    Assert.assertEquals(HttpStatus.OK.value(),response.getStatusCode());

    response = RestAssured.get(location);
    Assert.assertEquals(HttpStatus.NOT_FOUND.value(),response.getStatusCode());
}

测试结果:

10 . 总结

此教程是Spring Boot 2.0 系列教程的快速预览篇,通过一个简单的Demo快速的对Spring Boot有一个初步的认识。由于篇幅有限,不可能涵盖所有的技术细节,Spring Boot 2.0的核心技术教程将在其他教程中一一进行介绍。你可以通过Github网站获取本教程的全部源码:https://github.com/ramostear/spring-boot-tutorial-part1

如何在生产环境中重启Spring Boot应用?

如何在生产环境中重启Spring Boot应用?

通过HTTP重启Spring Boot应用程序

需求背景

在一个很奇葩的需求下,要求在客户端动态修改Spring Boot配置文件中的属性,例如端口号、应用名称、数据库连接信息等,然后通过一个Http请求重启Spring Boot程序。这个需求类似于操作系统更新配置后需要进行重启系统才能生效的应用场景。

动态配置系统并更新生效是应用的一种通用性需求,实现的方式也有很多种。例如监听配置文件变化、使用配置中心等等。网络上也有很多类似的教程存在,但大多数都是在开发阶段,借助Spring Boot DevTools插件实现应用程序的重启,或者是使用spring-boot-starter-actuator和spring-cloud-starter-config来提供端点(Endpoint)的刷新。

第一种方式无法在生产环境中使用(不考虑),第二种方式需要引入Spring Cloud相关内容,这无疑是杀鸡用了宰牛刀。

接下来,我将尝试采用另外一种方式实现HTTP请求重启Spring Boot应用程序这个怪异的需求。

尝试思路

重启Spring Boot应用程序的关键步骤是对主类中SpringApplication.run(Application.class,args);方法返回值的处理。SpringApplication#run()方法将会返回一个ConfigurableApplicationContext类型对象,通过查看官方文档可以看到,ConfigurableApplicationContext接口类中定义了一个close()方法,可以用来关闭当前应用的上下文:

package org.springframework.context;

import java.io.Closeable;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.io.ProtocolResolver;
import org.springframework.lang.Nullable;

public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {
void close();

}

继续看官方源码,AbstractApplicationContext类中实现close()方法,下面是实现类中的方法摘要:

public void close() {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            this.doClose();
            if (this.shutdownHook != null) {
                try {
                    Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
                } catch (IllegalStateException var4) {
                    ;
                }
            }

        }
    }

#close()方法将会调用#doClose()方法,我们再来看看#doClose()方法做了哪些操作,下面是doClose()方法的摘要:

protected void doClose() {
        if (this.active.get() && this.closed.compareAndSet(false, true)) {

            ...

            LiveBeansView.unregisterApplicationContext(this);

            ...

            this.destroyBeans();
            this.closeBeanFactory();
            this.onClose();
            if (this.earlyApplicationListeners != null) {
                this.applicationListeners.clear();
                this.applicationListeners.addAll(this.earlyApplicationListeners);
            }

            this.active.set(false);
        }

    }

#doClose()方法中,首先将应用上下文从注册表中清除掉,然后是销毁Bean工厂中的Beans,紧接着关闭Bean工厂。

官方文档看到这里,就产生了解决一个结局重启应用应用程序的大胆猜想。在应用程序的main()方法中,我们可以使用一个临时变量来存放SpringApplication.run()返回的ConfigurableApplicationContext对象,当我们完成对Spring Boot应用程序中属性的设置后,调用ConfigurableApplicationContext#close()方法,最后再调用SpringApplication.run()方法重新给ConfigurableApplicationContext对象进行赋值已达到重启的效果。

现在,我们再来看一下SpringApplication.run()方法中是如何重新创建ConfigurableApplicationContext对象的。在SpringApplication类中,run()方法会调用createApplicationContext()方法来创建一个ApplicationContext对象:

protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            try {
                switch(this.webApplicationType) {
                case SERVLET:
                    contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
                    break;
                case REACTIVE:
                    contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
                    break;
                default:
                    contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
                }
            } catch (ClassNotFoundException var3) {
                throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
            }
        }

        return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
    }

createApplicationContext()方法会根据WebApplicationType类型来创建ApplicationContext对象。在WebApplicationType中定义了三种种类型:NONESERVLETREACTIVE。通常情况下,将会创建servlet类型的ApplicationContext对象。

接下来,我将以一个简单的Spring Boot工程来验证上述的猜想是否能够达到重启Spring Boot应用程序的需求。

编码实现

首先,在application.properties文件中加入如下的配置信息,为动态修改配置信息提供数据:

spring.application.name= SPRING-BOOT-APPLICATION

接下来,在Spring Boot主类中定义两个私有变量,用于存放main()方法的参数和SpringApplication.run()方法返回的值。下面的代码给出了主类的示例:

public class ExampleRestartApplication {

    @Value ( "${spring.application.name}" )
    String appName;

    private static Logger logger = LoggerFactory.getLogger ( ExampleRestartApplication.class );

    private static String[] args;
    private static ConfigurableApplicationContext context;

    public static void main(String[] args) {
        ExampleRestartApplication.args = args;
        ExampleRestartApplication.context = SpringApplication.run(ExampleRestartApplication.class, args);
    }
}

最后,直接在主类中定义用于刷新并重启Spring Boot应用程序的端点(Endpoint),并使用@RestController注解对主类进行注释。

@GetMapping("/refresh")
public String restart(){
    logger.info ( "spring.application.name:"+appName);
    try {
        PropUtil.init ().write ( "spring.application.name","SPRING-DYNAMIC-SERVER" );
    } catch (IOException e) {
        e.printStackTrace ( );
    }

    ExecutorService threadPool = new ThreadPoolExecutor (1,1,0, TimeUnit.SECONDS,new ArrayBlockingQueue<> ( 1 ),new ThreadPoolExecutor.DiscardOldestPolicy ());
    threadPool.execute (()->{
        context.close ();
        context = SpringApplication.run ( ExampleRestartApplication.class,args );
    } );
    threadPool.shutdown ();
    return "spring.application.name:"+appName;
}

说明:为了能够重新启动Spring Boot应用程序,需要将close()和run()方法放在一个独立的线程中执行。

为了验证Spring Boot应用程序在被修改重启有相关的属性有没有生效,再添加一个获取属性信息的端点,返回配置属性的信息。

@GetMapping("/info")
public String info(){
    logger.info ( "spring.application.name:"+appName);
    return appName;
}

完整的代码

下面给出了主类的全部代码:

package com.ramostear.application;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;
import java.util.concurrent.*;

/**
 * @author ramostear
 */
@SpringBootApplication
@RestController
public class ExampleRestartApplication {

    @Value ( "${spring.application.name}" )
    String appName;

    private static Logger logger = LoggerFactory.getLogger ( ExampleRestartApplication.class );

    private static String[] args;
    private static ConfigurableApplicationContext context;

    public static void main(String[] args) {
        ExampleRestartApplication.args = args;
        ExampleRestartApplication.context = SpringApplication.run(ExampleRestartApplication.class, args);
    }

    @GetMapping("/refresh")
    public String restart(){
        logger.info ( "spring.application.name:"+appName);
        try {
            PropUtil.init ().write ( "spring.application.name","SPRING-DYNAMIC-SERVER" );
        } catch (IOException e) {
            e.printStackTrace ( );
        }

        ExecutorService threadPool = new ThreadPoolExecutor (1,1,0, TimeUnit.SECONDS,new ArrayBlockingQueue<> ( 1 ),new ThreadPoolExecutor.DiscardOldestPolicy ());
        threadPool.execute (()->{
            context.close ();
            context = SpringApplication.run ( ExampleRestartApplication.class,args );
        } );
        threadPool.shutdown ();
        return "spring.application.name:"+appName;
    }

    @GetMapping("/info")
    public String info(){
        logger.info ( "spring.application.name:"+appName);
        return appName;
    }
}

接下来,运行Spring Boot程序,下面是应用程序启动成功后控制台输出的日志信息:

[2019-03-12T19:05:53.053z][org.springframework.scheduling.concurrent.ExecutorConfigurationSupport][main][171][INFO ] Initializing ExecutorService 'applicationTaskExecutor'
[2019-03-12T19:05:53.053z][org.apache.juli.logging.DirectJDKLog][main][173][INFO ] Starting ProtocolHandler ["http-nio-8080"]
[2019-03-12T19:05:53.053z][org.springframework.boot.web.embedded.tomcat.TomcatWebServer][main][204][INFO ] Tomcat started on port(s): 8080 (http) with context path ''
[2019-03-12T19:05:53.053z][org.springframework.boot.StartupInfoLogger][main][59][INFO ] Started ExampleRestartApplication in 1.587 seconds (JVM running for 2.058)

在测试修改系统配置并重启之前,使用Postman测试工具访问:http://localhost:8080/info ,查看一下返回的信息:

成功返回SPRING-BOOT-APPLICATION提示信息。

然后,访问:http://localhost:8080/refresh ,设置应用应用程序spring.application.name的值为SPRING-DYNAMIC-SERVER,观察控制台输出的日志信息:

可以看到,Spring Boot应用程序已经重新启动成功,最后,在此访问:http://localhost:8080/info ,验证之前的修改是否生效:

请求成功返回了SPRING-DYNAMIC-SERVER信息,最后在看一眼application.properties文件中的配置信息是否真的被修改了:

配置文件的属性也被成功的修改,证明之前的猜想验证成功了。

本次内容所描述的方法不适用于以JAR文件启动的Spring Boot应用程序,以WAR包的方式启动应用程序亲测可用。┏ (^ω^)=☞目前该药方副作用未知,如有大牛路过,还望留步指点迷津,不胜感激。

结束语

本次内容记录了自己验证HTTP请求重启Spring Boot应用程序试验的一次经历,文章中所涉及到的内容仅代表个人的一些观点和不成熟的想法,并未将此方法应用到实际的项目中去,如因引用本次内容中的方法应用到实际生产开发工作中所带来的风险,需引用者自行承担因风险带来的后遗症(๑→ܫ←)——此药方还有待商榷(O_o)(o_O)。

Spring Boot Admin Client介绍

Spring Boot Admin Client介绍

Spring Boot(十八)— Admin Client

在上一章节中,我们学习了如何构建Spring Boot Admin Server应用程序。在本章节中,将学习如何让我们的应用程序被Admin Server所管理。相对于Admin Server来说,需要被管理的应用程序称为Admin Client

添加依赖

admin client需要在Maven build文件中添加如下的两个依赖:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-client</artifactId>
</dependency>

配置Admin Client

在application.properties文件中配置应用程序的启动端口、应用名称和Admin Server的URL地址:

server.port=8081
spring.application.name=Admin-Client-1
spring.boot.admin.client.url=http://localhost:9091
management.endpoints.web.exposure.include=*

打包运行

使用下面的maven命令对应用程序进行打包:

mvn clean install

打包成功后,使用入下的命令运行JAR文件:

java -jar JARFILE

最后,我们还需要将Admin Server启动。

接下来,在web浏览器中输入URL:http://localhost:9091 访问Spring Boot Admin Server:

Admin Server index

应用监控详情页:

应用监控详情页

JVM监控页面:

JVM监控页面

应用实例信息页面:

应用实例信息页面

日志信息页面:

日志信息页面

Spring Boot Admin Server的应用

Spring Boot Admin Server的应用

Spring Boot(十七)— Admin Server

在上一章节中,我们学习了如何使用Spring Boot Actuator来管理应用程序。但是,当我们有多个应用程序需要管理时,使用Actuator来管理这些应用将变得很吃力。因为,当你有N个应用程序需要管理时,每个应用程序都有自己独立的端点信息,维护这些独立的端点信息将是一件可怕的事情。

面对这样的窘境,Spring Boot为我们提供了另外一个神器——Spring Boot Admin Server。它可以统一的在一个地方来管理所有的端点信息,与此同时,CodeCentric团队还提供了一套基于VUE的管理界面,方便我们对各个应用程序进行管理。

在本章节中,我们将使用Spring Boot快熟的构建起一个Admin Server应用程序,在下一个章节中,我们将讲解Admin Client如何与Admin Server一起工作。

构建Spring Boot Admin Server

为了能够构建Admin Server应用程序,我们需要在Maven build文件中引入以下的两个依赖项:

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-server</artifactId>
</dependency>
<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-server-ui</artifactId>
</dependency>

其中,spring-boot-admin-server-ui为我们提供了一套漂亮的应用管理界面。

开启对Admin Server的支持

使用@EnableAdminServer注解对应用程序的主类进行注释。@EnableAdminServer注解可以让你的应用程序具备管理其他应用程序端点信息的能力。

package com.ramostear.application;

import de.codecentric.boot.admin.server.config.EnableAdminServer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableAdminServer
public class AdminServerApplication {

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

}

配置应用程序

现在,在application.properties文件中定义如下的几个配置:

server.port=9091
spring.application.name= Admin-Server
spring.application.admin.enabled=true

第一个参数时设置应用程序的启动端口号为9091,第二个参数时设置应用的名称为“Admin-Server”,最后一个参数时开启Admin Server服务。

Maven build 文件清单

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ramostear</groupId>
    <artifactId>admin-server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>admin-server</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-boot-admin.version>2.1.3</spring-boot-admin.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-server</artifactId>
        </dependency>
        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-server-ui</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>de.codecentric</groupId>
                <artifactId>spring-boot-admin-dependencies</artifactId>
                <version>${spring-boot-admin.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

接下来,使用下面的Maven命令对项目进行打包:

mvn clean install

打包成功后,使用下面的命令运行JAR文件:

java -jar JARFILE

现在,应用程序已经在Tomcat上启动成功,端口号为:9091 。

2019-03-12 01:44:55.289  INFO 18044 --- [           main] o.s.b.a.e.web.EndpointLinksResolver      : 
Exposing 2 endpoint(s) beneath base path '/actuator'
2019-03-12 01:44:55.803  INFO 18044 --- [           main] o.s.b.web.embedded.netty.NettyWebServer  : 
Netty started on port(s): 9091
2019-03-12 01:44:55.806  INFO 18044 --- [           main] c.r.application.AdminServerApplication   : 
Started AdminServerApplication in 2.81 seconds (JVM running for 3.933)

访问Admin Server

现在,打开Web浏览器,输入URL:http://localhost:9091/ ,然后查看服务管理的界面。

Spring Boot Admin Server UI

在下一章节中,我们将学习Admin Client的相关知识。