Spring Boot(1)-构建应用实践

秒速五厘米 2022-07-27 13:41 6阅读 0赞

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/][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、本地构建准备 #

--------------------

**本地构建准备：**

>  *  IDE（Eclipse、Idea Intellij）
>  *  Java环境（JDK 1.7或以上版本）
>  *  Maven 3.0+（Eclipse和Idea IntelliJ内置，如果使用IDE并且不使用命令行工具可以不安装）

spring-boot是一个mavan项目，所以其使用的jar包全部是通过maven管理，使用maven也是非常方便的。

spring-boot打出来的包是一个可执行jar包的状态，使用的是内置的tomcat服务器，所以不需要将项目转成EJB项目

**1) Eclipse安装maven插件**

点击菜单 Help -> Install new software 进行插件安装

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hndWlzdQ_size_16_color_FFFFFF_t_70][]

如果你已经成功安装了这个插件，当你打开Window→ Preferences...的时候，你应该能够在一个选项列表中看到一个Maven选项

安装好m2eclipse插件后,要作两个设置:

a) 禁用Downloadrepository index updates on startup(即取消这个选项的勾选,第三个第四个可以点上),如下图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hndWlzdQ_size_16_color_FFFFFF_t_70 1][]

b) 设置maven的setting.xml文件路径

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hndWlzdQ_size_16_color_FFFFFF_t_70 2][]

# 2、创建应用 #

--------------------

使用Spring Boot框架可以大大加速Web应用的开发过程，首先在Maven项目依赖中引入`spring-boot-starter-web`：

我们在Eclipse 创建maven项目：

![Center][]

![20160801155911248][]

填写GroupId和artifactId

![20160801160006394][]

后生成：

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 文件

<table> 
 <thead> 
  <tr> 
   <th style="vertical-align:top;">名称</th> 
   <th style="vertical-align:top;">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter</td> 
   <td style="vertical-align:top;">核心 POM，包含自动配置支持、日志库和对 YAML 配置文件的支持。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-amqp</td> 
   <td style="vertical-align:top;">通过 spring-rabbit 支持 AMQP。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-aop</td> 
   <td style="vertical-align:top;">包含 spring-aop 和 AspectJ 来支持面向切面编程（AOP）。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-batch</td> 
   <td style="vertical-align:top;">支持 Spring Batch，包含 HSQLDB。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-data-jpa</td> 
   <td style="vertical-align:top;">包含 spring-data-jpa、spring-orm 和 Hibernate 来支持 JPA。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-data-mongodb</td> 
   <td style="vertical-align:top;">包含 spring-data-mongodb 来支持 MongoDB。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-data-rest</td> 
   <td style="vertical-align:top;">通过 spring-data-rest-webmvc 支持以 REST 方式暴露 Spring Data 仓库。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-jdbc</td> 
   <td style="vertical-align:top;">支持使用 JDBC 访问数据库。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-security</td> 
   <td style="vertical-align:top;">包含 spring-security。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-test</td> 
   <td style="vertical-align:top;">包含常用的测试所需的依赖，如 JUnit、Hamcrest、Mockito 和 spring-test 等。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-velocity</td> 
   <td style="vertical-align:top;">支持使用 Velocity 作为模板引擎。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-web</td> 
   <td style="vertical-align:top;">支持 Web 应用开发，包含 Tomcat 和 spring-mvc。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-websocket</td> 
   <td style="vertical-align:top;">支持使用 Tomcat 开发 WebSocket 应用。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-ws</td> 
   <td style="vertical-align:top;">支持 Spring Web Services。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-actuator</td> 
   <td style="vertical-align:top;">添加适用于生产环境的功能，如性能指标和监测等功能。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-remote-shell</td> 
   <td style="vertical-align:top;">添加远程 SSH 支持。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-jetty</td> 
   <td style="vertical-align:top;">使用 Jetty 而不是默认的 Tomcat 作为应用服务器。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-log4j</td> 
   <td style="vertical-align:top;">添加 Log4j 的支持。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-logging</td> 
   <td style="vertical-align:top;">使用 Spring Boot 默认的日志框架 Logback。</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:top;">spring-boot-starter-tomcat</td> 
   <td style="vertical-align:top;">使用 Spring Boot 默认的 Tomcat 作为应用服务器。</td> 
  </tr> 
 </tbody> 
</table>

所有这些 POM 依赖的好处在于为开发 Spring 应用提供了一个良好的基础。Spring Boot 所选择的第三方库是经过考虑的，是比较适合产品开发的选择。但是 Spring Boot 也提供了不同的选项，比如日志框架可以用 Logback 或 Log4j，应用服务器可以用 Tomcat 或 Jetty。

## 3.2  java代码 ##

创建`src/main/java/Application.java`:

类似如下结构：

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会创建默认的内存[数据库][Link 1]的数据源`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官方文档][Thymeleaf 1]。

## 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 项目的[官方网站][Link 2]，了解更多信息。
 *  查看 Spring Boot 的[参考文档][Link 3]，学习更多关于 Spring Boot 的用法。
 *  查看 InfoQ 上关于 [Spring Boot][] 的介绍文章。
 *  下载 [Spring Boot 命令行工具][Spring Boot 1]。
 *  [developerWorks Java 技术专区][developerWorks Java]。

感谢您的支持，我会继续努力的! 扫码打赏，你说多少就多少

![20170331111807982][]          ![20170331111745092][]

[http_docs.spring.io_spring-boot_docs_current_reference_html]: http://docs.spring.io/spring-boot/docs/current/reference/html/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hndWlzdQ_size_16_color_FFFFFF_t_70]: /images/20220727/21e4dffc4cbc48289f947a6e90aa6234.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hndWlzdQ_size_16_color_FFFFFF_t_70 1]: /images/20220727/33743d2810e540bea7107edc1b18a803.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hndWlzdQ_size_16_color_FFFFFF_t_70 2]: /images/20220727/0a80b5b742b6478eab3415bd7f5e1a60.png
[Center]: /images/20220727/727d7c911cc046f0872632c0501e8ed8.png
[20160801155911248]: /images/20220727/1668e56dfbc342b8b54fbe9bbfcfe96b.png
[20160801160006394]: /images/20220727/b4a7b906097c46f594f376a1bd4d7cfa.png
[Link 1]: http://lib.csdn.net/base/14
[Thymeleaf]: http://www.thymeleaf.org/
[Thymeleaf 1]: http://www.thymeleaf.org/doc/tutorials/2.1/usingthymeleaf.html
[Link 2]: http://projects.spring.io/spring-boot/
[Link 3]: http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle
[Spring Boot]: http://www.infoq.com/cn/articles/microframeworks1-spring-boot
[Spring Boot 1]: http://repo.spring.io/release/org/springframework/boot/spring-boot-cli/1.1.4.RELEASE/spring-boot-cli-1.1.4.RELEASE-bin.zip
[developerWorks Java]: http://www.ibm.com/developerworks/cn/java/
[20170331111807982]: https://img-blog.csdn.net/20170331111807982
[20170331111745092]: /images/20220727/4b3e046360c541e2949cef6bfc6c0cc5.png