文章概要

Spring Boot 入门教程，包含且不仅限于使用Spring Boot构建API、使用Thymeleaf模板引擎以及Freemarker模板引擎渲染视图、使用MyBatis操作数据库等等。
本教程示例代码：https://github.com/ken-io/springboot-course
本系列所有代码示例都是基于Spring Boot 1.5.x，如果想在Spring Boot 2.0 环境下运行示例代码，需要注意配置中所有项都要修改为以小写字母命名。

使用Spring Boot构建第一个Web应用程序

一、前言

什么是Spring Boot？

Spring Boot就是一个让你使用Spring构建应用时减少配置的一个框架。约定优于配置，一定程度上提高了开发效率。https://zhuanlan.zhihu.com/p/22920391
另外Spring是一个IOC框架，如果之前未使用过IOC框架建议先了解下IOC：https://zh.wikipedia.org/wiki/%E6%8E%A7%E5%88%B6%E5%8F%8D%E8%BD%AC

本篇开发环境

1、操作系统： Windows 10 X64
2、Java SDK： jdk-8u141
3、Maven：3.5
4、IDE：IntelliJ IDEA 2017
5、Spring Boot：1.5.6

二、构建项目

1、创建项目并引入Spring Boot

  • 使用Maven项目模板创建项目

Spring Boot 入门教程 - 图1
项目模板：maven-archetype-webapp
GroupId:io.ken.springboot-course
ArtifactId:springboot-course

  • 创建Sources Root

Spring Boot 入门教程 - 图2
(1)在src/main创建文件夹：java，并使用右键菜单Mark Directory AS->Sources Root
(2)设置将src/resources Mark：使用右键菜单Mark Directory AS->Resources Root

  • 在pom.xml中引入spring boot
    1. <parent>
    2.   <groupId>org.springframework.boot</groupId>
    3.   <artifactId>spring-boot-starter-parent</artifactId>
    4.   <version>1.5.6.RELEASE</version>
    5. </parent>
    6. <dependencies>
    7.   <dependency>
    8.       <groupId>org.springframework.boot</groupId>
    9.       <artifactId>spring-boot-starter-web</artifactId>
    10.   </dependency>
    11. </dependencies>

    Ctrl + 鼠标左键点击 groupId/artifactId 可以查看引用的Packge的依赖等信息

2、创建应用程序类&应用程序入口

（1）创建package：io.ken.springboot.course
（2）创建应用程序类：CourseApplication
（3）增加注解：@SpringBootApplication 并配置启动

  1. package io.ken.springbootcourse;
  2. import org.springframework.boot.SpringApplication;
  3. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. @SpringBootApplication
  5. public class CourseApplication {
  6.     public static void main(String[] args) throws Exception {
  7.         SpringApplication.run(CourseApplication.class, args);
  8.     }
  9. }

3、创建测试Controller

（1）创建package：io.ken.springboot.course.controller
（2）创建控制器：HelloController

  1. package io.ken.springbootcourse.controller;
  2. import org.springframework.stereotype.Controller;
  3. import org.springframework.web.bind.annotation.RequestMapping;
  4. import org.springframework.web.bind.annotation.ResponseBody;
  5. @Controller
  6. public class HelloController {
  7.     @RequestMapping("/")
  8.     @ResponseBody
  9.     String index() {
  10.         return "Hello World!";
  11.     }
  12. }

4、启动配置

菜单：Run->Edit Configurations
Spring Boot 入门教程 - 图3
增加Spring Boot启动配置
Spring Boot 入门教程 - 图4
选择应用程序入口类
Spring Boot 入门教程 - 图5

5、启动项目&访问测试

  • 启动项目

使用快捷键Shift+F10启动即可
（或者在CourseApplication编辑区，使用右键菜单->Run “CourseApplication”启动）
控制台输出片段：

  1. [main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
  2. [main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
  3. [main] i.k.springboot.course.CourseApplication  : Started CourseApplication in 1.999 seconds (JVM running for 2.555)

从输出的信息可以看出，Spring Boot也是跑在Tomcat中的，关键是本机不用安装也不用做任何Tomcat的配置。就可以跑起来。这一点就很爽了。想知道Spring Boot还依赖了那些组件，在Pom.xml文件中Ctrl+鼠标单击org.springframework.boot即可

  • 访问测试

项目启动后，访问http://localhost:8080
Spring Boot 入门教程 - 图6
Hello World!

  • 更换运行端口

在/src/main/resources下新建配置文件application.yml
文件内容：

  1. server:
  2.   port: 8080

有了Spring Boot，构建Web应用程序So Easy！
赶紧去试试，嘿嘿~

三、备注

Spring注解说明

注解 ken.io的说明
@SpringBootApplication 等价于使用@Configuration, @EnableAutoConfiguration 和 @ComponentScan默认属性的情况。
@Controller 用于定义控制器类
@RestController 等价于@ResponseBody和@Controller
@RequestMapping 用于定义路由，也就是Url与Controller方法的映射
@ResponseBody 表示将结果直接填充到HTTP的响应体中，用于构建API
@EnableAutoConfiguration 将根据添加的jar依赖自动配置Spring，比如我们的应用依赖于spring-boot-starter-web，而它又依赖Tomcat和Spring MVC，有了这个注解，Spring boot将自动进行相关配置
@ComponentScan 表示将该类自动扫描并注册为Bean
@Configuration 用于定义配置文件类，可以将配置类替换xml配置

附录

  • 本文代码示例

https://github.com/ken-io/springboot-course/tree/master/chapter-01-01

使用Spring Boot+MyBatis访问数据库（CURD）注解版

一、前言

什么是MyBatis？

MyBatis是目前Java平台最为流行的ORM框架
https://baike.baidu.com/item/MyBatis/2824918

本篇开发环境

1、操作系统： Windows 10 X64
2、Java SDK： jdk-8u141
3、Maven：3.5
4、IDE：IntelliJ IDEA 2017
5、Spring Boot：1.5.6
本项目构建基于：https://ken.io/note/springboot-course-basic-helloworld

二、Spring Boot整合MyBatis

1、引入MyBatis

  • 引入核心依赖 | package | 说明 | | —- | —- | | mybatis-spring-boot-starter | MyBatis核心for Spring Boot | | mysql-connector-java | 用于连接MySQL |

pom.xml文件：

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>1.5.6.RELEASE</version>
  5. </parent>
  6. <dependencies>
  7.     <dependency>
  8.       <groupId>org.springframework.boot</groupId>
  9.       <artifactId>spring-boot-starter-web</artifactId>
  10.     </dependency>
  11.     <dependency>
  12.       <groupId>org.mybatis.spring.boot</groupId>
  13.       <artifactId>mybatis-spring-boot-starter</artifactId>
  14.     </dependency>
  15.     <dependency>
  16.       <groupId>mysql</groupId>
  17.       <artifactId>mysql-connector-java</artifactId>
  18.       <version>5.1.38</version>
  19.     </dependency>
  20.     <dependency>
  21.       <groupId>junit</groupId>
  22.       <artifactId>junit</artifactId>
  23.       <version>3.8.1</version>
  24.       <scope>test</scope>
  25.     </dependency>
  26. </dependencies>

2、配置数据库连接

  • 在配置文件：application.yml中增加以下配置：

    1. spring:
    2. datasource:
    3.   driver-class-name: com.mysql.jdbc.Driver
    4.   url: jdbc:mysql://localhost:3306/course
    5.   username: mysql
    6.   password: password

    数据库自行创建MySQL下载地址：https://dev.mysql.com/downloads/

  • Package创建 | Package | 说明 | | —- | —- | | io.ken.springboot.course.model | 用于存放实体 | | io.ken.springboot.course.dao | 用于存放数据访问映射*mapper |

3、创建User表并创建对应实体

  • user表创建脚本

    1. DROP TABLE IF EXISTS `user`;
    2. CREATE TABLE `user` (
    3. `id` int(11) NOT NULL AUTO_INCREMENT,
    4. `name` varchar(255) DEFAULT NULL,
    5. `age` int(11) DEFAULT NULL,
    6. `hobby` varchar(500) DEFAULT NULL,
    7. PRIMARY KEY (`id`)
    8. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

  • user实体创建

    1. package io.ken.springboot.course.model;
    2. public class User {
    3.   private int id;
    4.   private String name;
    5.   private int age;
    6.   private String hobby;
    7.   public int getId() {
    8.       return id;
    9.   }
    10.   public void setId(int id) {
    11.       this.id = id;
    12.   }
    13.   public String getName() {
    14.       return name;
    15.   }
    16.   public void setName(String name) {
    17.       this.name = name;
    18.   }
    19.   public int getAge() {
    20.       return age;
    21.   }
    22.   public void setAge(int age) {
    23.       this.age = age;
    24.   }
    25.   public String getHobby() {
    26.       return hobby;
    27.   }
    28.   public void setHobby(String hobby) {
    29.       this.hobby = hobby;
    30.   }
    31. }

    getger和setter可以选中类名之后使用快捷键Alt+Insert生成

4、数据库操作映射

创建UserMapper

  1. package io.ken.springboot.course.dao;
  2. import io.ken.springboot.course.model.User;
  3. import org.apache.ibatis.annotations.*;
  4. import java.util.List;
  5. @Mapper
  6. public interface UserMapper {
  7.     @Select("SELECT * FROM user WHERE id = #{id}")
  8.     User queryById(@Param("id") int id);
  9.     @Select("SELECT * FROM user")
  10.     List<User> queryAll();
  11.     @Insert({"INSERT INTO user(name,age,hobby) VALUES(#{name},#{age},#{hobby})"})
  12.     int add(User user);
  13.     @Delete("DELETE FROM user WHERE id = #{id}")
  14.     int delById(int id);
  15.     @Update("UPDATE user SET name=#{name},age=#{age},hobby=#{hobby} WHERE id = #{id}")
  16.     int updateById(User user);
  17. }

5、创建测试API

创建UserController并提供API

  1. package io.ken.springboot.course.controller;
  2. import io.ken.springboot.course.dao.UserMapper;
  3. import io.ken.springboot.course.model.User;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Controller;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.ResponseBody;
  8. import java.util.List;
  9. @Controller
  10. @RequestMapping("/user")
  11. public class UserController {
  12.     @Autowired
  13.     UserMapper userMapper;
  14.     @RequestMapping("/querybyid")
  15.     @ResponseBody
  16.     User queryById(int id) {
  17.         return userMapper.queryById(id);
  18.     }
  19.     @RequestMapping("/queryall")
  20.     @ResponseBody
  21.     List<User> queryAll() {
  22.         return userMapper.queryAll();
  23.     }
  24.     @RequestMapping("/add")
  25.     @ResponseBody
  26.     String add(User user) {
  27.         return userMapper.add(user) == 1 ? "success" : "failed";
  28.     }
  29.     @RequestMapping("/updatebyid")
  30.     @ResponseBody
  31.     String updateById(User user) {
  32.         return userMapper.updateById(user) == 1 ? "success" : "failed";
  33.     }
  34.     @RequestMapping("/delbyid")
  35.     @ResponseBody
  36.     String delById(int id) {
  37.         return userMapper.delById(id) == 1 ? "success" : "failed";
  38.     }
  39. }

6、API测试

API 示例
添加用户 /user/add?name=tom&age=1&hobby=football
更新用户 /user/updatebyid?name=ken&age=18&hobby=coding&id=1
查询指定用户 /user/querybyid?id=1
查询所有用户 /user/queryall
删除指定用户 /user/delbyid?id=2

三、备注

  • 本文代码示例

https://github.com/ken-io/springboot-course/tree/master/chapter-02-01

使用Spring Boot+MyBatis访问数据库（CURD）xml配置版

一、前言

什么是MyBatis？

MyBatis是目前Java平台最为流行的ORM框架
https://baike.baidu.com/item/MyBatis/2824918

本篇开发环境

1、操作系统： Windows 10 X64
2、Java SDK： jdk-8u141
3、Maven：3.5
4、IDE：IntelliJ IDEA 2017
5、Spring Boot：1.5.6
本项目构建基于：https://ken.io/note/springboot-course-basic-helloworld

二、Spring Boot整合MyBatis

1、引入MyBatis

  • 引入核心依赖 | package | 说明 | | —- | —- | | mybatis-spring-boot-starter | MyBatis核心for Spring Boot | | mysql-connector-java | 用于连接MySQL |

pom.xml文件：

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>1.5.6.RELEASE</version>
  5. </parent>
  6. <dependencies>
  7.     <dependency>
  8.       <groupId>org.springframework.boot</groupId>
  9.       <artifactId>spring-boot-starter-web</artifactId>
  10.     </dependency>
  11.     <dependency>
  12.       <groupId>org.mybatis.spring.boot</groupId>
  13.       <artifactId>mybatis-spring-boot-starter</artifactId>
  14.     </dependency>
  15.     <dependency>
  16.       <groupId>mysql</groupId>
  17.       <artifactId>mysql-connector-java</artifactId>
  18.       <version>5.1.38</version>
  19.     </dependency>
  20.     <dependency>
  21.       <groupId>junit</groupId>
  22.       <artifactId>junit</artifactId>
  23.       <version>3.8.1</version>
  24.       <scope>test</scope>
  25.     </dependency>
  26. </dependencies>

2、配置数据库连接

在配置文件：application.yml中增加以下配置：

  1. #数据库连接配置
  2. spring:
  3.   datasource:
  4.     driver-class-name: com.mysql.jdbc.Driver
  5.     url: jdbc:mysql://localhost:3306/course?zeroDateTimeBehavior=convertToNull&amp;useUnicode=true&amp;characterEncoding=utf-8
  6.     username: mysql
  7.     password: password
  8. #mybatis配置
  9. mybatis:
  10.   mapper-locations: classpath:conf/mybatis/mapper/*.xml

数据库自行创建MySQL下载地址：https://dev.mysql.com/downloads/

  • Package创建 | Package | 说明 | | —- | —- | | io.ken.springboot.course.model | 用于存放实体 | | io.ken.springboot.course.dao | 用于存放数据访问映射*mapper |

3、测试表和对应实体创建

user表&实体创建

  • user表创建脚本

    1. DROP TABLE IF EXISTS `user`;
    2. CREATE TABLE `user` (
    3. `id` int(11) NOT NULL AUTO_INCREMENT,
    4. `name` varchar(255) DEFAULT NULL,
    5. `age` int(11) DEFAULT NULL,
    6. `hobby` varchar(500) DEFAULT NULL,
    7. PRIMARY KEY (`id`)
    8. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

  • user实体创建

    1. package io.ken.springboot.course.model;
    2. public class User {
    3.   private int id;
    4.   private String name;
    5.   private int age;
    6.   private String hobby;
    7.   public int getId() {
    8.       return id;
    9.   }
    10.   public void setId(int id) {
    11.       this.id = id;
    12.   }
    13.   public String getName() {
    14.       return name;
    15.   }
    16.   public void setName(String name) {
    17.       this.name = name;
    18.   }
    19.   public int getAge() {
    20.       return age;
    21.   }
    22.   public void setAge(int age) {
    23.       this.age = age;
    24.   }
    25.   public String getHobby() {
    26.       return hobby;
    27.   }
    28.   public void setHobby(String hobby) {
    29.       this.hobby = hobby;
    30.   }
    31. }

    getger和setter可以选中类名之后使用快捷键Alt+Insert生成

  • 创建UserMapper，用于跟MyBatis数据操作配置(*mapper.xml)映射

    1. package io.ken.springboot.course.dao;
    2. import io.ken.springboot.course.model.User;
    3. import org.apache.ibatis.annotations.Mapper;
    4. import java.util.List;
    5. @Mapper
    6. public interface UserMapper {
    7.   User queryById(int id);
    8.   List<User> queryAll();
    9.   int add(User user);
    10.   int delById(int id);
    11.   int updateById(User user);
    12. }

    4、MyBatis Mapper配置

    1、创建MyBatis配置文件夹
    resources/conf/mybatis/mapper
    2、在mapper文件夹下创建UserMapper.xml

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    3. <mapper namespace="io.ken.springboot.course.dao.UserMapper">
    4.   <select id="queryById" resultType="io.ken.springboot.course.model.User"
    5.           parameterType="int">
    6.       SELECT *  FROM user WHERE id = #{id}
    7.   </select>
    8.   <select id="queryAll" resultType="io.ken.springboot.course.model.User">
    9.       SELECT * FROM user
    10.   </select>
    11.   <insert id="add" parameterType="io.ken.springboot.course.model.User">
    12.       INSERT INTO user(name,age,hobby) VALUES(#{name},#{age},#{hobby})
    13.   </insert>
    14.   <delete id="delById" parameterType="int">
    15.       DELETE FROM user WHERE id = #{id}
    16.   </delete>
    17.   <update id="updateById" parameterType="io.ken.springboot.course.model.User">
    18.       UPDATE user SET name=#{name},age=#{age},hobby=#{hobby} WHERE id = #{id}
    19.   </update>
    20. </mapper>

    5、创建UserController并提供API

    1. package io.ken.springboot.course.controller;
    2. import io.ken.springboot.course.dao.UserMapper;
    3. import io.ken.springboot.course.model.User;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.stereotype.Controller;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7. import org.springframework.web.bind.annotation.ResponseBody;
    8. import java.util.List;
    9. @Controller
    10. @RequestMapping("/user")
    11. public class UserController {
    12.   @Autowired
    13.   UserMapper userMapper;
    14.   @RequestMapping("/querybyid")
    15.   @ResponseBody
    16.   User queryById(int id) {
    17.       return userMapper.queryById(id);
    18.   }
    19.   @RequestMapping("/queryall")
    20.   @ResponseBody
    21.   List<User> queryAll() {
    22.       return userMapper.queryAll();
    23.   }
    24.   @RequestMapping("/add")
    25.   @ResponseBody
    26.   String add(User user) {
    27.       return userMapper.add(user) == 1 ? "success" : "failed";
    28.   }
    29.   @RequestMapping("/updatebyid")
    30.   @ResponseBody
    31.   String updateById(User user) {
    32.       return userMapper.updateById(user) == 1 ? "success" : "failed";
    33.   }
    34.   @RequestMapping("/delbyid")
    35.   @ResponseBody
    36.   String delById(int id) {
    37.       return userMapper.delById(id) == 1 ? "success" : "failed";
    38.   }
    39. }

    6、API测试

    | API | 示例 | | —- | —- | | 添加用户 | /user/add?name=tom&age=1&hobby=football | | 更新用户 | /user/updatebyid?name=ken&age=18&hobby=coding&id=1 | | 查询指定用户 | /user/querybyid?id=1 | | 查询所有用户 | /user/queryall | | 删除指定用户 | /user/delbyid?id=2 |

三、备注

  • 本文代码示例

https://github.com/ken-io/springboot-course/tree/master/chapter-02-02

使用Spring Boot+MyBatis多数据源配置（注解版）

一、前言

本教程主要内容

  • 使用Spring Boot+MyBatis访问多个数据源

    本教程开发环境

    1、操作系统： Windows 10 X64
    2、Java SDK： jdk-8u141
    3、Maven：3.5
    4、IDE：IntelliJ IDEA 2017
    5、Spring Boot：1.5.6
    本项目构建基于：https://ken.io/note/springboot-course-basic-curd-annotation

    二、多数据源配置

    1、创建数据库&表

  • 创建数据库test

    1. CREATE DATABASE test;

  • 创建表：note

    1. DROP TABLE IF EXISTS `note`;
    2. CREATE TABLE `note` (
    3. `id` int(11) NOT NULL AUTO_INCREMENT,
    4. `title` varchar(255) DEFAULT NULL,
    5. `body` longtext,
    6. PRIMARY KEY (`id`)
    7. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

    2、修改配置文件增加数据源

    修改数据库连接配置(application.yml)，将之前的spring.datasource更换为自定义的courseDataSource、testDataSource

    1. #数据库连接配置
    2. courseDataSource:
    3.   driver-class-name: com.mysql.jdbc.Driver
    4.   url: jdbc:mysql://localhost:3306/course?zeroDateTimeBehavior=convertToNull&amp;useUnicode=true&amp;characterEncoding=utf-8
    5.   username: root
    6.   password: root
    7. testDataSource:
    8.   driver-class-name: com.mysql.jdbc.Driver
    9.   url: jdbc:mysql://localhost:3306/test?zeroDateTimeBehavior=convertToNull&amp;useUnicode=true&amp;characterEncoding=utf-8
    10.   username: root
    11.   password: root

    3、调整数据源对应实体

    1、在io.ken.springboot.course.model下新建两个package：course、test
    2、将User.java移动到io.ken.springboot.course.model.course
    3、在io.ken.springboot.course.model.test下新建Note.java

    1. package io.ken.springboot.course.model.test;
    2. public class Note {
    3.   private int id;
    4.   private String title;
    5.   private String body;
    6.   public int getId() {
    7.       return id;
    8.   }
    9.   public void setId(int id) {
    10.       this.id = id;
    11.   }
    12.   public String getTitle() {
    13.       return title;
    14.   }
    15.   public void setTitle(String title) {
    16.       this.title = title;
    17.   }
    18.   public String getBody() {
    19.       return body;
    20.   }
    21.   public void setBody(String body) {
    22.       this.body = body;
    23.   }
    24. }

    4、调整数据访问接口

    1、在io.ken.springboot.course.dao下新建两个package：course、test
    2、将UserMapper.java移动到io.ken.springboot.course.dao.course
    3、在io.ken.springboot.course.dao.test下新建NoteMapper.java

    1. package io.ken.springboot.course.dao.test;
    2. import io.ken.springboot.course.model.test.Note;
    3. import org.apache.ibatis.annotations.Mapper;
    4. import org.apache.ibatis.annotations.Select;
    5. import java.util.List;
    6. @Mapper
    7. public interface NoteMapper {
    8.   @Select("SELECT * FROM note")
    9.   List<Note> queryAll();
    10. }

    5、配置数据源对应Configuration

    1、在io.ken.springboot.course下新建package：config
    2、在io.ken.springboot.course.config下创建CourseDbConfig.java

    1. package io.ken.springboot.course.config;
    2. import org.apache.ibatis.session.SqlSessionFactory;
    3. import org.mybatis.spring.SqlSessionFactoryBean;
    4. import org.mybatis.spring.annotation.MapperScan;
    5. import org.springframework.beans.factory.annotation.Qualifier;
    6. import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
    7. import org.springframework.boot.context.properties.ConfigurationProperties;
    8. import org.springframework.context.annotation.Bean;
    9. import org.springframework.context.annotation.Configuration;
    10. import org.springframework.context.annotation.Primary;
    11. import javax.sql.DataSource;
    12. @Configuration
    13. @MapperScan(basePackages = "io.ken.springboot.course.dao.course", sqlSessionFactoryRef = "courseSqlSessionFactory")
    14. public class CourseDbConfig {
    15.   @Bean(name = "courseDataSource")
    16.   @ConfigurationProperties(prefix = "courseDataSource")
    17.   @Primary
    18.   public DataSource courseDataSource() {
    19.       return DataSourceBuilder.create().build();
    20.   }
    21.   @Bean(name = "courseSqlSessionFactory")
    22.   @Primary
    23.   public SqlSessionFactory courseSqlSessionFactory(@Qualifier("courseDataSource") DataSource dataSource) throws Exception {
    24.       SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
    25.       bean.setDataSource(dataSource);
    26.       return bean.getObject();
    27.   }
    28. }

    3、在io.ken.springboot.course.config下创建TestDbConfig.java

    1. package io.ken.springboot.course.config;
    2. import org.apache.ibatis.session.SqlSessionFactory;
    3. import org.mybatis.spring.SqlSessionFactoryBean;
    4. import org.mybatis.spring.annotation.MapperScan;
    5. import org.springframework.beans.factory.annotation.Qualifier;
    6. import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
    7. import org.springframework.boot.context.properties.ConfigurationProperties;
    8. import org.springframework.context.annotation.Bean;
    9. import org.springframework.context.annotation.Configuration;
    10. import javax.sql.DataSource;
    11. @Configuration
    12. @MapperScan(basePackages = "io.ken.springboot.course.dao.test", sqlSessionFactoryRef = "testSqlSessionFactory")
    13. public class TestDbConfig {
    14.   @Bean(name = "testDataSource")
    15.   @ConfigurationProperties(prefix = "testDataSource")
    16.   public DataSource testDataSource() {
    17.       return DataSourceBuilder.create().build();
    18.   }
    19.   @Bean(name = "testSqlSessionFactory")
    20.   public SqlSessionFactory testSqlSessionFactory(@Qualifier("testDataSource") DataSource dataSource) throws Exception {
    21.       SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
    22.       bean.setDataSource(dataSource);
    23.       return bean.getObject();
    24.   }
    25. }

    6、创建NoteController并提供API

    1. package io.ken.springboot.course.controller;
    2. import io.ken.springboot.course.dao.test.NoteMapper;
    3. import io.ken.springboot.course.model.test.Note;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.stereotype.Controller;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7. import org.springframework.web.bind.annotation.ResponseBody;
    8. import java.util.List;
    9. @Controller
    10. @RequestMapping("/note")
    11. public class NoteController {
    12.   @Autowired
    13.   NoteMapper noteMapper;
    14.   @RequestMapping("/queryall")
    15.   @ResponseBody
    16.   List<Note> queryAll() {
    17.       return noteMapper.queryAll();
    18.   }
    19. }

    7、API测试

    | API | 示例 | | —- | —- | | 添加用户 | /user/add?name=tom&age=1&hobby=football | | 更新用户 | /user/updatebyid?name=ken&age=18&hobby=coding&id=1 | | 查询指定用户 | /user/querybyid?id=1 | | 查询所有用户 | /user/queryall | | 删除指定用户 | /user/delbyid?id=2 | | 查询所有日志 | /note/queryall |

三、备注

  • 本文代码示例

https://github.com/ken-io/springboot-course/tree/master/chapter-02-03

使用Spring Boot+MyBatis多数据源配置（xml配置版）

一、前言

本教程主要内容

  • 使用Spring Boot+MyBatis访问多个数据源

    本教程开发环境

    1、操作系统： Windows 10 X64
    2、Java SDK： jdk-8u141
    3、Maven：3.5
    4、IDE：IntelliJ IDEA 2017
    5、Spring Boot：1.5.6
    本项目构建基于：https://ken.io/note/springboot-course-basic-curd-xml

    二、多数据源配置

    1、创建数据库&表

  • 创建数据库test

    1. CREATE DATABASE test;

  • 创建表：note

    1. DROP TABLE IF EXISTS `note`;
    2. CREATE TABLE `note` (
    3. `id` int(11) NOT NULL AUTO_INCREMENT,
    4. `title` varchar(255) DEFAULT NULL,
    5. `body` longtext,
    6. PRIMARY KEY (`id`)
    7. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

    2、修改配置文件增加数据源

    修改数据库连接配置(application.yml)，将之前的spring.datasource更换为自定义的courseDataSource、testDataSource

    1. #数据库连接配置
    2. courseDataSource:
    3.   driver-class-name: com.mysql.jdbc.Driver
    4.   url: jdbc:mysql://localhost:3306/course?zeroDateTimeBehavior=convertToNull&amp;useUnicode=true&amp;characterEncoding=utf-8
    5.   username: root
    6.   password: root
    7. testDataSource:
    8.   driver-class-name: com.mysql.jdbc.Driver
    9.   url: jdbc:mysql://localhost:3306/test?zeroDateTimeBehavior=convertToNull&amp;useUnicode=true&amp;characterEncoding=utf-8
    10.   username: root
    11.   password: root

    3、调整数据源对应实体

    1、在io.ken.springboot.course.model下新建两个package：course、test
    2、将User.java移动到io.ken.springboot.course.model.course
    3、在io.ken.springboot.course.model.test下新建Note.java

    1. package io.ken.springboot.course.model.test;
    2. public class Note {
    3.   private int id;
    4.   private String title;
    5.   private String body;
    6.   public int getId() {
    7.       return id;
    8.   }
    9.   public void setId(int id) {
    10.       this.id = id;
    11.   }
    12.   public String getTitle() {
    13.       return title;
    14.   }
    15.   public void setTitle(String title) {
    16.       this.title = title;
    17.   }
    18.   public String getBody() {
    19.       return body;
    20.   }
    21.   public void setBody(String body) {
    22.       this.body = body;
    23.   }
    24. }

    4、配置数据源对应Configuration

    1、在io.ken.springboot.course.dao下新建两个package：course、test
    2、将UserMapper.java移动到io.ken.springboot.course.dao.course并去掉@Mapper注解
    3、在io.ken.springboot.course.dao.test下新建NoteMapper.java

    1. package io.ken.springboot.course.dao.test;
    2. import io.ken.springboot.course.model.test.Note;
    3. import java.util.List;
    4. public interface NoteMapper {
    5.   List<Note> queryAll();
    6. }

    5、调整MyBatis Mappere配置

    1、在/resources/conf/mybatis/mapper下新建两个文件夹：course、test
    2、将UserMapper.xml移动到/resources/conf/mybatis/mapper/course
    3、在/resources/conf/mybatis/mapper/test下新建NoteMapper.xml

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    3. <mapper namespace="io.ken.springboot.course.dao.test.NoteMapper">
    4.   <select id="queryAll" resultType="io.ken.springboot.course.model.test.Note">
    5.       SELECT * FROM note
    6.   </select>
    7. </mapper>

    6、配置数据源对应Configuration

    1、在io.ken.springboot.course下新建package：config
    2、在io.ken.springboot.course.config下创建CourseDbConfig.java

    1. package io.ken.springboot.course.config;
    2. import org.apache.ibatis.session.SqlSessionFactory;
    3. import org.mybatis.spring.SqlSessionFactoryBean;
    4. import org.mybatis.spring.annotation.MapperScan;
    5. import org.springframework.beans.factory.annotation.Qualifier;
    6. import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
    7. import org.springframework.boot.context.properties.ConfigurationProperties;
    8. import org.springframework.context.annotation.Bean;
    9. import org.springframework.context.annotation.Configuration;
    10. import org.springframework.context.annotation.Primary;
    11. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    12. import javax.sql.DataSource;
    13. @Configuration
    14. @MapperScan(basePackages = "io.ken.springboot.course.dao.course", sqlSessionFactoryRef = "courseSqlSessionFactory")
    15. public class CourseDbConfig {
    16.   @Bean(name = "courseDataSource")
    17.   @ConfigurationProperties(prefix = "courseDataSource")
    18.   @Primary
    19.   public DataSource courseDataSource() {
    20.       return DataSourceBuilder.create().build();
    21.   }
    22.   @Bean(name = "courseSqlSessionFactory")
    23.   @Primary
    24.   public SqlSessionFactory courseSqlSessionFactory(@Qualifier("courseDataSource") DataSource dataSource) throws Exception {
    25.       SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
    26.       bean.setDataSource(dataSource);
    27.       bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:conf/mybatis/mapper/course/*.xml"));
    28.       return bean.getObject();
    29.   }
    30. }

    3、在io.ken.springboot.course.config下创建TestDbConfig.java

    1. package io.ken.springboot.course.config;
    2. import org.apache.ibatis.session.SqlSessionFactory;
    3. import org.mybatis.spring.SqlSessionFactoryBean;
    4. import org.mybatis.spring.annotation.MapperScan;
    5. import org.springframework.beans.factory.annotation.Qualifier;
    6. import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
    7. import org.springframework.boot.context.properties.ConfigurationProperties;
    8. import org.springframework.context.annotation.Bean;
    9. import org.springframework.context.annotation.Configuration;
    10. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    11. import javax.sql.DataSource;
    12. @Configuration
    13. @MapperScan(basePackages = "io.ken.springboot.course.dao.test", sqlSessionFactoryRef = "testSqlSessionFactory")
    14. public class TestDbConfig {
    15.   @Bean(name = "testDataSource")
    16.   @ConfigurationProperties(prefix = "testDataSource")
    17.   public DataSource testDataSource() {
    18.       return DataSourceBuilder.create().build();
    19.   }
    20.   @Bean(name = "testSqlSessionFactory")
    21.   public SqlSessionFactory testSqlSessionFactory(@Qualifier("testDataSource") DataSource dataSource) throws Exception {
    22.       SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
    23.       bean.setDataSource(dataSource);
    24.       bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:conf/mybatis/mapper/test/*.xml"));
    25.       return bean.getObject();
    26.   }
    27. }

    7、创建NoteController并提供API

    1. package io.ken.springboot.course.controller;
    2. import io.ken.springboot.course.dao.test.NoteMapper;
    3. import io.ken.springboot.course.model.test.Note;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.stereotype.Controller;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7. import org.springframework.web.bind.annotation.ResponseBody;
    8. import java.util.List;
    9. @Controller
    10. @RequestMapping("/note")
    11. public class NoteController {
    12.   @Autowired
    13.   NoteMapper noteMapper;
    14.   @RequestMapping("/queryall")
    15.   @ResponseBody
    16.   List<Note> queryAll() {
    17.       return noteMapper.queryAll();
    18.   }
    19. }

    8、API测试

    | API | 示例 | | —- | —- | | 添加用户 | /user/add?name=tom&age=1&hobby=football | | 更新用户 | /user/updatebyid?name=ken&age=18&hobby=coding&id=1 | | 查询指定用户 | /user/querybyid?id=1 | | 查询所有用户 | /user/queryall | | 删除指定用户 | /user/delbyid?id=2 | | 查询所有日志 | /note/queryall |

三、备注

  • 本文代码示例

https://github.com/ken-io/springboot-course/tree/master/chapter-02-04

使用Spring Boot+Freemarker模板引擎开发Web应用

一、前言

为什么要使用模板引擎？

在最早的Java Web应用中，最为广泛使用的就是JSP，但是JSP已经是陈旧的技术了，ken.io觉得JSP主要有三个问题：
1、视图代码不能与Java代码完全分离，如果再JSP页面写Java代码维护成本高
2、无法实现页面继承工程，实现模板页的方式蹩脚
3、由于一些已知问题，Spring Boot官方不建议，比如：Spring Boot+JSP打成jar包会有问题
所以，ken.io选择了较为流行的Freemarker，本文我们介绍Spring Boot+Freemarker的基本使用
本项目构建基于：https://ken.io/note/springboot-course-basic-helloworld

二、操作步骤

1、引入Freemarker

在pom.xml文件的dependencies引入

  1. <dependencies>
  2.     <dependency>
  3.       <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-web</artifactId>
  5.   </dependency>
  6.   <dependency>
  7.     <groupId>org.springframework.boot</groupId>
  8.     <artifactId>spring-boot-starter-freemarker</artifactId>
  9.   </dependency>
  10. </dependencies>

2、创建Freemarker模板

  • 创建模板文件夹

在resources文件夹下新建templates文件夹，作为模板根目录
完整路径：src/main/resources/templates
为什么文件夹名字一定要叫templates？
答：Spring Boot就是这么约定的，如果有需要，可以通过配置application.yml修改

  1. spring:
  2.   freemarker:
  3.     template-loader-path: classpath:/templates/
  • 在templates新建welcome.ftl文件

ftl就是Freemarker模板文件后缀，可以通过配置application.yml修改

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4.     <title>Welcome - ken.io</title>
  5. </head>
  6. <body>
  7. Message: ${message}
  8. </body>
  9. </html>

使用${变量名}可以输出controller中返回的对象

3、创建Welcome访问入口

在HomeController中增加函数

  1. @RequestMapping("/")
  2. @ResponseBody
  3. String index() {
  4.     return "Hello World!";
  5. }
  6. @RequestMapping("/welcome")
  7. ModelAndView welcome(){
  8.     ModelAndView modelAndView = new ModelAndView();
  9.     modelAndView.setViewName("welcome");
  10.     modelAndView.addObject("message","Welcome to Spring Boot & Freemarker");
  11.     return modelAndView;
  12. }

对比index函数，主要发生了以下几个变化：
1、去掉@ResponseBody注解，如果使用该注解，返回结果会直接输出，而不是使用模板引擎渲染
2、使用ModelAndView对象，指定视图名&添加视图对象
对于setViewName函数，如果视图的路径是templates/home/index.ftl
那么使用方式应该是：

  1. modelAndView.setViewName("home/index");

4、启动&访问

启动项目&访问
访问：http://localhost:8080/welcome：

Message: Welcome to Spring Boot & Freemarker

三、备注

1、Freemarker 常用配置

配置项 说明
spring.freemarker.template-loader-path 模板根目录，例如：classpath:/templates/
spring.freemarker.cache 是否启用缓存(true/false)
spring.freemarker.charset 字符编码
spring.freemarker.content-type 内容类型，例如：text/html
spring.freemarker.suffix 模板文件后缀，默认为.ftl

2、附录

  • 本文参考：

https://docs.spring.io/spring-boot/docs/1.5.6.RELEASE/reference/htmlsingle/#boot-features-spring-mvc-template-engines
https://docs.spring.io/spring-boot/docs/1.5.6.RELEASE/reference/htmlsingle/#boot-features-jsp-limitations

  • 示例代码地址

https://github.com/ken-io/springboot-course/tree/master/chapter-03-01

  • 相关阅读

Freemarker母版页示例：https://ken.io/note/freemarker-skill-layout

使用Spring Boot+Thymeleaf模板引擎开发Web应用

一、前言

为什么要使用模板引擎？

在最早的Java Web应用中，最为广泛使用的就是JSP，但是JSP已经是陈旧的技术了，ken.io觉得JSP主要有三个问题：
1、视图代码不能与Java代码完全分离，如果再JSP页面写Java代码维护成本高
2、无法实现页面继承工程，实现模板页的方式蹩脚
3、由于一些已知问题，Spring Boot官方不建议，比如：Spring Boot+JSP打成jar包会有问题
所以，ken.io选择了较为流行的Thymeleaf，本文我们介绍Spring Boot+Thymeleaf的基本使用
本项目构建基于：https://ken.io/note/springboot-course-basic-helloworld

二、操作步骤

1、引入Thymeleaf

在pom.xml文件的dependencies引入

  1. <dependencies>
  2.   <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-web</artifactId>
  5.   </dependency>
  6.   <dependency>
  7.     <groupId>org.springframework.boot</groupId>
  8.     <artifactId>spring-boot-starter-thymeleaf</artifactId>
  9.   </dependency>
  10. </dependencies>

2、创建Thymeleaf模板

  • 创建模板文件夹

在resources文件夹下新建templates文件夹，作为模板根目录
完整路径：src/main/resources/templates
为什么文件夹名字一定要叫templates？
答：Spring Boot就是这么约定的，如果有需要，可以通过配置application.yml修改

  1. spring:
  2.   thymeleaf:
  3.     prefix: classpath:/templates/
  • 在templates新建welcome.html文件

html就是Thymeleaf模板文件后缀，可以通过配置application.yml修改

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4.     <title>Welcome - ken.io</title>
  5. </head>
  6. <body>
  7. </body>
  8. </html>

Thymeleaf的语法跟Freemarker差异比较大，因为Thymeleaf所有的语法都依赖于HTML标签。

  1. <p th:text="${message}"></p>

表示将controller返回的message对象以文本形式输出到标签内
相对来说，ken.io更喜欢Fremarker的语法

3、创建Welcome访问入口

在HomeController中增加函数

  1. @RequestMapping("/")
  2. @ResponseBody
  3. String index() {
  4.     return "Hello World!";
  5. }
  6. @RequestMapping("/welcome")
  7. ModelAndView welcome(){
  8.     ModelAndView modelAndView = new ModelAndView();
  9.     modelAndView.setViewName("welcome");
  10.     modelAndView.addObject("message","Welcome to Spring Boot & Thymeleaf");
  11.     return modelAndView;
  12. }

对比index函数，主要发生了以下几个变化：
1、去掉@ResponseBody注解，如果使用该注解，返回结果会直接输出，而不是使用模板引擎渲染
2、使用ModelAndView对象，指定视图名&添加视图对象
对于setViewName函数，如果视图的路径是templates/home/index.ftl
那么使用方式应该是：

  1. modelAndView.setViewName("home/index");

4、启动&访问

启动项目&访问
访问：http://localhost:8080/welcome：

Welcome to Spring Boot & Thymeleaf

三、备注

1、Thymeleaf 常用配置

配置项 说明
spring.thymeleaf.prefix 模板根目录，例如：classpath:/templates/
spring.thymeleaf.cache 是否启用缓存(true false)
spring.thymeleaf.encoding 字符编码
spring.thymeleaf.content-type 内容类型，例如：text/html
spring.thymeleaf.suffix 模板文件后缀，默认为.html

2、附录

  • 本文参考：

https://docs.spring.io/spring-boot/docs/1.5.6.RELEASE/reference/htmlsingle/#boot-features-spring-mvc-template-engines
https://docs.spring.io/spring-boot/docs/1.5.6.RELEASE/reference/htmlsingle/#boot-features-jsp-limitations

  • 示例代码地址

https://github.com/ken-io/springboot-course/tree/master/chapter-03-02

  • 相关阅读

Thymeleaf母版页示例：https://ken.io/note/thymeleaf-skill-layout

Spring Boot应用 打包与部署教程

一、前言

1、本教程主要内容

  1. 通过Maven将Spring Boot应用打包成jar包
  2. 将打包的jar包传输的服务器并配置启动、停止脚本
  3. 将Spring Boot应用配置为系统服务并配置开机启动

    2、Spring Boot打包与部署特点说明

    Java Web应用在Spring Boot之前，通常是打包成war（Web application ARchive）包，结合Tomcat来完成部署。
    对于Spring Boot，Spring官方的建议是将Spring Boot应用打包成一个fat jar（Java ARchive）,通过java命令来启动运行。这个fat jar会把Tomcat内置进来，所以部署时也不需要单独配置Tomcat。
    Spring官方的打包说明：
    https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/#getting-started-first-application-executable-jar

    3、本教程环境信息

  • 开发环境： | 用途 | 工具&版本 | | —- | —- | | 操作系统 | Windows 10 | | 开发工具 | IntelliJ IDEA 2017 | | 打包工具 | Maven 3.X | | JDK | 1.8.x | | 传输工具 | FlashFxp |

  • 生产环境： | 用途 | 工具&版本 | | —- | —- | | 操作系统 | CentOS 7 | | JDK | 1.8.x | | 传输工具 | Vsftp |

CentOS 7快速上手教程：https://ken.io/serie/centos7-quickstart

二、Spring Boot应用打包

1、打包基础依赖

打包工具的话如前面提到的，我们使用的是Maven
首先需要在pom.xml文件build节点增加如下配置：

  1. <build>
  2.     <finalName>springboot-course</finalName>
  3.     <plugins>
  4.         <plugin>
  5.             <groupId>org.springframework.boot</groupId>
  6.             <artifactId>spring-boot-maven-plugin</artifactId>
  7.         </plugin>
  8.     </plugins>
  9. </build>

另外，需要确认pom.xml文件的package节点配置：

  1. <packaging>jar</packaging>

本篇ken.io会介绍两种打包方式，一个是Maven命令打包。一个是IDEA+Maven插件打包。

2、 Maven命令打包

  • 准备工作

配置Java、Maven环境变量
参考：http://wiki.jikexueyuan.com/project/maven/environment-setup.html

  • cmd：进入项目目录

本次项目目录是：D:\Projects\GitHub\springboot-course\package-maven

  1. d: & cd D:\Projects\GitHub\springboot-course\package-maven

  • 清理package

    1. #清理已存在的编译结果
    2. mvn clean
    3. #清理成功后输出信息示例
    4. [INFO] -----------------------------------------------------------
    5. [INFO] BUILD SUCCESS
    6. [INFO] -----------------------------------------------------------

  • 打包

    1. #打包
    2. mvn package
    3. #清理成功后输出信息示例
    4. [INFO] -----------------------------------------------------------
    5. [INFO] BUILD SUCCESS
    6. [INFO] -----------------------------------------------------------
    7. #清理成功后会在项目根目录生成target文件夹
    8. #查看是否生成target文件夹
    9. ls
    10. #查看是否生了jar文件
    11. ls target
    12. #根据pom.xml文件的配置，生成的jar文件名是：springboot-course.jar

    2、IDEA + Maven插件打包

    通过View->Tool Windows->Maven projects 呼出Maven工具栏
    或者通过IDEA右侧工具栏呼出Maven工具栏
    Spring Boot 入门教程 - 图7
    图形化操作就很简单了。两个步骤：

  1. clean
  2. package

成功之后也会在IDEA 控制台显示以下输出：

  1. [INFO] --------------------------------------------------------------------
  2. [INFO] BUILD SUCCESS
  3. [INFO] --------------------------------------------------------------------
  4. [INFO] Total time: 7.839 s
  5. [INFO] Finished at: 2017-12-09T13:36:40+08:00
  6. [INFO] Final Memory: 21M/218M
  7. [INFO] --------------------------------------------------------------------

生成的jar包路径：项目根目录\target\springboot-course.jar

3、本地运行测试

  • 通过java命令运行jar包

    1. #进入jar包所在目录
    2. d: & cd D:\Projects\GitHub\springboot-course\package-maven\target
    3. #执行
    4. java -jar springboot-course.jar
    5. #运行成功后会输出如下信息（部分信息略去）
    6. [main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
    7. [main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
    8. [main] i.k.springboot.course.CourseApplication  : Started CourseApplication in 5.569 seconds (JVM running for 6.363)

    通过浏览器访问：localhost:8080，验证是否正常

  • 端口号

在/src/main/resources下新建配置文件application.yml
文件内容：

  1. server:
  2.   port: 8081

配置完成之后，重新打包即可

参考：https://ken.io/note/springboot-course-basic-helloworld

三、Spring Boot应用部署

1、 准备工作

通过FTP将jar包上传到CentOS的 /webroot/helloweb 目录

  • 创建日志目录：

    1. #创建应用目录&日志目录
    2. sudo mkdir /webroot/helloweb
    3. sudo mkdir /webroot/helloweb/logs
    4. #修改文件夹权限
    5. sudo chmod 777 /webroot/helloweb
    6. sudo chmod 777 /webroot/helloweb/logs

  • 开放端口

    1. #添加可访问端口
    2. sudo firewall-cmd --add-port=8081/tcp --permanent
    3. #重新加载防火墙策略
    4. sudo firewall-cmd --reload

    2、启动&停止脚本

  • 创建启动脚本

    1. #创建启动脚本start.sh
    2. sudo vi /webroot/helloweb/start.sh

    脚本内容：

    1. #!/bin/sh
    2. #指定JDK目录&AppName
    3. export JAVA_HOME=/usr/java/jdk1.8.0_151
    4. APP_NAME=springboot-course.jar
    5. echo $JAVA_HOME
    6. echo $APP_NAME
    7. #nohup命令后台启动jar包并写入日志
    8. nohup  java -jar $APP_NAME >>logs/start.log 2>>logs/startError.log &
    9. #sleep等待15秒后，判断包含AppName的线程是否存在
    10. sleep 15
    11. if test $(pgrep -f $APP_NAME|wc -l) -eq 0
    12. then
    13.  echo "Start Failed"
    14. else
    15.  echo "Start Successed"
    16. fi

  • 创建停止脚本

    1. #创建停止脚本文件
    2. sudo vi /webroot/helloweb/stop.sh

    脚本内容：

    1. #!/bin/sh
    2. #指定AppName
    3. APP_NAME=springboot-course.jar
    4. #找到包含AppName的进程
    5. PROCESS=`ps -ef|grep $APP_NAME|grep -v grep  |awk '{ print $2}'`
    6. #循环停用进程直到成功
    7. while :
    8. do
    9. kill -9 $PROCESS > /dev/null 2>&1
    10. if [ $? -ne 0 ];then
    11.  break
    12. else
    13.  continue
    14. fi
    15. done
    16. echo 'Stop Successed'

  • 启动/停止站点

    1. #启动
    2. sh /webroot/helloweb/start.sh
    3. #停止
    4. sh /webroot/helloweb/stop.sh

    3、访问测试

    启动应用后，访问 http://<ip address>:8081 验证是否正常即可

    四、开启启动&Nginx反向代理配置

    1、开机自动启动配置

    我们可以把Spring Boot应用配置为系统服务，就可以设置开机启动

  • 将站点停止脚本标记为可执行文件

    1. chmod +x /webroot/helloweb/stop.sh

  • 创建helloweb服务

    1. #创建服务文件
    2. sudo vi /usr/lib/systemd/system/helloweb.service
    3. #文件内容
    4. [Unit]
    5. Description=helloweb
    6. After=network.target
    7. [Service]
    8. WorkingDirectory=/webroot/helloweb
    9. ExecStart=/usr/java/jdk1.8.0_151/java -jar /webroot/helloweb/springboot-course.jar
    10. ExecStop=/webroot/helloweb/stop.sh
    11. Restart=always
    12. RestartSec=10
    13. [Install]
    14. WantedBy=multi-user.target

  • 设置服务开机启动&开启服务

    1. #设置服务开机启动
    2. sudo systemctl enable helloweb
    3. #启动服务
    4. sudo systemctl start helloweb

    2、Nginx反向代理配置

  • 创建helloweb站点配置

    1. #新建配置文件
    2. sudo vi /etc/nginx/conf.d/helloweb.conf
    3. #反向代理配置内容
    4. server {
    5.   listen       80;        #监听80端口
    6.   server_name  helloweb.mydomain.com; #绑定的域名
    7.   location / {            #转发或处理
    8.       proxy_pass http://localhost:8081;
    9.   }
    10.   error_page   500 502 503 504  /50x.html;#错误页
    11.   location = /50x.html {
    12.       root   /usr/share/nginx/html;
    13.   }
    14. }

  • 重载Nginx配置

    1. sudo nginx -s reload

  • 开放防火墙端口

    1. #添加可访问端口
    2. sudo firewall-cmd --add-port=80/tcp --permanent
    3. #重新加载防火墙策略
    4. sudo firewall-cmd --reload

    访问测试：
    通过设置本地hosts将helloweb.mydomain.com指向服务器IP
    然后通过浏览器访问： helloweb.mydomain.com 即可

    五、备注

  • 本篇源代码

https://github.com/ken-io/springboot-course/tree/master/package-maven