Spring Boot(1)-構建應用實踐

     Spring 框架作爲目前非常流行的一個 Java 應用開發框架，它所包含的內容是非常繁多的。Spring 框架包含幾十個不同的子項目，涵蓋應用開發的不同方面。要在這些子項目之間進行選擇，並快速搭建一個可以運行的應用是比較困難的事情。Spring Boot 的目的在於快速創建可以獨立運行的 Spring 應用。通過 Spring Boot 可以根據相應的模板快速創建應用並運行。Spring Boot 可以自動配置 Spring 的各種組件，並不依賴代碼生成和 XML 配置文件。Spring Boot 可以大大提升使用 Spring 框架時的開發效率。

      官方文檔：http://docs.spring.io/spring-boot/docs/current/reference/html/

Spring Boot提供了一個強大的一鍵式Spring的集成開發環境，能夠單獨進行一個Spring應用的開發，其中：

（1）集中式配置（application.properties）+註解，大大簡化了開發流程
（2）內嵌的Tomcat和Jetty容器，可直接打成jar包啓動，無需提供Java war包以及繁瑣的Web配置
（3）提供了Spring各個插件的基於Maven的pom模板配置，開箱即用，便利無比。
（4）可以在任何你想自動化配置的地方，實現可能
（5）提供更多的企業級開發特性，如何系統監控，健康診斷，權限控制
（6） 無冗餘代碼生成和XML強制配置
（7）提供支持強大的Restfult風格的編碼，非常簡潔

1、安裝

• 一個稱手的文本編輯器（例如Vim、Emacs、Sublime Text）或者IDE（Eclipse、Idea Intellij）
• Java環境（JDK 1.7或以上版本）
• Maven 3.0+（Eclipse和Idea IntelliJ內置，如果使用IDE並且不使用命令行工具可以不安裝）

1. spring-boot是一個mavan項目，所以其使用的jar包全部是通過maven管理，當然，使用maven也是非常方便的。

2. spring-boot打出來的包是一個可執行jar包的狀態，使用的是內置的tomcat服務器，所以不需要將項目轉成EJB項目。

Eclipse插件安裝

1) 插件安裝

點擊菜單 Help -> Install new software 進行插件安裝

插件地址 http://m2eclipse.sonatype.org/sites/m2e

如果你已經成功安裝了這個插件，當你打開Window→ Preferences...的時候，你應該能夠在一個選項列表中看到一個Maven選項

安裝好m2eclipse插件後,要作兩個設置 a) 禁用Downloadrepository index updates on startup(即取消這個選項的勾選,第三個第四個可以點上),如下圖

b) 設置maven的setting.xml文件路徑,如下圖

2、創建應用

使用Spring Boot框架可以大大加速Web應用的開發過程，首先在Maven項目依賴中引入spring-boot-starter-web：

我們在Eclipse 創建maven項目：

填寫GroupId和artifactId

後生成：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class Application {

    @RequestMapping("/")
    public String greeting() {
        return "Hello World!";
    }

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

 在IDE中直接直接執行main方法，然後訪問http://localhost:8080即可。
 另外可以使用maven打包爲可執行jar包，然後執行java -jar xxx.jar。
 或者執行mvn spring-boot:run運行項目。
 在瀏覽器中訪問http://localhost:8080/，Hello World!就出現在了頁面中。只用了區區十幾行Java代碼，一個Hello World應用就可以正確運行.

3、spring boot項目結構

3.1、pom.xml文件

 pom.xml文件就是項目依賴文件，maven根據pom.xml自動加載相應的依賴

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>guisu</groupId>
  <artifactId>guisu-demo</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>guisu</name>
  <description>Demo project for Spring WebMvc</description>

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

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <java.version>1.8</java.version>
  </properties>

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

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


</project>

在Maven依賴中引入了spring-boot-starter-web，它包含了Spring Boot預定義的一些Web開發的常用依賴:

• spring-web, spring-webmvc Spring WebMvc框架
• tomcat-embed-* 內嵌Tomcat容器
• jackson 處理json數據
• spring-* Spring框架
• spring-boot-autoconfigure Spring Boot提供的自動配置功能

    “org.springframework.boot:spring-boot-starter-web”是 Spring Boot 所提供的推薦的基礎 POM 文件之一，用來提供創建基於 Spring MVC 的 Web 應用所需的第三方庫依賴。除了這個 POM 文件之外，Spring Boot 還提供了其他類似的 POM 文件。所有這些基礎 POM 依賴都在“org.springframework.boot”組中。一些重要 POM 文件的具體說明見：

Spring Boot 推薦的基礎 POM 文件

名稱	說明
spring-boot-starter	核心 POM，包含自動配置支持、日誌庫和對 YAML 配置文件的支持。
spring-boot-starter-amqp	通過 spring-rabbit 支持 AMQP。
spring-boot-starter-aop	包含 spring-aop 和 AspectJ 來支持面向切面編程（AOP）。
spring-boot-starter-batch	支持 Spring Batch，包含 HSQLDB。
spring-boot-starter-data-jpa	包含 spring-data-jpa、spring-orm 和 Hibernate 來支持 JPA。
spring-boot-starter-data-mongodb	包含 spring-data-mongodb 來支持 MongoDB。
spring-boot-starter-data-rest	通過 spring-data-rest-webmvc 支持以 REST 方式暴露 Spring Data 倉庫。
spring-boot-starter-jdbc	支持使用 JDBC 訪問數據庫。
spring-boot-starter-security	包含 spring-security。
spring-boot-starter-test	包含常用的測試所需的依賴，如 JUnit、Hamcrest、Mockito 和 spring-test 等。
spring-boot-starter-velocity	支持使用 Velocity 作爲模板引擎。
spring-boot-starter-web	支持 Web 應用開發，包含 Tomcat 和 spring-mvc。
spring-boot-starter-websocket	支持使用 Tomcat 開發 WebSocket 應用。
spring-boot-starter-ws	支持 Spring Web Services。
spring-boot-starter-actuator	添加適用於生產環境的功能，如性能指標和監測等功能。
spring-boot-starter-remote-shell	添加遠程 SSH 支持。
spring-boot-starter-jetty	使用 Jetty 而不是默認的 Tomcat 作爲應用服務器。
spring-boot-starter-log4j	添加 Log4j 的支持。
spring-boot-starter-logging	使用 Spring Boot 默認的日誌框架 Logback。
spring-boot-starter-tomcat	使用 Spring Boot 默認的 Tomcat 作爲應用服務器。

所有這些 POM 依賴的好處在於爲開發 Spring 應用提供了一個良好的基礎。Spring Boot 所選擇的第三方庫是經過考慮的，是比較適合產品開發的選擇。但是 Spring Boot 也提供了不同的選項，比如日誌框架可以用 Logback 或 Log4j，應用服務器可以用 Tomcat 或 Jetty。

3.2  java代碼

創建src/main/java/Application.java:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class Application {

    @RequestMapping("/")
    public String greeting() {
        return "Hello World!";
    }

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

類似如下結構：

com
 +- example
     +- myproject
         +- Application.java
         |
         +- domain //<span style="color: rgb(51, 51, 51); font-family: Helvetica, Tahoma, Arial, sans-serif; font-size: 14px; line-height: 24px; background-color: rgb(245, 245, 245);">用來管理javaBean實體對象</span>
         |   +- Customer.java
         |   +- CustomerRepository.java
         |
         +- service //業務邏輯層，處理數據邏輯，驗證數據

         |   +- CustomerService.java
         |
         +- web //Controller控制器
             +- CustomerController.java

     

    Spring Boot建議將我們main方法所在的這個主要的配置類配置在根包名下。

     運行應用後，那麼這段代碼究竟做了什麼呢？我們從程序的入口SpringApplication.run(Application.class, args);開始分析：

    Java代碼中沒有任何配置，和傳統的Spring應用相比，多了兩個我們不認識的符號：

• @EnableAutoConfiguration
• @SpringApplication

    它們都是由Spring Boot框架提供。在SpringApplication.run()方法執行後，Spring Boot的autoconfigure發現這是一個Web應用（根據類路徑上的依賴確定），於是在內嵌的Tomcat容器中啓動了一個Spring的應用上下文，並且監聽默認的tcp端口8080（默認約定）。同時在Spring Context中根據默認的約定配置了Spring WebMvc：

• Servlet容器默認的Context路徑是/
• DispatherServlet匹配的路徑(servlet-mapping中的url-patterns)是/*
• @ComponentScan路徑被默認設置爲SampleController的同名package，也就是該package下的所有@Controller，@Service, @Component, @Repository都會被實例化後並加入Spring Context中。

    沒有一行配置代碼、也沒有web.xml。基於Spring Boot的應用在大多數情況下都不需要我們去顯式地聲明各類配置，而是將最常用的默認配置作爲約定，在不聲明的情況下也能適應大多數的開發場景。

1. SpringApplication是Spring Boot框架中描述Spring應用的類，它的run()方法會創建一個Spring應用上下文（Application Context）。另一方面它會掃描當前應用類路徑上的依賴，例如本例中發現spring-webmvc（由 spring-boot-starter-web傳遞引入）在類路徑中，那麼Spring Boot會判斷這是一個Web應用，並啓動一個內嵌的Servlet容器（默認是Tomcat）用於處理HTTP請求。

1. Spring WebMvc框架會將Servlet容器裏收到的HTTP請求根據路徑分發給對應的@Controller類進行處理，@RestController是一類特殊的@Controller，它的返回值直接作爲HTTP Response的Body部分返回給瀏覽器。@RestController註解是@Controller和@ResponseBody的合集，表示這是個控制器bean，並且是將函數的返回值直接填入HTTP響應體中，是REST風格的控制器。@RequestMapping("/books")表示該控制器處理所有“/books”的URL請求，具體由那個函數處理，要根據HTTP的方法來區分：GET表示查詢、POST表示提交、PUT表示更新、DELETE表示刪除。

2. @RequestMapping註解表明該方法處理那些URL對應的HTTP請求，也就是我們常說的URL路由（routing)，請求的分發工作是有Spring完成的。例如上面的代碼中http://localhost:8080/根路徑就被路由至greeting()方法進行處理。如果訪問http://localhost:8080/hello，則會出現404 Not Found錯誤，因爲我們並沒有編寫任何方法來處理/hello請求。

   4. 啓動項目SpringApplication.run

     啓動Spring Boot項目最簡單的方法就是執行下面的方法：

SpringApplication.run(Application.class, args);

      該方法返回一個ApplicationContext對象，使用註解的時候返回的具體類型是AnnotationConfigApplicationContext或AnnotationConfigEmbeddedWebApplicationContext，當支持web的時候是第二個。

除了上面這種方法外，還可以用下面的方法：

SpringApplication application = new SpringApplication(Application.class);
application.run(args);

SpringApplication包含了一些其他可以配置的方法，如果你想做一些配置，可以用這種方式。

除了上面這種直接的方法外，還可以使用SpringApplicationBuilder：

new SpringApplicationBuilder()
        .showBanner(false)
        .sources(Application.class)
        .run(args);

當使用SpringMVC的時候由於需要使用子容器，就需要用到SpringApplicationBuilder，該類有一個child(xxx...)方法可以添加子容器。

3.3  java代碼主要註解

     因爲默認和包有關的註解，默認包名都是當前類所在的包，例如@ComponentScan, @EntityScan, @SpringBootApplication註解。

     @RestController

     因爲我們例子是寫一個web應用，因此寫的這個註解，這個註解相當於同時添加@Controller和@ResponseBody註解。

     @EnableAutoConfiguration

      Spring Boot建議只有一個帶有該註解的類。

   @EnableAutoConfiguration作用：Spring Boot會自動根據你jar包的依賴來自動配置項目。例如當你項目下面有HSQLDB的依賴時，Spring Boot會創建默認的內存數據庫的數據源DataSource，如果你自己創建了DataSource，Spring Boot就不會創建默認的DataSource。

      如果你不想讓Spring Boot自動創建，你可以配置註解的exclude屬性，例如：

@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration {
}

        @SpringBootApplication

       由於大量項目都會在主要的配置類上添加@Configuration,@EnableAutoConfiguration,@ComponentScan三個註解。

       因此Spring Boot提供了@SpringBootApplication註解，該註解可以替代上面三個註解（使用Spring註解繼承實現）。

      注意：Spring Boot會自動掃描@SpringBootApplication所在類的同級包,以及下級包裏的所有BEAN，所以建議入口類放在最外層的包名下。

       @RequestMapping

       註解表明該方法處理那些URL對應的HTTP請求，也就是我們常說的URL路由（routing)，請求的分發工作是有Spring完成的。例如上面的代碼中http://localhost:8080/根路徑就被路由至greeting()方法進行處理。如果訪問http://localhost:8080/hello，則會出現404 Not Found錯誤，因爲我們並沒有編寫任何方法來處理/hello請求。

3.4  項目配置

Spring Boot最大的特色是“約定優先配置”，大量的默認配置對開發者十分的友好。但是在實際的應用開發過程中，默認配置不可能滿足所有場景，同時用戶也需要配置一些必須的配置項——例如數據庫連接信息。Spring Boot的配置系統能夠讓開發者快速的覆蓋默認約定，同時支持Properties配置文件和YAML配置文件兩種格式，默認情況下Spring Boot加載類路徑上的application.properties或application.yml文件，例如：

spring.datasource.url=jdbc:mysql://localhost/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

YAML格式更加簡潔：

spring:
  datasource:
    url: jdbc:mysql://localhost/test
    username: dbuser
    password: dbpass
    driver-class: com.mysql.jdbc.Driver

一旦發現這些信息，Spring Boot就會根據它們創建DataSource對象。另一個常見的配置場景是Web應用服務器：

# Server settings (ServerProperties)
server:
  port: 8080
  address: 127.0.0.1
  sessionTimeout: 30
  contextPath: /

  # Tomcat specifics
  tomcat:
    accessLogEnabled: false
    protocolHeader: x-forwarded-proto
    remoteIpHeader: x-forwarded-for
    basedir:
    backgroundProcessorDelay: 30 # secs

通過port和address可以修改服務器監聽的地址和端口，sessionTimeout配置session過期時間（再也不用修改web.xml了，因爲它根本不存在）。同時如果在生產環境中使用內嵌Tomcat，當然希望能夠配置它的日誌、線程池等信息，這些現在都可以通過Spring Boot的屬性文件配置，而不再需要再對生產環境中的Tomcat實例進行單獨的配置管理了。

下面是常用的一些配置項：

# tomcat最大線程數，默認爲200
server.tomcat.max-threads=800
# tomcat的URI編碼
server.tomcat.uri-encoding=UTF-8
# 存放Tomcat的日誌、Dump等文件的臨時文件夾，默認爲系統的tmp文件夾（如：C:\Users\Shanhy\AppData\Local\Temp）
server.tomcat.basedir=H:/springboot-tomcat-tmp
# 打開Tomcat的Access日誌，並可以設置日誌格式的方法：
#server.tomcat.access-log-enabled=true
#server.tomcat.access-log-pattern=
# accesslog目錄，默認在basedir/logs
#server.tomcat.accesslog.directory=
# 日誌文件目錄
logging.path=H:/springboot-tomcat-tmp
# 日誌文件名稱，默認爲spring.log
logging.file=myapp.log

4、Sping boot處理請求

@RequestMapping

   – 類定義處：提供初步的請求映射信息。相對於 WEB 應用的根目錄

   – 方法處：提供進一步的細分映射信息。相對於類定義處的 URL。若

     類定義處未標註 @RequestMapping，則方法處標記的 URL 相對於WEB 應用的根目錄

    DispatcherServlet 截獲請求後，就通過控制器上@RequestMapping 提供的映射信息確定請求所對應的處理方法。

@RequestMapping 除了可以使用請求 URL 映射請求外，還可以使用請求方法、請求參數及請求頭映射請求

4.1 URL路由

匹配多個URL

@RestController
public class Application {

    @RequestMapping("/")
    public String index() {
        return "Index Page";
    }

    @RequestMapping("/hello")
    public String hello() {
        return "Hello World!";
    }
}

@RequestMapping可以註解@Controller類：

@RestController
@RequestMapping("/classPath")
public class Application {
    @RequestMapping("/methodPath")
    public String method() {
        return "mapping url is /classPath/methodPath";
    }
}

method方法匹配的URL是/classPath/methodPath"。

 提示：可以定義多個@Controller將不同URL的處理方法分散在不同的類中

URL中的變量——PathVariable：獲取路徑中的參數

在Web應用中URL通常不是一成不變的，例如微博兩個不同用戶的個人主頁對應兩個不同的URL:http://weibo.com/user1，http://weibo.com/user2。我們不可能對於每一個用戶都編寫一個被@RequestMapping註解的方法來處理其請求，Spring MVC提供了一套機制來處理這種情況：

@RequestMapping("/users/{username}")
public String userProfile(@PathVariable("username") String username) {
    return String.format("user %s", username);
}

@RequestMapping("/posts/{id}")
public String post(@PathVariable("id") int id) {
    return String.format("post %d", id);
}

在上述例子中，URL中的變量可以用{variableName}來表示，同時在方法的參數中加上@PathVariable("variableName")，那麼當請求被轉發給該方法處理時，對應的URL中的變量會被自動賦值給被@PathVariable註解的參數（能夠自動根據參數類型賦值，例如上例中的int）。

4.2 HTTP請求方法和參數：

1）@RequestMapping( method = RequestMethod.POST, RequestMethod.GET) :指明http的請求方法是post還是get2）

2）@RequestParam :這個註解用來綁定單個請求數據，既可以是url中的參數，也可以是表單提交的參數和上傳的文件

     它有三個屬性:

      value用於設置參數名，

      defaultValue用於對參數設置默認值，

      required爲true時，如果參數爲空，會報錯.

對於HTTP請求除了其URL，還需要注意它的方法（Method）。例如我們在瀏覽器中訪問一個頁面通常是GET方法，而表單的提交一般是POST方法(method = RequestMethod.POST)。@Controller中的方法同樣需要對其進行區分：

package com.example.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.example.bean.RequestLoginBean;
import com.example.response.BaseResponse;
import com.google.gson.Gson;

@RestController
@RequestMapping(value = "/index")
public class Login {

	/**
	 * index home
	 * 
	 * @return
	 */
	@RequestMapping(value = "/home")
	public String home() {
		return "index home";
	}
	
	@RequestMapping(value = "/login", method = RequestMethod.GET)
	public String loginGet() {
		return "Login Page";
	}

	@RequestMapping(value = "/login", method = RequestMethod.POST)
	public String loginPost() {
		return "Login Post Request";
	}
	/**
	 * 得到1個參數
	 * 
	 * @param name
	 *            用戶名
	 * @return 返回結果
	 */
	@GetMapping(value = "/{name}")
	public String index(@PathVariable String name) {
		return "oh you are " + name + "<br> nice to meet you";// \n不起作用了,那就直接用html中的標籤吧
	}

	/**
	 * 簡單post請求
	 * 
	 * @param name
	 * @param pwd
	 * @return
	 */
	@RequestMapping(value = "/testpost", method = RequestMethod.POST)
	public String testpost() {
		System.out.println("hello  test post");
		return "ok";
	}

	/**
	 * 簡單post的body數據請求
	 * 
	 * @param name
	 * @param pwd
	 * @return
	 */
	@RequestMapping(value = "/testpost", method = RequestMethod.POST)
	public String testpost2(@RequestBody String dataJson) {
		System.out.println("hello  test post：" +dataJson);
		return "ok";
	}
	/**
	 * 同時得到兩個參數
	 * 
	 * @param name
	 *            用戶名
	 * @param pwd
	 *            密碼
	 * @return 返回結果
	 */
	@GetMapping(value = "/login/{name}&{pwd}")
	public String login(@PathVariable String name, @PathVariable String pwd) {
		if (name.equals("admin") && pwd.equals("admin")) {
			return "hello welcome admin";
		} else {
			return "oh sorry user name or password is wrong";
		}
	}

	/**
	 * 通過get請求去登陸
	 * 
	 * @param name
	 * @param pwd
	 * @return
	 */
	@RequestMapping(value = "/loginbyget", method = RequestMethod.GET)
	public String loginByGet(@RequestParam(value = "name", required = true) String name,
			@RequestParam(value = "pwd", required = true) String pwd) {
		return login4Return(name, pwd);
	}

	/**
	 * 通過post請求去登陸
	 * 
	 * @param name
	 * @param pwd
	 * @return
	 */
	@RequestMapping(value = "/loginbypost", method = RequestMethod.POST)
	public String loginByPost(@RequestParam(value = "name", required = true) String name,
			@RequestParam(value = "pwd", required = true) String pwd) {
		System.out.println("hello post");
		return login4Return(name, pwd);
	}

	/**
	 * 參數爲一個bean對象.spring會自動爲我們關聯映射
	 * @param loginBean
	 * @return
	 */
	@RequestMapping(value = "/loginbypost1", method = { RequestMethod.POST, RequestMethod.GET })
	public String loginByPost1(RequestLoginBean loginBean) {
		if (null != loginBean) {
			return login4Return(loginBean.getName(), loginBean.getPwd());
		} else {
			return "error";
		}
	}
	
	/**
	 * 請求內容是一個json串,spring會自動把他和我們的參數bean對應起來,不過要加@RequestBody註解
	 * 
	 * @param name
	 * @param pwd
	 * @return
	 */
	@RequestMapping(value = "/loginbypost2", method = { RequestMethod.POST, RequestMethod.GET })
	public String loginByPost2(@RequestBody RequestLoginBean loginBean) {
		if (null != loginBean) {
			return login4Return(loginBean.getName(), loginBean.getPwd());
		} else {
			return "error";
		}
	}

	


	/**
	 * 對登錄做出響應處理的方法
	 * 
	 * @param name
	 *            用戶名
	 * @param pwd
	 *            密碼
	 * @return 返回處理結果
	 */
	private String login4Return(String name, String pwd) {
		String result;
		BaseResponse response = new BaseResponse();
		if (name.equals("admin") && pwd.equals("admin")) {
			result = "hello welcome admin";
			response.setState(true);
		} else {
			result = "oh sorry user name or password is wrong";
			response.setState(false);
		}
		System.out.println("收到請求,請求結果:" + result);
		return new Gson().toJson(response);
	}
}

4.3 請求響應

    在之前所有的@RequestMapping註解的方法中，返回值字符串都被直接傳送到瀏覽器端並顯示給用戶。但是爲了能夠呈現更加豐富、美觀的頁面，我們需要將HTML代碼返回給瀏覽器，瀏覽器再進行頁面的渲染、顯示。

     一種很直觀的方法是在處理請求的方法中，直接返回HTML代碼，但是這樣做的問題在於——一個複雜的頁面HTML代碼往往也非常複雜，並且嵌入在Java代碼中十分不利於維護。更好的做法是將頁面的HTML代碼寫在模板文件中，渲染後再返回給用戶。爲了能夠進行模板渲染，需要將@RestController改成@Controller：

import org.springframework.ui.Model;

@Controller
public class HelloController {

    @RequestMapping("/hello/{name}")
    public String hello(@PathVariable("name") String name, Model model) {
        model.addAttribute("name", name);
        return "hello"
    }
}

     在上述例子中，返回值"hello"並非直接將字符串返回給瀏覽器，而是尋找名字爲hello的模板進行渲染，假如我們使用Thymeleaf模板引擎進行模板渲染，需要引入依賴：

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

接下來需要在默認的模板文件夾src/main/resources/templates/目錄下添加一個模板文件hello.html：

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Getting Started: Serving Web Content</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
    <p th:text="'Hello, ' + ${name} + '!'" />
</body>
</html>

th:text="'Hello, ' + ${name} + '!'"也就是將我們之前在@Controller方法裏添加至Model的屬性name進行渲染，並放入<p>標籤中（因爲th:text是<p>標籤的屬性）。模板渲染還有更多的用法，請參考Thymeleaf官方文檔。

4.4 處理靜態文件

      瀏覽器頁面使用HTML作爲描述語言，那麼必然也脫離不了CSS以及JavaScript。爲了能夠瀏覽器能夠正確加載類似/css/style.css, /js/main.js等資源。

      1、默認情況下我們只需要在src/main/resources/static目錄下添加css/style.css和js/main.js文件後，Spring MVC能夠自動將他們發佈，通過訪問/css/style.css, /js/main.js也就可以正確加載這些資源。這些資源經過編譯以後是在放在classes\static目錄下的。

     2 、可以在工程的根目錄直接建一個 "static"目錄（和src同級）。資源都放裏面。然後，就能訪問了。（這個不需要編譯）

     3、statis/和 src/main/resources/static目錄，如果是同一個靜態資源，如check.html. 優先訪問rc/main/resources/static/check.html。

5、實例：數據庫訪問

除了最基本的Web框架，另一種非常普遍的開發場景是訪問數據庫。在傳統的Spring應用中，訪問數據庫我們需要配置：

• 類路徑上添加數據庫訪問驅動
• 實例化DataSource對象，指定數據庫url, username, password等信息
• 注入JdbcTemplate對象，如果使用Hibernate，Mybatis等框架，還需要進一步配置框架信息

在Spring Boot中，上述過程會被簡化。首先在Maven項目依賴中定義：

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

spring-boot-starter-web-jdbc引入了spring-jdbc依賴，h2是一個內存關係型數據庫。在引入了這些依賴並啓動Spring Boot應用程序後，autoconfigure發現spring-jdbc位於類路徑中，於是：

• 根據類路徑上的JDBC驅動類型（這裏是h2，預定義了derby, sqlite, mysql, oracle, sqlserver等等），創建一個DataSource連接池對象，本例中的h2是內存數據庫，無需任何配置，如果是mysql, oracle等類型的數據庫需要開發者配置相關信息。
• 在Spring Context中創建一個JdbcTemplate對象（使用DataSource初始化）

接下來開發者的工作就非常簡單了，在業務邏輯中直接引入JdbcTemplate即可：

@Service
public class MyService {

    @Autowired
    JdbcTemplate jdbcTemplate;

}

除了spring-jdbc，Spring Boot還能夠支持JPA，以及各種NoSQL數據庫——包括MongoDB，Redis，全文索引工具elasticsearch, solr等等。

6、Production特性

      從前面的例子可以看出，Spring Boot能夠非常快速的做出一些原型應用，但是它同樣可以被用於生產環境。爲了添加生產環境特性支持，需要在Maven依賴中引入：

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

加入actuator依賴後，應用啓動後會創建一些基於Web的Endpoint：

• /autoconfig，用來查看Spring Boot的框架自動配置信息，哪些被自動配置，哪些沒有，原因是什麼。
• /beans，顯示應用上下文的Bean列表
• /dump，顯示線程dump信息
• /health，應用健康狀況檢查
• /metrics
• /shutdown, 默認沒有打開
• /trace

參考資料：

• 參考 Spring Boot 項目的官方網站，瞭解更多信息。
• 查看 Spring Boot 的參考文檔，學習更多關於 Spring Boot 的用法。
• 查看 InfoQ 上關於 Spring Boot 的介紹文章。
• 下載 Spring Boot 命令行工具。
• developerWorks Java 技術專區。  

感謝您的支持，我會繼續努力的! 掃碼打賞，你說多少就多少