SpringBoot开发记录

Dear 丶 2022-02-16 09:45 417阅读 0赞

**目录**

1.快速初始化

2.pom.xml文件

3.Mybatis自动生成代码

3.1 新建generatorCOnfig文件

3.2 pom.xml文件中添加插件

3.3 开始生成

3.4 使用

4.查询样例

4.1 普通单表操作

4.2 自增主键表的操作

4.3 联合查询

4.4 分页查询

5.关于事物

5.1 关于@EnableTransactionManagement注解

5.2 关于@Transactional注解的位置

5.3 关于try/catch

5.4 关于事物传播

6.druid监控

7.Controller

8.Swagger

8.1 添加maven依赖

8.2 添加自动配置类

8.3 给接口配置说明

8.4 界面化接口说明文档

9.关于restful

10.关于全局异常捕获

参考文献

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

# 1.快速初始化 #

SpringBoot基础工程的搭建，可以通过[这里在线界面化配置][Link 1]生成，生成后，直接本地导入即可。

其中，Dependencies中点击See all可以选择需要一类的jar包，一般情况下，可以选择以下几个：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpYW5nY2hhMDA3_size_16_color_FFFFFF_t_70][]

选完之后，点击Generate Project 就生成基础工程了，下载到本地，导入到idea即可。

# 2.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.1.4.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.tydic</groupId>
        <artifactId>cloud_wind</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>cloud_wind</name>
        <description>Demo project for Spring Boot</description>
        
        <packaging>jar</packaging>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.0.1</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.0.29</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </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>
                
                <plugin>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-maven-plugin</artifactId>
                    <configuration>
                        
                        <configurationFile>src/main/resources/mybatis-generator/generatorConfig.xml</configurationFile>
                        <verbose>true</verbose>
                        <overwrite>true</overwrite>
                    </configuration>
                    <executions>
                        <execution>
                            <id>Generate MyBatis Artifacts</id>
                            <goals>
                                <goal>generate</goal>
                            </goals>
                            <phase>generate-sources</phase>
                        </execution>
                    </executions>
                    <dependencies>
                        <dependency>
                            <groupId>mysql</groupId>
                            <artifactId>mysql-connector-java</artifactId>
                            <version>5.1.44</version>
                            <scope>runtime</scope>
                        </dependency>
                    </dependencies>
                </plugin>
            </plugins>
        </build>
    </project>

有些依赖是后面添加进去的，例如druid相关包。

# 3.Mybatis自动生成代码 #

Mybatis是需要通过xml和Mapper映射来完成正常使用，以前使用hibernate的时候，可以通过eclipse自动逆向工程生成各个表的hbm文件，Mybatis也提供的有类似的功能，通过maven插件来自动生成每一个表的实体类、对应的Mapper以及xml文件。

关于Mybatis Generator配置文件的详细介绍，[参考这里][Link 2]，博主写的非常详细，下面根据需要我在项目中的使用如下。

## 3.1 新建generatorCOnfig文件 ##

在resources目录下新建mybatis-generator目录，然后新建generatorConfig.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">
    
    <generatorConfiguration>
        
        
        
    
        
        
        <context id="MysqlTables" targetRuntime="MyBatis3Simple" defaultModelType="flat">
            
            <property name="autoDelimitKeywords" value="true"/>
            
            <property name="javaFileEncoding" value="utf-8"/>
            
            <property name="beginningDelimiter" value="`"/>
            <property name="endingDelimiter" value="`"/>
    
            
            <property name="javaFormatter" value="org.mybatis.generator.api.dom.DefaultJavaFormatter"/>
            
            <property name="xmlFormatter" value="org.mybatis.generator.api.dom.DefaultXmlFormatter"/>
            <plugin type="org.mybatis.generator.plugins.SerializablePlugin"/>
            <plugin type="org.mybatis.generator.plugins.ToStringPlugin"/>
    
            
            <commentGenerator>
                <property name="suppressAllComments" value="false"/>
                <property name="suppressDate" value="true"/> 
            </commentGenerator>
    
            
            <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                            connectionURL="jdbc:mysql://130.76.53.161:3306/customer"
                            userId="root"
                            password="root"/>
            
            <javaTypeResolver>
                
                <property name="forceBigDecimals" value="false"/>
            </javaTypeResolver>
    
            
            <javaModelGenerator targetPackage="com.tydic.cloud_wind.models" targetProject="src/main/java">
                <property name="enableSubPackages" value="false"/>
                <property name="trimStrings" value="true"/>
            </javaModelGenerator>
            
            <sqlMapGenerator targetPackage="mapper" targetProject="src/main/resources">
                <property name="enableSubPackages" value="false"/>
            </sqlMapGenerator>
            
            <javaClientGenerator targetPackage="com.tydic.cloud_wind.dao" targetProject="src/main/java" type="XMLMAPPER">
                <property name="enableSubPackages" value="true"/>
            </javaClientGenerator>
            
            
            <table tableName="%"
                   enableCountByExample="true"
                   enableUpdateByExample="true"
                   enableDeleteByExample="true"
                   enableSelectByExample="true"
                   selectByExampleQueryId="true">
                <property name="useActualColumnNames" value="false"/>
            </table>
        </context>
    </generatorConfiguration>

**我在用的时候有几个疑惑点：**

**（1）context的targeRuntime是什么，一定要用MyBatis3Simple吗？**

不单单有MyBatis3SImple，还有MyBatis3,区别在于：

>     targetRuntime:
>             1，MyBatis3：默认的值，生成基于MyBatis3.x以上版本的内容，包括XXXBySample；
>             2，MyBatis3Simple：类似MyBatis3，只是不生成XXXBySample；

**（2）如果后面有表结构新增了，我能不能一个表一个表的添加？**

可以，在配置文件中，关于table的配置，可以单独配置独立的表，如下所示：

注意修改targetProject中对应的目录，以及对应的文件夹需要提前创建好，例如：mapper/models/dao在相关包或者目录下的文件夹。

**（3）假设数据库表设计的不规范，有些字段名称和java的关键字一样，例如：有字段名为public，此时生成的实体类就会有错，怎么解决？**

可以通过再table中配置columnOverride来解决这个问题

## 3.2 pom.xml文件中添加插件 ##

添加在build下的plugins下，内容如下

<plugin>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-maven-plugin</artifactId>
                    <configuration>
                        
                        <configurationFile>src/main/resources/mybatis-generator/generatorConfig.xml</configurationFile>
                        <verbose>true</verbose>
                        <overwrite>true</overwrite>
                    </configuration>
                    <executions>
                        <execution>
                            <id>Generate MyBatis Artifacts</id>
                            <goals>
                                <goal>generate</goal>
                            </goals>
                            <phase>generate-sources</phase>
                        </execution>
                    </executions>
                    <dependencies>
                        <dependency>
                            <groupId>mysql</groupId>
                            <artifactId>mysql-connector-java</artifactId>
                            <version>5.1.44</version>
                            <scope>runtime</scope>
                        </dependency>
                    </dependencies>
                </plugin>

主要是指定generatorConfig配置文件的位置。

## 3.3 开始生成 ##

有两种操作方式，第一种是在idea中通过界面化操作来完成，如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpYW5nY2hhMDA3_size_16_color_FFFFFF_t_70 1][]

点击按钮之后，就能看到每个目录下的已经生成的文件的，一个表对应一个dao、Mapper、xml文件。

也可以直接使用maven命令，命令如下

mvn mybatis-generator:generate

## 3.4 使用 ##

相关代码生成之后，其实还没有和SpringBoot建立联系，因为其实相关实体类及映射文件的生成，其实和Springboot框架自身并没有关系，单独使用maven也可以生成，所以，在生成相关文件之后，我们还需要有一些其他配置。

**（1）在启动类添加注解**

/**
     * 配置MapperScan就不用再每一個Mapper文件上添加@Mapper的注解了
     */
    @SpringBootApplication
    @MapperScan("com.tydic.cloud_wind.dao")
    public class CloudWindApplication {
    	public static void main(String[] args) {
    		SpringApplication.run(CloudWindApplication.class, args);
    	}
    
    }

**（2）指定mapper的映射文件**

在application.properties中添加如下一行设置

#指定mapper映射文件位置
    mybatis.mapper-locations=classpath:/mapper/*Mapper.xml
    #指定models的位置，如果在mapper.xml文件中的resultType指定了具体的包路径，这里就可以不用设置
    #mybatis.type-aliases-package=com.tydic.cloud_wind.models

关于mybatis.type-aliases-package的配置，如果是通过自动生成的代码，是不需要配置的，因为我们随意打开一个xml文件，可以看到其namespace指定的都是具体的包路径下的Mapper文件，但是有时候，我们可以还会自定义一些Mapper文件和xml文件，此时如果namespace仅仅指定类名，而不指定具体的包路径，就需要在application.properties中配置mybatis.type-aliases-package，这样xml文件就能和Mapper文件自动建立映射。

# 4.查询样例 #

编写查询相关代码之前，我们还需要先设置mybatis的数据源相关信息，编辑application.properties，如下：

#数据库配置
    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
    spring.datasource.url=jdbc:mysql://192.168.1.120:3306/customer?useUnicode=true&characterEncoding=utf8
    spring.datasource.username=root
    spring.datasource.password=root
    #spring.datasource.filters=stat,wall,log4j
    
    #mybatis配置
    #开启二级缓存 一级缓存是mapper级别，二级缓存是namespaces级别的，所谓缓存就是相同查询不走数据库，除非触发了清楚缓存动作才会重新查询
    mybatis.configuration.cache-enabled=true
    mybatis.configuration.default-statement-timeout=3000
    mybatis.configuration.map-underscore-to-camel-case=true
    mybatis.configuration.use-generated-keys=true
    #指定mapper映射文件位置
    mybatis.mapper-locations=classpath:/mapper/*Mapper.xml
    #指定models的位置，如果在mapper.xml文件中的resultType指定了具体的包路径，这里就可以不用设置
    #mybatis.type-aliases-package=com.tydic.cloud_wind.models
    #开启打印sql查询日志的功能
    mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

## 4.1 普通单表操作 ##

在dao下对应每一个表生成的Mapper文件，都有如5个方法：

public interface DdMsgPushMapper {
        int deleteByPrimaryKey(Integer id);
        int insert(DdMsgPush record);
        DdMsgPush selectByPrimaryKey(Integer id);
        List<DdMsgPush> selectAll();
        int updateByPrimaryKey(DdMsgPush record);
    }

我们在使用的时候，可以非常方便的通过需要构造对应的实体类，然后完成对单表的增删改查，下面看几个简单的例子，在service包下新增一个MybatisService的类，部分样例查询代入如下：

@Service
    @Transactional
    public class MybatisService
    {
        @Autowired
        private TmpDispUserMapper   tMapper;
    
        //简单查询-直接查询全部
        public void simpleSelect()
        {
            List<TmpDispUser> rList = tMapper.selectAll();
            System.out.println(rList.size());
            for (TmpDispUser tU : rList)
            {
                System.out.println(tU.toString());
            }
        }
    
        //简单查询-根据id查询
        public void findUserById(Integer id)
        {
            TmpDispUser tUser = tMapper.selectByPrimaryKey(id);
            System.out.println(tUser.toString());
        }
    
        //正常新增
        public void addUser()
        {
            TmpDispUser tUser = new TmpDispUser();
            tUser.setName("刘ddd刘洋洋");
            tUser.setTel("18654745d21");
            Integer rId = tMapper.insert(tUser);
            //给Mapper.xml中的insert添加useGeneratedKeys="true" keyProperty="id"这俩属性，tUser.getId()就能获取插入后的自增id
            System.out.println(tUser.toString());
            System.out.println(rId);
        } 
    }

可以看到，相关操作还是非常的简单和便捷。但实际的开发中，往往联合查询多表操作的应用场景更多。

## 4.2 自增主键表的操作 ##

如果数据库中相关表的主键是自增的，如何操作？看上面的代码addUser方法中，就是操作自增主键表的样例，通过构造一个实体类，然后调用insert方法，插入。有以下几点注意事项：

**（1）实体类对应自增主键的成员不用调set方法，空的就行**

**（2）对应的xml文件要修改insert语句，添加userGeneratedKeys="true" keyProperty="id"，keyProperty指定的是对应表的主键名称**。如下：

<insert id="insert" parameterType="com.tydic.cloud_wind.models.TmpDispUser" useGeneratedKeys="true" keyProperty="id">
        insert into tmp_disp_user (id, `name`, tel
          )
        values (#{id,jdbcType=INTEGER}, #{name,jdbcType=VARCHAR}, #{tel,jdbcType=VARCHAR}
          )
      </insert>

在完成insert操作之后，入参的实体对象，通过调用get方法就可以直接获取插入进去记录的主键id。

## 4.3 联合查询 ##

前面提到，在实际的开发中，多表的联合查询以及不规则查往往比单表操作要多的多，对于我而言，我更喜欢使用Map作为查询的结果，下面记录下Mybatis的自定义查询开发。网上有有一些方案是通过对实体类的构造来完成的，例如关联查询的时候，会用某个实体类所有最大类，然后进行返回，这种有利有弊，好处在于可直接操作对象，不方便之处在于代码量大，而且总要去做类的开发，[参考这里][Link 3]。

联合查询或者说自定义查询，有两种方式，一种是通过xml文件配置相关的查询sql，一种是使用注解方式。

**（1） 自定义xml**

即：我们可以自己编写相关xml文件，然后指定对应的Mapper接口文件。先开看一个例子：

我在dao包下新增一个CommDaoMapper接口，定义如下几个方法：

/**
     * 公用三个查询方法
     * 1.结果返回是Map<String,Object>
     * 2.结果返回是List<Map<String,Object>>
     * 3.分页查询
     */
    public interface CommDaoMapper
    {
        //单独参数查询，出参是Map
        Map<String,Object> selectByParams(String p1);
        //单独参数查询，出单是实体类
        TmpServerUser selectByParamsWithBean(@Param("pid") String pid);
        //Map查询参数，出参是List
        List<Map<String,Object>> selectWithList(Map<String,Object> p1);
        //独立入参，表名是动态的，出参是List
        List<Map<String,Object>> selectWithListByDt(Map<String,Object> p1);
    }

然后在resources/mapper目录下新增一个CommDaoMapper.xml文件，内容如下：

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    <mapper namespace="com.tydic.cloud_wind.dao.CommDaoMapper" >
    
        
        
        
        
        
        <select id="selectByParams"
                resultType="java.util.Map"
                parameterType="java.lang.String" >
            select id,s_id,name,tel
            from tmp_server_user
            where id = #{0}
        </select>
        <select id="selectByParamsWithBean"
                resultType="com.tydic.cloud_wind.models.TmpServerUser"
                parameterType="java.lang.String" >
            select *
            from tmp_server_user
            where id = #{pid}
        </select>
        <select id="selectWithList"
                resultType="java.util.Map"
                parameterType="java.util.Map" >
            select *
            from tmp_disp_user a,tmp_server_user b
            where a.id=b.id and a.name like '%' || #{u_name} || '%'
        </select>
        <select id="selectWithListByDt"
                resultType="java.util.Map"
                parameterType="java.util.Map" >
            select *
            from ${t_name} a
            where a.name like '%' || #{u_name} || '%'
        </select>
    </mapper>

然后在MybatisService中写一个测试方法如下：

@Autowired
        private CommDaoMapper       cMapper;
        //自定义的查询
        public void selectWithDsign()
        {
            //selectByParams
            Map<String,Object> rMap = cMapper.selectByParams("2");
            System.out.println(rMap.toString());
            //selectByParamsWithBean
            TmpServerUser tUser = cMapper.selectByParamsWithBean("2");
            System.out.println(tUser.toString());
            //selectWithList
            Map<String,Object> p1 = new HashMap<>();
            p1.put("u_name","洋");
            List<Map<String,Object>> rList = cMapper.selectWithList(p1);
            System.out.println(rList.toString());
            //selectWithListByDt
            Map<String,Object> p2 = new HashMap<>();
            p2.put("t_name","tmp_disp_user");
            p2.put("u_name","洋");
            List<Map<String,Object>> rL2 = cMapper.selectWithListByDt(p2);
            System.out.println(rL2);
        }

这里有一个注意点，那就是在使用Map传参的时候，可以直接使用\#\{参数名\}的方式使用参数，在直接独立传参的时候可以使用\#\{参数顺序的数字\}方式传参。

而参数的传递，可以使用$\{\}也可以使用\#\{\}，他们的区别在于：

**\#是将闯入的值当做字符串形式，很大程度上可以防止sql注入，**

**$是将传入的数据直接显示成sql语句，即：sql是需要动态的，参数是表名、关键字、或者order by后要使用$，（预编译前）**

>   \#\{\}: 解析为一个 JDBC 预编译语句（prepared statement）的参数标记符，一个 \#\{ \} 被解析为一个参数占位符 。
> 
>    $\{\}: 仅仅为一个纯碎的 string 替换，在动态 SQL 解析阶段将会进行变量替换。

**（2）注解方式**

个人感觉注解方式更简单一些，不用配置xml文件，当然，不配置xml文件有些mybatis的高级特性可能也没法使用，各有利弊吧，样例如下：

public interface CommDaoMapper
    {
        //--通过注解方式进行数据库的操作，不用对应的xml文件
        @Select("select * from tmp_disp_user")
        List<TmpDispUser> findAllTmpUser();
    
        @Select("select * from tmp_disp_user where id= #{id}")
        TmpDispUser findTmpUserById(@Param("id") int id);
    
        @Update("update tmp_disp_user set name=#{name} where id=#{id}")
        int updateTmpUser(TmpDispUser tUser);
    
        @Select("select * from tmp_disp_user a,tmp_server_user b where a.id=b.id and a.name like '%' || #{u_name} || '%'")
        List<Map<String,Object>> findWithList(Map<String,Object> p1);
    
        @Select("select * from ${t_name} a where a.name like '%' || #{u_name} || '%'")
        List<Map<String,Object>> findWithListByDt(Map<String,Object> p1);
    }

这样就行了，很简单。

## 4.4 分页查询 ##

MyBatis的分页查询推荐使用pagehelper插件来完成，这个插件非常的好用，可以无侵入的完成分页，不用修改原来全量查询的sql语句和xml文件。只需要在使用的时候设置下分页相关信息即可。[具体参考这里][Link 4]。

**（1）pom.xml中增加依赖**

<dependency>
    	<groupId>com.github.pagehelper</groupId>
    	<artifactId>pagehelper-spring-boot-starter</artifactId>
    	<version>1.2.7</version>
    </dependency>

**（2）编写自动配置类**

@Configuration//将该类加到spring容器里
    public class PageHelperConfig {
        @Bean//加上该注解spring容器自动配置
        public PageHelper pageHelper() {
            PageHelper pageHelper = new PageHelper();
            Properties properties = new Properties();
            properties.setProperty("offsetAsPageNum", "true");
            properties.setProperty("rowBoundsWithCount", "true");
            properties.setProperty("reasonable", "true");
            properties.setProperty("dialect","mysql");
            pageHelper.setProperties(properties);
            return pageHelper;
        }
    }

**（3）使用样例**

使用的时候非常的方便，只需要在调用原来正常查询之前添加startPage方法即可，如下所示：

public void testFY1()
    {
         //xml单表分页查询
            PageHelper.startPage(1,5);
            List<QeUserAsk> rList = qAsk.selectAll();
            PageInfo<SysUserInfo> page = new PageInfo<>(rList);
            System.out.println("总数量：" + page.getTotal());
            System.out.println("当前页查询记录：" + page.getList().size());
            System.out.println("当前页码：" + page.getPageNum());
            System.out.println("每页显示数量：" + page.getPageSize());
            System.out.println("总页：" + page.getPages());
            System.out.println(rList);
    }

如上就是查询第一页，每页5条数据。而selectAll是查询全量数据的sql。所以可以说是无侵入的分页插件，很方便。

注意：一个方法中只能使用一次startPage和对应的一次查询，不能查询多次。

# 5.关于事物 #

SpringBoot的事物管理以及传播网上有很多非常优秀的博文，这里贴几个比较好的。我主要记录下我在学习过程中对遇到的一些点和认识。

[【事务相关】SpringBoot之数据库（四）——事务处理：隔离级别与传播行为][SpringBoot]

[【事务相关】原理剖析][Link 5]

[【事务相关】数据库-事务和锁][-]

[【事务相关】SpringBoot之事务处理机制][SpringBoot 1]

[【事务相关】SpringBoot 数据库事务7种传播行为][SpringBoot _7]

[【事务相关】spring事务@Transactional在同一个类中的方法调用不生效][spring_Transactional]

## 5.1 关于@EnableTransactionManagement注解 ##

网上不少博文都提到，要使用事物，需要先通过@EnableTransactionManagement注解开启事物，然后再对应的类上使用@Transactional注解。其实是@EnableTransactionManagement并不会必须的。SpringBoot会开启自动配置的事物管理器，如果你使用JDBC或者JPA作为数据库访问技术，就会自动开启@EnableTransactionManagement这个注解，所以不用再显示的调用了。只需要在进行事物管理的类上添加@Transactional注解即可。

## 5.2 关于@Transactional注解的位置 ##

注解最好是放置在类上，而不是方法上，如果放到方法上，有可能会有一些bug的存在，例如：  
A类中方法1和方法2，给方法1添加事物注解，方法2不添加，但是方法2中会调用方法1，这之后我们测试，如果出问题了，  
事物是不会回滚的。因为我们在调用方法2的时候，方法2并没有被拦截，而方法2中调用方法1属于类内部调用，也不会触动方法拦截，所以事物失效。

## 5.3 关于try/catch ##

不要在service中想进行事物控制的方法中进行try/catch，因为如果你自己拦截了异常，事物拦截器就无法正常工作了，进而事务也就失效了，最好的办法是把异常抛出去，在控制层处理，或者通过切面全局处理。

## 5.4 关于事物传播 ##

SpringBoot有7中传播行为，默认是REQUIRED(0)，即：如果当前存在事物，就沿用当前事物，否则新建一个事物运行子方法，在方法嵌套执行过程中，只要有一个出错，全部都会回退。

常用的还有REQUIRES\_NEW(3)，无论当前事务是否存在，都会创建新事务运行方法，新事务可以拥有新的锁和隔离级别等特性，与当前事务相互独立。谁出错了，谁回退。

还有NESTED(6)，在当前方法调用子方法时，如果子方法发生异常，只回滚子方法执行过的SQL，而不回滚当前方法的事务。

# 6.druid监控 #

写一个自动配置类即可，代码如下：

package com.tydic.cloud_wind.config;
    
    import com.alibaba.druid.pool.DruidDataSource;
    import com.alibaba.druid.support.http.StatViewServlet;
    import com.alibaba.druid.support.http.WebStatFilter;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.boot.web.servlet.FilterRegistrationBean;
    import org.springframework.boot.web.servlet.ServletRegistrationBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import javax.sql.DataSource;
    
    /**
     * @Author: Zhouc52
     * @Description:
     * @Date: Create in 10:40 2019/4/19
     * @Modified by:
     * 项目正常启动后，浏览器输入：
     * http://127.0.0.1:8080/druid  输入用户名密码即可访问
     */
    @Configuration
    public class DruidConfig
    {
        @Bean public ServletRegistrationBean druidServlet()
        {
            // 主要实现WEB监控的配置处理
            ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*"); // 现在要进行druid监控的配置处理操作
            servletRegistrationBean.addInitParameter("allow", "127.0.0.1,192.168.1.116"); // 白名单
            servletRegistrationBean.addInitParameter("deny", "192.168.1.200"); // 黑名单
            servletRegistrationBean.addInitParameter("loginUsername", "admin"); // 用户名
            servletRegistrationBean.addInitParameter("loginPassword", "admin"); // 密码
            servletRegistrationBean.addInitParameter("resetEnable", "false"); // 是否可以重置数据源
            return servletRegistrationBean;
        }
    
        @Bean public FilterRegistrationBean filterRegistrationBean()
        {
            FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
            filterRegistrationBean.setFilter(new WebStatFilter());
            filterRegistrationBean.addUrlPatterns("/*"); // 所有请求进行监控处理
            filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.css,/druid/*");
            return filterRegistrationBean;
        }
    
        /**
            这里@Bean如果不带参数，在进入druid的监控页的时候，会看到数据源未设置的错误提示，
            但是前台操作请求过一次数据库，这个错误就消失了，存在这样的问题在于mybatis可以独立SpringBoot
            使用，是需要指定数据源关闭方法以及初始化方法的，否则druid首次会获取数据源失败，待Spring有请求
            之后，druid从SpringBoot获取到SpringBoot接管的数据源，所以就显示正常了
         */
    
        @Bean(destroyMethod = "close",initMethod = "init")
        @ConfigurationProperties(prefix = "spring.datasource")
        public DataSource druidDataSource()
        {
            return new DruidDataSource();
        }
    }

项目启动之后，直接在浏览器中输入：

http://127.0.0.1:8080/druid

输入用户名密码，即可访问，这个监控非常强大，截图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpYW5nY2hhMDA3_size_16_color_FFFFFF_t_70 2][]

其中druidDataSource设置@Bean注解的时候，要添加参数，否则你会发现首次进入点击数据源，会有以下错误：

![2019042216151474.png][]

**注：**  
**有些时候可能会出现SQL监控中无数据，看不到sql查询的监控的情况**。主要问题在于，首先要在application.properties中添加：

spring.datasource.filters=stat,wall,log4j

然后如果没有引入log4j的依赖，要在pom.xml中引入log4j的依赖:

然后再查看，可以正常监控sql了。

# 7.Controller #

控制器通过@RestController注解来声明，这里我主要写了几个样例，因为控制器中主要涉及的就是接口的入参和出参。其中出参的话SpringBoot会自动帮我们转换成JSON对象。入参相关样例如下：

package com.tydic.cloud_wind.controller;
    
    import com.tydic.cloud_wind.models.TestLable;
    import org.springframework.web.bind.annotation.*;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 入参的几种情况
     * 1.使用HttpServletRequest req获取参数
     * 2.使用@RequestParam注解获取参数
     * 3.使用@RequestBody获取参数
     */
    
    @RestController
    @RequestMapping("/index")
    public class IndexController
    {
        /**
         * 前端请求时候Content-type=application/x-www-form-urlencoded;charset=UTF-8
         * 可以使用post或者get,入参要有参数名p1,p2
         * 可以是提交表单、也可以是普通的ajax提交
         * 如果使用axios，需要使用QS.stringify(params)规格化
         * params:
         * {
         *     "p1":"1",
         *     "p2":"2"
         * }
         *
         */
        @RequestMapping(value = "/t1",method = {RequestMethod.GET,RequestMethod.POST})
        public Object test1(HttpServletRequest req)
        {
            String p1 = req.getParameter("p1");
            String p2 = req.getParameter("p2");
            Map<String,Object> rMap=new HashMap<>();
            rMap.put("code","0");
            rMap.put("des","成功!");
            rMap.put("result","参数1="+p1+",参数2="+p2);
            return rMap;
        }
    
        /**
         * 同t1规则一样，需要说明的是，看到有些文章说@RequestParam无法接收到POST请求的参数，其实并不是
         * 只要Content-type=application/x-www-form-urlencoded;charset=UTF-8,都是可以的.默认参数的required都是必填，可以设置为false，调整为非必填。如果入参的参数名和这里参数名一致，也可以省略掉@RequestParam的注解。
         */
        @RequestMapping(value = "/t2",method = {RequestMethod.GET,RequestMethod.POST})
        public Object test2(@RequestParam(defaultValue = "") String p1,@RequestParam(required = false) String p2)
        {
            Map<String,Object> rMap=new HashMap<>();
            rMap.put("code","0");
            rMap.put("des","成功!");
            rMap.put("result","参数1="+p1+",参数2="+p2);
            return rMap;
        }
    
        /**
         * 前端请求的时候设置Content-type=application/json
         * 只支持post请求
         * 如果使用axios提交，则直接提交即可，一定不能再使用QS.stringify(params)规格化,
         * 不然后端收不到参数，这种方式，SpringBoot会自动把入参转换成对象
         */
        @PostMapping(value = "/t3")
        public Object test3(@RequestBody Map<String,Object> p1)
        {
            System.out.println(p1.toString());
            Map<String,Object> rMap=new HashMap<>();
            rMap.put("code","0");
            rMap.put("des","成功!");
            rMap.put("result",p1);
            return rMap;
        }
    
        /**
         * 同test3方法，不同之处在于，也可以指定Content-type=text/plain或者其他格式
         * 收到的入参String是什么就是什么，不会再做特殊处理。
         */
        @PostMapping(value="/t4")
        public Object test4(@RequestBody String p1)
        {
            System.out.println(p1);
            Map<String,Object> rMap=new HashMap<>();
            rMap.put("code","0");
            rMap.put("des","成功!");
            rMap.put("result",p1);
            return rMap;
        }
    
        /**
         * 同test3,不同之处在于，要求入参的json格式必须和实体类对的上，否则获取不到入参参数
         * 关于这种，假设前端入参的参数名和后端对象的成员名称一致，这里可以省略掉@RequestBody，同时前端请求的时候，也可以test1那样的请求，接口这边Spring会自动处理。
         */
        @PostMapping(value="/t5")
        public Object test5(@RequestBody TestLable p1)
        {
            System.out.println(p1.toString());
            Map<String,Object> rMap=new HashMap<>();
            rMap.put("code","0");
            rMap.put("result",p1);
            return rMap;
        }
    }

# 注： #

# 8.Swagger #

Swagger绝对是神器，在使用Swagger之前，接口的描述都需要通过word文档进行定义和描述，要写清楚出参和入参，对于接口对接方，还需要使用各种工具进行接口的测试，  
但是项目集成Swagger之后，这一切的一切都可以省掉了，Swagger是一个可视化的接口文档描述插件，只需要接口开发人员在接口代码上添加相关的注解说明，接口调用方  
就可以通过界面化的平台看到所有的接口说明，并且平台还提供的在线测试功能，简直爽的无以复加。下面记录下项目中如何引入Swagger以及如何使用。

## 8.1 添加maven依赖 ##

<dependency>
    	<groupId>io.springfox</groupId>
    	<artifactId>springfox-swagger2</artifactId>
    	<version>2.4.0</version>
    </dependency>
    <dependency>
    	<groupId>io.springfox</groupId>
    	<artifactId>springfox-swagger-ui</artifactId>
    	<version>2.4.0</version>
    </dependency>

## 8.2 添加自动配置类 ##

@Configuration
    @EnableSwagger2
    public class Swagger2
    {
        @Bean
        public Docket createRestApi(){
            return new Docket(DocumentationType.SWAGGER_2)
                    .apiInfo(apiInfo())
                    .select()
                    .apis(RequestHandlerSelectors.basePackage("com.tydic.cloud_wind"))
                    .paths(PathSelectors.any())
                    .build();
        }
        //访问url的端口号和服务的端口号一样，只不过后面多一个/swagger-ui.html
        private ApiInfo apiInfo(){
            return new ApiInfoBuilder()
                    .title("Spring Boot基础框架集成Swagger2")
                    .description("使用Swagger2测试接口及接口说明查看")
                    .termsOfServiceUrl("http://localhost:8080/swagger-ui.html")
                    .contact(new Contact("zhouc52","http://sina.com","49763652@qq.com"))
                    .version("1.0")
                    .build();
        }
    }

注意basePackage的设置，一定要设置正确，不然看不到相关接口说明。

## 8.3 给接口配置说明 ##

@RestController
    @RequestMapping("/index")
    @Api(value = "indexController控制器相关api" , description = "这里是描述信息，可以自己填写")
    public class IndexController
    {
        /**
         * 前端请求时候Content-type=application/x-www-form-urlencoded;charset=UTF-8
         * 可以使用post或者get,入参要有参数名p1,p2
         * 可以是提交表单、也可以是普通的ajax提交
         * 如果使用axios，需要使用QS.stringify(params)规格化
         * params:
         * {
         *     "p1":"1",
         *     "p2":"2"
         * }
         *
         */
        @ApiOperation(value="测试接口1",notes = "测试接口1，入参通过HttpServletRequest req方式获取")
        @ApiImplicitParams({
                @ApiImplicitParam(name="p1",value = "参数1",dataType = "String",paramType = "query",required = true),
                @ApiImplicitParam(name="p2",value = "参数2",dataType = "String",paramType = "query")
        })
        @RequestMapping(value = "/t1",method = {RequestMethod.GET,RequestMethod.POST})
        public Object test1(HttpServletRequest req)
        {
            String p1 = req.getParameter("p1");
            String p2 = req.getParameter("p2");
            Map<String,Object> rMap=new HashMap<>();
            rMap.put("code","0");
            rMap.put("des","成功!");
            rMap.put("result","参数1="+p1+",参数2="+p2);
            return rMap;
        }
    
        /**
         * 同t1规则一样，需要说明的是，看到有些文章说@RequestParam无法接收到POST请求的参数，其实并不是
         * 只要Content-type=application/x-www-form-urlencoded;charset=UTF-8,都是可以的
         */
        @ApiOperation(value="测试接口2",notes = "测试接口2，入参通过@RequestParam方式获取")
        @ApiImplicitParams({
                @ApiImplicitParam(name="p1",value = "参数1",dataType = "String",paramType = "query",required = true),
                @ApiImplicitParam(name="p2",value = "参数2",dataType = "String",paramType = "query")
        })
        @RequestMapping(value = "/t2",method = {RequestMethod.GET,RequestMethod.POST})
        public Object test2(@RequestParam String p1,@RequestParam String p2)
        {
            Map<String,Object> rMap=new HashMap<>();
            rMap.put("code","0");
            rMap.put("des","成功!");
            rMap.put("result","参数1="+p1+",参数2="+p2);
            return rMap;
        }
    
        /**
         * 前端请求的时候设置Content-type=application/json
         * 只支持post请求
         * 如果使用axios提交，则直接提交即可，一定不能再使用QS.stringify(params)规格化,
         * 不然后端收不到参数，这种方式，SpringBoot会自动把入参转换成对象
         */
        @ApiOperation(value="测试接口3",notes = "测试接口3，入参通过@RequestBody获取对象")
        @ApiImplicitParam(name = "p1",value = "查询的Map对象")
        @PostMapping(value = "/t3")
        public Object test3(@RequestBody Map<String,Object> p1)
        {
            System.out.println(p1.toString());
            Map<String,Object> rMap=new HashMap<>();
            rMap.put("code","0");
            rMap.put("des","成功!");
            rMap.put("result",p1);
            return rMap;
        }
    
        /**
         * 同test3方法，不同之处在于，也可以指定Content-type=text/plain或者其他格式
         * 收到的入参String是什么就是什么，不会再做特殊处理。
         */
        @PostMapping(value="/t4")
        public Object test4(@RequestBody String p1)
        {
            System.out.println(p1);
            Map<String,Object> rMap=new HashMap<>();
            rMap.put("code","0");
            rMap.put("des","成功!");
            rMap.put("result",p1);
            return rMap;
        }
    
        /**
         * 同test3,不同之处在于，要求入参的json格式必须和实体类对的上，否则获取不到入参参数
         *
         */
        @ApiOperation(value="测试接口5",notes = "测试接口5，入参是实体类通过@RequestBody获取对象")
        @ApiImplicitParam(name = "p1",value = "实体类",dataType = "TestLable")
        @PostMapping(value="/t5")
        public Object test5(@RequestBody TestLable p1)
        {
            System.out.println(p1.toString());
            Map<String,Object> rMap=new HashMap<>();
            rMap.put("code","0");
            rMap.put("result",p1);
            return rMap;
        }
    }

## 8.4 界面化接口说明文档 ##

在浏览器中输入：[http://localhost:8080/swagger-ui.html][http_localhost_8080_swagger-ui.html]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpYW5nY2hhMDA3_size_16_color_FFFFFF_t_70 3][]

# 9.关于restful #

Restful api是一种规范，不是什么新技术。我对restful的简单理解就是通过url可以直接看出请求是什么资源，简而言之就是以前强调动作，现在强调资源，  
然后通过使用http的不同请求标识不同动作，例如：get是查询，post是提交修改、delete是删除、put是修改等等。然后url的末尾是资源标识。  
但现实中，这种方式并不是很理想，例如：我想批量删除怎么办？我的一个动作要更新多个订单的状态，此时怎么设计？等等。  
其实，我们平常用的http post请求也是restful api，只不过不规范而已，但是，满足需求，并能快速解决问题就是好的方案。  
[这篇博文说的也很好][Link 6]，可以参考下。

# 10.关于全局异常捕获 #

为了避免服务直接报异常，对服务调用方产生不好的体验，可以添加一个全局异常捕获类，对于运行过程中由控制器抛出的异常，我们都可以拦截到，并给出统一的提示，这样在一定程度上增加友好度。当然，最好还是后台开发人员在写代码的时候能自己对自己的代码负责，处理好相关异常逻辑。  
增加全局异常拦截的非常简单，写一个配置类即可，如下所示：

@ControllerAdvice
    public class GlobalExceptionHandler
    {
        @ExceptionHandler({RuntimeException.class})
        @ResponseBody
        public ResultJson exceptionHandler(RuntimeException e,HttpServletResponse resp)
        {
            ResultJson rJson = new ResultJson();
            rJson.setCode(CONST.FAILE);
            rJson.setDescription("很遗憾，服务器开小差了，请稍后再试!");
            rJson.setResult(e.getMessage());
            return rJson;
        }
    
        @ExceptionHandler({HttpRequestMethodNotSupportedException.class})
        @ResponseBody
        public ResultJson supportedException(HttpRequestMethodNotSupportedException e,HttpServletResponse resp)
        {
            ResultJson rJson = new ResultJson();
            rJson.setCode(CONST.FAILE);
            rJson.setDescription("很遗憾，服务不支持GET请求!");
            rJson.setResult(e.getMessage());
            return rJson;
        }
    }

# 参考文献 #

[【1】Mybatis Generator最完整配置详解][Link 2]

[【2】SpringBoot整合MyBatis][2_SpringBoot_MyBatis]

[【3】Springboot mybatis generate 自动生成实体类和Mapper][3_Springboot mybatis generate _Mapper]

[【4】SpringBoot----用MyBatis注解实现数据的增删查改][4_SpringBoot----_MyBatis]

[【5】Mybatis 中$与\#的区别][5_Mybatis]

[【6】springboot整合mybatis进行分页查询][Link 4]

[【7】SpringBoot整合Swagger2][7_SpringBoot_Swagger2]

[Link 1]: https://start.spring.io/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpYW5nY2hhMDA3_size_16_color_FFFFFF_t_70]: /images/20220216/74b91bad629e4d9d99049e0bda28538d.png
[Link 2]: https://www.jianshu.com/p/e09d2370b796
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpYW5nY2hhMDA3_size_16_color_FFFFFF_t_70 1]: /images/20220216/a98d9967bc584b85b6906ac074cccd33.png
[Link 3]: https://blog.csdn.net/qq_25652949/article/details/80889204
[Link 4]: https://blog.csdn.net/csonst1017/article/details/85064029
[SpringBoot]: https://blog.csdn.net/huangjun0210/article/details/84202333
[Link 5]: https://blog.csdn.net/qq_38182963/article/details/78891044
[-]: https://www.cnblogs.com/tian666/p/7852646.html
[SpringBoot 1]: https://blog.csdn.net/smartdt/article/details/78834005
[SpringBoot _7]: https://www.jianshu.com/p/ab6195310548
[spring_Transactional]: https://blog.csdn.net/qq_30336433/article/details/83338835
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpYW5nY2hhMDA3_size_16_color_FFFFFF_t_70 2]: /images/20220216/47385f9dc1364eb68847b55f8a7baf08.png
[2019042216151474.png]: /images/20220216/78cc7278b65643a8bd75192bd6b74434.png
[http_localhost_8080_swagger-ui.html]: http://localhost:8080/swagger-ui.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpYW5nY2hhMDA3_size_16_color_FFFFFF_t_70 3]: /images/20220216/ee59867656014ea9853124f593935f29.png
[Link 6]: https://www.cnblogs.com/binlin1987/p/6971808.html
[2_SpringBoot_MyBatis]: http://www.cnblogs.com/leeSmall/p/8719455.html
[3_Springboot mybatis generate _Mapper]: https://blog.csdn.net/xintingandzhouyang/article/details/80599987
[4_SpringBoot----_MyBatis]: https://blog.csdn.net/zz2713634772/article/details/79542518
[5_Mybatis]: https://www.cnblogs.com/hellokitty1/p/6007801.html
[7_SpringBoot_Swagger2]: https://www.cnblogs.com/jtlgb/p/8532433.html