SpringBoot学习笔记2

九：创建父工程

注意：打包方式选择为pom

将创建SpringBoot常用的依赖和插件放在父工程的pom.xml,如下：

 1 <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">
 2   <modelVersion>4.0.0</modelVersion>
 3   <groupId>com.wu</groupId>
 4   <artifactId>SpringBoot_Parent</artifactId>
 5   <version>0.0.1-SNAPSHOT</version>
 6   <packaging>pom</packaging>
 7   <dependencyManagement>
 8       <dependencies>
 9           <dependency>
10               <groupId>org.springframework.boot</groupId>
11             <artifactId>spring-boot-dependencies</artifactId>
12             <version>1.5.6.RELEASE</version>
13             <type>pom</type>
14             <scope>import</scope>
15           </dependency>
16       </dependencies>
17   </dependencyManagement>
18   
19   <build>
20       <plugins>
21           <plugin>
22               <groupId>org.apache.maven.plugins</groupId>
23             <artifactId>maven-compiler-plugin</artifactId>
24             <configuration>
25                 <source>1.8</source>
26                 <target>1.8</target>
27             </configuration>
28           </plugin>
29       </plugins>
30   </build>
31 </project>

pom.xml

9.1建立子工程

点击Next,

9.2在子工程的pom.xml中引入相应的依赖

 1 <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">
 2   <modelVersion>4.0.0</modelVersion>
 3   <parent>
 4     <groupId>com.wu</groupId>
 5     <artifactId>SpringBoot_Parent</artifactId>
 6     <version>0.0.1-SNAPSHOT</version>
 7   </parent>
 8   <artifactId>SpringBoot_Child1</artifactId>
 9   <dependencies>
10       <dependency>
11           <groupId>org.springframework.boot</groupId>
12         <artifactId>spring-boot-starter-web</artifactId>
13       </dependency>
14   </dependencies>
15 </project>

子工程的pom.xml

9.3:SpringBoot整合测试

首选需要添加测试相关依赖

 1     <!-- 测试相关 -->
 2       <dependency>
 3           <groupId>org.springframework.boot</groupId>
 4           <artifactId>spring-boot-starter-test</artifactId>
 5           <scope>test</scope>
 6       </dependency>
 7       
 8       <dependency>
 9           <groupId>junit</groupId>
10           <artifactId>junit</artifactId>
11           <scope>test</scope>
12       </dependency>

测试相关依赖

编写需要测试的controller类

 1 package com.wu.controller;
 2 
 3 import org.springframework.boot.SpringApplication;
 4 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 5 import org.springframework.stereotype.Controller;
 6 import org.springframework.web.bind.annotation.RequestMapping;
 7 import org.springframework.web.bind.annotation.ResponseBody;
 8 
 9 @Controller
10 @EnableAutoConfiguration
11 public class SpringController {
12     @ResponseBody
13     public String yes(){
14         
15         return "yes";
16     }
17     
18     //程序启动入口
19     public static void main(String []args){
20         SpringApplication.run(SpringController.class, args);
21     }
22 }

SpringController .java

编写测试类

 1 import org.junit.Test;
 2 import org.junit.runner.RunWith;
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.boot.test.context.SpringBootTest;
 5 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 6 import org.springframework.test.context.web.WebAppConfiguration;
 7 
 8 import com.wu.controller.SpringController;
 9 
10 import junit.framework.TestCase;
11 
12 @SpringBootTest(classes=SpringController.class)
13 @RunWith(SpringJUnit4ClassRunner.class)
14 @WebAppConfiguration//和Web整合
15 public class TestSpringController {
16     @Autowired
17     private SpringController springController;
18     
19     @Test
20     public void test1(){
21         TestCase.assertEquals(this.springController.yes(),"yes");
22     }
23 }

TestSpringController

十：设置专门的启动类

目的：

将程序启动入口单独放入一个类中

方法1：使用@EnableAutoConfiguration,和@ComponentScan("要扫描的包的路径")默认扫描是当前包和当前包的子包

注意：原本加在Controller类的@EnableAutoConfiguration放在启动类上，Controller类上只需要添加@Controller

 1 package com.wu.app;
 2 
 3 import org.springframework.boot.SpringApplication;
 4 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 5 import org.springframework.context.annotation.ComponentScan;
 6 
 7 import com.wu.controller.SpringController;
 8 
 9 @EnableAutoConfiguration
10 @ComponentScan("com.wu.controller")//默认扫描的是当前包和当前包的子包
11 public class SpringApplications {
12         //程序启动入口
13         public static void main(String []args){
14             SpringApplication.run(SpringApplications.class, args);
15         }
16 }

启动类

方法2：在启动类上只使用一个注解@SpringBootApplication

 1 package com.wu.app;
 2 
 3 import org.springframework.boot.SpringApplication;
 4 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 5 import org.springframework.boot.autoconfigure.SpringBootApplication;
 6 import org.springframework.context.annotation.ComponentScan;
 7 
 8 import com.wu.controller.SpringController;
 9 
10 //@EnableAutoConfiguration
11 //@ComponentScan("com.wu.controller")//默认扫描的是当前包和当前包的子包
12 @SpringBootApplication(scanBasePackages={"com.wu.controller"})
13 public class SpringApplications {
14         //程序启动入口
15         public static void main(String []args){
16             SpringApplication.run(SpringApplications.class, args);
17         }
18 }

只设置@SpringBootApplication

十一：@RestController的使用（该注解类中整合了@ResponseBody，@Controller)

 1  * Copyright 2002-2016 the original author or authors.
 2 
 3 package org.springframework.web.bind.annotation;
 4 
 5 import java.lang.annotation.Documented;
 6 import java.lang.annotation.ElementType;
 7 import java.lang.annotation.Retention;
 8 import java.lang.annotation.RetentionPolicy;
 9 import java.lang.annotation.Target;
10 
11 import org.springframework.stereotype.Controller;
12 
13 /**
14  * A convenience annotation that is itself annotated with
15  * {@link Controller @Controller} and {@link ResponseBody @ResponseBody}.
16  * <p>
17  * Types that carry this annotation are treated as controllers where
18  * {@link RequestMapping @RequestMapping} methods assume
19  * {@link ResponseBody @ResponseBody} semantics by default.
20  *
21  * <p><b>NOTE:</b> {@code @RestController} is processed if an appropriate
22  * {@code HandlerMapping}-{@code HandlerAdapter} pair is configured such as the
23  * {@code RequestMappingHandlerMapping}-{@code RequestMappingHandlerAdapter}
24  * pair which are the default in the MVC Java config and the MVC namespace.
25  * In particular {@code @RestController} is not supported with the
26  * {@code DefaultAnnotationHandlerMapping}-{@code AnnotationMethodHandlerAdapter}
27  * pair both of which are also deprecated.
28  *
29  * @author Rossen Stoyanchev
30  * @author Sam Brannen
31  * @since 4.0
32  */
33 @Target(ElementType.TYPE)
34 @Retention(RetentionPolicy.RUNTIME)
35 @Documented
36 @Controller
37 @ResponseBody
38 public @interface RestController {
39 
40     /**
41      * The value may indicate a suggestion for a logical component name,
42      * to be turned into a Spring bean in case of an autodetected component.
43      * @return the suggested component name, if any
44      * @since 4.0.1
45      */
46     String value() default "";
47 
48 }

@RestController

目的：

当Controller类的方法需要向页面传递数据时，会在方法前加@ResponseBody, 如果在每个方法前都加，可能有些麻烦，因此，可以在类上直接加@RestController,之后该类中的每个方法的return，都会向页面返回数据

示例：

 1 package com.wu.controller;
 2 
 3 import org.springframework.boot.SpringApplication;
 4 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 5 import org.springframework.stereotype.Controller;
 6 import org.springframework.web.bind.annotation.PathVariable;
 7 import org.springframework.web.bind.annotation.RequestMapping;
 8 import org.springframework.web.bind.annotation.ResponseBody;
 9 import org.springframework.web.bind.annotation.RestController;
10 
11 @RestController
12 public class SpringController {
13     //@ResponseBody
14     @RequestMapping("/yes")
15     public String yes(){
16         
17         return "yes";
18     }
19     
20     @RequestMapping("/show/{id}")
21     public String showId(@PathVariable String id){
22         return "show"+id;
23         
24     }
25     
26 }

使用@RestController的Controller类

十二：SpringBoot日志管理

12.1默认：

不用再单独配置日志依赖，SpringBoot使用的默认日志框架是Logback,默认使用ERROR,WARN,INFO级别的日志输出到控制台

12.2日志具体信息：

日志时间：精确到毫秒 日志级别：TRACE<DEBUG<INFO<WARN<ERROR<FATAL<OFF 进程ID - - - {线程名} Logger名：通常是类名 ：日志类容

12.3在全局配置文件application.properties中配置日志级别

示例：

1 #让日志输出warn及以上级别的输出
2 logging.level.root=WARN
3 
4 #让该类输出DEBUG及以上的日志信息
5 logging.level.org.springframework.web=DEBUG

在application.properties中配置日志级别

12.4将日志信息同时写入到日志文件中

同样需要在全局配置文件中配置相关日志文件的路径

示例：

 1 #让日志输出warn及以上级别的输出
 2 logging.level.root=WARN
 3 
 4 #让该类输出DEBUG及以上的日志信息
 5 logging.level.org.springframework.web=DEBUG
 6 
 7 #配置日志文件方式一
 8 #logging.file=D:\\BaiduNetdiskDownload\\SpringBoot\\logs\\info.log
 9 
10 #配置日志文件方式二
11 logging.path=D:\\BaiduNetdiskDownload\\SpringBoot\\logs

配置日志文件

注意：路径可以是绝对路径，也可以是相对路径，两种配置日志文件的方式任选其一，但是如果俩个都配置，会执行logging.file

12.5配置相关日志格式

整体配置如下：

 1 #让日志输出warn及以上级别的输出
 2 logging.level.root=WARN
 3 
 4 #让该类输出DEBUG及以上的日志信息
 5 logging.level.org.springframework.web=DEBUG
 6 
 7 #配置日志文件方式一
 8 logging.file=D:\\BaiduNetdiskDownload\\SpringBoot\\logs\\info.log
 9 
10 #配置日志文件方式二
11 #logging.path=D:\\BaiduNetdiskDownload\\SpringBoot\\logs
12 
13 #配置输出到控制台的格式
14 logging.pattern.console=%d{yyyy-MM-dd-HH:mm:ss} [%thread] %-5level %logger- %msg%n
15 
16 #配置输出到日志文件的格式
17 logging.pattern.file=%d{yyyy-MM-dd-HH:mm} [%thread] %-5level %logger- %msg%n

SpringBoot日志简单配置

12.6自定义日志配置文件

SpringBoot官方推荐优先带有“-spring"的作为日志配置，如使用logback-spring.xml,而不是logback.xml,名命为logback-spring.xml的日志配置文件，SpringBoot可以为其配置一些spring boot特有的配置项，如果想自己命名日志文件，可以在全局配置文件中加入logging.config=classpath:logging.config.xml

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
  3 <!-- scan:当此属性设置为true时，配置文档如果发生改变，将会被重新加载，默认值为true -->
  4 <!-- scanPeriod:设置监测配置文档是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。 当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
  5 <!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
  6 <configuration scan="true" scanPeriod="10 seconds">
  7     <contextName>logback</contextName>
  8 
  9     <!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义后，可以使“${}”来使用变量。 -->
 10     <property name="log.path" value="D:/BaiduNetdiskDownload/SpringBoot/logs" />
 11 
 12     <!--0. 日志格式和颜色渲染 -->
 13     <!-- 彩色日志依赖的渲染类 -->
 14     <conversionRule conversionWord="clr"
 15         converterClass="org.springframework.boot.logging.logback.ColorConverter" />
 16     <conversionRule conversionWord="wex"
 17         converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
 18     <conversionRule conversionWord="wEx"
 19         converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
 20     <!-- 彩色日志格式 -->
 21     <property name="CONSOLE_LOG_PATTERN"
 22         value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}" />
 23 
 24     <!--1. 输出到控制台 -->
 25     <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
 26         <!--此过滤器是将debug级别以下的日志过滤掉，此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息 -->
 27         <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
 28             <level>debug</level>
 29         </filter>
 30         <encoder>
 31             <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
 32             <!-- 设置字符集 -->
 33             <charset>UTF-8</charset>
 34         </encoder>
 35     </appender>
 36 
 37     <!--2. 输出到文档 -->
 38     <!-- 2.1 level为 DEBUG 日志，时间滚动输出 -->
 39     <appender name="DEBUG_FILE"
 40         class="ch.qos.logback.core.rolling.RollingFileAppender">
 41         <!-- 正在记录的日志文档的路径及文档名 -->
 42         <file>${log.path}/web_debug.log</file>
 43         <!--日志文档输出格式 -->
 44         <encoder>
 45             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} -
 46                 %msg%n</pattern>
 47             <charset>UTF-8</charset> <!-- 设置字符集 -->
 48         </encoder>
 49         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
 50         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
 51             <!-- 日志归档 -->
 52             <fileNamePattern>${log.path}/web-debug-%d{yyyy-MM-dd}.%i.log
 53             </fileNamePattern>
 54             <timeBasedFileNamingAndTriggeringPolicy
 55                 class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
 56                 <maxFileSize>100MB</maxFileSize>
 57             </timeBasedFileNamingAndTriggeringPolicy>
 58             <!--日志文档保留天数 -->
 59             <maxHistory>15</maxHistory>
 60         </rollingPolicy>
 61         <!-- 此日志文档只记录debug级别的 -->
 62         <filter class="ch.qos.logback.classic.filter.LevelFilter">
 63             <level>debug</level>
 64             <onMatch>ACCEPT</onMatch>
 65             <onMismatch>DENY</onMismatch>
 66         </filter>
 67     </appender>
 68 
 69     <!-- 2.2 level为 INFO 日志，时间滚动输出 -->
 70     <appender name="INFO_FILE"
 71         class="ch.qos.logback.core.rolling.RollingFileAppender">
 72         <!-- 正在记录的日志文档的路径及文档名 -->
 73         <file>${log.path}/web_info.log</file>
 74         <!--日志文档输出格式 -->
 75         <encoder>
 76             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} -
 77                 %msg%n</pattern>
 78             <charset>UTF-8</charset>
 79         </encoder>
 80         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
 81         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
 82             <!-- 每天日志归档路径以及格式 -->
 83             <fileNamePattern>${log.path}/web-info-%d{yyyy-MM-dd}.%i.log
 84             </fileNamePattern>
 85             <timeBasedFileNamingAndTriggeringPolicy
 86                 class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
 87                 <maxFileSize>100MB</maxFileSize>
 88             </timeBasedFileNamingAndTriggeringPolicy>
 89             <!--日志文档保留天数 -->
 90             <maxHistory>15</maxHistory>
 91         </rollingPolicy>
 92         <!-- 此日志文档只记录info级别的 -->
 93         <filter class="ch.qos.logback.classic.filter.LevelFilter">
 94             <level>info</level>
 95             <onMatch>ACCEPT</onMatch>
 96             <onMismatch>DENY</onMismatch>
 97         </filter>
 98     </appender>
 99 
100     <!-- 2.3 level为 WARN 日志，时间滚动输出 -->
101     <appender name="WARN_FILE"
102         class="ch.qos.logback.core.rolling.RollingFileAppender">
103         <!-- 正在记录的日志文档的路径及文档名 -->
104         <file>${log.path}/web_warn.log</file>
105         <!--日志文档输出格式 -->
106         <encoder>
107             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} -
108                 %msg%n</pattern>
109             <charset>UTF-8</charset> <!-- 此处设置字符集 -->
110         </encoder>
111         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
112         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
113             <fileNamePattern>${log.path}/web-warn-%d{yyyy-MM-dd}.%i.log
114             </fileNamePattern>
115             <timeBasedFileNamingAndTriggeringPolicy
116                 class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
117                 <maxFileSize>100MB</maxFileSize>
118             </timeBasedFileNamingAndTriggeringPolicy>
119             <!--日志文档保留天数 -->
120             <maxHistory>15</maxHistory>
121         </rollingPolicy>
122         <!-- 此日志文档只记录warn级别的 -->
123         <filter class="ch.qos.logback.classic.filter.LevelFilter">
124             <level>warn</level>
125             <onMatch>ACCEPT</onMatch>
126             <onMismatch>DENY</onMismatch>
127         </filter>
128     </appender>
129 
130     <!-- 2.4 level为 ERROR 日志，时间滚动输出 -->
131     <appender name="ERROR_FILE"
132         class="ch.qos.logback.core.rolling.RollingFileAppender">
133         <!-- 正在记录的日志文档的路径及文档名 -->
134         <file>${log.path}/web_error.log</file>
135         <!--日志文档输出格式 -->
136         <encoder>
137             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} -
138                 %msg%n</pattern>
139             <charset>UTF-8</charset> <!-- 此处设置字符集 -->
140         </encoder>
141         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
142         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
143             <fileNamePattern>${log.path}/web-error-%d{yyyy-MM-dd}.%i.log
144             </fileNamePattern>
145             <timeBasedFileNamingAndTriggeringPolicy
146                 class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
147                 <maxFileSize>100MB</maxFileSize>
148             </timeBasedFileNamingAndTriggeringPolicy>
149             <!--日志文档保留天数 -->
150             <maxHistory>15</maxHistory>
151         </rollingPolicy>
152         <!-- 此日志文档只记录ERROR级别的 -->
153         <filter class="ch.qos.logback.classic.filter.LevelFilter">
154             <level>ERROR</level>
155             <onMatch>ACCEPT</onMatch>
156             <onMismatch>DENY</onMismatch>
157         </filter>
158     </appender>
159     <!-- root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性 level:用来设置打印级别，大小写无关：TRACE, 
160         DEBUG, INFO, WARN, ERROR, ALL 和 OFF， 不能设置为INHERITED或者同义词NULL。默认是DEBUG 可以包含零个或多个元素，标识这个appender将会添加到这个logger。 -->
161     <root level="info">
162         <appender-ref ref="CONSOLE" />
163         <appender-ref ref="DEBUG_FILE" />
164         <appender-ref ref="INFO_FILE" />
165         <appender-ref ref="WARN_FILE" />
166         <appender-ref ref="ERROR_FILE" />
167     </root>
168 
169     <!-- <logger>用来设置某一个包或者具体的某一个类的日志打印级别、 以及指定<appender>。<logger>仅有一个name属性， 
170         一个可选的level和一个可选的addtivity属性。 name:用来指定受此logger约束的某一个包或者具体的某一个类。 level:用来设置打印级别，大小写无关：TRACE, 
171         DEBUG, INFO, WARN, ERROR, ALL 和 OFF， 还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。 
172         如果未设置此属性，那么当前logger将会继承上级的级别。 addtivity:是否向上级logger传递打印信息。默认是true。 -->
173     <!-- 该包下的类将日志信息传递给上级，即root,然后跟着root打印日志到控制台和日志文件中 -->
174     <logger name="com.wu.controller" level="info" />
175 
176     <!-- 此种设置是将该类产生的日志信息不传递到上级，而是单独将WARN以上的日志信息输出到控制台 -->
177     <logger name="com.wu.controller.SpringController" level="WARN"
178         addtivity="false">
179         <appender-ref ref="CONSOLE" />
180     </logger>
181 
182     <!-- 多环境下的日志输出 -->
183 
184     <!--开发环境:打印控制台 -->
185     <springProfile name="dev">
186         <logger name="com.wu.controller" level="debug" />
187     </springProfile>
188 
189     <!--生产环境:输出到文档并打印到控制台 <springProfile name="pro"> <root level="info"> <appender-ref 
190         ref="CONSOLE" /> <appender-ref ref="DEBUG_FILE" /> <appender-ref ref="INFO_FILE" 
191         /> <appender-ref ref="ERROR_FILE" /> <appender-ref ref="WARN_FILE" /> </root> 
192         </springProfile> -->
193 
194 </configuration>

logback-spring.xml

具体配置参考

测试：

 1 package com.wu.controller;
 2 
 3 import org.slf4j.Logger;
 4 import org.slf4j.LoggerFactory;
 5 import org.springframework.boot.SpringApplication;
 6 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 7 import org.springframework.stereotype.Controller;
 8 import org.springframework.web.bind.annotation.PathVariable;
 9 import org.springframework.web.bind.annotation.RequestMapping;
10 import org.springframework.web.bind.annotation.ResponseBody;
11 import org.springframework.web.bind.annotation.RestController;
12 
13 @RestController
14 public class SpringController {
15     
16     private Logger logger=LoggerFactory.getLogger(this.getClass());
17     
18     //@ResponseBody
19     @RequestMapping("/yes")
20     public String yes(){
21         logger.debug("debug信息");
22         //由于在 <logger/>中配置了只打印WARN级别以上的信息，因此应该会只输出"error信息"
23         logger.error("error信息");
24         return "yes";
25     }
26 }

需要打印日志信息的Controller类

结果：

12.7不同环境下的日志输出

在原先的自定义日志配置文件中已经添加了

<springProfile>标签的属性name可以设置不同的开发环境名

注意：需要在全局配置文件application.properties中添加所需要的环境，如：

1 spring.profiles.active=

在application.properties中添加需要的日志环境

12.8使用log4j 进行日志管理

1，在pom.xml中添加如下：

 1 <!-- log4j -->
 2       <!-- 排除自带的logback日志框架-->
 3       <dependency>
 4           <groupId>org.springframework.boot</groupId>
 5           <artifactId>spring-boot-starter</artifactId>
 6           <exclusions>
 7               <exclusion>
 8           <groupId>org.springframework.boot</groupId>
 9           <artifactId>spring-boot-starter-logging</artifactId>
10         </exclusion>
11           </exclusions>
12       </dependency>
13       <!-- 添加log4j相关依赖 -->
14       <dependency>
15           <groupId>org.springframework.boot</groupId>
16           <artifactId>spring-boot-starter-log4j</artifactId>
17           <version>1.3.8.RELEASE</version>
18       </dependency>

SpringBoot中使用log4j

2，在src/main/resource下创建log4j.properties,具体如下：

 1 #log4j.rootLogger=CONSOLE,info,error,DEBUG
 2 log4j.rootLogger=info,error,CONSOLE,DEBUG
 3 
 4 log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender     
 5 log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout     
 6 log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n     
 7       
 8 log4j.logger.info=info
 9 log4j.appender.info=org.apache.log4j.DailyRollingFileAppender
10 log4j.appender.info.layout=org.apache.log4j.PatternLayout     
11 log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
12 log4j.appender.info.datePattern='.'yyyy-MM-dd
13 log4j.appender.info.Threshold = info   
14 log4j.appender.info.append=true   
15 #日志输出文件位置
16 log4j.appender.info.File=D:/BaiduNetdiskDownload/SpringBoot/logs/api_services_info.log
17 
18 log4j.logger.error=error  
19 log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
20 log4j.appender.error.layout=org.apache.log4j.PatternLayout     
21 log4j.appender.error.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
22 log4j.appender.error.datePattern='.'yyyy-MM-dd
23 log4j.appender.error.Threshold = error   
24 log4j.appender.error.append=true   
25 #log4j.appender.error.File=/home/admin/pms-api-services/logs/error/api_services_error
26 log4j.appender.error.File=D:/BaiduNetdiskDownload/SpringBoot/logs/api_services_error.log
27 
28 log4j.logger.DEBUG=DEBUG
29 log4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppender
30 log4j.appender.DEBUG.layout=org.apache.log4j.PatternLayout     
31 log4j.appender.DEBUG.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
32 log4j.appender.DEBUG.datePattern='.'yyyy-MM-dd
33 log4j.appender.DEBUG.Threshold = DEBUG   
34 log4j.appender.DEBUG.append=true   
35 #log4j.appender.DEBUG.File=/home/admin/pms-api-services/logs/debug/api_services_debug
36 log4j.appender.DEBUG.File=D:/BaiduNetdiskDownload/SpringBoot/logs/api_services_debug.log
37 
38 ### Debug
39 log4j.logger.com.ibatis=DEBUG
40 log4j.logger.com.ibatis.common.jdbc.SimpleDataSource=DEBUG
41 log4j.logger.com.ibatis.common.jdbc.ScriptRunner=DEBUG
42 log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate=DEBUG
43 log4j.logger.java.sql.Connection=DEBUG
44 log4j.logger.java.sql.Statement=DEBUG
45 log4j.logger.java.sql.PreparedStatement=DEBUG

log4j.properties

3, 测试

 1 package com.wu.controller;
 2 
 3 import org.apache.log4j.Logger;
 4 import org.springframework.web.bind.annotation.RequestMapping;
 5 import org.springframework.web.bind.annotation.RestController;
 6 
 7 @RestController
 8 public class TestController {
 9     private Logger logger=Logger.getLogger(TestController.class);
10     
11     @RequestMapping("/yes")
12     public String yes(){
13         logger.debug("这是debug日志");
14         logger.info("这是info日志");
15         logger.error("这是error日志");
16         return "yes";
17     }
18 }

简单测试的Controller类

十三将工程设置为开发模式（代码修改后，不用重新运行）

只需要在pom.xml中加入以下依赖：

1         <!-- 加入以下两个依赖，代码作了修改，不用重新运行 -->
2       <dependency>
3           <groupId>org.springframework</groupId>
4           <artifactId>springloaded</artifactId>
5       </dependency>
6       <dependency>
7           <groupId>org.springframework.boot</groupId>
8           <artifactId>spring-boot-devtools</artifactId>
9       </dependency>

所需依赖

十四 SpringBoot的web开发

14.1 前提

如前面一样，加入以下依赖，即给我自动配置tomcat和springmvc等的配置（在spring-boot-autoconfigure.jar/org.springframework.boot.autoconfigure.web下）

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

14. 2InternalResourceViewResolver（视图解析器）

注意： 自己需要在application.properties中配置前缀和后缀，如下：

1 spring.mvc.view.prefix=
2 spring.mvc.view.suffix=

在application.properties中配置前后缀

14.3静态资源访问

SpringBoot默认从 /classpath/static/ 或 /classpath/public/ 或 /META-INF/resources/ 下获取css和js

示例：

启动后访问 localhost:8080/wjs.jpg

要点：可以在application.properties中自定义静态文件(js,css,images)路径，如在全局配置文件中加入

1 spring.resources.static-locations=

注意： 自定义静态资源路径后，原本默认的路径将失效！

十五：消息转换器

参考资料1，资料2

15.1，SpringBoot中已经默认配置了消息转换器，如需要自定义，可以参考以上资料

15.2，使用FastJson解析Json数据（默认使用的是JacksonHttpMessageConverters)

导入相关依赖：

1     <!-- FastJson -->
2       <dependency>
3           <groupId>com.alibaba</groupId>
4           <artifactId>fastjson</artifactId>
5           <version>1.2.15</version>    
6       </dependency>

fastjson依赖

　　15.2.1 配置fastjson方式一：

　　　　启动类 extends WebMvcConfigurerAdapter 并重写 configureMessageConverters方法，如下：

 1 package com.wu.app;
 2 
 3 import java.util.List;
 4 
 5 import org.springframework.boot.SpringApplication;
 6 import org.springframework.boot.autoconfigure.SpringBootApplication;
 7 import org.springframework.http.converter.HttpMessageConverter;
 8 import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
 9 
10 import com.alibaba.fastjson.serializer.SerializerFeature;
11 import com.alibaba.fastjson.support.config.FastJsonConfig;
12 import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
13 
14 @SpringBootApplication(scanBasePackages={"com.wu.controller"})
15 public class SpringApplications extends WebMvcConfigurerAdapter {
16         @Override
17     public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
18         //创建FastJson消息转换器
19         FastJsonHttpMessageConverter converter=new FastJsonHttpMessageConverter();
20         //创建FastJson配置对象
21         FastJsonConfig config=new FastJsonConfig();
22         //对json数据进行格式化
23         config.setSerializerFeatures(SerializerFeature.PrettyFormat);
24         //装载配置
25         converter.setFastJsonConfig(config);
26         //装载转换器
27         converters.add(converter);
28     }
29 
30         //程序启动入口
31         public static void main(String []args){
32             SpringApplication.run(SpringApplications.class, args);
33         }
34 }

在启动类中配置FastJson转换器

　　　　测试： 创建实体类，如下

 1 package com.wu.pojo;
 2 
 3 import java.util.Date;
 4 
 5 public class Person {
 6     private String name;
 7     private String date;
 8     public String getName() {
 9         return name;
10     }
11     public void setName(String name) {
12         this.name = name;
13     }
14     public String getDate() {
15         return date;
16     }
17     public void setDate(String date) {
18         this.date = date;
19     }
20     
21 }

Person.java

　　　　创建Controller类将person类json化并返回给页面，如下：

 1 package com.wu.controller;
 2 
 3 import java.text.SimpleDateFormat;
 4 import java.util.Date;
 5 
 6 import org.springframework.web.bind.annotation.RequestMapping;
 7 import org.springframework.web.bind.annotation.RestController;
 8 
 9 import com.wu.pojo.Person;
10 
11 @RestController
12 public class PersonController {
13     @RequestMapping("/person")
14     public Object showPerson(){
15         Person person=new Person();
16         SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd:HH-mm-ss");
17         person.setName("夏明");
18         person.setDate(format.format(new Date()));
19         return person;
20     }
21 }

PersonController.java

　　　　启动，结果为：

　　　　发现有乱码

　　　　将springboot的response编码设置为utf-8的设置开启（默认为false)，在全局配置文件中加入：

1 spring.http.encoding.force=true

　　　　即回复正常：

　　　　也可以在Person类的Date date 字段上添加日期格式化，如：

@JSONField(format="yyyy-MM-dd HH:mm:ss")private Date date;

　　 15.2.2 配置fastjson方式二：

　　　　通过@Bean 将fastjson转换器注入到Spring容器中

　　　　也是在启动类中配置，具体如下：

 1 package com.wu.app;
 2 
 3 import java.util.List;
 4 
 5 import org.springframework.boot.SpringApplication;
 6 import org.springframework.boot.autoconfigure.SpringBootApplication;
 7 import org.springframework.boot.autoconfigure.web.HttpMessageConverters;
 8 import org.springframework.context.annotation.Bean;
 9 import org.springframework.http.converter.HttpMessageConverter;
10 import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
11 
12 import com.alibaba.fastjson.serializer.SerializerFeature;
13 import com.alibaba.fastjson.support.config.FastJsonConfig;
14 import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
15 
16 @SpringBootApplication(scanBasePackages={"com.wu.controller"})
17 public class SpringApplications {
18         @Bean
19         public HttpMessageConverters fastJsonMessageConverter(){
20             //创建FastJson消息转换器
21             FastJsonHttpMessageConverter converter=new FastJsonHttpMessageConverter();
22             //创建FastJson配置对象
23             FastJsonConfig config=new FastJsonConfig();
24             //对json数据进行格式化
25             config.setSerializerFeatures(SerializerFeature.PrettyFormat);
26             //装载配置
27             converter.setFastJsonConfig(config);
28             HttpMessageConverter<?> con=converter;
29             return new HttpMessageConverters(con);
30         }
31 
32         //程序启动入口
33         public static void main(String []args){
34             SpringApplication.run(SpringApplications.class, args);
35         }
36 }