一文教你如何整合SpringBoot+MyBatis+swagger2框架

最新推荐文章于 2023-03-21 10:00:16 发布

请叫我小美同学

最新推荐文章于 2023-03-21 10:00:16 发布

阅读量328

点赞数

分类专栏： Java 文章标签： java mysql intellij idea spring boot

本文链接：https://blog.csdn.net/weixin_42210825/article/details/104616336

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

今日一说：
成年人的世界哪有“容易”二字，
我们走过的路，吃过的苦，
都会在岁月的洗涤中，
变成保护我们的铠甲。
——小美同学

SpringBoot详细说明：

Spring Boot让我们的Spring应用变的更轻量化。
比如：你可以仅仅依靠一个Java类来运行一个Spring引用。
你也可以打包你的应用为jar并通过使用java -jar来运行你的Spring Web应用。

SpringBoot 是一个快速开发的框架,能够快速的整合第三方框架，简化XML配置，全部采用注解形式，内置Tomcat容器,
帮助开发者能够实现快速开发，
SpringBoot的Web组件默认集成的是SpringMVC框架。
SpringMVC是控制层。

SpringBoot的主要优点：

为所有Spring开发者更快的入门
开箱即用，提供各种默认配置来简化项目配置
内嵌式容器简化Web项目
没有冗余代码生成和XML配置的要求

搭建须知：

Java1.8及以上
Spring Framework 4.1.5及以上
本文采用Java 1.8.0_191、Spring Boot 2.0版本调试通过。

step 1：搭建空的项目
创建项目

填写项目详情填写GroupId和ArtifactId，next，
选择项目的地址，
next->new window open 在新的窗口打开
最后Finish，Maven项目搭建完成，目录如下：
项目首页
接下来我们构建项目基本骨架，：
（1）在java下新建com
（2）在com下新建product
（3）在product下新建controller、config、mapper、
pojo、service
（4）在service下新建impl
如下图：
项目骨架
step 2：配置文件的说明

（备注）：
SpringBoot使用一个全局的配置文件，
配置文件名是固定的，
1.application.properties
2.application.yml(或者是yaml)
配置文件的作用：修改SpringBoot自动配置的默认值。SpringBoot在底层都给我们自动配置好。
这里是个人喜好的application.yml 配置，不强行要求一致！

搭建全局配置文件骨架

接下来我们构建SQL配置文件基本骨架，：
（1）在resource下新建application.yml
（2）在resource下新建application-dev.yml
（3）在resource下新建application-test.yml

application.yml

spring:
  profiles:
    active: dev

application-dev.yml

apollo:
  bootstrap:
    enabled: true
    namespaces: application
    ## 缓存配置
  cacheDir: C:opt
  ## Apollo配置中心
  meta: http://你的内网地址:48000
## 应用ID
app:
  id: egc-iot-version-service
## 配置环境
env: DEV

application-test.yml

apollo:
  bootstrap:
    enabled: true
    namespaces: application
    ## 缓存配置
  cacheDir: C:opt
  ## Apollo配置中心
  meta: http://你的内网地址:48001
## 应用ID
app:
  id: egc-iot-version-service
## 配置环境
env: UAT

为什么这里需要这么多配置文件？
由于本公司有多个环境配置，如果经常修改文件容易遗忘，
根据不同环境进行了区分，dev 表示开发环境、
test 表示测试环境，pro表示线上环境，
当需要切换环境的时候，直接在application.yml 里面
指定文件名称，即可切换环境

为什么没有看见数据库连接的相关代码？
因为我公司是用的是Apollo 来进行管理配置文件的，
Apollo（阿波罗）是携程框架部门研发的开源配置管理中心，
能够集中化管理应用不同环境、不同集群的配置，
配置修改后能够实时推送到应用端，
并且具备规范的权限、流程治理等特性本地代码，
只需要引用一个appId，即可获取相关连接，
不管你配置文件再多，都不需要担心，
有阿波罗帮你解决，删改以后点击回滚，
还可以回到你之前更改的配置版本中，
是管理配置文件的好帮手。

Apollo 开发环境配置：

server.port = 9801
apollo.meta = http://192.168.1.243:48000/
app.id = egc-iot-version-service
spring.application.name = egc-iot-version-service
eureka.instance.prefer-ip-address = true
#开发环境内网地址
eureka.instance.ip-address = 192.168.1.74
eureka.client.service-url.defaultZone = http://192.168.1.74:8761/eureka/
eureka.instance.status-page-url = http://${eureka.instance.ip-address}:${server.port}/swagger-ui.html
#数据源1
spring.datasource.driver-class-name = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://192.168.1.74:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.username = username
spring.datasource.password = password
#mybatis 配置
logging.level.org.springframework = INFO
mybatis.typeAliasesPackage = com.product.version.pojo
mybatis.mapperLocations = classpath:mapper/**/*.xml
mybatis.configuration.log-impl = org.apache.ibatis.logging.stdout.StdOutImpl
#分页配置
pagehelper.helperDialect = mysql
pagehelper.reasonable = true
pagehelper.supportMethodsArguments = true

Apollo 测试环境配置：

server.port = 9801
apollo.meta = http://192.168.1.243:48001/
app.id = egc-iot-version-service
spring.application.name = egc-iot-version-service
eureka.instance.prefer-ip-address = true
#测试环境内网地址
eureka.instance.ip-address = 192.168.1.52
eureka.client.service-url.defaultZone = http://192.168.1.52:8761/eureka/
eureka.instance.status-page-url = http://${eureka.instance.ip-address}:${server.port}/swagger-ui.html
#数据源1
spring.datasource.driver-class-name = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://192.168.1.52:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.username = username
spring.datasource.password = password
#mybatis 配置
logging.level.org.springframework = INFO
mybatis.typeAliasesPackage = com.product.version.pojo
mybatis.mapperLocations = classpath:mapper/**/*.xml
mybatis.configuration.log-impl = org.apache.ibatis.logging.stdout.StdOutImpl
#分页配置
pagehelper.helperDialect = mysql
pagehelper.reasonable = true
pagehelper.supportMethodsArguments = true

搭建SQL配置文件骨架

接下来我们构建SQL配置文件基本骨架，：
（1）在resource下新建mapper
（2）在mapper下新建UserMapper.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.product.version.mapper.UserMapper">

    <resultMap id="BaseResultMap" type="com.product.version.pojo.User">
        <id column="id" property="id" jdbcType="INTEGER"/>
        <result column="name" property="name" jdbcType="VARCHAR"/>
        <result column="pwd" property="pwd" jdbcType="VARCHAR"/>
        <result column="mark" property="mark" jdbcType="INTEGER"/>
        <result column="dept" property="dept" jdbcType="VARCHAR"/>
    </resultMap>

    <sql id="Base_Column_List">
        id,`name`, pwd,mark,dept
    </sql>

    <!--查询用户列表-->
    <select id="findUserList" resultMap="BaseResultMap" >
        select  <include refid="Base_Column_List"/>  from user
    </select>

</mapper>

step 3：整合SpringBoot和SSM框架的依赖jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.product.version</groupId>
    <artifactId>egc-iot-version-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <skipTests>true</skipTests>
    </properties>
    <!-- 管理依赖 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.M7</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <!--mysql数据库连接 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
		 <!--整合Mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>
		<!--lombok插件，简化实体类冗余代码-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- SpringBoot整合Web组件 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--读取配置文件 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>
        <!-- SpringBoot整合eureka客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!--日志打印 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.1</version>
        </dependency>
        <!--测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--apollo相关jar包 -->
        <dependency>
            <groupId>com.ctrip.framework.apollo</groupId>
            <artifactId>apollo-client</artifactId>
            <version>1.1.0</version>
        </dependency>
        <dependency>
            <groupId>com.ctrip.framework.apollo</groupId>
            <artifactId>apollo-core</artifactId>
            <version>1.1.0</version>
        </dependency>
		 <!--gson,把实体类对象转换为gson，从而对参数进行校验-->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.2</version>
        </dependency>
        <!-- springboot 整合 pagehelper 分页插件 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8.1</version>
        </dependency>
		<!-- 阿里巴巴的开源库 - Fastjson。
		Fastjson是一个Java库，可用于将Java对象转换为其JSON表示。
		它还可用于将JSON字符串转换为等效的Java对象 -->
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency> 

        <!--配置文件读取-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
		<!--swagger配置需要的jar-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.5.0</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.5.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.8.RELEASE</version>
        </dependency>
       
    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
    <!-- 注意： 这里必须要添加， 否者各种依赖有问题 -->
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/libs-milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
</project>

step 4：各层代码详细分析

目录解释如下：
controller层：

http（GET和POST等）请求的入口，调用Service，
想客户端返回数据。

package com.product.version.controller;

import com.github.pagehelper.PageInfo;
import com.product.version.pojo.User;
import com.product.version.service.UserService;
import io.swagger.annotations.Api;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;


/**
 * 用户信息控制器类
 * @author ZB
 */
@Api(value = "用户列表操作")
@RestController
public class UserController {

    @Autowired
    UserService userService;

    @GetMapping("/findUserList")
    public PageInfo<User> findUserList
            (@RequestParam Integer page,
             @RequestParam Integer size) {
        return userService.findUserList(page,size);

    }
}

mapper层：

主要放置接口，
有mybatis自动化工具生成的文件之一，
定义了数据表映射成的对象，具有的操作
mapper：具体是sql语句，
以xml格式存在，即mybatis的语法文件。

package com.product.version.mapper;

import com.product.version.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
@Mapper
public interface UserMapper {
    /**
     * 查询用户列表
     * @return
     */
    List<User> findUserList();
}

注解说明:

@Mapper 的作用是可以给mapper接口自动生成一个实现类，
让spring对mapper接口的bean进行管理，
并且可以省略去写复杂的xml文件
@Repository 的作用是告诉Spring，
让Spring创建一个名字叫“userMapper”的userMapper实例。
当Service需要使用 Spring 创建的名字
叫“userMapper”的 userMapper实例时，
就可以使用 @Autowired (name = "userMapper")
注解告诉Spring，Spring 把创建好的userDao注入给Service即可。

pojo层：实体类

package com.product.version.pojo;

import lombok.*;

/**
 * 用户信息
 * 指定方法的封装为 public
 * @Author cmt
 */
@AllArgsConstructor(access = AccessLevel.PUBLIC)
@NoArgsConstructor
@EqualsAndHashCode
@Data
public class User {
    /**
     * 用户id
     */
    private  Integer id;
    /**
     * 用户名称
     */
    private  String name;
    /**
     * 用户密码
     */
    private  String pwd;
    /**
     * 标记用户
     */
    private  Integer mark;
    /**
     *用户部门
     */
    private  String dept;
}

注解说明：

　实体类中注解大多都使用了lombok，这有什么作用？
　lombok 提供了简单的注解的形式来帮助我们简化消除一些必须有但显得很臃肿的 java 代码。特别是相对于 POJO。
  如果还未了解的同学，可参考[lombok的深入了解](https://www.cnblogs.com/cb0327/p/10040671.html)

service层：
controller调用的服务，
service调用dao里面定义的数据库行为方法，
来执行对应mapping里的mybatis，
从而完成与数据库完整的交互。

package com.product.version.service;

import com.github.pagehelper.PageInfo;
import com.product.version.pojo.User;

/**
 * 用户业务接口
 * @author ZB
 */
public interface UserService {
    /**
     * 查询用户列表
     * @param page 分页数量
     * @param size 分页大小
     * @return
     */
    PageInfo<User> findUserList(Integer page, Integer size);
}

引用说明：
这里使用到了Mybatis的分页插件，
若需要使用该插件的同学，
需要在pom.xml 里面配置依赖jar包。

  <!-- springboot 整合 pagehelper 分页插件 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.5</version>
        </dependency>

service-impl层：
接口，定义了服务应该具有的函数方法
（此处可以理解是提现软件的设计思想，
你要是乐意，直接写service也可以）

package com.product.version.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.product.version.mapper.UserMapper;
import com.product.version.pojo.User;
import com.product.version.service.UserService;
import com.product.version.utils.PageUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 用户操作业务实现类
 * @author ZB
 */
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    UserMapper userMapper;

    @Override
    public PageInfo<User> findUserList
    (Integer page, Integer size) {
        PageInfo<User> userPageInfo = null;
        //定义分页对象
        PageUtil pageUtil = new PageUtil();
        pageUtil.setNumber(page);
        pageUtil.setSize(size);

        //严谨操作，避免输入不合法，在这里进行校验
        if (pageUtil.getNumber() <= 0 ||
            pageUtil.getNumber() == null) {
            pageUtil.setNumber(1);
        }
        //设置默认每页显示15条
        if (pageUtil.getSize() <= 0 ||
            pageUtil.getSize() == null) {
            pageUtil.setSize(15);
        }
        //1、设置分页信息，包括当前页数和每页显示的总计数
        PageHelper.
                startPage(pageUtil.getNumber(), pageUtil.getSize());
        //2.执行查询
        List<User> userList = userMapper.findUserList();
        //封装需要返回的分页列表
        userPageInfo = new PageInfo<User>(userList);

        return userPageInfo;
    }
}

config层：
定义需要的配置类，这里使用了swagger接口文档，
随着互联网技术的发展，现在的网站架构基本都由原来的后端渲染，变成了：前端渲染、先后端分离的形态，
而且前端技术和后端技术在各自的道路上越走越远。
前端和后端的唯一联系，
变成了API接口；API文档变成了前后端开发人员联系的纽带，变得越来越重要，
swagger就是一款让你更好的书写API文档的框架。

package com.product.version.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.service.Parameter;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

import java.util.ArrayList;
import java.util.List;


/**
 * Swagger配置
 * @author ZB
 */
@Configuration
@EnableSwagger2
public class SwaggerConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("swagger-ui.html")
                .addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**")
                .addResourceLocations
                 ("classpath:/META-INF/resources/webjars/");
    }

    @Bean
    public Docket productApi() {
        List<Parameter> pars = new ArrayList<Parameter>();
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors
                .basePackage("com.product.version.controller"))
                .paths(PathSelectors.any())
                .build()
                .globalOperationParameters(pars)
                .apiInfo(metaData());

    }


    private ApiInfo metaData() {
        ApiInfo apiInfo = new ApiInfo(
                "Spring Boot integration MyBatis",
                "ProductVersion REST API",
                "1.0",
                "Terms of service",
                new Contact("小美同学",
                        "",
                        ""),
                "Apache License Version 2.0",
                "https://www.apache.org/licenses/LICENSE-2.0");
        return apiInfo;
    }
}

utils层：

package com.product.version.utils;

import io.swagger.annotations.ApiModelProperty;
import lombok.*;

/**
 * 指定方法的封装为 public
 * 分页工具类
 * @author ZB
 */
@AllArgsConstructor(access = AccessLevel.PUBLIC)
@NoArgsConstructor
@EqualsAndHashCode
@Data
public class PageUtil {

    @ApiModelProperty(value = "当前第几页", name = "number")
    private Integer number;
    @ApiModelProperty(value = "返回几笔数据", name = "size")
    private Integer size;
}

最后结果：
输入本地地址，访问swagger
http://你的本地ip:9801/swagger-ui.html#/
运行结果
搭建感想：
SpringBoot+SSM+Swagger 就这样搭建好了，
如果有遇到问题，欢迎在底下留言。
让我们一起共同学习，共同进步！

请叫我小美同学

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
一文教你如何整合SpringBoot+MyBatis+swagger2框架

今日一说：成年人的世界哪有“容易”二字，我们走过的路，吃过的苦，都会在岁月的洗涤中，变成保护我们的铠甲。——小美同学搭建须知：本文章使用IDEA为开发工具，如果是使用Eclipse的道友可以参考其他文章。...
复制链接

扫一扫