Java Web基础入门

淡淡的烟草味﹌ 2022-06-03 23:15 212阅读 0赞

![timg_image_quality_80_size_b9999_10000_sec_1510489587800_di_367ad9e5c4515afa93b501d8db399296_imgtype_0_src_http_3A_2F_2Fa2.att.hudong.com_2F43_2F87_2F20300543669437145007874802107.jpg][]

![39e6aef0d951457ba627d5d64c6142b5_th.png][]

# 前言 #

语言都是相通的，只要搞清楚概念后就可以编写代码了。而概念是需要学习成本的。

作者：@Ryan-Miao  
本文为作者原创，转载请注明出处：[http://www.cnblogs.com/woshimrf/p/java-web-springboot.html][http_www.cnblogs.com_woshimrf_p_java-web-springboot.html]

# Java基础 #

不用看《编程思想》,基础语法看 [http://www.runoob.com/java/java-basic-syntax.html][http_www.runoob.com_java_java-basic-syntax.html] 就可以了，入门后想干啥干啥，如果感兴趣，如果有时间。

# Web #

这里讲的web是指提供API(Application Programming Interface)的能力。那么什么是API?

API是指server端和client端进行资源交互的通道。Client可以通过API来获取和修改server端的资源(Resource). 实际上，API差不多就是URL的代称，现阶段，推荐采用RESTfull API.

## RESTfull API ##

API表现方式就是URL(Uniform Resoure Locator)。RESTfull API是一个概念，规定了应该以什么样的结构去构建API，即应该如何拼接URL。先来看看URL是什么样子的。

![url.png][]

**资源（Resources）**  
path中的`groups`和`users`都是资源的名称，通过参数来确定资源的位置。

**行为/操作(Method)**  
我们通过约定的`Http Method`来表示对Resource的操作。

常用的HTTP动词有下面五个（括号里是对应的SQL命令）。

GET（SELECT）：从服务器取出资源（一项或多项）。 POST（CREATE）：在服务器新建一个资源。 PUT（UPDATE）：在服务器更新资源（客户端提供改变后的完整资源）。 PATCH（UPDATE）：在服务器更新资源（客户端提供改变的属性）。 DELETE（DELETE）：从服务器删除资源。

还有两个不常用的HTTP动词。

HEAD：获取资源的元数据。
    OPTIONS：获取信息，关于资源的哪些属性是客户端可以改变的。

示例:

GET /zoos：列出所有动物园
    POST /zoos：新建一个动物园
    GET /zoos/ID：获取某个指定动物园的信息
    PUT /zoos/ID：更新某个指定动物园的信息（提供该动物园的全部信息）
    PATCH /zoos/ID：更新某个指定动物园的信息（提供该动物园的部分信息）
    DELETE /zoos/ID：删除某个动物园 GET /zoos/ID/animals：列出某个指定动物园的所有动物 DELETE /zoos/ID/animals/ID：删除某个指定动物园的指定动物

当path的组成仍旧无法准确定位资源的时候，可以通过queryParam来进一步缩小范围。

?limit=10：指定返回记录的数量
    ?offset=10：指定返回记录的开始位置。
    ?page=2&per_page=100：指定第几页，以及每页的记录数。
    ?sortby=name&order=asc：指定返回结果按照哪个属性排序，以及排序顺序。
    ?animal_type_id=1：指定筛选条件

更多关于构建RESTfull API的信息，参阅[https://codeplanet.io/principles-good-restful-api-design/][https_codeplanet.io_principles-good-restful-api-design]

## ContentType ##

现在的接口都是基于JSON传输的，什么是JSON(JavaScript Object Notation)?

一个基于JSON的API的response应该包含以下header

Content-Type:application/json; charset=utf-8

## NodeJS Web ##

安装[NodeJS][]

然后，创建app.js, `npm install express --save`, `node app.js`， 访问`localhost:3000/`，`localhost:3000/json`

// 这句的意思就是引入 `express` 模块，并将它赋予 `express` 这个变量等待使用。
    var express = require('express');
    // 调用 express 实例，它是一个函数，不带参数调用时，会返回一个 express 实例，将这个变量赋予 app 变量。
    var app = express();
    
    // app 本身有很多方法，其中包括最常用的 get、post、put/patch、delete，在这里我们调用其中的 get 方法，为我们的 `/` 路径指定一个 handler 函数。
    // 这个 handler 函数会接收 req 和 res 两个对象，他们分别是请求的 request 和 response。
    // request 中包含了浏览器传来的各种信息，比如 query 啊，body 啊，headers 啊之类的，都可以通过 req 对象访问到。
    // res 对象，我们一般不从里面取信息，而是通过它来定制我们向浏览器输出的信息，比如 header 信息，比如想要向浏览器输出的内容。这里我们调用了它的 #send 方法，向浏览器输出一个字符串。
    app.get('/', function (req, res) { 
      res.send('Hello World');
    });
    
    app.get('/json', function (req, res) { 
      var rs = {};
      rs.id=1;
      rs.name = "Ryan";
    
      res.send(rs);
    });
    
    // 定义好我们 app 的行为之后，让它监听本地的 3000 端口。这里的第二个函数是个回调函数，会在 listen 动作成功后执行，我们这里执行了一个命令行输出操作，告诉我们监听动作已完成。
    app.listen(3000, function () { 
      console.log('app is listening at port 3000');
    });

## Java Web ##

Java Web的开源框架中，目前最常用的是SpringBoot. SpringBoot可以提供API，可以渲染页面，是作为API Server的最佳选择。

写了无数遍hello world, 这次还是要从hello world开始。

## demo source ##

[https://github.com/Ryan-Miao/springboot-demo-gradle][https_github.com_Ryan-Miao_springboot-demo-gradle]

Java Web的包管理工具有maven，gradle。这里将使用gradle作为依赖管理工具。

## Gradle是什么 ##

[gradle][]是继maven之后，Java项目构建工具的集大成者。它管理依赖，为什么要管理依赖？我们的项目中将会使用很多其他的lib，这些lib有我们自己的，也有开源的，甚至大部分都是开源的。当引入这些lib的时候，引入哪个版本？去哪里下载？多个版本产生了冲突怎么办？以及最后我们项目开发完成后，怎么打包？甚至，想使用CI/CD自动化构建工具，如何集成？这就是gradle可以做的事情。

gradle要怎么学？

一般来说不用学，不用理会内置的逻辑，只需要用就好。就好比IDE，你不会深究IDE是c编写的还是Java编写的，但会使用IDE来编写代码。同样，gradle的用法很简单，可以满足我们开发中觉得部分需求。当然，当需要自定义功能的时候，可以使用`groovy`来编写gradle脚本。

## IntelIj IDEA ##

IDEA是目前构建Java Web项目最火IDE。用法和Eclipse还是有不少的区别，刚转过来的时候可能有点不习惯。但根据2-8原则，我们只需要掌握其中一部分用法就可以开发了，剩下的高级用法可以在开发中慢慢摸索。即，其实用法也很简单。

## 新建一个gradle项目 ##

点击`File`\->`New`\->`project`\->`gradle`\->勾选`Java`  
![new.png_raw_true][]

如果发现没有JDK，那么new一个就好。

下一步，设置项目标签，group通常是公司名称倒写，比如`com.google`，`com.alibaba`等. ArtifactId就是我们的项目名称，比如这次demo为`springboot-demo`  
![group.png_raw_true][]

然后一路next，完成后确定。IDEA会下载gradle，下载简单的依赖，完毕后，项目根目录下多出几个文件，目前不用care。

.
    ├── build.gradle
    ├── gradle
    │   └── wrapper
    │       ├── gradle-wrapper.jar
    │       └── gradle-wrapper.properties
    ├── gradlew
    ├── gradlew.bat
    ├── settings.gradle
    └── src
        ├── main
        │   ├── java
        │   └── resources
        └── test
            ├── java
            └── resources

接下来修改`build.gradle`，这个文件是依赖管理的核心文件

buildscript {
        repositories {
            maven {
                url "http://maven.aliyun.com/nexus/content/groups/public/"
            }
            mavenCentral()
        }
        dependencies {
            classpath("org.springframework.boot:spring-boot-gradle-plugin:1.5.8.RELEASE")
        }
    }
    
    apply plugin: 'java'
    apply plugin: 'eclipse'
    apply plugin: 'idea'
    apply plugin: 'org.springframework.boot'
    
    jar {
        baseName = 'springboot-demo'
        version =  '0.1.0'
    }
    
    repositories {
        maven {
            url "http://maven.aliyun.com/nexus/content/groups/public/"
        }
        mavenCentral()
    }
    
    sourceCompatibility = 1.8
    targetCompatibility = 1.8
    
    dependencies {
        compile("org.springframework.boot:spring-boot-starter-web")
        testCompile('org.springframework.boot:spring-boot-starter-test')
    }

*  maven是一个仓库，一些开源的第三方库lib都从这里下载，这里引用了aliyun镜像，因为maven在国内访问比较慢，如果在国外可以移除这个节点
 *  `buildscript`里就这么写，不用关心为什么，只需要知道这里这样写就可以引入springboot的版本
 *  `dependencies`是唯一会改变和增加内容的地方，当需要第三方库的时候添加，添加规则就是`groupId:artifactId:version`, 正好和我们创建项目的时候声明的标签一样

修改`build.gradle`之后就要重新build，在IDEA中，点击右侧的工具栏，gradle，点击刷新按钮。就会自动下依赖，如果没有下载，点击gradle下Task里的`build`按钮。

另一个方式就是命令行：

细心可以发现项目根目录下有`gradlew`和`gradlew.bat`这个文件，这是分别为linux和windows准备的启动工具，在Linux系统中

./gradlew build
    or
    sh gradlew build

在windows中

gradlew build

编译完成后，在左侧的项目目录下的`External Libraties`下可以看到我们引入的第三方库。为什么这么多？因为依赖是树状的，或者说网状的。lib也有他自己的依赖，gradle会负责把我们引入的lib的依赖也给下载下来。在没有maven和gradle这种构建工具之前，项目开发都是自己下载jar，自己丢进去classpath里，很容遗漏，也很容易造成冲突。gralde会负责下载依赖，还会解决冲突，比如不同版本等问题。

## 开始编写服务端配置 ##

Springboot的一个优点是约定大于配置，意思是我们都约定好怎么配置，我帮你配置好了，你直接用就好。因此，springmvc时代的大部分配置都可以自动化完成。我们的启动类也只有一行.

可以看到，`src/main/java`这个目录变成蓝色，在IDEA里是指sourceSet，也就是源文件，我们的Java代码就是放在这文件下的，这也是约定好的。

在该目录下新建`com.test.demo.Application.java`

package com.test.demo;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    /** * Created by Ryan on 2017/11/13/0013. */
    @SpringBootApplication
    public class Application { 
    
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    }

到这里，我们的服务端就配置完毕了。运行main方法即可启动。

## 编写第一个API ##

虽然服务端配置好了，但并没有API. 新建`com.test.demo.controller.HelloController.java`

package com.test.demo.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    /** * Created by Ryan on 2017/11/14/0014. */
    @Controller
    public class HelloController { 
    
    
        @ResponseBody
        @GetMapping("/hello")
        public String hello(){
            return "{\"hello\":\"world\"}";
        }
    }

然后，再次运行main方法，启动完毕后，访问 [http://localhost:8080/hello][http_localhost_8080_hello], 第一个API开发完毕。

*  `@Controller`这个注解标注这个类是一个controller，用来接收请求和响应response
 *  `@GetMapping("/hello")`标注这个方法是一个路由请求实现，括号里就是我们的路由
 *  `@ResponseBody`这个注解标注这个API的返回值是json，其实就是再response的header里塞入了contentType, 当然，在这里还涉及到class转json的问题。那么，回到开始的问题，json是什么东西？

JSON在Java里没有这个数据结构，其实就是一个String，遵从JSON规则的String，我们的方法在返回这段String的时候，加上header里的contentType，浏览器就会当做JSON读取。在Javascript去读Ajax的结果就变成了一个JSON对象了。其他的，比如Android，读取出来的还是一个字符串，需要手动反序列化成我们想要的类。

说到序列化，我们不可能每个返回结构都这样拼接字符串吧。所以，`ResponseBody`标注的请求还会使用一个jackson的适配器，这些都是springboot内置的。暂时也不需要研究实现原理。jackson是什么鬼？

jackson是Java中使用最广泛的一个json解析lib，他可以将一个Java 类转变成一个json字符串，也同样可以把一个json字符串反序列化成一个java对象。Springboot是如何做到的？这就需要去研究源码了。

## 启动和调试 ##

最简单的是启动就是运行main方法，还可以命令行启动

gradlew bootRun

debug，最简单的就是以debug启动main方法。当然也可以远程。

gradlew bootRun --debug-jvm

![commandline-debug.png_raw_true][]

然后，在IDEA中，点击Edit configurations  
![edit-configurations.png_raw_true][]

选择remote  
![remote.png_raw_true][]  
![debug.png_raw_true][]

然后，点击debug  
![debug-start.png_raw_true][]

如果想支持热加载，则需要添加

compile("org.springframework.boot:spring-boot-devtools")

在IDEA里修改Java class后需要，重新build当前class才能生效。快捷键 `ctrl+shif+F9`

## 配置文件 ##

spring boot默认配置了很多东西，但有时候我们想要修改默认值，比如不想用8080作为端口，因为端口被占用了。

在`resources`下，新建`application.properties`, 然后在里面输入

server.port=8081

然后，重启项目，发现端口已经生效。

再配置一些common的自定义，比如日志。项目肯定要记录日志的，`System.out.println`远远达不到日志的要求。springboot默认采用`Logback`作为日志处理工具。

spring.output.ansi.enabled=ALWAYS
    logging.file=logs/demo.log
    logging.level.root=INFO

接着，开发和生产环境的配置必然不同的，比如数据库的地址不同，那么可以分配置文件来区分环境。

在resources下新建`application-dev.properties`, `application-prod.properties`. spring默认通过后缀不同来识别不同的环境，不加后缀的是base配置。那么如何生效呢？

只要在base的配置文件中

spring.profiles.active=dev

比如，我们在dev环境中设置loglevel为debug

logging.level.root=debug

这样，springboot会优先读取base文件，然后读取dev，当dev有相同的配置项时，dev会覆盖base。

这样，本地开发和生产环境隔离，部署也方便。事实上，springboot接收参数的优先级为`resources下的配置文件`<`命令行参数`. 通常，我们部署项目的脚本会使用命令行参数来覆盖配置文件，这样就可以动态指定配置文件了。

## 接收参数，响应JSON ##

新建一个controller, com.test.demo.controller.ParamController

package com.test.demo.controller;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /** * Created by Ryan on 2017/11/16/0016. */
    @RestController
    @RequestMapping("/param")
    public class ParamController { 
    
        private static final Logger LOGGER = LoggerFactory.getLogger(ParamController.class);
    
        @GetMapping("/hotels/{htid}/rooms")
        public List<Long> getRooms(
                @PathVariable String htid,
                @RequestParam String langId,
                @RequestParam(value = "limit", required = false, defaultValue = "10") int limit,
                @RequestParam(value = "offset", required = false, defaultValue = "1") int offset
        ){
            final Map<String, Object> params = new HashMap<>();
            params.put("hotelId", htid);
            params.put("langId", langId);
            params.put("limit", limit);
            params.put("offset", offset);
    
            LOGGER.info("The params is {}", params);
    
            List<Long> roomIds = new ArrayList<>();
            roomIds.add(1L);
            roomIds.add(2L);
            roomIds.add(3L);
    
            return roomIds;
        }
    }

*  LOG: 采用Sl4J接口
 *  参数： `@PathVariable` 可以接收url路径中的参数
 *  参数： `@RequestParam` 可以接收`?`后的query参数
 *  响应： `@RestController` == `@Controller+@ResponseBody`, 其实，`@ResponseBody`注解表明这个方法会返回json，会将Java类转换成JSON字符串，默认转换器为Jackason

### 参数为JSON ###

新建class com.test.demo.entity.Room

public class Room {
        private Integer roomId;
        private String roomName;
        private String comment;
    
        public Integer getRoomId() {
            return roomId;
        }
    
        public void setRoomId(Integer roomId) {
            this.roomId = roomId;
        }
    
        public String getRoomName() {
            return roomName;
        }
    
        public void setRoomName(String roomName) {
            this.roomName = roomName;
        }
    
        public String getComment() {
            return comment;
        }
    
        public void setComment(String comment) {
            this.comment = comment;
        }
    }

假设，我们需要保存一个Room信息，先来get一个

@GetMapping("/hotels/{htid}/rooms/{roomId}")
    public Room getRoomById(
            @PathVariable String htid,
            @PathVariable Integer roomId
    ){
    
        if (htid.equals("6606")){
            final Room room = new Room();
            room.setComment("None");
            room.setRoomId(roomId);
            room.setRoomName("豪华双人间");
    
            return room;
        }
    
        return null;
    }

然后保存一个

@PostMapping("/hotels/{htid}/rooms")
    public Integer addRoom(@RequestBody Room room){
        final Random random = new Random();
        final int id = random.nextInt(10);
        room.setRoomId(id);
    
        LOGGER.info("Add a room: {}", room);
    
        return id;
    }

![save-room.png_raw_true][]

### 接收数组参数 ###

@GetMapping("/hotels/{htid}/rooms/ids")
    public String getRoomsWithIds(@RequestParam List<Integer> ids){
        String s = ids.toString();
        LOGGER.info(s);
        return s;
    }

浏览器访问 [http://localhost:8081/param//hotels/6606/rooms/ids?ids=1,2,3][http_localhost_8081_param_hotels_6606_rooms_ids_ids_1_2_3]

## 参数校验 ##

我们除了一个个的if去判断参数，还可以使用注解

public class Room { 
        private Integer roomId;
        @NotEmpty
        @Size(min = 3, max = 20, message = "The size of room name should between 3 and 20")
        private String roomName;

只要在参数前添加`javax.validation.Valid`

@PostMapping("/hotels/{htid}/rooms")
        public Integer addRoom(
               @Valid @RequestBody Room room,
                @RequestHeader(name = "transactionId") String transactionId
        ){

![valid.png_raw_true][]

## 静态文件 ##

在springboot中，static content默认寻找规则是

> By default Spring Boot will serve static content from a directory called `/static` (or `/public` or `/resources` or `/META-INF/resources`) in the classpath or from the root of the ServletContext.

在`resources`下新建文件夹 `static`,  
src\\main\\resources\\static\\content.html

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Hello static content</title>
        <script src="/js/test.js"></script>
    </head>
    
    
    <body>
    <h1>Static Content</h1>
    
    <p>Static content is the files that render directly, the file is the whole content. The different between template is that
    the template page will be resolved by server and then render out.
    </p>
    </body>
    </html>

浏览器访问： [http://localhost:8081/content.html][http_localhost_8081_content.html]

同理，放在static下的文件都可以通过如此映射访问。

## 模板文件 ##

模板文件是指通过服务端生成的文件。比如Jsp，会经过servlet编译后，最终生成一个html页面。Springboot默认支持以下几种模板：

> FreeMarker  
> Groovy  
> Thymeleaf  
> Mustache

JSP在jar文件中的表现有问题，除非部署为war。

官方推荐的模板为`Thymeleaf`， 在depenency中添加依赖：

compile("org.springframework.boot:spring-boot-starter-thymeleaf")

rebuild.

SpringBoot默认模板文件读取位置为：`src\main\resources\templates`. 新建 `src\main\resources\templates\home.html`

<!DOCTYPE html>
    <html xmlns:th="http://www.thymeleaf.org">
    <head lang="en">
        <meta charset="UTF-8"/>
        <title>Home</title>
    </head>
    <body>
    <h1>Template content</h1>
    
    <p th:text="${msg} + ' The current user is:' + ${user.name}">Welcome!</p>
    
    
    </body>
    </html>

模板文件只能通过服务端路由渲染，也就是说不能像刚开始静态文件那样直接路由过去。

创建一个controller， `com.test.demo.controller.HomeController`

package com.test.demo.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /** * Created by Ryan on 2017/11/18/0018. */
    @Controller
    public class HomeController { 
    
        @RequestMapping("/home")
        public String index(Model model, String name){
            final Map<String, Object> user = new HashMap<>();
            user.put("name", name);
    
            model.addAttribute("user", user);
            model.addAttribute("msg", "Hello World!");
            return "home";
        }
    }

这个和之前的API的接口有一点不同，首先是没有`@ResponseBody`注解，然后是方法的返回值是一个String，这个String不是value，而是指模板文件的位置，相对于`templates`的位置。

浏览器访问：[http://localhost:8081/home?name=Ryan123][http_localhost_8081_home_name_Ryan123]

方法参数的`Model`是模板文件的变量来源，模板文件从这个对象里读取变量，将这个类放到参数里，Spring会自动注入这个类，绑定到模板文件。这里，放入两个变量。

在模板端，就可以读取这个变量了。

为什么要这么做？既然有了静态文件，为什么还要模板文件？

首先，这是早期web开发的做法，之前是没有web 前端这个兵种的，页面从静态页面变成动态页面，代表就是jsp，php等。模板文件的有个好处是，服务端可以控制页面，比如从session中拿到用户信息，放入页面。这个在静态页面是做不到的。

然而，现在前后端的分离实践，使得模板文件的作用越来越小。目前主要用于基础数据传递，其他数据则通过客户端的异步请求获得。

当然，随着页面构建复杂，异步请求太多，首屏渲染时间越来越长，严重影响了用户体验，比如淘宝双11的宣传页。这时候，服务端渲染的优势又体现出来了，静态页面直接出数据，不需要多次的ajax请求。

## 跨域 ##

> Cross-origin resource sharing (CORS) is a W3C specification implemented by most browsers that allows you to specify in a flexible way what kind of cross domain requests are authorized, instead of using some less secure and less powerful approaches like IFRAME or JSONP.

CORS是浏览器的一种安全保护，隔离不同域名之间的可见度。比如，不允许把本域名下cookie发送给另一个域名，否则cookie被钓鱼后，黑客就可以模拟本人登陆了。更多细节参考[MDN][]

为什么浏览器要拒绝cors?  
摘自博客园

![2009040916453171.jpg][]

cors执行过程摘自[自由的维基百科][Link 1]  
![Flowchart_showing_Simple_and_Preflight_XHR.svg][]

首先，本地模拟跨域请求。

我们当前demo的域名为`localhost:8081`，现在新增一个本地域名, 在HOSTS文件中新增：

127.0.0.1   corshost

然后，访问[http://corshost:8081][http_corshost_8081]，即本demo。

新增src\\main\\resources\\static\\cors.html

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Test Cors</title>
    </head>
    <body>
    
    <script src="http://cdn.staticfile.org/jquery/3.2.1/jquery.min.js"></script>
    
    <script> $.ajax({ url: "http://localhost:8081/hello", success: function(data){ console.log(data); }}); </script>
    </body>
    </html>

访问之前创建的hello接口，可以看到访问失败，

Failed to load http://localhost:8081/hello: No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://corshost:8081' is therefore not allowed access.

这是浏览器正常的行为。

但，由于前后端分离，甚至分开部署，域名肯定不会是同一个了，那么就需要支持跨域。Springboot支持跨域，解决方案如下：

在需要跨域的method上，添加一个`@CrossOrigin`注解即可。

@CrossOrigin(origins = {
       "http://corshost:8081"})
    @ResponseBody
    @GetMapping("/hello")
    public String hello(){
        return "{\"hello\":\"world\"}";
    }

如果是全局配置允许跨域，新建`com.test.demo.config.CorsConfiguration`

package com.test.demo.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.CorsRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
    
    /** * Created by Ryan on 2017/11/18/0018. */
    @Configuration
    public class CorsConfiguration {
    
        @Bean
        public WebMvcConfigurer corsConfigurer() {
            return new WebMvcConfigurerAdapter() {
                @Override
                public void addCorsMappings(CorsRegistry registry) {
                    registry.addMapping("/api/**")
                            .allowedOrigins("http://domain2.com")
                            .allowedMethods("PUT", "DELETE")
                            .allowedHeaders("header1", "header2", "header3")
                            .exposedHeaders("header1", "header2")
                            .allowCredentials(false).maxAge(3600);
                }
            };
        }
    }

## 部署 ##

刚开始看Springboot的时候看到推荐使用`fat jar`部署，于是[记录][Link 2]下来。后面看到公司的生产环境中既有使用war也有使用jar的，为了方便，非不得已，还是使用jar来部署。

首先，打包：

gradlew cl

## 引入MySQL/MariaDB ##

MySQL被Oracle收走之后，他的father另外创建了新的社区分支[MariaDB][], 据说用法和MySQL一致。然后，各大Linux开源系统都预置了MariaDB。 当然，由于新出没多久，市场还不够开阔。根据\[DB-Engines Ranking\]发布的[2017年11月份排行][2017_11]， MySQL几乎完全接近Oracle，排名第二。而MariaDB的上升之路还比较遥远。So，还是入手MySQL靠谱。因为开源技术的掌握能力和跳槽能力成正相关。

### 安装MySQL ###

MAC安装参考[Mac install MySQL][]。

Windows安装

去[官网][Link 3]下载安装包(mysql-5.7.20-winx64.zip). 当然，需要先注册oracle账号。

解压当目录，然后将bin目录加入环境变量，同Java设置环境变量。这里再次演示下。复制bin目录地址，我的为`D:\data\mysql\mysql-5.7.20-winx64\bin`, 在`此电脑`右键，–> 属性 –> 高级系统设置 –> 高级 –> 环境变量 –> 在系统环境变量中找到path –> 新建 –> 填入 –> 确认。

然后，重新打开cmd。输入`mysqld --initialize --console`

C:\Users\Ryan
    λ mysqld --initialize --console
    mysqld: Could not create or access the registry key needed for the MySQL application to log to the Windows EventLog. Run the application with sufficient privileges once to create the key, add the key manually, or turn off logging for that application. 2017-11-26T05:22:48.434089Z 0 [Warning] TIMESTAMP with implicit DEFAULT value is deprecated. Please use --explicit_defaults_for_timestamp server option (see documentation for more details). 2017-11-26T05:22:48.437096Z 0 [ERROR] Cannot open Windows EventLog; check privileges, or start server with --log_syslog=0 2017-11-26T05:22:49.148986Z 0 [Warning] InnoDB: New log files created, LSN=45790 2017-11-26T05:22:49.276866Z 0 [Warning] InnoDB: Creating foreign key constraint system tables. 2017-11-26T05:22:49.370828Z 0 [Warning] No existing UUID has been found, so we assume that this is the first time that this server has been started. Generating a new UUID: d7e6ac05-d269-11e7-a91e-9883891ed8e3. 2017-11-26T05:22:49.383970Z 0 [Warning] Gtid table is not ready to be used. Table 'mysql.gtid_executed' cannot be opened. 2017-11-26T05:22:49.398975Z 1 [Note] A temporary password is generated for root@localhost: /r.Vtktfl9FN

复制我们的临时密码`/r.Vtktfl9FN`.

命令行启动MySQL：

mysqld --console

新开一个cmd，命令行输入账号密码`mysql -u root -p`

C:\Users\Ryan
    λ mysql -u root -p
    Enter password: ************
    Welcome to the MySQL monitor.  Commands end with ; or \g.
    Your MySQL connection id is 3
    Server version: 5.7.20
    
    Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
    
    Oracle is a registered trademark of Oracle Corporation and/or its
    affiliates. Other names may be trademarks of their respective
    owners.
    
    Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
    
    mysql>

然后就连接到MySQL了。第一个命令行就是启动mysql，第二个命令行就是client，连接MySQL。现在修改我们的`root`密码

mysql> set password=password('123456');
    Query OK, 0 rows affected, 1 warning (0.00 sec)

然后，关闭client，输入`exit`退出。 重新以新密码123456登陆(不要自己难为自己，设置密码为123456是最佳选择).

确认成功就安装完毕。账号为`root`, 密码为`123456`。

### 基本操作 ###

关于MySQL的基本语法，学习[http://www.runoob.com/mysql/mysql-tutorial.html][http_www.runoob.com_mysql_mysql-tutorial.html] 即可。

这里简单记录几个简单的概念。

#### database ####

MySQL以不同的database为单位存储数据。所以，开发数据库的时候，先要创建一个database。

查看已有的database

创建我们的database

mysql> create database if not exists springboot_demo charset utf8 collate utf8_general_ci;
    Query OK, 1 row affected (0.01 sec)

进入database：

mysql> use springboot_demo
    Database changed

#### 创建表 ####

查看当前database的所有表

mysql> use springboot_demo
    Database changed
    mysql> show tables;
    Empty set (0.00 sec)

创建一个表`room`

mysql> create table if not exists room (
        -> id INT(11) NOT NULL AUTO_INCREMENT,
        -> `name` VARCHAR(80) NOT NULL,
        -> `comment` VARCHAR(200),
        -> create_date DATE,
        -> update_date DATE,
        -> PRIMARY KEY(id)
        -> )ENGINE=InnoDB DEFAULT CHARSET=utf8;
    Query OK, 0 rows affected (0.08 sec)

*  `create table` 创建表
 *  `if not exists` 如果不存在则创建
 *  `room` 表名
 *  `id` 表字段，字段名为`id`, `NOT NULL`表示会给这个字段建立非空索引，当存入空时会报错。如果不写明`NOT NULL`，则默认该字段可以为空。
 *  `AUTO_INCREMENT`表示这个字段会自动增加，即当保存一条记录的时候，如果不传入`id`这个字段，则该字段会从系统序列中取出一个。该序列是一个递增序列。即实现了每次id都增加1
 *  `反引号`包裹字段名是为了防止与关键字冲突
 *  `INT` 是指数字类型，括号里的`11`是指MySQL里的显示宽度，和最大值取值范围无关，是指需要多少位来表示这个数字，不够长度的补齐。int最大值为`2147483647`
 *  `VARCHAR`是变长字符串，即当存储1个字符，则占用空间就是1个字节，当存储2个字符，则占用空间为2个字符。与之对应的是`char`定长。括号里的是指字符的个数，即最大允许200个字符。
 *  `DATA`是日期类型，通常每条记录都需要记录创建时间和更新时间
 *  `PRIMARY KEY`表示这个字段是`主键`，即该记录的唯一标识符。

#### 插入一条记录 ####

mysql> insert into room(`name`, `comment`, `create_date`, `update_date`) values ("大床房", "", "2017-11-26","2017-11-26 11:00:00");
    Query OK, 1 row affected, 1 warning (0.01 sec)
    
    mysql>insert into room(`name`, `comment`, `create_date`, `update_date`) values ("双人床房", "有窗户", "2017-11-26","201 7-11-26 11:00:00");
    Query OK, 1 row affected, 1 warning (0.01 sec)

#### 查看所有记录 ####

mysql> select * from room; +----+----------+---------+-------------+-------------+
    | id | name | comment | create_date | update_date | +----+----------+---------+-------------+-------------+
    |  1 | 大床房   |         | 2017-11-26  | 2017-11-26  |
    | 2 | 双人床房 | 有窗户 | 2017-11-26 | 2017-11-26 | +----+----------+---------+-------------+-------------+
    2 rows in set (0.00 sec)

#### 更新一条记录 ####

mysql> update room set comment="无窗" where id=1;
    Query OK, 1 row affected (0.01 sec)
    Rows matched: 1  Changed: 1  Warnings: 0
    
    mysql> select * from room; +----+----------+---------+-------------+-------------+
    | id | name | comment | create_date | update_date | +----+----------+---------+-------------+-------------+
    |  1 | 大床房   | 无窗    | 2017-11-26  | 2017-11-26  |
    | 2 | 双人床房 | 有窗户 | 2017-11-26 | 2017-11-26 | +----+----------+---------+-------------+-------------+
    2 rows in set (0.00 sec)

#### 删除一条记录 ####

mysql> delete from room where id = 2;
    Query OK, 1 row affected (0.01 sec)
    
    mysql> select * from room; +----+--------+---------+-------------+-------------+
    | id | name | comment | create_date | update_date | +----+--------+---------+-------------+-------------+
    | 1 | 大床房 | 无窗 | 2017-11-26 | 2017-11-26 | +----+--------+---------+-------------+-------------+
    1 row in set (0.00 sec)

到此，增删改查语句复习完毕。开始引入项目。

## 项目连接MySQL ##

保持MySQL打开状态。

引入mysql驱动和spring-jdbc

compile("org.springframework.boot:spring-boot-starter-jdbc")
    compile group: 'mysql', name: 'mysql-connector-java', version: '6.0.6'

修改配置文件，新增：

spring.datasource.url=jdbc:mysql://localhost:3306/springboot_demo?serverTimezone=UTC&characterEncoding=utf-8
    spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.driver-class-name=com.mysql.jdbc.Driver

新建com.test.demo.config.DBConfiguration

package com.test.demo.config;
    
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.jdbc.core.JdbcTemplate;
    
    import javax.sql.DataSource;
    
    @Configuration
    public class DBConfiguration { 
    
        @Bean
        public JdbcTemplate jdbcTemplate(@Qualifier("dataSource") DataSource dataSource) {
            return new JdbcTemplate(dataSource);
        }
    }

*  `@Configuration` 标注这个类是一个配置类，spring会自动扫描这个注解，将里面的配置运行。
 *  `@Bean` 标注声明一个Bean，由spring管理，在需要的地方注入。
 *  `@Qualifier("dataSource")` @Bean的参数列表中对象会从spring容器中查找bean，找到后注入参数。而`Qualifier`则声明要注入的bean的name或者id是什么，这在spring容器包含2个以上同类型的bean的时候有用。
 *  `DataSource` 这个对象是springboot自动创建的，通过扫描配置类里的配置，当检测到有配置datasource的时候会创建这个bean。于是，在这里就可以注入了，即我们配置的那几个属性。
 *  `JdbcTemplate` 一个封装了对DB操作的library, 通过它来对数据库操作。

下面写一个测试来测试是否联通了。在src/test/java下，新建com.test.demo.config.DBConfigurationTest

package com.test.demo.config;
    
    import com.test.demo.Application;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.context.annotation.Import;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.List;
    import java.util.Map;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    @Import({Application.class, DBConfiguration.class})
    public class DBConfigurationTest { 
    
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
        @Test
        public void testSelect() {
    
            List<Map<String, Object>> maps = jdbcTemplate.queryForList("select * from room");
            System.out.println(maps);
        }
    }

控制太打印出刚才的数据库中的数据：

[{
       id=1, name=大床房, comment=无窗, create_date=2017-11-26, update_date=2017-11-26}]

*  `@RunWith(SpringRunner.class)`运行spring容器的测试
 *  `@SpringBootTest` springboot测试
 *  `@Import({Application.class, DBConfiguration.class})` 导入我们需要的配置
 *  `@Autowired`自动注入属性，刚才在Configuration中声明了一个Bean，在这里通过这个注解获取那个bean
 *  `@Test` 这是一个JUnit测试

## JDBCTemplate ##

## 分层架构 ##

## DI ##

## 面向接口编程 ##

## 编写测试 ##

## 集成CI ##

## 登陆拦截 ##

## OAuth2.0 ##

## 事物 ##

## JPA ##

## 缓存 ##

## 远程调用 ##

# 参考 #

*  [https://codeplanet.io/principles-good-restful-api-design/][https_codeplanet.io_principles-good-restful-api-design]
 *  [https://github.com/aisuhua/restful-api-design-references][https_github.com_aisuhua_restful-api-design-references]
 *  [http://www.jianshu.com/p/5659e6e16115][http_www.jianshu.com_p_5659e6e16115]
 *  [https://www.zhihu.com/question/28557115][https_www.zhihu.com_question_28557115]

[timg_image_quality_80_size_b9999_10000_sec_1510489587800_di_367ad9e5c4515afa93b501d8db399296_imgtype_0_src_http_3A_2F_2Fa2.att.hudong.com_2F43_2F87_2F20300543669437145007874802107.jpg]: https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1510489587800&di=367ad9e5c4515afa93b501d8db399296&imgtype=0&src=http%3A%2F%2Fa2.att.hudong.com%2F43%2F87%2F20300543669437145007874802107.jpg
[39e6aef0d951457ba627d5d64c6142b5_th.png]: /images/20220604/6a7fb9a684f64f5fa5d44dfb620007d1.png
[http_www.cnblogs.com_woshimrf_p_java-web-springboot.html]: http://www.cnblogs.com/woshimrf/p/java-web-springboot.html
[http_www.runoob.com_java_java-basic-syntax.html]: http://www.runoob.com/java/java-basic-syntax.html
[url.png]: /images/20220604/7c707a63c51f4c3f979eead1b2c3e8cf.png
[https_codeplanet.io_principles-good-restful-api-design]: https://codeplanet.io/principles-good-restful-api-design/
[NodeJS]: http://www.cnblogs.com/woshimrf/p/nodejs-enrionment-install.html
[https_github.com_Ryan-Miao_springboot-demo-gradle]: https://github.com/Ryan-Miao/springboot-demo-gradle
[gradle]: https://gradle.org/
[new.png_raw_true]: https://github.com/Ryan-Miao/springboot-demo-gradle/blob/master/doc/new.png?raw=true
[group.png_raw_true]: https://github.com/Ryan-Miao/springboot-demo-gradle/blob/master/doc/group.png?raw=true
[http_localhost_8080_hello]: http://localhost:8080/hello
[commandline-debug.png_raw_true]: https://github.com/Ryan-Miao/springboot-demo-gradle/blob/master/doc/commandline-debug.png?raw=true
[edit-configurations.png_raw_true]: /images/20220604/528c20414a5d4b36b538a1a86966feff.png
[remote.png_raw_true]: /images/20220604/6cdcd86faa6a4b08b30e31f6cfb4218e.png
[debug.png_raw_true]: /images/20220604/c9402b9f25ce4f6da7339a6c38e3c3fd.png
[debug-start.png_raw_true]: /images/20220604/01db4dac855d402b921b7906f52ffc21.png
[save-room.png_raw_true]: /images/20220604/c3c891dac28a46b099b989dbbeb2f055.png
[http_localhost_8081_param_hotels_6606_rooms_ids_ids_1_2_3]: http://localhost:8081/param//hotels/6606/rooms/ids?ids=1,2,3
[valid.png_raw_true]: /images/20220604/364190d35748487ba7a36ba4827a1a0f.png
[http_localhost_8081_content.html]: http://localhost:8081/content.html
[http_localhost_8081_home_name_Ryan123]: http://localhost:8081/home?name=Ryan123
[MDN]: https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Access_control_CORS
[2009040916453171.jpg]: /images/20220604/20d0923013a9401a8ceb3ff4dcd1940d.png
[Link 1]: https://en.wikipedia.org/wiki/Cross-origin_resource_sharing
[Flowchart_showing_Simple_and_Preflight_XHR.svg]: https://upload.wikimedia.org/wikipedia/commons/c/ca/Flowchart_showing_Simple_and_Preflight_XHR.svg
[http_corshost_8081]: http://corshost:8081
[Link 2]: http://www.cnblogs.com/woshimrf/p/springboot-jar.html
[MariaDB]: https://downloads.mariadb.org/mariadb/10.2.10/
[2017_11]: https://db-engines.com/en/ranking
[Mac install MySQL]: http://ryan-miao.github.io/2017/06/28/mac-install-mysql/
[Link 3]: https://dev.mysql.com/downloads/mysql/
[http_www.runoob.com_mysql_mysql-tutorial.html]: http://www.runoob.com/mysql/mysql-tutorial.html
[https_github.com_aisuhua_restful-api-design-references]: https://github.com/aisuhua/restful-api-design-references
[http_www.jianshu.com_p_5659e6e16115]: http://www.jianshu.com/p/5659e6e16115
[https_www.zhihu.com_question_28557115]: https://www.zhihu.com/question/28557115