SpringBoot是Spring新出的一个框架，他的目的一如始初- 简化开发。我们开发项目的时候，为了让项目运行起来，我们要考虑很多架构、配置、依赖等问题，这些问题其实每个项目都要考虑，而且每个项目的开发都有固定的模版，这些重复的工作是每个项目的样板代码，SpringBoot做的就是帮我们完成这些重复行的工作，让我们只关注业务逻辑。

主要帮我们完成了以下几个部分：

1、自动装配：针对Spring应用程序常见的应用功能，SpringBoot自动提供相关的配置。

2、起步依赖：告诉SpringBoot需要什么功能后，他能帮我们引入需要的jar包。

3、命令行界面：这个这里不介绍。

4、Actuator：监控观察你的程序运行。

接下来，我们创建一个简单的SpringBoot应用：

一、创建骨架

我们要使用Spring Initializr 来生成一个项目框架，可以通过sts、idea、SpringBoot CLI和web界面来完成Spring Initializr 的工作，我们这里选用的是web界面，访问网址：http://start.spring.io/

根据你的情况，填写表单，点击generate Project 按钮，生成项目框demo.zip并下载到本地。这个框架除了业务代码，该有的都有了。将demo.zip复制到sts工作空间，解压后，删除多余的代码，只留下src文件夹和pom.xml文件，在sts中通过引入maven项目的方式引入demo项目。

        

pom.xml报错，原因是spring-boot-starter-parent默认用的是2.1.3，这里有的jar我的私服上下载不到，改成低点的版本2.0.2问题就解决了。如果你连接的是中央仓库，且网络通畅，是不会有这个问题的。

我们在Spring initializr中选择了web和mysql，给我们生成的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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

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

</project>

pom.xml

我们看的他给我们生成的项目结构是这样的，使用的jdk版本是1.8。(需要强调的是，SpringBoot使用的jdk版本要是1.8或高于1.8)

和我们以往的web项目比，最大的不同应该就是我们的项目里居然没有了web.xml，打包类型也变成了jar。那这样行不行呢？我们写个简单的action，启动一下应用试试。

                      

这里要注意的是，springBoot已经给我们内嵌了一个tomcat，所以我们不需要自己再搭建一个，因为是内置tomcat，我们的项目访问也有一点不同就是，访问的时候不需要加上项目名了，直接访问资源就可以，这里我们直接访问http://localhost:8080  就可以进入我们action。

启动：选中项目-> 右键debug as -> spring Boot app （其他启动方式可以参考https://my.oschina.net/oosc/blog/1627384）

     打开浏览器，输入：http://localhost:8080      

既然成功了，我们来逐一介绍一下，他给我们生成的东西都是干啥的：

1、  2、application.properties默认是空的    3、

这是为我们生成了一个基本骨架，那我们接下来要看，怎么在其中开发，开发之后怎么部署应用。我们来通过开发一个ssm框架的web项目来介绍具体操作。

二、开发应用

1、自定义配置springBoot，使其支持jsp（SpringBoot虽然支持JSP，但是官方不推荐使用，推荐使用thymeleaf）

　　1）、配置application.properties

#关闭默认模板引擎
spring.thymeleaf.cache=false
spring.thymeleaf.enabled=false

#jsp 支持
spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

　　2）、加入依赖（切记：这三个依赖都是必须的）

<!--jsp支持  start-->
        <!-- servlet 依赖. -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <scope>provided</scope>
        </dependency>
        <!--jsp支持  end-->

pom.xml添加依赖

　　3）、控制层建议使用@Controller，不要使用@RestController，毕竟不是每一个方法都返回JSON的，有的需要跳转到界面。

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * @author thc
 * @E-mail  2353635701@qq.com
 * @date 2019年2月19日 下午3:12:03 
 * @Description 类描述
 */
@Controller
public class DemoController {

    @RequestMapping(value = {"/", "/view"} ,method=RequestMethod.GET)
    public String helloworld() {
        System.out.println("helloworld！！");
        return "index";
    }
}

java action代码

　　4）、 像往常的web项目一样，在文件夹src下创建main\webapp\WEB-INF\views\index.jsp测试页面。

　　　　　　　　

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>index</title>
<!-- Tell the browser to be responsive to screen width -->
<meta
    content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no"
    name="viewport">
</head>
<body class="hold-transition login-page">
    <center>
        <h3>你好，欢迎 ！！！</h3>
    </center>
</body>
</html>

index.jsp 页面代码

启动应用，访问http://localhost:8080，测试成功！！

2、支持mybatis做数据库持久化

　　1）、添加依赖

<!-- mybatis start -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!-- mysql 连接 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- mybatis end -->

支持mybatis的相关依赖

备份程序！！！

　   2）、添加自定义配置（添加mybatis支持方法一，本人不支持使用，官方配置文档不好找，反正我是没找到全部的数据库连接池配置参数）

　　　　修改application.properties，添加mybatis和dataSource相关配置

#使用mybatis连接数据库信息
#mybatis自定义配置信息
mybatis.mapper-locations = classpath:mybatis/mapper/*Mapper.xml
mybatis.config-location = classpath:mybatis/mybatis_config.xml
mybatis.type-aliases-package = com.example.demo.dao.db
#数据库连接信息
spring.datasource.driver-class-name= com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8
spring.datasource.username = root
spring.datasource.password = 123

添加使用mybatis连接数据库信息

　　　　写样例测试，数据库表可以随意创建两张，添加测试程序

　　　　a、在src/main/resources下创建mybatis文件夹，在mybatis文件夹下创建mybatis_config.xml（内容如下）文件、generator_test.xml文件（方向工程生成文件内容如下）和mapper文件夹（这个要与application.properties中的配置一致classpath:mybatis/mapper），在src/main/java创建com.example.demo.dao.db包，使用mybatis方向工程生成数据代码。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>        
    
</configuration>

mybatis_config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<!-- 配置Run As Maven build : Goals 参数 : mybatis-generator:generate -Dmybatis.generator.overwrite=true -->
<!-- 配置 tableName,使用 Run As Maven build 生成 dao model 层 -->
<generatorConfiguration>
    <!-- 配置文件路径 -->
    <!-- <properties url="${mybatis.generator.generatorConfig.properties}"/> -->
    <!-- <properties resource="generatorConfig.properties"/> -->

    <!--数据库驱动包路径 -->
    <classPathEntry
        location="E:\m2\repository\mysql\mysql-connector-java\5.1.46\mysql-connector-java-5.1.46.jar" />
    <context id="EditionManagerTables" targetRuntime="MyBatis3">
        <!-- mybatio分页插件 -->
        <plugin type="org.mybatis.generator.plugins.RowBoundsPlugin"></plugin>
        <!--关闭注释 -->
        <commentGenerator>
            <property name="suppressAllComments" value="true" /><!-- 是否取消注释 -->
            <property name="suppressDate" value="true" /> <!-- 是否生成注释代时间戳 -->
        </commentGenerator>

        <!--数据库连接信息 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
            connectionURL="jdbc:mysql://localhost:3306/test" userId="root"
            password="123">
        </jdbcConnection>

        <!-- 类型转换 -->
        <javaTypeResolver>
            <!-- 是否使用bigDecimal， false可自动转化以下类型（Long, Integer, Short, etc.） -->
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

        <!--生成的model 包路径 -->
        <javaModelGenerator targetPackage="com.example.demo.dao.db.model"
            targetProject="demo/src/main/java">
            <!-- 是否在当前路径下新加一层schema,eg：fase路径cn.ffcs.test.domain"， true:cn.ffcs.test.domain".[schemaName] -->
            <property name="enableSubPackages" value="ture" />
            <!-- 是否针对string类型的字段在set的时候进行trim调用 -->
            <property name="trimStrings" value="true" />
            <!-- <property name="rootClass" value="com.sinosig.xb.rms.base.BaseEntity"/> -->
        </javaModelGenerator>

        <!--生成xml mapper文件 路径 -->
        <sqlMapGenerator targetPackage="mybatis.mapper"
            targetProject="demo/src/main/resources">
            <!-- 是否在当前路径下新加一层schema,eg：fase路径cn.ffcs.test.domain"， true:cn.ffcs.test.domain".[schemaName] -->
            <property name="enableSubPackages" value="ture" />
        </sqlMapGenerator>

        <!-- 生成的Dao接口 的包路径 -->
        <javaClientGenerator type="XMLMAPPER"
            targetPackage="com.example.demo.dao.db" targetProject="demo/src/main/java">
            <property name="enableSubPackages" value="ture" />
            <!-- baseDao -->
            <!-- <property name="rootInterface" value="com.xb.alert.platform.db.dao.BaseDao" 
                /> -->
        </javaClientGenerator>

        <!--对应数据库表名 -->
        <!-- schema即为数据库名 tableName为对应的数据库表 domainObjectName要生成的实体类名 enable*ByExample是否生成 
            example类 -->
        <!-- <table tableName="ts_user" schema="" enableInsert="true" -->
        <!-- <table tableName="tp_%" schema="" enableInsert="true" useGeneratedKeys="true" 
            keyProperty="id" -->
        <!-- <table tableName="te_employee_info" schema="" enableInsert="true" -->
        <!-- <table tableName="%" schema="" enableInsert="true" -->
        <table tableName="%" schema="" enableInsert="true"
            enableCountByExample="true" enableUpdateByExample="true"
            enableDeleteByExample="true" enableSelectByExample="true"
            selectByExampleQueryId="true">
            <!-- enableCountByExample="true" enableUpdateByExample="false" enableDeleteByExample="false" -->
            <!-- enableSelectByExample="true" selectByExampleQueryId="true"> -->
            <!-- 忽略列，不生成bean 字段 <ignoreColumn column="FRED" /> -->
            <!-- 指定列的java数据类型 <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" 
                /> -->
        </table>
    </context>
</generatorConfiguration>

mybatis方向工程文件generator_test.xml

　　　　

　　　　b、创建service层：创建包com.example.demo.service、com.example.demo.service.impl及接口TestDemoService和实现类TestDemoServiceImpl如下：

 　　　　

package com.example.demo.service;

import com.example.demo.dao.db.model.TsUser;

public interface TestDemoService {

    public boolean testTransactional();
    public TsUser selectByPrimaryKey(int id);
}

service层接口TestDemoService.java代码

package com.example.demo.service.impl;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.example.demo.dao.db.TdScoreMapper;
import com.example.demo.dao.db.TsUserMapper;
import com.example.demo.dao.db.model.TdScore;
import com.example.demo.dao.db.model.TsUser;
import com.example.demo.service.TestDemoService;

@Service
public  class TestDemoServiceImpl implements  TestDemoService{
    @Resource
    TsUserMapper mapper;
    
    @Resource
    TdScoreMapper scMapper;
    
    public TsUser selectByPrimaryKey(int id){
        return mapper.selectByPrimaryKey(id);
    }
    
    
    @Transactional
    public boolean testTransactional(){
        
        try {
            TsUser tu = new TsUser();
            tu.setId(1);
            tu.setName("张三100");
            mapper.updateByPrimaryKey(tu);
            TdScore sc = new TdScore();
            sc.setId(1);
            sc.setScore(100);
            scMapper.updateByPrimaryKey(sc);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return true;
    }
}

Service层实现类TestDemoServiceImpl代码

　　　　c、添加修改action代码如下

package com.example.demo.controller;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.example.demo.dao.db.model.TsUser;
import com.example.demo.service.TestDemoService;

/**
 * @author thc
 * @E-mail  2353635701@qq.com
 * @date 2019年2月19日 下午3:12:03 
 * @Description 类描述
 */
@Controller
public class DemoController {
    @Autowired
    TestDemoService service;

    @RequestMapping(value = {"/", "/view"} ,method=RequestMethod.GET)
    public String helloworld() {
        System.out.println("helloworld！！");
        service.testTransactional();
        // 查询数据库
        TsUser tu = service.selectByPrimaryKey(1);
        System.out.println("数据库查出用户名" + tu.getName());
        return "index";
    }
}

DemoController 测试数据库连接成功代码

 　　　　d、修改应用启动入口DemoApplication.java，添加@EnableTransactionManagement注解，用来支持spring事物；添加@MapperScan("com.example.demo.dao.db")，用来配置扫描**Mapper接口，也可以使用@Mapper注解，二选一（注解写法如下第二张截图）

           

　　e、启动测试：控制台打印用户名，成功！！

　　　　

　 备份程序！！！！ 因为这个也是用来支持mybaits的介绍，和上面的操作重复了，所有我们导入之前备份的程序，再做之下操作。

　　3）、支持读取自定义的配置文件（添加mybatis支持方法二，这个学习成本很小，老方式配置DataSource参数就可以了）

　　　　这个操作就是使用springBoot对xml配置文件的支持，直接用程序读我们原来的mybaits配置文件（官方文档  https://docs.spring.io/spring-boot/docs/2.1.3.RELEASE/reference/htmlsingle/#using-boot-importing-xml-configuration）

　　　　

　　　　a、在src/main/resources下创建mybatis文件夹，在mybatis文件夹下创建mybatis_config.xml（内容如下）文件、generator_test.xml文件（方向工程生成文件内容如下）和mapper文件夹（这个要与application.properties中的配置一致classpath:mybatis/mapper），在src/main/java创建com.example.demo.dao.db包，使用mybatis方向工程生成数据代码。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">


    <!-- 自动扫描 -->
    <!-- <context:component-scan base-package="com.sinosig.xb.em.*" /> -->

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <!-- 基本属性 url、user、password -->
        <property name="url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8&amp;zeroDateTimeBehavior=convertToNull" /> 
        <property name="username" value="root" />
        <property name="password" value="123" />
        <!-- 配置初始化大小、最小、最大 -->
        <property name="initialSize" value="1" />
        <property name="minIdle" value="1" />
        <property name="maxActive" value="20" />
        <property name="maxIdle" value="20"></property>
        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="60000" />
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000" />
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="300000" />
        <property name="validationQuery" value="SELECT 'x'" />
        <property name="testWhileIdle" value="true" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />

        <!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
        <property name="poolPreparedStatements" value="false" />
        <!-- 配置监控统计拦截的filters -->
    </bean>


    <!-- MyBatis配置 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 自动扫描entity目录, 省掉Configuration.xml里的手工配置 -->
        <!-- <property name="typeAliasesPackage" value="com.hjf.boot.api.domain" 
            /> -->
        <!-- 显式指定Mapper文件位置 -->
        <property name="mapperLocations" value="classpath*:mybatis/mapper/*Mapper.xml" />
    </bean>
    <!-- 扫描basePackage下所有以@MyBatisRepository标识的 接口 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.example.demo.dao.db" />
        <!-- <property name="annotationClass" value="com.hjf.boot.demo.boot_mybatis.dao.Mapper" 
            /> -->
    </bean>

    <!-- 开启事务注解驱动 -->
    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>


    <!-- 自动扫描，多个包以 逗号分隔 <context:component-scan base-package="com.sinosig.xb.em"/> -->
    <context:component-scan base-package="com.example.demo.dao.db"/>
    <aop:aspectj-autoproxy />




</beans>

mybatis_config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<!-- 配置Run As Maven build : Goals 参数 : mybatis-generator:generate -Dmybatis.generator.overwrite=true -->
<!-- 配置 tableName,使用 Run As Maven build 生成 dao model 层 -->
<generatorConfiguration>
    <!-- 配置文件路径 -->
    <!-- <properties url="${mybatis.generator.generatorConfig.properties}"/> -->
    <!-- <properties resource="generatorConfig.properties"/> -->

    <!--数据库驱动包路径 -->
    <classPathEntry
        location="E:\m2\repository\mysql\mysql-connector-java\5.1.46\mysql-connector-java-5.1.46.jar" />
    <context id="EditionManagerTables" targetRuntime="MyBatis3">
        <!-- mybatio分页插件 -->
        <plugin type="org.mybatis.generator.plugins.RowBoundsPlugin"></plugin>
        <!--关闭注释 -->
        <commentGenerator>
            <property name="suppressAllComments" value="true" /><!-- 是否取消注释 -->
            <property name="suppressDate" value="true" /> <!-- 是否生成注释代时间戳 -->
        </commentGenerator>

        <!--数据库连接信息 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
            connectionURL="jdbc:mysql://localhost:3306/test" userId="root"
            password="123">
        </jdbcConnection>

        <!-- 类型转换 -->
        <javaTypeResolver>
            <!-- 是否使用bigDecimal， false可自动转化以下类型（Long, Integer, Short, etc.） -->
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

        <!--生成的model 包路径 -->
        <javaModelGenerator targetPackage="com.example.demo.dao.db.model"
            targetProject="demo/src/main/java">
            <!-- 是否在当前路径下新加一层schema,eg：fase路径cn.ffcs.test.domain"， true:cn.ffcs.test.domain".[schemaName] -->
            <property name="enableSubPackages" value="ture" />
            <!-- 是否针对string类型的字段在set的时候进行trim调用 -->
            <property name="trimStrings" value="true" />
            <!-- <property name="rootClass" value="com.sinosig.xb.rms.base.BaseEntity"/> -->
        </javaModelGenerator>

        <!--生成xml mapper文件 路径 -->
        <sqlMapGenerator targetPackage="mybatis.mapper"
            targetProject="demo/src/main/resources">
            <!-- 是否在当前路径下新加一层schema,eg：fase路径cn.ffcs.test.domain"， true:cn.ffcs.test.domain".[schemaName] -->
            <property name="enableSubPackages" value="ture" />
        </sqlMapGenerator>

        <!-- 生成的Dao接口 的包路径 -->
        <javaClientGenerator type="XMLMAPPER"
            targetPackage="com.example.demo.dao.db" targetProject="demo/src/main/java">
            <property name="enableSubPackages" value="ture" />
            <!-- baseDao -->
            <!-- <property name="rootInterface" value="com.xb.alert.platform.db.dao.BaseDao" 
                /> -->
        </javaClientGenerator>

        <!--对应数据库表名 -->
        <!-- schema即为数据库名 tableName为对应的数据库表 domainObjectName要生成的实体类名 enable*ByExample是否生成 
            example类 -->
        <!-- <table tableName="ts_user" schema="" enableInsert="true" -->
        <!-- <table tableName="tp_%" schema="" enableInsert="true" useGeneratedKeys="true" 
            keyProperty="id" -->
        <!-- <table tableName="te_employee_info" schema="" enableInsert="true" -->
        <!-- <table tableName="%" schema="" enableInsert="true" -->
        <table tableName="%" schema="" enableInsert="true"
            enableCountByExample="true" enableUpdateByExample="true"
            enableDeleteByExample="true" enableSelectByExample="true"
            selectByExampleQueryId="true">
            <!-- enableCountByExample="true" enableUpdateByExample="false" enableDeleteByExample="false" -->
            <!-- enableSelectByExample="true" selectByExampleQueryId="true"> -->
            <!-- 忽略列，不生成bean 字段 <ignoreColumn column="FRED" /> -->
            <!-- 指定列的java数据类型 <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" 
                /> -->
        </table>
    </context>
</generatorConfiguration>

generator_test.xml

　　　　b、添加依赖

<!-- https://mvnrepository.com/artifact/commons-dbcp/commons-dbcp -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>

pom.xml添加依赖

　　　　c、修改应用启动入口DemoApplication.java

 

　　d、重复上面的测试方法，成功！！！！

3、支持logback配置（有两种读取方式） ，logback的依赖是springBoot的默认起步依赖，所以我们不需要单独引入依赖。

　　1）、application.properties直接配置logback日志设置

# LOGGING
logging.config= # Location of the logging configuration file. For instance `classpath:logback.xml` for Logback
logging.exception-conversion-word=%wEx # Conversion word used when logging exceptions.
logging.file= # Log file name. For instance `myapp.log`
logging.level.*= # Log levels severity mapping. For instance `logging.level.org.springframework=DEBUG`
logging.path= # Location of the log file. For instance `/var/log`
logging.pattern.console= # Appender pattern for output to the console. Only supported with the default logback setup.
logging.pattern.file= # Appender pattern for output to the file. Only supported with the default logback setup.
logging.pattern.level= # Appender pattern for log level (default %5p). Only supported with the default logback setup.
logging.register-shutdown-hook=false # Register a shutdown hook for the logging system when it is initialized.

官方文档介绍

#=========== 日志配置·简易（spring boot已经集成logback日志）=========  
#controller层日志 WARN级别输出  
#logging.level.com.example.demo.controller=WARN  
#mapper层 sql日志 DEBUG级别输出  
#logging.level.com.example.demo.service.impl=DEBUG  

#logging.pattern.console=%d{yyyy/MM/dd-HH:mm:ss} [%thread] %-5level %logger- %msg%n  
#logging.pattern.file=%d{yyyy/MM/dd-HH:mm} [%thread] %-5level %logger- %msg%n  
#打印运行时sql语句到控制台  
spring.jpa.show-sql=true  
# 同时使用，则只有logging.file生效
# 绝对路径或者相对路径
logging.file=logs/spring-boot-logging.log  
# 设置目录
logging.path=/var/log
# 级别控制
# 默认级别为：ERROR、WARN、INFO,10MB时会切分一次
# 格式logging.level.* = LEVEL
# TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF
logging.level.root=info
logging.level.com.example.demo=info
logging.level.com.example.demo.controller=WARN

application.properties文件添加日志配置

　　2）、application.properties配置读取logback xml配置文件

　　　　a、application.properties添加配置读取logback.xml

# 自定义日志配置路径
logging.config=classpath:logging-config.xml

　　　　b、创建logback.xml文件

　　　　　　

<?xml version="1.0" encoding="UTF-8"?>  
<configuration>      
    <!-- %m输出的信息,%p日志级别,%t线程名,%d日期,%c类的全名,%i索引【从数字0开始递增】,,, -->      
    <!-- appender是configuration的子节点，是负责写日志的组件。 -->  
    <!-- ConsoleAppender：把日志输出到控制台 -->  
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">      
        <encoder>      
            <pattern>%d %p (%file:%line\)- %m%n</pattern>    
            <!-- 控制台也要使用UTF-8，不要使用GBK，否则会中文乱码 -->  
            <charset>UTF-8</charset>     
        </encoder>      
    </appender>      
    <!-- RollingFileAppender：滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 -->  
    <!-- 以下的大概意思是：1.先按日期存日志，日期变了，将前一天的日志文件名重命名为XXX%日期%索引，新的日志仍然是demo.log -->  
    <!--             2.如果日期没有发生变化，但是当前日志的文件大小超过1KB时，对当前日志进行分割 重命名-->  
    <appender name="demolog" class="ch.qos.logback.core.rolling.RollingFileAppender">      
        <File>log/demo.log</File>      
        <!-- rollingPolicy:当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名。 -->  
        <!-- TimeBasedRollingPolicy： 最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动 -->  
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">      
            <!-- 活动文件的名字会根据fileNamePattern的值，每隔一段时间改变一次 -->  
            <!-- 文件名：log/demo.2017-12-05.0.log -->  
            <fileNamePattern>log/demo.%d.%i.log</fileNamePattern>   
            <!-- 每产生一个日志文件，该日志文件的保存期限为30天 -->   
            <maxHistory>30</maxHistory>     
            <timeBasedFileNamingAndTriggeringPolicy  class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">      
                <!-- maxFileSize:这是活动文件的大小，默认值是10MB，测试时可改成1KB看效果 -->    
                <maxFileSize>1KB</maxFileSize>      
            </timeBasedFileNamingAndTriggeringPolicy>      
        </rollingPolicy>      
        <encoder>      
            <!-- pattern节点，用来设置日志的输入格式 -->  
            <pattern>      
                %d %p (%file:%line\)- %m%n    
            </pattern>      
            <!-- 记录日志的编码:此处设置字符集 - -->  
            <charset>UTF-8</charset>  
        </encoder>      
    </appender>      
    <!-- 控制台输出日志级别 -->  
    <root level="info">      
        <appender-ref ref="STDOUT" />      
    </root>      
    <!-- 指定项目中某个包，当有日志操作行为时的日志记录级别 -->  
    <!-- com.example.demo为根包，也就是只要是发生在这个根包下面的所有日志操作行为的权限都是DEBUG -->  
    <!-- 级别依次为【从高到低】：FATAL > ERROR > WARN > INFO > DEBUG > TRACE  -->
    <!-- <logger name="com.example.demo.controller" level="info"> -->
    <logger name="com.example.demo" level="debug">     
        <appender-ref ref="demolog" />      
    </logger>      
</configuration>

logback配置文件logback.xml

4、支持读profile

三、部署应用

1、jar包配置

对于web项目，springBoot默认的打包方式配置的是jar包，他帮我们内嵌了一个tomcat，我们只需要使用我们常用的打包工具打包，通过部署jar包的方式部署到服务器上即可。

2、war包配置

 虽然使用内置tomcat在开发上很方便，但是当我们在企业中开发的时候，有可能公司就是规定我们使用运维统一部署的tomcat服务器，那么我们就必须把项目打包成部署在tomcat中的war包，，这有有一个问题，我们的项目没有servlet容器的加载入口——web.xml文件。

　　这时候，我们就需要对程序做些修改：

　　1、修改pom.xml中的打包配置：war　　

　　　　

　　2、创建一个servlet初始化入口：springBoot给我们提供了一个SpringBootServlertInitializer类。

　　　　官方文档：https://docs.spring.io/spring-boot/docs/2.1.4.BUILD-SNAPSHOT/reference/htmlsingle/     　　ctrl+f 搜索：SpringBootServletInitializer

　　　　

　　　　我们要在我们的项目中写一个SpringBootServlertInitializer类的子类，重写他的configure()方法来完成配置，实现代码如下：

package com.example.demo;

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

public class DemoServletInitializer extends SpringBootServletInitializer {

    @Override
    public SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        // DemoApplication 程序入口，指定Spring的配置
        return builder.sources(DemoApplication.class);
    }
}

SpringBootServletInitializer子类DemoServletInitializer.java代码

　　3、使用maven打包命令打包　　

　这个时候打成的war包既可以部署在tomcat中，也可以使用"java -jar 项目名.war"来作为jar包部署。