[SpringBoot]知识点总结_springboot知识点总结

springboot

springboot优势：

• 快速搭建spring项目
• 纯java配置不需要xml配置，开箱即用很少的配置就可以搭建J2E项目
• 内嵌服务器可以快速部署

springboot基础配置

• spring-boot-parent配置在pom.xml中，主要做java默认版本编码格式默认资源过滤插件等配置，是可以不使用该，进行更改的
• @SpringBootApplicaton是一个由
  • @Configuration,配置类，
  • @EnableAutoCOnfiguration 开启自动化配置
  • @ConponentScan（完成包扫描），该注解默认扫描的类都位于当前类所在包下

Web容器配置

• SpringBoot项目添加spring-boot-starter-web后默认为tomcat作为容器，可以在application,propertise中配置服务器，端口，项目出错跳转路径
• 可以进行https配置
• 配置Jetty，Undertow等服务器

类型安全配置属性

• 无论是Properties还是YAML配置都会被加载到SpringEnvironment中，Spring提供了==@Value注解以及 EnvironmentAware 接口==，将SpringEnvironment中的数据注入到属性上
• Spring Boot 对此进一步提出了类型安全配置属性 ，即使在数据量非常庞大的情况下，也可以更加方便地将配置文件中 的数据注入 Bean

application.properties

将这一段配置数据注入Bean

• @ConfigurationProperties 中的 prefix 属性描述了要加载的配置文件的前缀
• 此类配置可能会乱码，需要对中文进行转码，只需再IDEA/Settings做简单配置即可

Properties配置（YML配置）

• 一些自定义的配置
• YAML 的使用非常简单，利用缩进 来表示层级关系，并且大小写敏感

Profile配置

通过类似@Profile注解等解决方案，可以避免项目在开发环境/测试环境/生产环境之间来回切换时频繁大量的修改代码

springboot整合视图层技术

虽然目前前后端分离是趋势，但是视图层技术还是有一定的意义

• thymelef
• freemarker

springboot整合web开发

Json数据

• spring-boot-starter-web默认添加了了 jackson-databind 作为 JSON 处理器，可以直接返回json
• 前后端数据的主流传输方式为json
• 注解@Responsebody可以返回json数据，频繁使用该注解时可以使用@RestController注解

静态资源访问

• springmvc中需要手动对静态资源进行过滤
• springboot提供了自动化配置

默认策略

• springboot默认会过滤所有的静态资源，共有五个位置(任意位置下都会规律)
  • ”classpath：/META-INF /resources
  • classpath：/resources
  • classpath：/static
  • classpath：/public
  • /
• 对于intellij可以将静态资源放在其默认创建出来的classpath：/static/目录下（一般都这样放置）
• springboot项目默认是不需要webapp目录的

classpath

• src 路径下的文件 在编译后都会放到 WEB-INF/classes 路径下。默认classpath 就是指这里
• 用maven构建 项目时，resources 目录就是默认的classpath

自定义策略

@ControllerAdvice

• @Controller增强版，主要用来处理全局数据，一般搭配@Exceptionhandler，@Modelattibute使用
• 最常用的使用场景就是全局异常处理，配合@Exceptionhandler定义全局异常捕获机制

• 添加＠ControllerAdvice 注解即可。当系 统启动时，该类就会被扫描到 Spring 容器中
• 后定义 uploadException 方法，在该方法上添加了 @ExceptionHandler注解，其中定义的 MaxUploadS izeExceededException. class 表明该方法用来处理 Max UploadSizeExceededException 类型的异常
• 方法的参数可以有异常实例、 HttpServletResponse 以 及 HttpServletRequest 、 Model 等
• 果想让该方法处理所有类型的异常，只需将 Max U ploadS izeExceededException 改为 Exception 即可

自定义错误页

• springboot可以用@ControllerAdvice做全局异常处理，但是这种异常处理机制只能处理应用级别的异常而无法处理容器级别的异常，比如filter抛出的异常
• springboot在用户访问出错时会有一个默认的页面返回给用户，可以进行自定义

CORS支持

• CORS跨域资源共享技术标准，支持多种HTTP请求（JSNOP只支持GET）

• 支持CORS的服务端在响应头中用Access-Control-Allow-Origin字段用来记录可访问该资源的域，浏览器会提取该字段该字段的值包含当前页面也在的域则不再对前段的跨域请求限制，这个流程只针对GET，POST，和HEAD请求且没自定义头

• 而复杂请求则会有两次请求，一次OPTIONS（用来判断真正请求是否可用）一次真正的请求，简单请求和复杂请求前端代码一致，额外处理均在后端完成

CORS简单请求实例

支持CORS浏览器请求

服务器支持CORS，响应格式为，主要是添加了Access-Control-Allow-Origin字段记录可以访问该资源的域（包含了当前页面所在的域）

CORS复杂请求实例

OPTIONS请求和处理

• DELETE为例，前端浏览器发起的DELETE请求会先发送一个OPTIONS请求，这个请求将向服务端询问是否具备该资源的 DELETE 权限
  

• 服务端给浏览器响应，Allow 头信息表示服务端支持的请求方法当浏览器分析了请求头宇段之后，知道服务端支持本次请求，则进入下一步

   HTTP/1.1 200 
   Access-Control-Allow- Origin: http://localhost:8081 
   Access-Control-Allow-Methods: DELETE 
   Access- Control-Max-Age: 1800 Allow: GET, HEAD, POST, PUT , DELETE, OPTIONS , PATCH 
   Content-Length : 0 Date: Thu, 12 Jul 2018 13 :20:26 GMT 
   ..
   .. 
  1
  2
  3
  4
  5
  6
  7

DELETE请求

浏览器就会发送一个跨域的 DELETE 请求

服务器响应

• 至此一个跨域的DELETE请求完成，简单复杂请求的前端代码都是一样的，额外处理实在服务端完成的
• 在传统的JavaEE 开发中，可以通过过滤器统一配置，而 Spring Boot 中对此则提 供了更加简洁的解决方案

SpringBoot跨域解决

• 在注解在方法上配置@CrossOrigin（value=“http：//localhost：8081”，maxAge=1800，allowHeaders=“*”）

  在注解在方法上的细粒度的控制

  • value表示支持的域
  • maxAge：探测请求有效期
  • allowHeaders表示允许的请求头

• 配置一个全局配置类

  • 自定类实现WebMvcConfig接口，再实现其中addCorsMappings方法

  • addCorsMappings

    • addMapping表示对哪种请求格式进行跨域处理
    • allowHeaders允许的请求头
    • allowedMethods允许的请求方法
    • allowedOrigins 支持的域

配置类与XML配置

• springboot推荐使用Java完成相关配置工作而不建议将配置放入配置类，而是根据不同需求设置不同配置类
• 在相关配置类上加上@Configuration注解，@ComponentScan会扫描所有的Spring组件包括@Configuration，@ComponentScan在项目的入口类的@SpringbootApplication注解已经提供
• springboot并不推荐使用xml配置，尽量用java代替

注册拦截器

• springMVC提供了AOP风格的拦截器是更细粒度的控制
• springboot项目中，自定义类实现HandlerInterceptor接口，实现其中的方法，preHandle，Controller，postHandle，afterCompletion，且这几个方法是优先级逐渐降低的

启动系统任务

• spring中一些在系统启动时需要执行的任务如配置文件的加载数据库的初始化等，可以配置Listener解决
• springboot提供了ConmandLineRunner和ApplicationRunner两种方案，两者基本只在参数上有所区别
• 使用方法上是自定义类实现CommandLineRunner并实现run（），springboot项目在启动时会遍历所有CommandLineRunner实现类病调用其中run（）方法，多个类之间可以用@Order进行排序

整合Servlet，Filter和Listener

这些基本web组件在spring springmvc整合后基本告别，springboot提供了几个注解能够对这几个组件进行标记

路径映射

• 一般情况下， 使用了页面模板后，用户需要通过控制器才能访问页面（有一些页面需要在控 制器中加载数据，然后渲染，才能显示出来）
• 对于在控制器中不需要加载数据，只是完成简单的跳转，可以直接配置路径映射，提高访问速度
  
• 如上配置完成后，就可以直接访问 http：／／localhost:8080/login 等地址

aop

• springboot提供了对aop的自动化配置解决方案
• 引入springboot-starter-aop依赖即可

其他

springboot项目启动后会默认找静态资源路径下的index.html找不到则会找动态的index文件作为首页文件3

Spring Boot 整合持久层技术

整合JdbcTemplate

• JdbcTemplate 是 Spring 提供的JDBC 模板框架，利用 AOP 技术来解决直接使用JDBC时 大量重复代码的问题
• JdbcTemplat巳 虽然没有 MyBatis 那么灵活，但是比直接使用 JDBC 要方便很多
• Spring Boot 中对 JdbcTemplate 的使用提供了自动化配置类 JdbcTemplateAutoConfiguration

整合MyBatis

• MyBatis 支持定制化 SQL、存储过程以及高级映射， MyBatis 几乎避免了所有的 JDBC 代码手动设置参数以及获取结果集
• 在传统的SSM框架整合中 ，使用MyBatis需要大量的XML配置，而在 Spring Boot 中， MyBatis 官方 提供了一套自动化配置方案，可以做到 MyBatis 开箱即用

创建项目

创建 Spring Boot 项目，添加 MyBatis 依赖、数据库驱动依赖以及数据库连接池依赖

创建数据库、表、实体类等

• 在项目的根包下面创建一个子包 Mapper， 在 Mapper 中创建 Book.Mapper
• 有两种方式指明该类是一个 Mapper
  • 第一种，在 Book.Mapper 上添加 @Mapper 注解， 表明该接口是一个 MyBatis 中的 Mapper，这种方式需要在每一个 Mapper 上 都添加注解
  • 在配置类上添加＠MapperScan（”org.sang.mapper"）引主解， 表示扫描 org.sang.mapper 包下的所有接口作为 Mapper

创建 BookMapper.xml()

• 在与 Boo刷apper 相同的位置创建 Book.Mapp巳r.xml 文件
• 
  可采用注解开发

创建 Service 和 Controller

配置 pom.xml 文件

• 在 Maven 工程中 ， XML 配置文件建议写在 resources 目录下

• 上文的 Mapper.xml 文件写 在包下， Maven 在运行时会忽略包下的 XML 文件，因此需要在 pom.xml 文件中重新指明资源文件位置

     <build>  
     	<resources> 
     		<resource>  <directory>src/main/j ava</ directory> 
     		 	<includes> 
     		 		<include>**/* .xml</include> 
     		 	</includes> 
     		 </resource> 
     	<resource>
     		<directory>src/main/resources</directory> 
     			</resource> 
     				</resources> 
     	</build> 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

整合SpringDataJPA

多数据源

• 多数据源，是指Java EE 项目中采用了不同数据库实例中的多个库，或者同一个数据库实例中多个不同的库
• 采用 MyCat 等分布式数据库中间件是比较好的解决方案，这 样可以把数据库读写分离、分库分表、备份等操作交给中间件去做， Java 代码只需要专注于业务
• 同样可以使用 Java 代码解决类似的问题， 在SpringFramework中就可以配 置多数据源， SpringBoot继承其衣钵，只不过配置方式有所变化

JdbcTemplate 多数据源

• JdbcTemplate 多数据源的配置是比较简单的， 因为一个 JdbcTemplate 对应一个 DataSource， 开 发者只需要手动提供多个 DataSource， 再手动配置 JdbcTemplate

Mybatis多数据源

JPA多数据源

Spring Boot 整合 NoSQL

NoSQL 是指非关系型数据库
- NoSQL 不使用 SQL 作为查询语言
- 其数据存储可以不需要固定的表格模式
- 一般都有水平可扩展性的特征
- 分类有 键值存储（Redis），列存储（HBase），文档型数据库（MongoDB）图形数据库（DEX）

整合 Redis

• Redis 是一个使用 C 编写的基于内存的 NoSQL 数据库
• Redis 由一个 Key/Value 映射的字典构成，Redis 中 Value 的类型不局限于字符串，还支持列表、集合、有序集合、散列等
• Redis 不仅可以当作缓存使用，也可以配置数据持久化后当作 NoSQL 数据库使用，目前支持两种持久化方式： 快照持久化和 AOF 持久化
• Redis 也可以搭建集群或者主从复制结构，在高并发环境下具有高可用性

整合SpringBoot

• 创建 Spring Boot 项目，添加依赖

spring-boot-starter-data-redis 使用的 Redis 工具是 Lettuce， 考虑到有的开发者习惯使用 Jedis，因此可以从 spring-boot-starter-data- redis 中排除 Lettuce 井引入 Jedis

• 配置 Redis ，在 Spring Boot 的自动配置类中提供了RedisAutoConfiguration 进行 Redis 的配置
  • 在 application.properties 中配置 Redis ,配置了数据库的ip，端口，密码，指定了使用那个库，redis.jedie.pool 数据库连接池最大连接数，最大空闲连接数，最小空闲连接数，最大阻塞等待时间（-1为没有限制）
  • 若使用了lettuce，将配置中的jedis更改就行
    
    

• 创建实体类

• 创建Controller测试
  

  • StringRedisTemplate 是 Redis Template 的子类， StringRedisTemplate 中的Key和 value 都是字符 串，采用的序列化方案是 StringRedisSerializer，而 RedisTemplate 则可以用来操作对象， RedisTemplate 采用的序列化方案是 JdkSerializationRedisSerializer。无论是 StringRedisTemplate 还是 RedisTemplate，操作 Redis 的方法都是一致的
  • StringRedisTemplate 和 RedisTemplate 都是==通过 opsForValue、 opsForZSet 或者 opsForSet ==等方法首先获取一个操作对象， 再使用该操作对象完成数据的读写
  • 第 10 行向 Redis 中存储一条记录，第 11 行将之读取出来。 第 18 行向 Redis 中存储一个对象， 第 19 行将之读取出
  • 在浏览器中输入 http://localhost:8080/test 1 ， 可看到控制打印日志
    

Redis集群整合SpringBoot

• 在 Redis 集群中，所有的 Redis 节点彼此互联，节点内部使用二进制协议优化传输速度和带宽。 当一个节点挂掉后， 集群中超过半数的节点检测失效时才认为该节点己失效（所以最少需要3个节点）
• Tomcat 集群 需要使用反向代理服务器，Redis 集群中的任意节点都可以直接和 Java 客户端连接
• redis集群内置了16834个哈希槽，存储时经过算法将每一个key分配在对应Redis节点，可以根据每隔Redis实例的性能调整每个Redis实例上哈希槽的分布范围

集群配置

• 在一台服务器上用不同端口表示不同的Redis服务器（伪分布式集群）

    主节点： 192.168.248.144:8001 , 192.168.248.144:8002, 192.168.248. 144:8003  
    从节点： 192.168.248.144:8004, 192.168.248.144:8005' 192.168.248.144:8006 
  1
  2

• Redis 集群管理工具 redis-trib.rb 依赖 Ruby 环境， 首先需要安装 Ruby 环境

• 创建redisCluster 文件夹，，将 Redis 压缩文件复制到 redisClustrr 文件 夹中之后编译安装，安装完后将 redis-4.0 .1 01 src 目录下的 redis-trib.rb 文件复制到 redisCluster 目录

• 在 redisCluster 目录下创建 6 个文件夹，分别命名为 8001 、 8002、 8003、 8004、 8005、 8006, 再将 redis-4.0.10 目录下的 redis.conf 文件分别往这 6 个目录中复制一份，然后对每个目录中的 redis.conf文件进行修改，

    主要配置
    port 8001 
    #bind 127 . 0.0.1 
    #开启集群
    cluster- enabled yes 
    #制定当前集群节点的配置文件
    cluster- config- file nodes- 8001.conf 
    protected no 
    daemonize yes 
    #开启密码认证
    requirepass 123@456
    #masterauth 配置，使得从机可以登录到主机上
    masterauth 123@456 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

• 启动6个Redis实例

    redis-server .. /8001/redis .conf 
    redis- server .. /8002/redis .conf 
    redis- server . . /8003/redis.conf 
    redis- server . . /8004/redis .conf 
    redis- server .. /8005/redis .conf 
    redis- server . . /8006/redis .conf
  1
  2
  3
  4
  5
  6

• 回到 redisCluster 目录下， 首先对 redis-trib.rb 文件进行修改， 由于配置了密码登录，而该命令在执行时默认没有密码，因此将登录不上各个 Redis 实例

  
  修改添加密码参数，123@456 就是之前设置的各个 Redis 实例的登录密码
  

• 创建集群

    . /redis- trib.rb create - replicas 1 192 .168 .248 .144 :8001 192 . 168.248 .144 :8002 192 .168 . 248 . 144 : 8003 192 .168 .248.144 :8004 192 .168 .248.144 :8005 192 .168 .248 .144 :8006 
     
      
     -  replicas 表示每个主节点的 slave 数量
     - 在集群的创建过程中会分配主机和从机， 每个集群在创建过程中都将分配到一个唯一的 id 井分配到一段 slot。
  1
  2
  3
  4
  5

  • 集群创建成功后，进入 redis-4.0.10 目录中， 登录任意 Redis 实例
    
    • -p表示要登陆的集群的端口（任一实例的端口）
    • -a表示要登陆的集群密码
    • -c表示以集群的方式登陆
    • 登陆成功后可以过 cluster info 命令可以查询集群状态信息，过 cluster nodes 命令 可以查询集群节点信息

添加主从节点

主节点

• 添加主节点

  • 随着业务的增长，有可能需要添加主节点，添加主节点需要先构建主节点实例
  • 将 redisCluster 目录下的 8001 目录再复制一份，名为 8007，修改该目录得先啊的redis.conf
  • 然后再redis-4.0.10 目录下运行如下命令启动该节点
    
  • 进入 redisCluster 目录下，执行如下命令将该节点添加到集群中 （中间的参数是要添加的 Redis 实例地址，最后的参数是集群中的实例，添加成功后，登录任意 一个 Redis 实例，查看集群节点信息，就可以看到该实例己经被添加进集群）
  • 新实例虽然添加进集群，但是slot已经被之前实例分完，新实例没有slot则无法存储数据，从另外三个实例中拿出一部分slot分配给新实例
    • 在 redisCluster 目录下执行如下命令对 slot 重新分配（第二个参数表示连接集群中的任意一个实例）
      
    • 在命令执行过程中手动配置三个核心设置
    1. 配置是要拿出多少个 slot 分配给新实例，本案例分配1000个
    2. 把拿出来的 1000 个 slot 分配给谁，输入接收这 1000 个 slot 的 Redis 实例的 id，这个 id 在节点添加成功后就可以看到， 也可以进入集群控制台后利用 cluster nodes 命令查看
    3. 这 1000 个 slot 由l哪个实例出， 例如从端口为 8001 的实例中拿出 1000 个 slot 分 配给端口为 8007 的实例，那么这里输入 8001 的 id 后按回车键， 再输入 done 接回车键即可，如果 想将 1000 个 slot 均摊到原有的所有实例中，那么这里输入 all 按回车键即可

从节点

• 将 redisCluster 目录下的 8001 目录复制一份，命名为 8008，修改8008 目录下的 redis.conf，启动该实例，输入如下命令添加从节点

- 添加从节点需要指定该从节点的 masterid, --master-id 后面的参数即表示该从节点 master 的 id, 
	
- 192.168.248.144:8008 表示从节点的地址，192.168.248.144:8001 则表示集群中任意一个实例的地址。
- 当从节点添加成功后，登录集群中任意一个 Redis 实例， 通过 cluster nodes 命令就可以看到从节点 的信息
1
2
3
4

整合Springboot

Redis 集群整合 Spring Boot 需要开发者手动配置

添加依赖

<dependency> 
	<groupid>org . springframework. boot</ group Id> 
	<artifactid>spring-boot- starter- web</artifactid> 
</dependency> 
<dependency> 
	<groupid>redis . clients</ group Id>
		<artifactid>jedis</artifactid> 
< dependency> 
<dependency>
	<groupid>org . springframework.data</groupid>  
	<artifactid>spring- data- redis</artifactid>  
</dependency> 
<dependency>  
	<groupid> apache.commons</groupid> 
	<artifactid>commons- pool2</artifactid>
</dependency> 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 注意客户端使用了jedis，要添加相关依赖

配置集群信息

由于集群节点有多个，可以保存在一个集合中，因此这里的配置文件使用 YAML 格式的

• 由于本案例 Redis 实例的 host 都是一样的，因此这里配置了一个 host，而 port此 配置成了一个 集合，这些 port 将被注入一个集合中
• poolConfig 则是基本的连接池信息配置

配置Redis

创建 RedisConfig， 完成对 Redis 的配置

• 通过==＠CorrfigurationProperties ==注解声明配直文件前缀， 配直文件中定义的 ports 数组、 host 以 及连接池配直信息都将被注入po此、 host、 poolConf1g 三个属性中
• 配直 RedisClusterConfiguration 实例，设直 Redis 登录密码以及 Redis 节点信息
• 根据 RedisClusterConfiguration 实例以及连接池配置信息创建 Jedis链接工厂JedisConnectionFactory.
• 根据 JedisConnectionF actory 创建 RedisTemplate 和 StringRedisTemplate，同时配直 key 和 value 的序列化方式。 有了 RedisTemplate 和 StringRedisTemplate，剩下的用法就和单实例的用法一致

MongoDB整合SpringBoot

Session 共享

• 一般 HttpSession 是通过 Serviet 容器创建并进行管理的，创建成功之后都是保存在内存中，需要对项目进行横向扩展搭建集群，可以利用一些硬件或者软件工具来做负载均衡，此时， 来自同一用户的 HTTP 请求就有可能被分发到不同的实例上去需要保证各个实例之间Session的同步
• Spring Boot 提供了=自动化的 Session 共享配置==， 结合 Redis 方便解决问题
• 使用 Redis 解决 Session 共享：把原本存储在不同服务器上的 Session 拿出来放在一个独立的服务器
• 当一个请求到达Nginx 服务器后， 首先进行请求分发，无论哪个真实服务器处理请求， 都去操作 Session 服务器而不是操作自身内存中的Session即可以实现 Session 共享了
  

Session共享配置

• SpringBoot中的Session共享配置非常容易，创建SpringBootWeb项目，添加 Redis 和 Session依赖
  • 除了redis还要提供 spring-session-data-redis 依赖， SpringSession 可以做到透明化地替换掉应用的Session 容器
    
• application.properties 中进行 Redis 基本连 接信息配置

• 创建Controller测试

  • save 接口用来向 Session 中存储数据，get 接口用来从 Session 中获取数据， 这里注入了项目启动的端口号 server.port， 主要是为了区分到底是哪个服务器提供的服务

  • 另外虽然还是操作的 HttpSession，但是实际上 HttpSession 容器已经被透明替换， 真正的Session此时存储在 Redis 服务器上

      @RestController 
      public class HelloController{ 
      @Value （ ”$｛ server.port ｝ ” ） 
      String port; 
      @PostMapping (” / save” ) 
      public String saveName (String name , HttpSession session) { 
      session . setAttribute (” name ”, name) ; 
      return port; 
      }
       @GetMapping (” / get" ) 
       public String getName(HttpSession session) { 
       	return port + ” :”+ session .getAttribute("name” ) . toString (); 
      	}
      }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

• 将项目打成jar 包上传到 CentOS 上。执行如下两条命令启动项目
  

  • nohup 表示不挂断程序运行，即当终端窗口关闭后，程序依然在后台运行，最后的==＆表示让程序在后台运行==
  • 一server.port此表示设置启动端口，一个为 8080，另一个为 8081 启动成功后，接下来就可以配置负载均衡器了

Nginx负载均衡

• Nginx 做负载均衡，Nginx 启动成功后，默认端口是 80，可以在物理机直接访问
• 配置nginx.conf
  
  重启nginx：／usr/local/nginx/sbin/nginx s reload
• 测试： 启动所有服务器和Nginx，Postman进行测试
• 
• 

思考

本人做过app的前后端开发，在这次开发过程中童同样做了服务器集群，但是并未考虑跨域问题，其实会话共享的原因是跨域问题，而跨域问题是浏览器行为（浏览器同源策略：浏览器脚本只能加载相同ip端口的静态资源）

构建RESTful服务

• REST (Representational State Transfer）是一种 Web 软件架构风格，不是标 准，匹配或兼容这种架构风格的网络服务称为REST服务
• REST 服务简洁并且有层次，REST通常基于HTTP、 URI 和 XML 以及 HTML 这些现有的广泛流行的协议和标准
• 在 REST 中资源是由URI来指定的，对资源的增删改查操作可以通过 HTTP 协议提供的GET、POST、PUT、DELETE 等方法实现
• 使用 REST可以更高效地利用缓存来提高响应速度， 同时 REST 中客户端维持通话状态这可以让不同的服务器处理一系列请求中的不同请求，进而提高服务器的扩展性
• 在前后端分离项目中， 一个设计良好的 Web 软件架构必然要满足 REST 风格

在Spring MVC 框架中，开发者可以通过＠RestController 注解开发一个RESTful 服务， Spring Boot 对此提供了自动化配置方案，开发者只需要添加相关依赖 Spring Data Rest 就能快速构建一个REST服务

开发者工具和测试工具

devtools

• SpringBoot中提供了一组开发工具 spring-boot-devtools，可以提高开发者的工作效率， 开发者可以将该模块包含在任何项目中 ， spring-boot-devtools 最方便的地方莫过于热部署了

• 要想在项目中加入 devtools 模块， 只需添加相关依赖

     <dependency> 
     	<groupid>org. springfrarnework. boot</ group Id> 
     	<artifactid>spring boot-devtools</artifactid> <optional>true</optional> 
     </dependency> 
  1
  2
  3
  4

• 当开发者将 spring-boot-devtools 引入项目后，只要 classpath 路径下的文件发生了变化，项目就会自动重启 这极大地提高了项目的开发速度
• 开发如果使用了IntelliJ IDEA，默认情况下， 需要开发者手动编译才会触发重启。手动编译时＼ 单击 Build→Build Project 菜单或者按 Ctrl+F9 快捷键进 行编译，编译成功后就会触发项目重启 ，使用 IntelliJ IDEA 的开发者也可以配置项目自动编译

单元测试

• 遇到需要测试的地方都是创建一个Controller进行测试，这样操作脚肿， 效率低下
• 在 Spring Boot 中使用单元测试可以实现对每一个环节的代码进行测试
• Spring Boot中的单元测试与 Spring中的测试一脉相承， 但是又做了大量的简化，只需要少量的代码就能搭建一个测试环境，进而实现对 Controller、 Service 或者 Dao 层的代码进行测试

搭建项目

使用 IntelliJ IDEA 或者在线创建一个 Spring Boot 项目时，创建成功后， 默认都添加 了 spring-boot-starter-test 依赖，井且创建好了测试类

• 使用 ＠RunWith i主解，该注解将Junit执行类改为 SpringRunner，而 SpringRunner 是 Spring Framework 中测试类 SpringJUnit4ClassRunner 的别名
• @Spring BootTest 注解除了提供 Spring TestContext 中 的常规测试功能之外，还提供了其他特性：提供默认的 ContextLoader、自动搜索＠Spring BootConfiguration、自定义环境属性、为 不同的 webEnvironment模式提供支持
• 在 Spring 测试中，开发者一般使用 ＠ContextConfiguration(classes = ）或者 @ContextConfiguration(locations ＝）来指定要加载的 Spring 配直，而在 Spring Boot 中， Spring Boot 中的 ＠Test主解将会去包含测试类的包下查找带有＠Spring BootApplication 或者＠Spring BootConfiguration 注解的主配配类
• @Test 注解来自 junit, junit 中的＠After、＠AfterClass、 ＠Before、 ＠B巳foreClass、 ＠Ignore 等注解一样可以在这里使用

Service测试

Service 层的测试就是常规测试

对 HelloServic巳进行测试， 直接在测试类中注入 HelloService

使用 Assert 判断测试结果是否正确

断言机制

Controller 测试

• Controller 测试则要使用到 Mock 测试，即对一些不易获取的对象采用虚拟的对象来创建进而方便测试

• Spring 中提供的MockMvc则提供了对 HTTP 请求的模拟，使开发者能够在不依赖网络环境的情况下实现对 Controller 的快速测试

   @RestController 
   	public class HelloController { 
   		@GetMapping (” / hello") 
   		public String hello(String name) { 
   		return "Hello ” + name + ”!”; 
   		@PostMapping (” / book”) 
   		public Strinq addBook(@RequestBody Book book) {
   		return book. toString ();
   		} 
   	}
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

Controller 中涉及的实体类 Book

• 对这个 Controller 进行测试，就需要借助 Mockmvc
  
  
  
• 除了 MockMvc 这种测试方式之外， Spring Boot 还专门提供了 TestRestTemplate 用来实现集成 测试

JSON 测试

• 开发者可以使用==＠JsonTest 测试 JSON 序列化和反序列化是否工作正常==
• 该注解将自动配置 Jackson ObectMapper、＠JsonComponent 以及 Jackson Modules。如果开发者使用 Gson 代替 Jackson, 该注解将配置 Gson代替Jackson, 该注解将配置 Gson

Spring Boot 缓存

• Spring 3.1 中开始对缓存提供支持， 核心思路是对方法的缓存， 当开发者调用一个方法时，将方法的参数和返回值作为 key/value缓存起来，当再次调用该方法时，如果缓存中有数据，就直接从缓存中获取，否则再去执行该方法
• Spring 中并未提供缓存的实现，而是提供了一套缓存 API，开发者可以自由选择缓存的实现
• 目前常用的缓存实现 Ehcache 2.x 和 Redis, Spring 早己将缓存领域统一，缓存实现的实现只是不同的只是缓存配置，开发者使用的缓存注解是一致的（Spring 缓存注解和各种缓存实现的关系就像 JDBC 和各种数据库驱动的关系一样）
• 用Reids实现单机缓存和集群缓存

Spring Boot 安全管理

• Java 开发领域常见 的安全框架有 Shiro 和 Spring Security
• Shiro 是一个轻量级的安全管理框架，提供了认证、授权、 会话管理、密码管理、缓存管理等功能
• Spring Security 是一个相对复杂的安全管理框架，功能比 Shiro 更加强大，权限控制细粒度更高，对 OAuth 2 的支持也更友好，又因为 Spring Security 源自 Spring 家族，因此可以和 Spring 框架无缝整合，特别是 Spring Boot 中提供的自动化配置方案，可以让SpringSecurity的使用更加便捷

Spring Security

Spring Boot针对SpringSecurity提供了自动化配置方案，因此可以使 Spring Security 非常容易地整合进 Spring Boot 项目中

基于数据库的认证

项目开发中，用户的基本信息以及角色等都存储在数据库中，需要从数据库中获取数据进行认证

设计数据表

设计一个基本的用户角色表，一共三张表，分别是用户表、角色表 以及用户角色关联表

创建项目

创建 Spring Boot Web 项目添加如下依赖

配置数据库

创建实体类

• 用户实体类需要实现 UserDetails 接口，并实现该接口中的 7 个方法
  

• 用户根据实际情况设直这 7 个方法的返回值， 因为默认情况下不需要开发者自己进行密码角色等信息的比对，只需要提供相关信息，例如 getPasswordO方法返回的密码和用 户输入的登录密码不匹配，会自动抛出 BadCredentialsException 异常， isAccountNonExpiredO 方法返回了 false，会自动抛出 AccountExpiredException 异常，开发者只需要按照数据库中数据在这里返回相应的配置即可，本案例因为数据库中只有 enabled 和 locked 字段，故账户未过期和密码未过期两个方法都返回 true.

• getAuthoritiesO方法用来获取当前用户所具有的角色信息，本案例中，用户所具有的角色存储 在 roles 属性中，因此该方法直接遍历 roles 属性，然后构造 SimpleGrantedAuthority 集合并返回

创建 UserService

• 定义 UserService 实现 UserDetailsService 接口，并==实现该接口中的 loadUserByUsername ==方法， 该方法的参数就是用户登录时输入的用户名，通过用户名去数据库中查找用户，如果没有查找到用户，就抛出一个账户不存在的异常
• 如果查找到了用户，就继续查找该用户所具有的角色信息，并将获取到的 user 对象返回，再由系统提供的DaoAuthenticationProvider 类去比对密码是否正确
• loadUserByUsername 方法将在用户登录时自动调用
• 相关的 UserMapper 和 UserMapper.xml
  

配置 Spring Security

基于内存配置

创建项目，添加依赖

• 创建一个 Spring Boot Web 项目，然后添加 spring-boot-starter-security 依赖即可
• 只要开发者在项目中添加了 spring-boot-starter-security 依赖，项目中所有资源都会被保护起来

• 添加 hello 接口测试
  
• 启动项目测试
  来启动项目，启动成功后，访问/hello 接口会自动跳转到登录页面（SS提供），默认的用户名是 user，默认的登录密码则在每次启动项目时随机生成， 查看项目启动日志，从项目启动日志中可以看到默认的登录密码，登录成功后，用户就可以访问“/hello”接口了
  

配置用户名和密码

• 如果开发者对默认的用户名和密码不满意，可以在 application.properties 中配置默认的用户名、 密码以及用户角色
• 当开发者在 application.properties 中配置了默认的用户名和密码后，再次启动项目，项目启动日志就不会打印出随机生成的密码了，用户可直接使用配置好的用户名和密码登录，登录成功后， 用户还具有一个角色一admin

基于内存的认证

• 自定义类继承WebSecurityConfigurerAdapter，进而实现对 Spring Security 更多的自定义配置，例如基于内存的认证
  
• 自定义 MyWebSecurityConfig 继承自 WebSecurityConfigurerAdapter ，并重写 configure(AuthenticationManagerBuilder auth）方法，在该方法中配直两个用户，一个用户名是admin，密码 123，具备两个角色 ADMIN 和 USER； 另一个用户名是 sang，密码是 123，具 备一个角色 USER
• 本案例使用 的 Spring Security 版本是 5.0.6，在 Spring Security 5.x 中引入了 多种密码加密方式， 开发者必须指定一种， 本案例使用 NoOpPasswordEncoder，即不对密码进行加密
• 配置完成后，重启 Spring Boot 项目，就可以使用这里配置的两个用户进行登录了
  

HttpSecurity

• 目前可实现认证功能，但是受保护的资源都是默认的，也不能根据实际情况进行角色管理

• 如果要实现这些功能，就需要重写 WebSecurityConfigurerAdapter 中的另一个方法
  
  

• 配置了三个用户， root 用户具备 ADMIN 和 DBA 的角色， admin 用户具备 ADMIN 和 USER 的角色， sang 用户具备USER 的角色

• authorizeRequestsO方法开启 HttpSecurity 的配直

  • 用户 访问“／admin/＊＊”模式的 URL 必须具备 ADMIN 的角色
    
    
  • 用户访问“／user/＊＊”模式的 URL 必须具备 AD孔1IN 或 USER 的角色
    
  • 用户访问“／db／＊＊”模式的 URL 必须具备 ADMIN和 DBA 的角色
    
  • 除了前面定义的 URL 模式之外，用户访问其他的 URL 都必须认证后访问 （登录后访问）
    
  • 开启表单登录（用户一开始看到的登录界面配置了登录接口为/login，即直接调用/login接口发起一个post请求登录，登录参数中用户 名必须命名为 usemame，密码必须命名为 password，配置 loginProcessingUrl 接口主要是方便Ajax或移动端调用登录接口 。最后还配置了 permitAll，表示和登录相关的接口都不需要认证即可访问）
    

• 关闭csrf

• 调试

登录表单详细配置

• 目前登录表单一直使用 Spring Security 提供的页面，登录成功后也是默认的页面跳转

• 前后端分离正在成为企业级应用开发的主流，在前后端分离的开发方式中，前后端的数据交互通过JSON，进行登录成功后不是页面跳转了，而是一段 JSON提示，要实现这些功能， 只需要继续完善上文的配置
  
  

• 配直了loginPage，即登录页面，配直了 loginPage 后，如果用户未获授权就访问一个需要授权才能访问的接口，就会自动跳转到 login_page 页面让用户登录，这个 login_page 就是开发者自定义的登录页面，而不再是 Spring Security 提供的默认登录页
  

• 配置了 loginProcessingUrl，表示登录请求处理接口，无论是自定义登录页面还是移动端登录，都需要使用该接口

• 

• 定义了认证所需的用户名和密码的参数名，默认用户名参数是 usemame，密码参 数是 password，可以在这里自定义

• 定义了登录成功的处理逻辑，用户登录成功后可以跳转到某一个页面，也可以返回一段 JSON，这个要看具体业务逻辑，本案例假设是第二种，用户登录成功后，返回一段 登录成功的 JSON， onAuthenticationSuccess 方法的第三个参数一般用来获取当前登录用户的信息，在登录成功后， 可以获取当前登录用户的信息一起返回给客户端

• 定义了登录失败的处理逻辑，和登录成功类似，不同的是，登录失败的回调方法 里有一个 AuthenticationException 参数，通过这个异常参数可以获取登录失败的原因，进而给用户一个明确的提示
  
  

• 配置完成后，使用 Postman 进行登录测试
  

注销登录配置

想要注销登录， 也只需要提供简单的配置即可

• 开启注销登陆的配置

• 配置注销登陆请求URL为”URL“，默认是”/logout“

• 是否清除身份认证信息，默认为 true， 表示清除

• 是否使 Session 失效，默认为住ue

• 配直一个 LogoutHandler，开发者可以在 LogoutHandler 中完成一些数据清除工作，例 如 Cookie 的清除。 Spring Security 提供了一些常见的实现

• 配置一个 LogoutSuccessHandler， 开发者可以在这里处理注销成功后的业务逻辑， 例 如返回一段JSON提示或者跳转到登录页面等

多HttpSecurity

如果业务比较复杂，开发者也可以配置多个 HttpSecurity， 实现对 WebSecurityConfigurerAdapter 的多次扩展

密码加密

• 密码加密一般会用到散列函数（散列算法，哈希函数）（常用的散列函数有 MD5 消息摘要算法、安全散列算法 (Secure Hash Algorithm）)

• 使用散列函数还不够，为了增加密码的安全性，一般在密码加密过程中还需要加盐(随机数)

  • 加盐之后，即使密码明文相同的用户生成的密码， 密文也不相同，这可以极大地提高密码的安全性

• Spring Security 提供了多种密码加密方案，官方推荐使用 BCryptPasswordEncoder, BCryptPasswordEncoder 使用 BCrypt 强哈希函数，开发者在使用时可以选 择提供由ength 和 SecureRandom 实例。 strength 越大，密钥的迭代次数越多，密钥i是代次数为 2"strength。 strength 取值在 4～31 之间，默认为 10

使用

• 要修改上文配置的 PasswordEncoder 这个 Bean 的实现即可
• 创建 BCryptPasswordEncoder 时传入的参数 10 就是 strength，即密钥的迭代次数（也可以不配 置，默认为 10）。同时，配置的内存用户的密码也不再是 123 了
  
• 一般情况下，用户信息是存储在数据库中的，因此需要在用户注册时对密码进行加密处理，用户将密码从前端传来之后， 通过调用 BCryptPasswordEncoder 实例中的 encode 方法对密码 进行加密处理，加密完成后将密文存入数据库。

方法安全

• 目前的认证与授权都是基于 URL 的，开发者也可以通过注解来灵活地配置方法安全
• 要使用相关注解，首先要通过＠EnableGloba!MethodSecurity 注解开启基于注解的安全配置
  
• 测试
  
• @Secured(”ROLE_ AD MIN＂）注解表示访问该方法需要 ADMIN 角色，注意这里需要在角色前 力口一个前缀“ROLE ’
• @PreAuthorize（”hasRole（’ADMIN’） and hasRole('DBA＇）”）注解表示访问该方法既需妥 ADMIN 角色又需要 DBA 角色
• @PreAuthorize("hasAnyRole（’ADMIN’,‘DBA’,'USER’）”）表示访问该方法需要 ADMIN、 DBA 或 USER 角色
• @PreAuthorize 和＠PostAuthorize 中都可以使用基于表达式的语法

在 Controller 中注入 Service 井调用 Service 中的方法进行测试，这里比较简单，读者可 以自行测试。

动态权限认证

OAuth 2

• OAuth 是一个开放标准，该标准允许用户让第三方应用访问该用户在某一网站上存储的私 资源（如头像、照片、视频等〉，而在这个过程中==无须将用户名和密码提供给第三方应用 ==
• 这 一功能是通过提供一个令牌token
• 采用令牌的方式可以让用户灵活地对第三方应用授权或者收回权限
• 传统的 Web 开发登录认证一般都是基于 Session ，在前后端分离的架构中继续使用 Session 会有许多不便，因为移动端（Android、iOS、 微信小程序等）要么不支持 Cookie（微信小程序〉，要么使用非常不便，OAuth 2 认证都能解决

Spring Boot 整合 Shiro

• Apache Shiro 是一个开源的轻量级的Java安全框架，它提供身份验证、 授权、密码管理以及 会话管理等功能
• 相对于 Spring Security，Shiro 框架更加直观、易用，同时也能提供健壮的安全性
• 在传统的 SSM 框架中，手动整合 Shiro 的配置步骤还是比较多的，针对 Spring Boot, Shiro 官方提供了== shiro-spring-boot-web-starter== 用来简化 Shiiro

创建项目

• 先创建一个普通的SpringBootWeb 项目，添加 Shiro 依赖以及页面模板
  

• 不需要添加 spring-boot-starter-web 依赖， shiro-spring-boot-web-starter 中已经依赖了 spring-boot-starter-web

• 本案例使用 Thymeleaf 模版，因此添加 Thymeleaf 依赖，另外，为 了在 Thymeleaf 中使用 shiro 标签，因此引入了 thymeleaf-extra-shiro 依赖

Shiro 基本配置

• application.properties 中配置 Shiro 的基本信息
  
  

• 在 Java 代码中配置 Shiro，提供两个最基本的 Bean 即可
  

  • 这里提供两个关键Bean，一个是Realm，另一个是ShiroFilterChainDefinition. 至于 ShiroDialect, 则是为了支持在 Thymeleaf 中使用 Shiro 标签，如果不在 Thymeleaf 中使用 Shiro 标签，那么 可以不提供 ShiroDialect.
  • Realm 可以是自定义 Realm，也可以是 Shiro 提供的 Ream， 简单起见，本案例没有配直数据库连接，这里直接配直了两个用户： sang/123 和 admin/123，分别对应角色 user 和 admin, user 具有 read 权限， admin 则具有 read， write 权限
  • ShiroFilterChainDefinition Bean 中配直了基本的过滤规则，“／login”和“／doLogin”可以匿名 访问，“logout”是一个注销登录请求，其余请求则都需要认证后才能访问

• 配置登录接口以及页面的访问接口
  

  • 在 doLogin方法中，首先构造一个 UsemamePasswordToken 实例，然后获取一个 Subject对象 并调用该对象中的 login 方法执行登录操作
  • 在登录操作执行过程中，当有异常抛出时，说 明登录失败，携带错误信息返回登录视图；当登录成功时，重定向到“／index".
  • 暴露两个接口“／admin”和“／user”，对于“／admin”接口，需要具有 admin 角色才可 以访问；对于“／user”接口，具备 admin 角色和 user 角色其中任意一个即可访问

• 对于其他不需要角色就能访问的接口，直接在 WebMvc 中配置即可

• 来创建全局异常处理器进行全局异常处理， 本案例主要是处理授权异常
  
  • 当用户访问未授权的资源时－，跳转到 unauthorized 视图中，井携带出错信息

测试

在 resources/templates 目录下创建 5 个 HTML 页面进行测试

• 在 Spring Boot 中整合 Shiro ，在 Thymeleaf 中使用 Shiro 标签

Spring Boot 整合 WebSocket

• 在 HTTP 协议中，所有的请求都是由客户端发起的，由服务端进行响应，服务端无法向客户端推送消息，在一些需要即时通信的应用中，又不可避免地需要服务端向客户端推送消息，传 统的解决方案主要有如下几种：

  • 轮询

    • 客户端在固定的时间间隔下不停地向服务端发送请求，查看服务端是否有最新的数据，若服务端有最新的数据，则返回给客户端，若服务端没 有，则返回一个空的 JSON 或者 XML 文档
    • 轮询对开发人员而言实现方便， 客户端每次都要新建 HTTP 请求，服务端要处理大量的无效请求，在高并发场景下会严重拖慢服务端的运行效率，同时服务端的资源被极大的浪费

  • 长轮询

    • 长轮询是传统轮询的升级版，服务端有在服务端有最新数据的时候才会立即响应客户端的请求，否则服务端会持有这个请求而不返回， 直到有新数据时才返回， 这种方式可以在一定程度上节省网络资源和服务器资源，但是也存在一些 问题
    • 长轮询并不能一直持续， 如果浏览器在服务器响应之前有新数据要发送，就只能创建一个新的并发请求，或者先尝试 断掉当前请求，再创建新的请求

  • Applet 和 Flash

WebSocket

• 是一种在单个 TCP 连接上进行全双工通信的协议，已被 W3C 定为标准
• 使用 WebSocket 可以使得客户端和服务器之间的数据交换变得更加简单它允许服务端主动向客户端推送数据
• 在 WebSocket 协议中，浏览器和服务器只需要完成一次握手，两者之间就可以直接创建持久性的连接，并进行双向数据传输

消息服务

• 消息队列（Message Queue）是一种进程间或者线程间的异步通信方式，使用消息队列，消息生产者在产生消息后，会将消息保存在消息队列中，直到消息消费者来取走它，即消息的发送者和接收者不需要同时与消息队列交互
• 使用消息队列可以有效实现服务的解耦，并提高系统的可靠性 以及可扩展性，目前，开源的消息队列服务非常多，如 Apache ActiveMQ、 RabbitMQ 等，这些产品也就是常说的消息中间件

JMS

• JMS CJava Message Service） Java 消息服务，它通过统一 JAVA API 层面的标准，使得多 个客户端可以通过 JMS 进行交互， 大部分消息中间件提供商都对 JMS 提供支持
• JMS 和 ActiveMQ 的关系就象 JDBC 和 JDBC 驱动的关系。
• JMS 包括两种消息模型：点对点和发布者／订阅者，同时 JMS 仅支持 Java 平台

AMQP

• AMQP (Advanced Message Queuing Protocol，高级消息队列协议）是一个线路层的协议规范， 而不是 API 规范（例如 JMS）

• 由于 AMQP 是一个线路层协议规范，因此它天然就是跨平台的， 就像 SMTP、 HTTP 等协议一样，只要开发者按照规范的格式发送数据，任何平台都可以通过 AMQP 进行消息交互。像目前流行的 StormMQ、 RabbitMQ 等都实现了 AMQP

• JMS 从 API 的层面对消息中间件进行了统一， JMS 不支持跨平台，

• AMQP 从协议层面来统一，而 AMQP 天然地具备跨平台功能。 AMQP 支持的消息模型也更加丰富

企业开发

邮件发送

• 邮件发送是一个非常常见的功能，注册时的身份认证、 重要通知发送等都会用到邮件发送
• Sun 公司提供了 JavaMail 用来实现邮件发送，但是配置烦琐， Spring 中提供了 JavaMai!Sender 用来简化邮件配置
• SpringBoot 则提供了 MailSenderAutoConfiguration 对邮件的发送做了进一步简化

定时任务

• 简单的定时任务可以直接通过 Spring 中的＠Scheduled 注解来实 现
• 复杂的定时任务则可以通过集成 Quartz 来实现

批处理

• Spring Batch 是一个开源的、全面的、轻量级的批处理框架，通过 Spring Batch 可以实现强大的批处理应用程序的开发

Swagger2

在前后端分离开发中，为了减少与其他团队的沟通成本，一般构建一份RESTful API 文档来描述所有的接口信息，但是这种做法有很大的弊端

• 接口众多，编写阻STful API 文档工作量巨大(RESTful API 文档不仅要包含接口的基本信息，如接口地址、接口请求参数以及接口返回值等，还要包含 HπP 请求类型、 Hπp 请求头、请求参数类型、返回值类型、所需权限等 )
• 维护不方便，一旦接口发生变化，就要修改文档
• 接口测试不方便，一般只能借助第三方工具（如 Postman ）来测试

Swagger 2

开源软件框架，可以帮助开发人员设计、构建、记录和使用RESTful Web 服务，它将代码和文档融为一体，可以完美解决上面描述的问题，使开发人员将大部分精力集中到业务中，而不是繁杂琐碎的文档中

数据校验

• 为了提高系统运行效率，都会在前端进行数据校验，但后端同样需要数据校验，因为用户还是可能在获取数据接口后手 动传入非法数据
• Spring Boot 对此也提供了相关的自动化配置解决方案
  

应用监控

项目构建与部署

Spring Boot 项目可以内嵌 Serviet 容器， 因此它的部署变得极为方便，可以直接打成可执行 JAR 包部署在有 Java 运行环境的服务器上，也可以像传统的 Java Web 应用程序那样打成 WAR 包运行

JAR

项目打包

• spring-boot-maven-plugin 插件可以创建一个可执行的 JAR 应用程序， parent 为 spring-boot-starter-parent

   <build> 
   	<plug ins> 
   		<plug in> 
   			<groupid>org.springframework.boot</groupid> 
   			<artifactid>spring-boot-maven-plugin</artifactid> 
   		</plugi n> </plugins> 
    </build> 
  1
  2
  3
  4
  5
  6
  7

• 配置完成后，在当前项目的根目录下执行如下 Maven 命令进行打包：

    mvn package 
  1

• IntelliJ IDEA 中单击 Maven Project，找到 Lifecycle 中的 package 双击打包

• 打包成功后，在当前项目的根目录下找到 target 目录， target 目录中就有刚刚打成的 JAR 包

• 对于parent不是 springboot-starter-parent，需要额外配置

项目运行

• Windows 中的运行比较容易，直接进入 target 目录中执行如下命令即可启动项目

    	java - jar jar-0.0.1-SNAPSHOT. jar
  1

• Linux 上运行 Spring Boot 项目需要确保 Linux 上安装了 Java 运行环境

  	java - jar jar-0.0.1-SNAPSHOT. jar
  1

• 由于在生产环境中， Linux 大多数情况下都是远程服务器， 开发者通过远程工具连接 Linux，如果使用上面的命令启动 JAR， 一旦窗口关闭， JAR 也 就停止运行了，因此一般通过如下命令启动 JAR

    nohup	java - jar jar-0.0.1-SNAPSHOT. jar &
      -  nohup， 表示当窗口关闭时服务不挂起，继续在后台运行的
      - ＆表示让项目在后台运行（信息不打印在控制台）
  1
  2
  3

WAR

SpringBoot与Spring比较

整合web上

• sb是纯注解开发，sp需要大量xml注解

跨域支持

• SB可以在浏览器请求的后端方法上加上CrossOrigin注解或者自定义类实现WebMvcConfig接口并重写addCorsMappping添加支持的域允许的请求头等
• SP是通过配置过滤器统一配置

拦截器

• SB自定义类实现HandlerInterceptor接口重写其中的方法如preHanle，postHandler等
• SP 提供的是AOP风格的拦截器拥有更加精细的拦截处理能力

启动系统任务

• SB可以通过实现CommandLineRunner调用其中run方法实现
• SP需要配置监听器Listener