第一章 SpringBoot基础入门笔记

你的名字 2023-06-16 02:25 45阅读 0赞

# **一、SpringBoot简介**  #

## **1、SpringBoot基础介绍**  ##

Spring Boot使开发独立的，产品级别的基于Spring的应用变得非常简单，你只需"just run"。我们为Spring平台及第三方库提供开箱即用的设置，这样你就可以有条不紊地开始。多数Spring Boot应用需要很少的Spring配置。你可以使用Spring Boot创建Java应用，并使用java -jar启动它或采用传统的war部署方式。

### **1.1、解决的问题** ###

*  依赖太多了，且存在版本问题。
 *  配置太多了且每次都一样，大部分工程配置每次都是一样的，从一个地方拷贝到另外一个地方；且Spring发展10多年，各种配置版本太多，对于很多程序员来说分不清哪个是有效、哪个无效。
 *  部署太麻烦，需要tomcat部署，项目结构也需要照着Java EE的目录结构来写。

### **1.2、SpringBoot特点** ###

*  创建独立的Spring应用程序
 *  嵌入的Tomcat，无需部署WAR文件
 *  简化Maven配置
 *  自动配置Spring
 *  提供生产就绪型功能，如指标，健康检查和外部配置
 *  绝对没有代码生成和对XML没有要求配置

### **1.3、SpringBoot功能** ###

**自动配置(auto-configuration)：**

一项简化配置的功能，比如在classpath中发现有spring security的jar包，则自动创建相关的bean等。

**starters(简化依赖)：**

这个比较关键，方便spring去集成各类组件，比如redis、mongodb等等。

## **2、系统要求** ##

默认情况下，目前使用SpringBoot 2.2.1最新版本，最好安装JDK8以及以上的版本，maven使用3.3或者以上的版本。

## **3、第一个SpringBoot项目** ##

新建一个普通maven项目，创建pom文件：

<**parent**>  
  <**groupId**>org.springframework.boot</**groupId**>  
  <**artifactId**>spring-boot-starter-parent</**artifactId**>  
  <**version**>2.2.1.RELEASE</**version**>  
</**parent**>

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

### **3.1、编写代码：** ###

为了完成应用程序，我们需要创建一个单独的Java文件，Maven默认会编译src/main/java下的源码。

新建：com.chj.Example.java

@RestController  
@EnableAutoConfiguration  
**public class** Example \{   
    @RequestMapping(**"/"**)  
    String home() \{   
        **return** **"Hello World!"**;  
    \}  
    **public static void** main(String\[\] args) **throws** Exception \{   
        SpringApplication.*run*(Example.**class**, args);  
    \}  
\}

### **3.2、@RestController和@RequestMapping说明** ###

**1）****@RestController****：**这被称为一个构造型（stereotype）注解，它为阅读代码的人们提供建议。对于Spring该类扮演了一个特殊角色，在本示例中，我们的类是一个web @Controller，所以当处理进来的web请求时，Spring会询问它。

**RestController****源码如下：**

@Target(\{ElementType.TYPE\})  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
@Controller  
@ResponseBody  
**public** @**interface** RestController \{   
    @AliasFor(  
        annotation = Controller.**class**  
**    **)  
    String value() **default** **""**;  
\}

**2）****@RequestMapping注解提供路由信息****：**它告诉Spring任何来自"/"路径的HTTP请求都应该被映射到home方法，@RestController注解告诉Spring以字符串的形式渲染结果，并直接返回给调用者。

@Target(\{ElementType.METHOD, ElementType.TYPE\})  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
@Mapping  
**public** @**interface** RequestMapping \{   
    String name() **default** **""**;  
    @AliasFor(**"path"**)  
    String\[\] value() **default** \{\};  
    @AliasFor(**"value"**)  
    String\[\] path() **default** \{\};  
    RequestMethod\[\] method() **default** \{\};  
    String\[\] params() **default** \{\};  
    String\[\] headers() **default** \{\};  
    String\[\] consumes() **default** \{\};  
    String\[\] produces() **default** \{\};  
\}

**3）****@EnableAutoConfiguration****：**这个注解告诉Spring Boot根据添加的jar依赖猜测你想如何配置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC，所以auto-configuration将假定你正在开发一个web应用并相应地对Spring进行设置。

@Target(\{ElementType.TYPE\})  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
@Inherited  
@AutoConfigurationPackage  
@Import(\{AutoConfigurationImportSelector.**class**\})  
**public** @**interface** EnableAutoConfiguration \{   
    String ENABLED\_OVERRIDE\_PROPERTY = **"spring.boot.enableautoconfiguration"**;  
    Class<?>\[\] exclude() **default** \{\};  
    String\[\] excludeName() **default** \{\};  
\}

**4）****main方法****：**这只是一个标准的方法，它遵循Java对于一个应用程序入口点的约定。我们的main方法通过调用run，将业务委托给了Spring Boot的SpringApplication类。SpringApplication将引导我们的应用，启动Spring，相应地启动被自动配置的Tomcat web服务器；我们需要将Example.class作为参数传递给run方法来告诉SpringApplication谁是主要的Spring组件。

**public static** ConfigurableApplicationContext run(Class<?> primarySource, String... args) \{   
    **return** run(**new** Class\[\]\{primarySource\}, args);  
\}

执行main方法，使用一个浏览器打开 localhost:8080，以下输出：Hello World!

## **4、注意事项** ##

Spring Boot不需要使用任何特殊的代码结构，然而这里有一些地方需要注意。

### **4.1、使用"default"包** ###

当类没有包含package声明时，它被认为处于default package下，通常不推荐使用default package，并应该避免使用它；因为对于使用@ComponentScan，@EntityScan或@SpringBootApplication注解的Spring Boot应用来说，来自每个jar的类都会被读取，这会造成一定的问题。

### **4.2、定位main应用类** ###

通常建议你将main应用类放在位于其他类上面的根包（root package）中，通常使用@EnableAutoConfiguration注解你的main类，并且暗地里为某些项定义了一个基础“search package”。例如，如果你正在编写一个JPA应用，被@EnableAutoConfiguration注解的类所在包将被用来搜索@Entity项。

使用根包允许你使用@ComponentScan注解而不需要定义一个basePackage属性，如果main类位于根包中，你也可以使用@SpringBootApplication注解。

# **二、SpringBoot快速入门** #

## **1、spring-boot-starter-parent使用** ##

可以继承spring-boot-starter-parent项目来获取合适的默认设置，想配置你的项目继承spring-boot-starter-parent只需要简单地设置parent为：

<**parent**>  
    <**groupId**>org.springframework.boot</**groupId**>  
    <**artifactId**>spring-boot-starter-parent</**artifactId**>  
    <**version**>2.2.1.RELEASE</**version**>  
</**parent**>

**备注****：**

你应该只需要在该依赖上指定Spring Boot版本，如果导入其他的starters，你可以放心的省略版本号。

**使用没有父POM的Spring Boot****：**

不是每个人都喜欢继承spring-boot-starter-parent POM，你可能需要使用公司标准parent，或你可能倾向于显式声明所有Maven配置。如果你不使用spring-boot-starter-parent，通过使用一个scope=import的依赖，你仍能获取到依赖管理的好处：

<**dependencyManagement**>  
  <**dependencies**>  
    <**dependency**>  
      <**groupId**>org.springframework.boot</**groupId**>  
      <**artifactId**>spring-boot-dependencies</**artifactId**>  
      <**version**>2.2.1.RELEASE</**version**>  
      <**type**>pom</**type**>  
      <**scope**>import</**scope**>  
    </**dependency**>  
  </**dependencies**>  
</**dependencyManagement**>

## **2、搭建springboot环境** ##

**2.1、新建App.java**

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

**2.2、新建Controller：**

@RestController  
**public class** UserController \{   
    @RequestMapping(**"/hello"**)  
    **public** Object sayHello() \{   
        **return** **"hello"**;  
    \}  
\}

运行App，在浏览器输入：localhost:8080/hello，发现“hello”说明第一步部署成功。

## **3、集成mybatis** ##

[https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter/1.3.5][https_mvnrepository.com_artifact_org.mybatis.spring.boot_mybatis-spring-boot-starter_1.3.5]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70][]

<**dependency**>  
    <**groupId**>org.mybatis.spring.boot</**groupId**>  
    <**artifactId**>mybatis-spring-boot-starter</**artifactId**>  
    <**version**>1.3.5</**version**>  
</**dependency**>  
<**dependency**>  
    <**groupId**>mysql</**groupId**>  
    <**artifactId**>mysql-connector-java</**artifactId**>  
</**dependency**>

### **3.1、生成mapper** ###

在resources目录，新建application.properties文件，增加内容如下

@ConfigurationProperties( prefix = **"spring.datasource"**)  
**public class** DataSourceProperties **implements** BeanClassLoaderAware, InitializingBean \{

特别注意：driverClassName与driver-class-name在不同的springboot版本中是不一样的

*\#数据库相关配置*  
**spring.datasource.name**=**mysql**  
**spring.datasource.driverClassName**=**com.mysql.jdbc.Driver**  
**spring.datasource.url**=**jdbc:mysql://localhost:3306/mybatis?serverTimezone=GMT%2B8**  
**spring.datasource.username**=**root**  
**spring.datasource.password**=**root**

配置mybatis映射文件：mybatis.mapperLocations=classpath:mapping/\*.xml

@ConfigurationProperties(prefix = **"mybatis"**)  
**public class** MybatisProperties \{   
    **public static final** String MYBATIS\_PREFIX = **"mybatis"**;  
    **private** String configLocation;  
    **private** String\[\] mapperLocations;  
    **private** String typeAliasesPackage;

准备mybatis的生成文件generatorConfig.xml，并在相应目录创建好entity、dao、mapping文件夹，右键生成对应的文件。

注意：得再App启动类上增加@MapperScan扫描注解

@SpringBootApplication  
@MapperScan("com.chj.dao")  
**public class** App \{   
    **public static void** main( String\[\] args ) \{   
        SpringApplication.*run*(App.**class**, args);  
    \}  
\}

### **3.2、新增mapper登陆方法** ###

dao接口类增加接口：

TUser findUserByNamePasswd(@Param(**"userName"**) String **userName**, @Param(**"**password **"**) String password );

对应的XML配置：

<**select** **id****="findUserByNamePasswd"** **resultType****="com.chj.entity.TUser"** **parameterType****="map"**>  
  select  
  <**include** **refid****="Base\_Column\_List"** />  
  from t\_user where 1=1  
  <**if** **test****="password != null"** >  
    and password = \#\{password,jdbcType=VARCHAR\}  
  </**if**>  
  <**if** **test****="userName != null"** >  
    and user\_name = \#\{userName,jdbcType=VARCHAR\}  
  </**if**>  
  limit 1  
</**select**>

## **4、SpringBoot单元测试** ##

要测试刚才新增的Mapper方法是否成功，这里需要单元测试，在springboot中是有专门的组件来做单元测试的，在pom文件中新增依赖。

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

新建UserTest放置在test目录下：

@SpringBootTest(classes = \{App.**class**\})  
@RunWith(SpringRunner.**class**)  
**public class** UserTest \{   
    @Resource  
    **private** TUserMapper **tUserMapper**;  
    @Test  
    **public void** testAdd() \{   
        TUser user = **new** TUser() ;  
        user.setUserName(**"hankin"**);  
        user.setPassword(**"123456"**);  
        **tUserMapper**.insert(user);  
    \}  
\}

这样SpringBoot集成单元测试成功！

### **特别注意：springboot配置问题整理** ###

## **1、问题1：** ##

Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured.

//无法配置数据库，没有指定url属性，并且无法配置embedded datasource

Reason: Failed to determine a suitable driver class

//原因：无法明确指定正确的驱动类（driver.class）:

Action:

Consider the following:  //建议：

//如果如果需要加载嵌入式的数据库，请将他放入路径中

If you want an embedded database (H2, HSQL or Derby), please put it on the classpath.

//如果有数据库设置需要从指定配置文件中加载，需要调用该配置文件（目前没有活动的配置文件）

If you have database settings to be loaded from a particular profile you may need to activate it (no profiles are currently active).

### **问题分析：** ###

通过比较两个项目结构，和修改的文件，会发现只因为有pom文件的修改导致项目中增加的mysql、redis、es、mongodb的依赖包的导入，需要添加新的database配置文件，可能因为springboot的启动会自动加载这些依赖启动时候需要的以来文件。

**结果：报错的原因是因为导入的两个依赖**

经过排查根据网上各种尝试发现还是没能解决问题，最终新建一个springboot项目，然后依次加入各种配置发现可以正常启动！！！

## **2、问题2** ##

数据库连接配置时区问题，因为springboot2以后需要加时区，否则报错如下所示：

java.sql.SQLException: The server time zone value 'ÖÐ¹ú±ê×¼Ê±¼ä' is unrecognized or represents more than one time zone. You must configure either the server or JDBC driver (via the serverTimezone configuration property) to use a more specifc time zone value if you want to utilize time zone support.

注意添加：serverTimezone=GMT%2B8

**spring.datasource.url**=**jdbc:mysql://localhost:3306/mybatis?serverTimezone=GMT%2B8**

### **4.1、新建service** ###

**新增接口UserService：**

**public interface** UserService \{   
    **boolean** login(String username,String password);  
    **boolean** register(String username,String password);  
\}

**创建实现类：**

@Service  
**public class** UserServiceImpl **implements** UserService \{   
    @Resource  
    **private** TUserMapper **usersMapper**;  
    @Override  
    **public boolean** login(String username, String passwd) \{   
        TUser users = **usersMapper**.findUserByNamePasswd(username, passwd);  
        **return** users != **null**;  
    \}  
    @Override  
    **public boolean** register(String username, String passwd) \{   
        TUser users = **new** TUser();  
        users.setUserName(username);  
        users.setPassword(passwd);  
        **int** cnt = **usersMapper**.insert(users);  
        **return** cnt > 0;  
    \}  
\}

### **4.2、修改controller** ###

修改UserController,增加login和register方法

@RestController  
**public class** UserController \{   
    @Resource  
    **private** UserService **userService**;  
    @RequestMapping(**"/hello"**)  
    **public** Object sayHello() \{   
        **return** **"hello"**;  
    \}  
    @RequestMapping(**"/login"**)  
    **public** String login(String username,String passwd) \{   
        **boolean** login = **userService**.login(username, passwd);  
        **if**(login) \{   
            **return** **"登陆成功"**;  
        \}**else** \{   
            **return  ****"登陆失败"**;  
        \}  
    \}  
    @RequestMapping(**"/register"**)  
    **public** String register(String username,String passwd) \{   
        **boolean** login = **userService**.register(username, passwd);  
        **if**(login) \{   
            **return** **"注册成功"**;  
        \}**else** \{   
            **return  ****"注册失败"**;  
        \}  
    \}  
\}

在浏览器上输入：[localhost:8080/register?username=hankin&passwd=123456，显示“注册成功”][localhost_8080_register_username_hankin_passwd_123456]。

在浏览器上输入：localhost:8080/login?username=hankin&passwd=123456，显示“登陆成功”。

## **5、事务支持** ##

修改UserService接口，增加一个新增batchAdd方法，在UserServiceImpl增加相应实现类，在实现类中故意产生一个被0整除得异常。

@Override  
**public void** batchAdd(String username, String passwd) \{   
    User user = **new** User();  
    user.setUserName(username);  
    user.setPassword(passwd);  
    **usersMapper**.insertSelective(user);  
    **int** i = 10 /0;  
    user = **new** User();  
    user.setUserName(username+**"2"**);  
    user.setPassword(passwd);  
    **usersMapper**.insertSelective(user);  
\}

**修改UserContoller增加batchAdd方法：**

@RequestMapping(**"/batchAdd"**)  
**public** String batchAdd(String username,String passwd) \{   
    **userService**.batchAdd(username, passwd);  
    **return** **"成功"**;  
\}

重新运行，在浏览器上输入：

localhost:8080/batchAdd?username=chj&passwd=123456，可以发现在浏览器上出现500错误。

检查数据库，发现表里面已经产生了一个错误的数据，产生了事务问题。

**事务支持：**

在batchAdd方法上增加@Transactional注解，重启服务后，在浏览器上输入：

localhost:8080/batchAdd?username=chj&passwd=123456

浏览器还继续报错，但检查数据库，事务问题已经得到了解决

## **6、全局异常处理** ##

通过上面步骤，虽然已经解决了事务问题，但界面上出现这500错误，这对用户来说还是不友好；一般在企业里面对这些异常一般都会统一捕获，由一个专门的异常处理类来统一处理。

### **6.1、异常捕获** ###

@ControllerAdvice  
**public class** GlobalExceptionHandler \{   
    @ExceptionHandler(value = RuntimeException.**class**)  
    @ResponseBody  
    **public** Object defaultErrorHandler(HttpServletRequest req, Exception e) **throws** Exception \{   
        e.printStackTrace();  
        **return** **"我是个异常处理类"**;  
    \}  
\}

重启服务后，在浏览器重新访问会出现异常的服务，界面返回：

![20191123215816973.png][]

### **6.2、404页面处理** ###

在浏览器上故意输错地址：[localhost:8080/batchAddx?username=enjoy&passwd=123，后端并没有这服务，虽然已经做了相关的异常捕获][localhost_8080_batchAddx_username_enjoy_passwd_123]，但浏览器还是显示了404错误，这个时候就要做404处理了（其他异常代码一样）。

1）在配置这样错误页面的时候，以前是在WEB.XML中进行配置，而在这里，需要有个WebServerFactoryCustomizer的实例进行配置，在前面建立的GlobalExceptionHandler，新建一个方法：

@Bean  
**public** WebServerFactoryCustomizer<ConfigurableWebServerFactory> webServerFactoryCustomizer()\{   
    **return** (factory->\{   
        ErrorPage error404Page = **new** ErrorPage(HttpStatus.***NOT\_FOUND***, **"/404.do"**);  
        factory.addErrorPages( error404Page);  
    \});  
\}

**2）新建BaseController：**

@RestController  
**public class** BaseController \{   
    @RequestMapping(**"/404.do"**)  
    **public** Object error\_404() \{   
        **return** **"你要找的页面，就是我！"**;  
    \}  
\}

**3）重启服务，在浏览器上输入：**

localhost:8080/batchAddx?username=enjoy&passwd=123，此时页面返回“你要找的页面，就是我！”。

**注意：**

WebServerFactoryCustomizer这种配置方式是在SpringBoot2之后才这样配置的，在1.X的版本需要用到的是EmbeddedServletContainerCustomizer。

**代码如下：**

@Bean  
**public** EmbeddedServletContainerCustomizer containerCustomizer() \{   
    **return** (container -> \{   
        ErrorPage error404Page = **new** ErrorPage(HttpStatus.***NOT\_FOUND***, **"/404.do"**);  
        container.addErrorPages( error404Page);  
    \});  
\}

## **7、静态资源访问** ##

**静态资源：**js、css、html、图片、音视频等。

**静态资源路径：**是指系统可以直接访问的路径，且路径下的所有文件均可被用户直接读取。

Spring Boot默认提供静态资源目录位置需置于classpath下，目录名需符合如下规则：

/static

/public

/resources

/META-INF/resources

在resources目录下面建立static文件夹，在文件夹里面任意放张图片，命名为：image.png，在地址栏上输入localhost:8080/image.png，可以看到图片。

# **三、前端界面访问** #

## **1、JSP集成** ##

一般来说springboot不建议直接使用jsp页面，但不排除有些公司的项目依然使用jsp做前端界面。springboot内置的tomcat并没有集成对jsp的支持，也没有对EL表达式的支持，因此要使用jsp应该先把相关的依赖集成进来

### **1.1、在pom文件里面新增** ###

**  
<**dependency**>  
    <**groupId**>javax.servlet</**groupId**>  
    <**artifactId**>jstl</**artifactId**>  
</**dependency**>  
**  
<**dependency**>  
    <**groupId**>org.apache.tomcat.embed</**groupId**>  
    <**artifactId**>tomcat-embed-jasper</**artifactId**>  
</**dependency**>

### **1.2、配置视图解析器** ###

由于要springmvc解析jsp，要配置视图解析器，在applicaiton.properties 里面新增：

*\# jsp视图解析器*  
**spring.mvc.view.prefix**=**/WEB-INF/jsp/**  
**spring.mvc.view.suffix**=**.jsp**

在resources里面新建WEB-INF文件夹，在里面放一个index.jsp页面。

最后新建一个controller，注意这里的注解是**@Controller**，千万不能用@RestController

@Controller  
@RequestMapping(**"/jsp"**)  
**public class** JspController \{   
    @RequestMapping(**"/hello"**)  
    **public** String sayHello() \{   
        **return** **"index"**;  
    \}  
\}

在浏览器上输入：localhost:8080/jsp/hello，可以看到JSP页面。

## **2、模板引擎** ##

SpringBoot推荐使用模板引擎来渲染html，如果你不是历史遗留项目，一定不要使用JSP，常用的模板引擎很多，有freemark、thymeleaf等，其实都大同小异，其中springboot强烈推荐的是用thymeleaf。

**1）pom文件种添加thymeleaf的支持，并且删除JSP的支持：**

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

**2）删除application.properties文件里面视图解析器内容：**

\#spring.mvc.view.prefix=/WEB-INF/jsp/

\#spring.mvc.view.suffix=.jsp

**3）新建Controller代码如下：**

*   *@Controller  
   @RequestMapping(**"/test"**)  
   **public class** ThymeleafController \{   
       *// ModelMap = LinkedHashMap<String, Object>*  
*   **   ** *@RequestMapping(**"/testThymeleaf"**)  
       **public** String testThymeleaf(ModelMap map) \{   
           *// 设置属性*  
*       **   ** *map.addAttribute(**"name"**, **"hankin"**);  
          *// testThymeleaf：为模板文件的名称*  
*        **   **// 对应src/main/resources/templates/testThymeleaf.html*  
*        **   ***return** **"testThymeleaf"**;  
      \}  
   \}

注意：Springboot默认的模板配置路径为：src/main/resources/templates

**4）在resources目录里面新建一个****templates****目录，在目录里面新建testThymeleaf.html文件**

<body>

</body>

在浏览器上输入：localhost:8080/tpl/testThymeleaf，可以看到页面。

# **四、集成Swagger2构建API文档** #

## **1、Swagger2 的作用** ##

*  随项目自动生成强大RESTful API文档，减少工作量
 *  API文档与代码整合在一起，便于同步更新API说明
 *  页面测试功能来调试每个RESTful API

## **2、添加swagger2的相关依赖** ##

**  
<**dependency**>  
    <**groupId**>io.springfox</**groupId**>  
    <**artifactId**>springfox-swagger2</**artifactId**>  
    <**version**>2.7.0</**version**>  
</**dependency**>  
<**dependency**>  
    <**groupId**>io.springfox</**groupId**>  
    <**artifactId**>springfox-swagger-ui</**artifactId**>  
    <**version**>2.7.0</**version**>  
</**dependency**>

## **3、新建一个swagger的配置类** ##

@Configuration  
@EnableSwagger2  
**public class** SwaggerConfig \{   
    @Bean  
    **public** Docket createRestApi() \{   
        **return new** Docket(DocumentationType.***SWAGGER\_2***)  
                .apiInfo(apiInfo())  
                .select()  
                .apis(RequestHandlerSelectors.basePackage("com.chj")) //TODO 指定扫描包下面的注解  
*                *.paths(PathSelectors.*any*())  
                .build();  
    \}  
    *// 创建api的基本信息*  
*    ***private** ApiInfo apiInfo() \{   
        **return new** ApiInfoBuilder()  
                .title(**"集成Swagger2构建RESTful APIs"**)  
                .description(**"集成Swagger2构建RESTful APIs"**)  
                .termsOfServiceUrl(**"https://blog.csdn.net/m0\_37661458"**)  
                .contact(**new** Contact(**"hankin"**,**"blog.csdn.net"**,**"1032291008@qq.com"**))  
                .version(**"1.0.0"**)  
                .build();  
    \}  
\}

## **4、新建Controller用于显示相关接口** ##

@RestController

@RequestMapping(value="/swagger")  
**public class** SwaggerController \{   
    @ApiOperation(value=**"获取用户信息"**, notes=**"根据id来获取用户详细信息"**)  
    @ApiImplicitParam(name=**"id"**, value=**"用户ID"**, required=**true**, dataType=**"String"**)  
    @RequestMapping(value=**"/\{id\}"**, method= RequestMethod.***GET***)  
    **public** Map<String,String> getInfo(@PathVariable String id) \{   
        Map<String ,String> map = **new** HashMap<String, String>();  
        map.put(**"name"**, **"zacker"**);  
        map.put(**"age"**, **"32"**);  
        **return** map;  
    \}  
\}

访问：[http://localhost:8080/swagger-ui.html][http_localhost_8080_swagger-ui.html]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1][]

# **五、日志集成** #

java有许多的日志组件，比如log4j、log4j2、logback还有java自生提供的Java Util Logging，其实在springboot中对这些组件都提供了支持，log4j、log4j2和logback都提供相应的组件支持。

## **1、Logback日志实现** ##

**在springboot中默认使用的日志工具是logback，**不过在提及具体的日志工具之前要提一个名词，这个名词就是slf4j(Simple Logging Facade For Java)。slf4j不是具体的日志解决方案，它有点类似于jdbc，使用了门面模式，是一个针对各类日志的抽象实现，既然是抽象的日志实现，在springboot中不需要额外引入。

注意：spring-boot-starter中就提供了对spring-boot-starter-logging的依赖

在spring-boot-starter-logging中可以看到以及集成了slf4j与具体实现logback的默认支持：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2][]

**修改UserController**

**import org.slf4j.Logger;**

**import org.slf4j.LoggerFactory;**

**private final** Logger **logger** = LoggerFactory.*getLogger*(UserController.**class**);

@RequestMapping(**"/hello"**)  
**public** Object sayHello() \{   
    **logger**.info(**"这是个hello的info日志!"**);  
    **logger**.debug(**"这是个hello的debug日志!!"**);  
    **return** **"hello"**;  
\}

在浏览器上输入：localhost:8080/hello，可以看控制台日志的输出：这是个hello的info日志!。

### **1.1、日志级别** ###

修改controller 把日志的输出改成：logger.debug("这是个hello的debug日志!!")，这个时候重启再调用，发现后台并不会有任何输出，这原因是日志级别在作祟。默认情况下Spring Boot配置的是INFO日志级别，也就是会输出INFO级别以上的日志(ERROR、WARN、NFO)。

如果需要Debug 级别的日志，在 src/main/resources/application.properties中配置debug=true，此外配置logging.level.\* 来具体输出哪些包的日志级别。

**例如：**

*\#  日志级别配置*  
**logging.level.root**=**INFO**  
**logging.level.org.springframework.web**=**DEBUG**  
**logging.level.com.chj.controller**=**DEBUG**

这个时候，包括springframework.web以及com.chj.controller的info\\debug日志都可以输出来了。

### **1.2、日志文件** ###

一般情况下，springboot日志只会输出到控制台，并不会写入到日志文件，但是在一些正式环境的应用中，我们需要通过在application.properties文件中配置logging.file文件名称和logging.path文件路径，将日志输出到日志文件中。

*\# 日志输出*  
**logging.path** = **D:****\\\\****tmp****\\\\****testlog**  
**logging.file** = **test.log**

**注意：**

如果只配置logging.path，在/var/tmp文件夹生成一个日志文件为spring.log；如果只配置logging.file，会在项目的当前路径下生成一个xxx.log日志文件。这里有一个坑，logging.path和logging.file都配置了，只会有logging.file生效，所以如果要指定日志生成的具体位置使用logging.file配置就好。

在application.properties中配置：logging.file =F:\\\\log\\\\testlog，这样在F盘的相应位置出现日志文件。

## **2、log4j2方式实现** ##

在spring-boot-dependencies POM中搜索spring-boot-starter-log4j2，发现Spring boot父Pom中自己提供了这个依赖，于是我们加入如下jar依赖：

**修改pom.xml文件：**

**  
<**dependency**>  
    <**groupId**>org.springframework.boot</**groupId**>  
    <**artifactId**>spring-boot-starter-web</**artifactId**>  
    <**exclusions**>  
        <**exclusion**>  
            <**groupId**>org.springframework.boot</**groupId**>  
            <**artifactId**>spring-boot-starter-logging</**artifactId**>  
        </**exclusion**>  
    </**exclusions**>  
</**dependency**>  
<**dependency**>  
    <**groupId**>org.springframework.boot</**groupId**>  
    <**artifactId**>spring-boot-starter-log4j2</**artifactId**>  
</**dependency**>

**注意:**

由于默认使用logback在扩展log4j2之前先要把logback移除，日志使用跟上面logback一样。

## **3、log4j方式实现** ##

如果不只为了学习集成log4j，在工作是最好不要使用log4j，毕竟有了log4j2，也有了logback使用log4j就是吃饱了撑着。在springboot中并没有提供对log4j这个依赖的支持，因此要使用它配置起来还是挺麻烦的。在mvnrepository.com 中发现log4j最新版本spring-boot-starter-log4j是1.3.8.RELEASE。

修改pom.xml文件：

<**dependency**>  
        <**groupId**>org.springframework.boot</**groupId**>  
        <**artifactId**>spring-boot-starter-web</**artifactId**>  
        <**exclusions**>  
            <**exclusion**>  
                <**groupId**>org.springframework.boot</**groupId**>  
                <**artifactId**>spring-boot-starter-logging</**artifactId**>  
            </**exclusion**>  
        </**exclusions**>  
    </**dependency**>  
    <**dependency**>  
        <**groupId**>org.springframework.boot</**groupId**>  
        <**artifactId**>spring-boot-starter-log4j</**artifactId**>  
        <**version**>1.3.8.RELEASE</**version**>  
    </**dependency**>

**在classpath下增加****log4j.properties****文件：**

**log4j.rootCategory**=**INFO, stdout, file, errorfile**  
**log4j.category.****com****.****chj**=**INFO, myFile**  
**log4j.logger.error**=**errorfile**  
*\# 控制台输出*  
**log4j.appender.stdout**=**org.apache.log4j.ConsoleAppender**  
**log4j.appender.stdout.layout**=**org.apache.log4j.PatternLayout**  
**log4j.appender.stdout.layout.ConversionPattern**=**%d\{yyyy-MM-dd HH:mm:ss,SSS\} %5p %c\{1\}:%L - %m%n**  
*\# root日志输出*  
**log4j.appender.file**=**org.apache.log4j.DailyRollingFileAppender**  
**log4j.appender.file.file**=**logs/all.log**  
**log4j.appender.file.DatePattern**=**'.'yyyy-MM-dd**  
**log4j.appender.file.layout**=**org.apache.log4j.PatternLayout**  
**log4j.appender.file.layout.ConversionPattern**=**%d\{yyyy-MM-dd HH:mm:ss,SSS\} %5p %c\{1\}:%L - %m%n**  
*\# error日志输出*  
**log4j.appender.errorfile**=**org.apache.log4j.DailyRollingFileAppender**  
**log4j.appender.errorfile.file**=**logs/error.log**  
**log4j.appender.errorfile.DatePattern**=**'.'yyyy-MM-dd**  
**log4j.appender.errorfile.Threshold** = **ERROR**  
**log4j.appender.errorfile.layout**=**org.apache.log4j.PatternLayout**  
**log4j.appender.errorfile.layout.ConversionPattern**=**%d\{yyyy-MM-dd HH:mm:ss,SSS\} %5p %c\{1\}:%L - %m%n**  
*\#* *com.chj**下的日志输出*  
**log4j.appender.myFile**=**org.apache.log4j.DailyRollingFileAppender**  
**log4j.appender.myFile.file**=**logs/my.log**  
**log4j.appender.myFile.DatePattern**=**'.'yyyy-MM-dd**  
**log4j.appender.myFile.layout**=**org.apache.log4j.PatternLayout**  
**log4j.appender.myFile.layout.ConversionPattern**=**%d\{yyyy-MM-dd HH:mm:ss,SSS\} %5p %c\{1\}:%L ---- %m%n**

**在代码中使用**：

import org.apache.log4j.Logger;

private final Logger logger = Logger.getLogger(xxx.class);

## **4、使用AOP统一日志处理** ##

为了防止在工作中经常在代码中加入大量的日志处理代码，在实际项目开发中，一般使用AOP统一完成日志处理工作，修改pom文件引入springboot对aop的支持：

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

**新增AOP日志处理类：**

@Aspect  
@Component  
**public class** WebLogAspect \{   
    **private static final** Logger ***logger*** = LoggerFactory.*getLogger*(WebLogAspect.**class**);  
    @Pointcut(**"execution(public \* com.chj.controller.\*.\*(..))"**)  
    **public void** webLog() \{   
    \}  
    @Before(**"webLog()"**)  
    **public void** doBefore(JoinPoint joinPoint) **throws** Throwable \{   
        *// 接收到请求，记录请求内容*  
*        *ServletRequestAttributes attributes = (ServletRequestAttributes)

RequestContextHolder.*getRequestAttributes*();  
        HttpServletRequest request = attributes.getRequest();  
        *// 记录下请求内容*  
*        ****logger***.info(**"URL : "** \+ request.getRequestURL().toString());  
        ***logger***.info(**"HTTP\_METHOD : "** \+ request.getMethod());  
        ***logger***.info(**"IP : "** \+ request.getRemoteAddr());  
        Enumeration<String> enu = request.getParameterNames();  
        **while** (enu.hasMoreElements()) \{   
            String name = (String) enu.nextElement();  
            ***logger***.info(**"name:\{\},value:\{\}"**, name, request.getParameter(name));  
        \}  
    \}  
    @AfterReturning(returning = **"ret"**, pointcut = **"webLog()"**)  
    **public void** doAfterReturning(Object ret) **throws** Throwable \{   
        *// 处理完请求，返回内容*  
*        ****logger***.info(**"RESPONSE : "** \+ ret);  
    \}  
\}

启动访问接口hello，日志打印结果如下：

URL : http://localhost:8080/hello

IP : 0:0:0:0:0:0:0:1

这是个hello的info日志!

这是个hello的debug日志!!

RESPONSE : hello

# **六、Spring Boot热加载/部署** #

热部署不会用在生产环境，但对于程序员开发的效率，还是有一定帮助的，所谓的热部署，就是在应用程序在不停止的情况下，实现新的部署。

spring-boot-devtools是一个为开发者服务的一个模块，其中最重要的功能就是自动应用代码更改到最新的App上面去。原理是在发现代码有更改之后，重新启动应用，但是速度比手动停止后再启动还要更快，更快指的不是节省出来的手工操作的时间。

其深层原理是使用了**两个ClassLoader**，一个Classloader加载那些不会改变的类（第三方Jar包），另一个ClassLoader加载会更改的类，称为restart ClassLoader，这样在有代码更改的时候，原来的restart ClassLoader被丢弃，重新创建一个restart ClassLoader，由于需要加载的类相比较少，所以实现了较快的重启时间。

**修改pom文件增加引用：**

**  
<**dependency**>  
    <**groupId**>org.springframework.boot</**groupId**>  
    <**artifactId**>spring-boot-devtools</**artifactId**>  
</**dependency**>

**修改properties文件：**

如果使用的Thymeleaf模板，那么请直接在application.properties中添加：spring.thymeleaf.cache=false

如果使用的FreeMarker模板，那么请直接在application.properties中添加：spring.freemarker.cache=false

## **1、IDEA中使用** ##

如果你是使用eclipse请忽略，但如果你是使IDEA，由于idea没有保存修改的，也就是说在idea中并不会因为你ctrl+s就重新编译代码。那么就需要额外的配置，在pom文件中增加编译插件，让代码有变动的时候也编译：

<**plugin**>  
    <**groupId**>org.springframework.boot</**groupId**>  
    <**artifactId**>spring-boot-maven-plugin</**artifactId**>  
    <**configuration**>  
        **  
*        *<**fork**>true</**fork**>  
    </**configuration**>  
</**plugin**>

### **1.1、手动：** ###

修改完代码，按快捷键Ctrl+F9，手动构建项目，或者只修改单个类文件的话，按Ctrl+Shift+F9，重新编译该类文件，即可触发重启服务。

### **1.2、自动** ###

1）File -> Settings -> Compiler，勾选 Build Project automatically

2）按快捷键Ctrl+Shift+Alt+/，选择1.Registry...

3）勾选 compiler.automake.allow.when.app.running 即可

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3][]

这个时候修改JAVA文件或者模板文件都自动会生效。

## **2、编译，打包** ##

快速入门进行到这里，其实已经差不多了，能应对绝大多数开发常见，接下来就是导包部署。

**在pom文件中新增：**

**  
<**plugin**>  
    <**groupId**>org.apache.maven.plugins</**groupId**>  
    <**artifactId**>maven-compiler-plugin</**artifactId**>  
    <**configuration**>  
        <**source**>1.8</**source**>  
        <**target**>1.8</**target**>  
    </**configuration**>  
</**plugin**>  
<**plugin**>  
    <**groupId**>org.springframework.boot</**groupId**>  
    <**artifactId**>spring-boot-maven-plugin</**artifactId**>  
    <**configuration**>  
        **  
*        *<**fork**>true</**fork**>  
    </**configuration**>  
    **  
*    *<**executions**>  
        <**execution**>  
            <**goals**>  
                <**goal**>repackage</**goal**>  
            </**goals**>  
        </**execution**>  
    </**executions**>  
</**plugin**>

使用：mvn clean package 打包，java -jar springboot-basic-0.0.1-SNAPSHOT.jar运行。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 4][]

## **3、war部署** ##

如果并不希望使用内置的tomcat，希望部署到其他tomcat服务器，那么就需要使用war包部署了。

1）修改pom文件，打包方式改成war。

2）修改在pom文件，剔除内置tomcat的支持，否则会和外面的tomcat冲突。

<**dependency**>  
    <**groupId**>org.springframework.boot</**groupId**>  
    <**artifactId**>spring-boot-starter-tomcat</**artifactId**>  
    **  
*    *<**scope**>provided</**scope**>  
 </**dependency**>

3）修改启动类，使其继承org.springframework.boot.web.servlet.support.SpringBootServletInitializer，并重写configure方法：

@SpringBootApplication  
@MapperScan(**"com.chj.dao"**)  
@EnableTransactionManagement  
**public class** WarApp **extends** SpringBootServletInitializer \{   
    **public static void** main(String\[\] args) \{   
        *//启动类 定制化*  
*        *SpringApplication.*run*(WarApp.**class**, args);  
    \}  
    @Override  
    **protected** SpringApplicationBuilder configure(SpringApplicationBuilder builder) \{   
        **return** builder.sources(WarApp.**class**);  
    \}  
\}

使用：mvn clean package打包，把war包拷贝到tomcat webapps中，访问：

http://localhost:8080/springbootvip/hello

[https_mvnrepository.com_artifact_org.mybatis.spring.boot_mybatis-spring-boot-starter_1.3.5]: https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter/1.3.5
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191123215944985.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70
[localhost_8080_register_username_hankin_passwd_123456]: http://localhost:8080/register?username=deer&passwd=123%EF%BC%8C%E6%98%BE%E7%A4%BA%5C%E2%80%9C%E6%B3%A8%E5%86%8C%E6%88%90%E5%8A%9F%5C%E2%80%9D
[20191123215816973.png]: https://img-blog.csdnimg.cn/20191123215816973.png
[localhost_8080_batchAddx_username_enjoy_passwd_123]: http://localhost:8080/batchAddx?username=enjoy&passwd=123%EF%BC%8C%E5%90%8E%E7%AB%AF%E5%B9%B6%E6%B2%A1%E6%9C%89%E8%BF%99%E6%9C%8D%E5%8A%A1%EF%BC%8C%E8%99%BD%E7%84%B6%E5%B7%B2%E7%BB%8F%E5%81%9A%E4%BA%86%E7%9B%B8%E5%85%B3%E7%9A%84%E5%BC%82%E5%B8%B8%E6%8D%95%E8%8E%B7
[http_localhost_8080_swagger-ui.html]: http://localhost:8080/swagger-ui.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191123215615655.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191123215535418.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191123215348461.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191123215319176.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70