spring-boot 学习笔记

/* jerry 20180427 */

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Boot致力于在蓬勃发展的快速应用开发领域（rapid application development）成为领导者。

特点：
1. 创建独立的Spring应用程序
2. 嵌入的Tomcat，无需部署WAR文件
3. 简化Maven配置
4. 自动配置Spring
5. 提供生产就绪型功能，如指标，健康检查和外部配置

6. 绝对没有代码生成和对XML没有要求配置

需要
jdk 1.8.0_161
maven 3.5.3
eclipse Release 4.7.0 (Oxygen)

windows10 x64

步骤
1,安装jdk(加环境变量)

2,安装maven(加环境变量)

3,安装eclipse

4,配置eclipse maven
Window -> Maven -> Installations
->add
External
Installation home = Maven 安装目录
->finished
->Apply and Close

5,创建Maven项目
Eclipse -> File -> New -> Other -> Maven -> Maven Project->Next

勾选 Create a simple project
勾选 Use default Workspace location
Next

Group Id = 随便起
Artifact Id = 随便起
Packaging = jar
Finish

6,更新Jar System Library
在项目右键 -》 属性 -》java Build Path
Libraries
选择 JRE System Library -> Edit
选择 Workspace default JRE (就是自己安装的)

Finish -> Apply and Close

7,Maven pom.xml

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

	<!-- Inherit defaults from Spring Boot -->
	<parent>
	<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.12.RELEASE</version>
	</parent>

	<!-- Add typical dependencies for a web application -->
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
	</dependencies>

	<!-- Package as an executable jar -->
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

8,创建hello

新建文件src/main/hello/HelloController.java

	package hello;

	import org.springframework.web.bind.annotation.RequestMapping;
	import org.springframework.web.bind.annotation.RestController;

	@RestController
	public class HelloController {

	    @RequestMapping("/")
	    public String hello(){
		return "Greetings from Spring Boot!";
	    }
	}

        新建src/main/hello/Application.java

备注：必须放在其他类之外。

	package hello;

	import org.springframework.boot.SpringApplication;
	import org.springframework.boot.autoconfigure.SpringBootApplication;

	@SpringBootApplication
	public class Application {

	    public static void main(String[] args) {
		// http://localhost:8080/
		SpringApplication.run(Application.class, args);
	    }
	}

9,Run

        Run -》 java Application

10,浏览器访问 localhost:8080/

11,服务配置
在src/main/resources新建文件application.properties

服务配置

	server.context-path=/helloboot
	server.port=8081

        中文处理

	server.tomcat.uri-encoding=UTF-8
	spring.http.encoding.charset=UTF-8
	spring.http.encoding.enabled=true
	spring.http.encoding.force=true
	spring.messages.encoding=UTF-8

12,Profile配置
在src/main/resources文件夹下定义不同环境下的Profile配置文件，文件名分别为application-prod.properties、application-dev.properties、application-test.properties，这两个前者表示生产环境下的配置，后者表示开发环境下的配置。
发布
application-prod.properties:
server.port=8080

开发
application-dev.properties:
server.port=8081

测试
server.port=8082

然后在application.properties中进行简单配置:

spring.profiles.active=dev

13,日志配置
配置 logback

在 src/main/resources 下创建 logback-spring.xml 文件

	<?xml version="1.0" encoding="UTF-8"?>
	<configuration>
	    <!-- 文件输出格式 -->
	    <property name="PATTERN" value="%-12(%d{yyyy-MM-dd HH:mm:ss.SSS}) |-%-5level [%thread] %c [%L] -| %msg%n" />
	    <!-- test文件路径 -->
	    <property name="TEST_FILE_PATH" value="d:/test.log" />
	    <!-- pro文件路径 -->
	    <property name="PRO_FILE_PATH" value="/opt/test/log" />
	    
	    <!-- 开发环境 -->
	    <springProfile name="dev">
		<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
		    <encoder>
			<pattern>${PATTERN}</pattern>
		    </encoder>
		</appender>
		<logger name="com.light.springboot" level="debug" />
		<root level="info">
		    <appender-ref ref="CONSOLE" />
		</root>
	    </springProfile>
	    
	    <!-- 测试环境 -->
	    <springProfile name="test">
		<!-- 每天产生一个文件 -->
		<appender name="TEST-FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
		    <!-- 文件路径 -->
		    <file>${TEST_FILE_PATH}</file>
		    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
			<!-- 文件名称 -->
			<fileNamePattern>${TEST_FILE_PATH}/info.%d{yyyy-MM-dd}.log</fileNamePattern>
			<!-- 文件最大保存历史数量 -->
			<MaxHistory>100</MaxHistory>
		    </rollingPolicy>
		    <layout class="ch.qos.logback.classic.PatternLayout">
			<pattern>${PATTERN}</pattern>
		    </layout>
		</appender>
		<root level="info">
		    <appender-ref ref="TEST-FILE" />
		</root>
	    </springProfile>
	    
	    <!-- 生产环境 -->
	    <springProfile name="prod">
		<appender name="PROD_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
		    <file>${PRO_FILE_PATH}</file>
		    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
			<fileNamePattern>${PRO_FILE_PATH}/warn.%d{yyyy-MM-dd}.log</fileNamePattern>
			<MaxHistory>100</MaxHistory>
		    </rollingPolicy>
		    <layout class="ch.qos.logback.classic.PatternLayout">
			<pattern>${PATTERN}</pattern>
		    </layout>
		</appender>
		<root level="warn">
		    <appender-ref ref="PROD_FILE" />
		</root>
	    </springProfile>
	</configuration>

        其中，springProfile 标签的 name 属性对应 application.properties 中的 spring.profiles.active 的配置。

        即 spring.profiles.active 的值可以看作是日志配置文件中对应的 springProfile 是否生效的开关。

        配置 log4j2

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

spring boot 默认会加载 classpath:log4j2.xml 或者 classpath:log4j2-spring.xml。
如需要自定义文件名称，在 application.properties 中配置 logging.config 选项即可。

log4j2.xml 文件内容如下：

	<?xml version="1.0" encoding="utf-8"?>
	<configuration>
	    <properties>
		<!-- 文件输出格式 -->
		<property name="PATTERN">%d{yyyy-MM-dd HH:mm:ss.SSS} |-%-5level [%thread] %c [%L] -| %msg%n</property>
	    </properties>
	    <appenders>
		<Console name="CONSOLE" target="system_out">
		    <PatternLayout pattern="${PATTERN}" />
		</Console>
	    </appenders>
	    <loggers>
		<logger name="com.light.springboot" level="debug" />
		<root level="info">
		    <appenderref ref="CONSOLE" />
		</root>
	    </loggers>
	</configuration>

      log4j2 不能像 logback 那样在一个文件中设置多个环境的配置数据，只能命名 3 个不同名的日志文件，分别在 application-dev，application-test 和 application-prod 中配置 logging.config 选项。


除了在日志配置文件中设置参数之外，还可以在 application-*.properties 中设置，日志相关的配置：
logging.config                    # 日志配置文件路径，如 classpath:logback-spring.xml
logging.exception-conversion-word # 记录异常时使用的转换词
logging.file                      # 记录日志的文件名称，如：test.log
logging.level.*                   # 日志映射，如：logging.level.root=WARN，logging.level.org.springframework.web=DEBUG
logging.path                      # 记录日志的文件路径，如：d:/
logging.pattern.console           # 向控制台输出的日志格式，只支持默认的 logback 设置。
logging.pattern.file              # 向记录日志文件输出的日志格式，只支持默认的 logback 设置。
logging.pattern.level             # 用于呈现日志级别的格式，只支持默认的 logback 设置。
logging.register-shutdown-hook    # 初始化时为日志系统注册一个关闭钩子

14,打包发布
打包的形式有两种：jar 和 war
打包成可执行的 jar 包
默认情况下，通过 maven 执行 package 命令后，会生成 jar 包，且该 jar 包会内置了 tomcat 容器，因此我们可以通过 java -jar 就可以运行项目
打包成部署的 war 包，打包成功后，将 war 包部署到 tomcat 容器中运行即可。
让 SpringbootApplication 类继承 SpringBootServletInitializer 并重写 configure 方法，如下：

	@SpringBootApplication
	public class SpringbootApplication extends SpringBootServletInitializer {

	    @Override
	    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
		return application.sources(SpringbootApplication.class);
	    }

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

        修改 pom.xml 文件，将 jar 改成 war，如下：

<packaging>war</packaging>

15,JSON 数据格式转换
在SpringBootApplication衍生类添加：

	// JSON格式转换
	@Bean
	public HttpMessageConverters fastJsonConverters()
	{
		FastJsonHttpMessageConverter fastJsonConverter = new FastJsonHttpMessageConverter();
		FastJsonConfig fastConf = new FastJsonConfig();

		fastConf.setSerializerFeatures(SerializerFeature.PrettyFormat);
		fastJsonConverter.setFastJsonConfig(fastConf);

		HttpMessageConverter<?> converter = fastJsonConverter;
		return new HttpMessageConverters(converter);    
	}

	/*@Override
	public void configureMessageConverters(List<HttpMessageConverter<?>> converters) 
	{
		super.configureMessageConverters(converters);
		// 1.需要定义一个convert转换消息的对象;
		FastJsonHttpMessageConverter fastJsonHttpMessageConverter = new FastJsonHttpMessageConverter();
		// 2.添加fastJson的配置信息，比如：是否要格式化返回的json数据;
		FastJsonConfig fastJsonConfig = new FastJsonConfig();
		fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);
		// 3处理中文乱码问题
		List<MediaType> fastMediaTypes = new ArrayList<MediaType>();
		fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
		// 4.在convert中添加配置信息.
		fastJsonHttpMessageConverter.setSupportedMediaTypes(fastMediaTypes);
		fastJsonHttpMessageConverter.setFastJsonConfig(fastJsonConfig);
		// 5.将convert添加到converters当中.
		converters.add(fastJsonHttpMessageConverter);
	}*/

16,替换favicon.ico
spring-boot默认的是个小叶子，替换方法：
在application.properties中设置关闭favicon，默认为开启
spring.mvc.favicon.enabled = false

将自己的favicon.ico 复制到 src/main/resources/static/下

17,过滤器
创建时间监听类TimeFilter,实现Filter
TimeFilter implements Filter
重写
init、doFilter、destroy三个函数

类前，添加：
@Order(1) // 数字越小，越优先
@WebFilter(filterName = "TimeFilter", urlPatterns = "/*")

方法一（new）：

在SpringBootApplication衍生类前添加@ServletComponentScan

        方法二（old）：

在SpringBootApplication衍生类添加：

	@Bean
	public FilterRegistrationBean someFilterRegistration() 
	{
		FilterRegistrationBean registration = new FilterRegistrationBean();
		registration.setFilter(TimeFilter());
		registration.addUrlPatterns("/*");
		registration.addInitParameter("paramName", "paramValue");
		registration.setName("TimeFilter");
		return registration;
	}
    
	@Bean(name = "TimeFilter")
	public Filter TimeFilter() 
	{
		return new TimeFilter();
	}

18,监听器

创建类MyListener实现ServletContextListener

	import javax.servlet.ServletContextEvent;
	import javax.servlet.ServletContextListener;
	import javax.servlet.annotation.WebListener;
	@WebListener
	public class MyListener  implements ServletContextListener{
	    @Override
	    public void contextInitialized(ServletContextEvent servletContextEvent) {
		System.out.println("监听器初始化");
		System.out.println(servletContextEvent.getServletContext().getServerInfo());
	    }

	    @Override
	    public void contextDestroyed(ServletContextEvent servletContextEvent) {
		System.out.println("监听器销毁");
	    }
	}

19,拦截器

        创建类MyInterceptor实现HandlerInterceptor

	import org.springframework.web.servlet.HandlerInterceptor;
	import org.springframework.web.servlet.ModelAndView;
	import javax.servlet.http.HttpServletRequest;
	import javax.servlet.http.HttpServletResponse;
	public class MyInterceptor implements HandlerInterceptor {

	    @Override
	    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
		System.out.println("--------------拦截器请求前调用-----------------------------");
		return true;// 只有返回true才会继续向下执行，返回false取消当前请求
	    }

	    @Override
	    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
		System.out.println("请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）");

	    }

	    @Override
	    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
		System.out.println("在整个请求结束之后被调用，也就是在DispatcherServlet渲染了对应的视图之后执行（主要是用于进行资源清理工作）");

	    }
	}

20,消息转换器

        创建类MyConver继承与FastJsonHttpMessageConverter

	import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
	import org.springframework.http.HttpInputMessage;
	import org.springframework.http.HttpOutputMessage;
	import org.springframework.http.converter.HttpMessageNotReadableException;
	import org.springframework.http.converter.HttpMessageNotWritableException;
	public class MyConver extends FastJsonHttpMessageConverter {
	    @Override
	    protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
		//fastJson的版本影响是否可以获取
		System.out.println("--------------请求进入到消息转化器-------------------");
		return super.readInternal(clazz, inputMessage);
	    }

	    @Override
	    protected void writeInternal(Object obj, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
		System.out.println("--------------响应进入到消息转化器-------------------");
		super.writeInternal(obj, outputMessage);
	    }
	}

备注：拦截器、消息转换器配置

application 类之前添加：

	@ServletComponentScan   //扫描过滤器、拦截器、监听器、servlet
	@ImportResource(locations = {"classpath:application-bean.xml"}) //加载配置的xml(路径是src/main/resourcse/application-bean.xml)

        application-bean.xml内容：

	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
	       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	       xmlns:mvc="http://www.springframework.org/schema/mvc"
	       xmlns:context="http://www.springframework.org/schema/context"
	       xsi:schemaLocation="
		http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		http://www.springframework.org/schema/mvc
		http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context-3.1.xsd">

	    <!-- spring可以自动去扫描base-pack下面的包或者子包下面的java文件，
		如果扫描到有Spring的相关注解的类，则把这些类注册为Spring的bean -->
	    <context:component-scan base-package="com.eternal"/>
	    <!-- 实际开发中使用<mvc:annotation-driven/>代替注解适配器和映射器,设置配置方案 -->
	    <mvc:annotation-driven>
		<!-- 设置不使用默认的消息转换器 -->
		<mvc:message-converters register-defaults="false">
		    <!-- 配置Spring的转换器 -->
		    <!-- 配置fastjson中实现HttpMessageConverter接口的转换器 -->
		    <bean id="fastJsonHttpMessageConverter"  class="com.conver.MyConver">
			<!-- 加入支持的媒体类型：返回contentType -->
			<property name="supportedMediaTypes">
			    <list>
				<!-- 这里顺序不能反，一定先写text/html,不然ie下会出现下载提示 -->
				<value>text/html;charset=UTF-8</value>
				<value>application/json;charset=UTF-8</value>
			    </list>
			</property>
		    </bean>
		    <!--<bean class="org.springframework.http.converter.StringHttpMessageConverter"/>-->
		    <!--<bean class="org.springframework.http.converter.xml.XmlAwareFormHttpMessageConverter"/>-->
		    <!--<bean class="org.springframework.http.converter.ByteArrayHttpMessageConverter"/>-->
		    <!--<bean class="org.springframework.http.converter.BufferedImageHttpMessageConverter"/>-->
		</mvc:message-converters>
	    </mvc:annotation-driven>
	    <mvc:interceptors>
		<mvc:interceptor>
		    <mvc:mapping path="/**"/>
		    <bean class="com.interceptor.MyInterceptor" />
		</mvc:interceptor>
	    </mvc:interceptors>
	</beans>

21,控制器 controller
类注解
@Controller
@RestController

方法注解
@RequestMapping("/Logout")
@RequestMapping(value="/Logout",method=RequestMethod.GET)

区别，默认GET、POST都支持，制定后只支持一种

	import java.io.IOException;
	import javax.servlet.http.HttpServletRequest;
	import javax.servlet.http.HttpSession;
	import org.springframework.beans.factory.annotation.Value;
	import org.springframework.web.bind.annotation.RequestMapping;
	import org.springframework.web.bind.annotation.RestController;
	import com.entity.User;
	import com.entity.res.ResBasic;;

	@RestController
	@RequestMapping("/UserController")
	public class UserController{
		@Value("${session_key}")   
		private String session_key;
		
		@RequestMapping("/Login")
		private ResBasic Login(HttpServletRequest request,HttpSession session) throws IOException {
			// TODO Auto-generated method stub
			User user = new User();
			user.setUser_name(request.getParameter("user_name"));
			user.setUser_pwd(request.getParameter("user_pwd"));
			session.setAttribute(session_key, user);
			ResBasic res = new ResBasic();
			res.setStatus(0);
			res.setDes("home");
		return res;
		}
		
		@RequestMapping("/Logout")
		private ResBasic Logout(HttpServletRequest request,HttpSession session) {
			// TODO Auto-generated method stub
			session.removeAttribute(session_key);
			ResBasic res = new ResBasic();
			res.setStatus(0);
			res.setDes("login");
			return res;
		}
		
		@RequestMapping("/GetLoginState")
		private User GetLoginState(HttpServletRequest request,HttpSession session) {
			// TODO Auto-generated method stub
			User user = (User) session.getAttribute(session_key);
		return user;
		}
	}

22,servlet

servlet映射覆盖控制器映射

	import javax.servlet.ServletException;
	import javax.servlet.annotation.WebServlet;
	import javax.servlet.http.HttpServlet;
	import javax.servlet.http.HttpServletRequest;
	import javax.servlet.http.HttpServletResponse;
	import java.io.IOException;

	@WebServlet(urlPatterns = "/home")
	public class MyServlet extends HttpServlet {
	
		private static final long serialVersionUID = 1L;

		@Override
	    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
			System.out.println("doGet()");
	    }

	    @Override
	    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		System.out.println("doPost()");
	    }
	}

23,html模板支持

        pom.xml增加

	<dependency>
	    <groupId>org.springframework.boot</groupId>
	    <artifactId>spring-boot-starter-thymeleaf</artifactId>
	</dependency>
	<!-- hot swapping, disable cache for template, enable live reload -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-devtools</artifactId>
		<optional>true</optional>
	</dependency>

	<!-- Optional, for bootstrap -->
	<dependency>
		<groupId>org.webjars</groupId>
		<artifactId>bootstrap</artifactId>
		<version>3.3.7</version>
	</dependency>

        application.properties增加

	application.properties增加
	spring.thymeleaf.cache=true
	spring.thymeleaf.prefix=classpath:/templates/
	spring.thymeleaf.suffix=.html
	spring.thymeleaf.mode=HTML5
	spring.thymeleaf.encoding=UTF-8
	spring.thymeleaf.content-type=text/html

将html放在 src/main/resources/templates 下
将js、css、icon、image 等待放在 src/main/resources/static下
备注：html标签要求及严格，比如

<br> 必须 <br/> 等等。

24,关于重定向

        在Controller
类前注解 @Controller
return "html路径" // 不带.html，不带前/，相对于src/main/resources/templates 和 src/main/resources/static

不是很清楚。待了解。

25,Eclipse 下调试

        全局 调试上次启动 F11
全局 运行上次启动 Ctrl+F11
全局 继续 F8
全局 单步跳过 F6
全局 单步跳入 F5
Ctrl+L 跳到第几行
Ctrl+Shift+D 删除一行
Ctrl+Shift+B 下断点

26,过滤器、拦截器、监听器、消息转换器、AOP、控制器执行顺序

         Request
过滤器 doFilter
拦截器 preHandle
消息转换器 readInternal
AOP @Before
Controller
Response
AOP @AfterReturning
消息转换器 writeInternal
拦截器 postHandle

27,全局异常处理

添加类GlobalExceptionHandler

	@ControllerAdvice
	public class GlobalExceptionHandler {
	/**
	     * 所有异常报错
	     * @param request
	     * @param exception
	     * @return
	     * @throws Exception
	     */
	    @ExceptionHandler(value=Exception.class)  
	//    @ResponseBody //在返回自定义相应类的情况下必须有，这是@ControllerAdvice注解的规定  
	    public String allExceptionHandler(HttpServletRequest request,  
		    Exception exception) throws Exception  
	    {  
		exception.printStackTrace();
		System.out.println("我报错了："+exception.getLocalizedMessage());
		System.out.println("我报错了："+exception.getCause());
		System.out.println("我报错了："+exception.getSuppressed());
		System.out.println("我报错了："+exception.getMessage());
		System.out.println("我报错了："+exception.getStackTrace());
		return "服务器异常，请联系管理员！";  
	    } 
	}

说明：
@ControllerAdvice是controller的一个辅助类，最常用的就是作为全局异常处理的切面类
@ControllerAdvice可以指定扫描范围

@ControllerAdvice约定了几种可行的返回值，如果是直接返回model类的话，需要使用@ResponseBody进行json转换

1、返回String，表示跳到某个view
2、返回modelAndView
3、返回model + @ResponseBody

28,数据加载类

该组件在项目启动时会立即执行

	@Component
	public class MyStartupRun implements CommandLineRunner {
	    @Override
	    public void run(String... args) throws Exception {
		System.out.println(">>>>>>>>>>>>>>>服务启动执行");
	    }
	}

29,外部配置

优先级如下：
1,命令行参数
java -jar app.jar –name=”Spring” –server.port=9090方式来传递参数.参数用–xxx=xxx的形式传递.可以使用的参数可以是自定义的，也可以是Spring Boot中定义的参数。 
2,来自java:comp/env的JNDI属性
3,Java系统属性（System.getProperties()）
Java系统属性位置java -Dname=”isea533” -jar app.jar，可以配置的属性都是一样的，优先级不同。
如java -Dname=”isea533” -jar app.jar –name=”Spring!”中name值为Spring!
4,操作系统环境变量
5,RandomValuePropertySource配置的random.*属性值
random.int*支持value参数和,max参数，当提供max参数的时候，value就是最小值。
6,jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
7,jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
8,jar包外部的application.properties或application.yml(不带spring.profile)配置文件
9,jar包内部的application.properties或application.yml(不带spring.profile)配置文件
10,@Configuration注解类上的@PropertySource
11,通过SpringApplication.setDefaultProperties指定的默认属性

30,文档生成

使用swagger,首先在pom中引入jar依赖

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

Application.java中引入@EnableSwagger2来启动swagger注解

	@Configuration
	@SpringBootApplication // 组件扫描
	@EnableScheduling
	@EnableAsync
	@EnableSwagger2
	public class Application

@Api：用在类上，说明该类的作用
@ApiOperation：用在方法上，说明方法的作用
@ApiImplicitParams：用在方法上包含一组参数说明
@ApiImplicitParam：用在@ApiImplicitParams注解中，指定一个请求参数的各个方面
paramType：参数放在哪个地方
header-->请求参数的获取：@RequestHeader
query-->请求参数的获取：@RequestParam
path（用于restful接口）-->请求参数的获取：@PathVariable
body（不常用）
form（不常用）
name：参数名
dataType：参数类型
required：参数是否必须传
value：参数的意思
defaultValue：参数的默认值
@ApiResponses：用于表示一组响应
@ApiResponse：用在@ApiResponses中，一般用于表达一个错误的响应信息
code：数字，例如400
message：信息，例如"请求参数没填好"
response：抛出异常的类
@ApiModel：描述一个Model的信息（这种一般用在post创建的时候，使用@RequestBody这样的场景，请求参数无法使用@ApiImplicitParam注解进行描述的时候）
@ApiModelProperty：描述一个model的属性


启动服务，浏览器输入"http://localhost:8081/swagger-ui.html"