SpringBoot+Mybatis integration - Final Version (integrated with Swagger)

catalogue

Create SpringBoot project

Create a new project

Create a new module

Prepare database

New database

New user table t_user

Insert test data

Integrate Mybatis

Add corresponding Jar package

code implementation

User

dao(UserMapper)

mapper.xml

UserService

UserService

UserController

application.properties

verification

Integrate Swagger

What is Swagger?

Integrate Swagger dependent packages

Create Swagger related Docket Bean

Add the annotation of Swagger in the controller layer to let spring automatically load and identify

Create SpringBoot project

This time we use IDEA as a development tool. A great advantage of IDEA is that it can build a project, and then there are multiple module s below. This feature is very convenient for us to do Java development, especially for micro service development.

Create a new project

 

We first adopt the default maven project, and then add what components we need later.

 

In this way, we have built a projec, which is mainly used for directory function, not business code. Therefore, in the future, we will add the corresponding module to it.

Create a new module

 

The interface of different versions of IDEA may be a little different, but the basic meaning is probably the same, so if you encounter friends with different interfaces, you can carefully look at them and compare them.

 

In some versions of IDEA, "Spring Web" may be "WEB". In fact, they are the same.

 

If you don't have a maven library on your computer, you may have to wait a while.

It can be seen from the above figure that the module has been successfully created. Let's test it to see whether it has been successfully built.

Let's run it and see the effect.

The default is port 8080. Let's visit it in the browser.

http://localhost:8080/

If the above interface appears, it proves that it has been successfully built.

Prepare database

Because we want to integrate Mybatis, which belongs to the persistence layer framework, we need to prepare the Mysql database environment in advance. I won't elaborate on the Mysql installation tutorial here. You can find the tutorial online or in my blog.

New database

New user table t_user

I created the above through database tools. You can also create it through commands.

 

CREATE TABLE `t_user` (
  `id` int NOT NULL AUTO_INCREMENT COMMENT 'id,Primary key',
  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT 'user name',
  `age` int DEFAULT NULL COMMENT 'Age',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

 

Insert test data

In order to facilitate debugging, we first insert some test data.

You can also implement it through command statements.

 

INSERT INTO `t_user` (`name`, `age`) VALUES ('zhangsan', '20')
INSERT INTO `t_user` (`name`, `age`) VALUES ('lisi', '25')

 

Integrate Mybatis

Add corresponding Jar package

Add Mybatis related packages first:

 

<!-- Mybatis -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.0</version>
</dependency>

 

Since the database we choose is mysql, we also need to add MySQL related packages.

 

<!-- Mysql -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

 

code implementation

SpringBoot is mainly used for web projects, so we will complete the coding from the web project development process this time.

Generally speaking, web projects are generally divided into three layers: controller, service and dao. So where should we start? To be honest, there are no mandatory requirements, but most developers may start from the controller layer and write to the dao side. Then go back and improve the controller. But in order to demonstrate this time, our business code will be relatively simple. I'll write it in reverse and write dao first. Before writing dao layer, I post the package structure of the project.

User

We use a classic entity class this time, which is similar to the T of the database_ The user table does not match.

 

package com.ispeasant.demo.entity;

/**
 * User Entity class
 */
public class User {
    private int id; // id
    private String name; // user name
    private int age; // Age

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

 

In projects, we often need to create entity classes. Generally, we need to write get/set methods. We should flexibly apply development work and improve coding efficiency.

dao(UserMapper)

 

package com.ispeasant.demo.dao;


import com.ispeasant.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;


/**
 * UserMapper
 */
@Mapper
public interface UserMapper {
    User getUserById(int id);
}

 

It should be noted here that the "@ Mapper" annotation must be used, and the corresponding mapper.xml file needs to be configured, otherwise spring cannot scan it.

mapper.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.ispeasant.demo.dao.UserMapper">


    <resultMap type="User" id="UserMap">

        <id column="id" property="id" jdbcType="INTEGER"/>
        <result column="name" property="name" jdbcType="VARCHAR"/>
        <result column="age" property="age" jdbcType="INTEGER"/>

    </resultMap>


    <select id="getUserById" parameterType="INTEGER" resultMap="UserMap">
        select *
        from t_user
        where 1=1
        and id = #{id,jdbcType=INTEGER}
    </select>


</mapper>

 

Split Description:

 

<mapper namespace="com.ispeasant.demo.dao.UserMapper">

 

This part is to directly copy the full path corresponding to your dao interface.

 

 

<resultMap type="User" id="UserMap">

    <id column="id" property="id" jdbcType="INTEGER"/>
    <result column="name" property="name" jdbcType="VARCHAR"/>
    <result column="age" property="age" jdbcType="INTEGER"/>

</resultMap>

 

This is done on demand, and there may be several different definitions. Some friends may find it difficult to understand this part. That's what I told my team. You can regard this part as an entity object in the configuration file to facilitate data interaction.

 

 

<select id="getUserById" parameterType="INTEGER" resultMap="UserMap">
    select *
    from t_user
    where 1=1
    and id = #{id,jdbcType=INTEGER}
</select>

 

The id of the select tag should correspond to the method of UserMapper, and then write the corresponding business sql logic in it.

 

UserService

 

package com.ispeasant.demo.service;

import com.ispeasant.demo.entity.User;

public interface UserService {
    User getUserById(int id);
}

 

In the Java EE code specification, we generally encapsulate the service layer into two layers, one is the interface layer and the other is the implementation layer, which can facilitate the decoupling of business code.

UserService

 

package com.ispeasant.demo.service.impl;

import com.ispeasant.demo.dao.UserMapper;
import com.ispeasant.demo.entity.User;
import com.ispeasant.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


@Service
public class UserSeviceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public User getUserById(int id) {
        User user = userMapper.getUserById(id);
        return user;
    }
}

 

We need to implement the UserService interface first and rewrite the methods inside. The UserMapper needs to be loaded automatically and annotated with "@ Autowired".

On the class, we need to adopt the "@ Service" annotation, which will be injected into the controller layer by spring.

 

UserController

 

package com.ispeasant.demo.controller;

import com.ispeasant.demo.entity.User;
import com.ispeasant.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/getUserById")
    public User getUserById(int id){
        User user = userService.getUserById(id);
        return user;
    }
}

 

The Controller layer is a little similar to the service layer. It also needs to automatically load UserService with "@ Autowired" annotation.

On the top of the class, you also need to add "@ RestController", which is the combination of two annotations of responsebobby + controller.

@GetMapping encapsulates API interface definitions@ The GetMapping annotation maps HTTP GET requests to specific handler methods. It is a combined annotation used as a shortcut to @ RequestMapping(method = RequestMethod.GET).

application.properties

 

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://10.18.0.57:3306/springbootmybatisDB
spring.datasource.username=root
spring.datasource.password=123456

mybatis.type-aliases-package=com.ispeasant.demo.entity
mybatis.mapperLocations=classpath:mappers/*.xml

 

Finally, you need to configure database related information. Since I use mysql8, the driver should use "com.mysql.cj.jdbc.Driver". If it is a database of other lower versions, you can use "com.mysql.jdbc.Driver".

Finally, the entity package path and mapper file path should be configured there (through configuration).

verification

Open the following link in the browser:

http://localhost:8080/getUserById?id=1

If the following data is returned, the integration is successful. Later, you can develop other businesses according to your actual needs.

{"id":1,"name":"zhangsan","age":20}

Integrate Swagger

The last part is the integration of Swagger. In the actual project development, the role of Java EE project is more and more inclined to interface, providing interfaces for multiple terminals, such as web terminal, mobile terminal, applet terminal and so on.

What is Swagger?

The official website describes this:

API Development for Everyone

Simplify API development for users, teams, and enterprises with the Swagger open source and professional toolset. Find out how Swagger can help you design and document your APIs at scale.

Swagger is used for API development, which is similar to the API documents we wrote before, which is convenient for the collaborative development of the development team.

effect:

  • Automatically generate interface documentation.

  • Interface test

Integrate Swagger dependent packages

In POM Add the following to the XML file.

 

<dependency>

   <groupId>io.springfox</groupId>

   <artifactId>springfox-swagger2</artifactId>

   <version>2.7.0</version>

</dependency>

<dependency>

   <groupId>io.springfox</groupId>

   <artifactId>springfox-swagger-ui</artifactId>

   <version>2.7.0</version>

</dependency>

 

Create Swagger related Docket Bean

 

package com.ispeasant.demo.config;

import io.swagger.annotations.ApiOperation;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SpringFoxSwaggerConfig {
    @Bean
    public Docket swaggerSpringMvcPlugin() {
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
                .build().apiInfo(apiInfo())
                ;
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("RESTful API")
                .description("Basic management")
                .termsOfServiceUrl("")
                .version("1.0")
                .build();
    }
}

 

Let's run the code first to see the effect. Directly run the "DemoApplication" class, and then enter the link of Swagger UI in the browser: http://localhost:8080/swagger-ui.html

 

The above figure shows that we have successfully integrated swagger. Let me explain the above code first, and then get some API interfaces to experience it.

We use the createRestApi() method to create a Docket Bean, and then use the apiInfo() method to create the basic information of the whole API, that is, the information we see above.

@Configuration and @ EnableSwagger2 annotations must be declared, otherwise spring cannot load and recognize them.

We can also use our browser to open the following link to view the swagger metadata that has been generated to describe the API.

http://localhost:8080/v2/api-docs

 

{"swagger":"2.0","info":{"description":"test","version":"1.0","title":"API Demo"},"host":"localhost:8080","basePath":"/"}

 

It's a little hard to see the content, so we'd better use the UI interface at the top.

Add the annotation of Swagger in the controller layer to let spring automatically load and identify

 

package com.ispeasant.demo.controller;

import com.ispeasant.demo.entity.User;
import com.ispeasant.demo.service.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Api(value = "User module", description = "User module interface")
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping(value = "/getUserById", method = RequestMethod.GET)
    @ApiOperation(value = "According to user ID Get user", notes = "query")
    @ApiImplicitParams({@ApiImplicitParam(name = "id",value = "Primary key id",required = true,paramType = "query",dataType = "int")})
    public User getUserById(int id) {
        User user = userService.getUserById(id);
        return user;
    }
}

 

We can also test the interface in Swagger's web UI.

As can be seen from the above figure, we have successfully assembled Swagger.

I have put this code on Baidu. If necessary, please follow my official account and reply to "2020102802" to get the download link.

Tags: Mybatis Spring Boot Microservices swagger

Posted by eranwein on Tue, 10 May 2022 02:38:43 +0300