[RestfulTool] 使用RestfulTool插件模拟前端向后端发送请求体,通过SpringMVC结合MyBaits响应返回体

沫洺

已于 2022-11-19 21:31:10 修改

阅读量912

点赞数 1

于 2022-09-22 19:07:32 首次发布

本文链接：https://blog.csdn.net/HeyVIrBbox/article/details/126996514

版权

SpringMVC 同时被 2 个专栏收录

10 篇文章 1 订阅

订阅专栏

MyBatis

8 篇文章 2 订阅

订阅专栏

✨✨个人主页:沫洺的主页

📚📚系列专栏: 📖 JavaWeb专栏📖 JavaSE专栏 📖 Java基础专栏📖vue3专栏

📖MyBatis专栏📖Spring专栏📖SpringMVC专栏📖SpringBoot专栏

📖Docker专栏📖Reids专栏📖MQ专栏📖SpringCloud专栏

💖💖如果文章对你有所帮助请留下三连✨✨

🎨搭建案例环境

📌创建数据库db5,表user_email

📌创建maven Web项目,pom.xml添加坐标依赖,配置tomcat

📍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>

  <groupId>com.beiyou</groupId>
  <artifactId>cms-api</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>cms-api Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <!--引入webmvc-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.2</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>cn.hutool</groupId>
      <artifactId>hutool-all</artifactId>
      <version>5.8.5</version>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.16.10</version>
    </dependency>


    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.12.0</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>5.3.2</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.19</version>
      <scope>runtime</scope>
    </dependency>
    <!--mybatis-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.9</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.6</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.3.2</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>


    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>


  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <!--端口号-->
          <port>8080</port>
          <!--虚拟目录-->
          <path>/</path>
          <!--解决tomcat7及以前get乱码-->
          <uriEncoding>utf-8</uriEncoding>
        </configuration>
      </plugin>
    </plugins>
    <finalName>cms-api</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

📌搭建SpringMVC运行环境

📍web.xml配置前端控制器DispatcherServlet

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
  <!--前端控制器-->
  <servlet>
    <servlet-name>springDispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springDispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
    <!-- / 代表： 所有请求都交给springDispatcherServlet处理-->
  </servlet-mapping>


</web-app>

📍resources下创建spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation=" http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
      ">
    <context:component-scan base-package="com.moming"/>

    <!--<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">-->
    <!--    <property name="dataSource" ref="dataSource" />-->
    <!--    <property name="mapperLocations" value="classpath:mapper/**.xml" />-->
    <!--    <property name="typeAliasesPackage" value="com.moming.entity"/>-->
    <!--</bean>-->

    <!--<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">-->
    <!--    <property name="basePackage" value="com.moming.dao" />-->
    <!--    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />-->
    <!--</bean>-->
</beans>

📍java下新建com/moming/config/WebConfig

package com.moming.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.nio.charset.StandardCharsets;
import java.util.List;

/**
 * mvc配置文件
 */
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        for (HttpMessageConverter<?> converter:converters){
            if(converter instanceof StringHttpMessageConverter){
                ((StringHttpMessageConverter)converter).setDefaultCharset(StandardCharsets.UTF_8);
            }
            if(converter instanceof MappingJackson2HttpMessageConverter){
                ((MappingJackson2HttpMessageConverter)converter).setDefaultCharset(StandardCharsets.UTF_8);
            }

        }
    }
}

📌配置MyBatis

📍在resources下创建druid.properties

username=root
password=123456
url=jdbc:mysql:///db5?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&allowMultiQueries=true
driverClassName=com.mysql.cj.jdbc.Driver
initialSize=5
maxActive=10
maxWait=3000

📍创建config/DbConfig

package com.moming.config;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;

import javax.sql.DataSource;
import java.io.InputStream;
import java.util.Properties;

/**
 * 数据库配置文件
 */
@Configuration
@MapperScan("com.moming.dao")
public class DbConfig {

    /**
     * 手动注册 Druid dataSource 数据源
     * @return DataSource
     */
    @Bean
    public DataSource dataSource() throws Exception {

        InputStream resourceAsStream = DbConfig.class.getClassLoader().getResourceAsStream("druid.properties");
        Properties prop = new Properties();
        prop.load(resourceAsStream);
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
        return dataSource;
    }



    /**
     * 手动注册 JdbcTemplate
     * @return JdbcTemplate
     */
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource){

        JdbcTemplate jdbcTemplate  = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;

    }

    /**
     * 事务管理器
     * @param dataSource
     * @return
     */
    @Bean
    public DataSourceTransactionManager dataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager  transactionManager  = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }

    /**
     * 事务模板
     * @param dataSourceTransactionManager
     * @return
     */
    @Bean
    public TransactionTemplate transactionTemplate(DataSourceTransactionManager dataSourceTransactionManager){

        TransactionTemplate transactionTemplate  = new TransactionTemplate(dataSourceTransactionManager);
        //transactionTemplate.setTransactionManager(dataSourceTransactionManager);
        return transactionTemplate;

    }
    /**
     * SqlSessionFactory
     * @param
     * @return
     */

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource());
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        Resource[] resources = resolver.getResources("classpath:mapper/**.xml");
        sqlSessionFactoryBean.setMapperLocations(resources);
        sqlSessionFactoryBean.setTypeAliasesPackage("com.moming.entity");
        return  sqlSessionFactoryBean.getObject();
    }
}

📍在resources下创建mapper/user.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.moming.dao.UserDao">

</mapper>

📍创建com/moming/entity/UserEntity实体类

package com.moming.entity;

import lombok.Data;

/**
 * 对应数据表的实体类
 */
@Data
public class UserEntity {
    private Integer id;
    private String email;
    private String password;
}

📍创建com/moming/entity/UserEntityQuery查询参数类

package com.moming.entity;

import lombok.Data;

/**
 * 查询参数类
 */
@Data
public class UserEntityQuery {

    private Integer id;
    private String email;
    private Integer[] ids;
}

📌创建拦截器对响应数据进行协议包装

📍com/moming/advice/MyResponseAdvice

package com.moming.advice;

import cn.hutool.json.JSONUtil;
import com.moming.dto.ResponseDto;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

/**
 * 拦截器
 */
@ControllerAdvice
@ResponseBody
public class MyResponseAdvice implements ResponseBodyAdvice<Object> {

    @ExceptionHandler(Exception.class)
    public Object processException(Exception ex){
        ResponseDto responseDto  = new ResponseDto();
        responseDto.setCode(1);
        responseDto.setMessage(ex.getMessage());
        return  responseDto;
    }

    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {

        if(body instanceof  ResponseDto){
            return  body;
        }
        ResponseDto  responseDto  = new ResponseDto();
        responseDto.setCode(0);
        responseDto.setMessage("请求成功");
        responseDto.setData(body);

        if (selectedConverterType == StringHttpMessageConverter.class) {
            return JSONUtil.toJsonStr(responseDto);
        } else {
            return responseDto;
        }


    }
}

📍创建com/moming/dto/ResponseDto数据传输类

package com.moming.dto;

import lombok.Data;

/**
 * 数据传输对象
 */
@Data
public class ResponseDto {
    private int code;
    private  String message;
    private Object  data;
}

📌SpringMVC

📍数据访问层

创建com/moming/dao/UserDao

package com.moming.dao;

import com.moming.entity.UserEntity;
import com.moming.entity.UserEntityQuery;
import org.apache.ibatis.annotations.*;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * 数据访问层
 */
//@Repository
@Mapper
public interface UserDao {
    /**
     * 查
     * @param query
     * @return
     */
    @Select("select * from user_email where id=#{id}")
    List<UserEntity> select(UserEntityQuery query);

    /**
     * 增
     * @param userEntity
     * @return
     */
    @Insert("insert into user_email (email,password) values (#{email},#{password})")
    @SelectKey(statement = "select LAST_INSERT_ID() as id", keyProperty = "id", keyColumn = "id", before = false, resultType = Integer.class)
    int insert(UserEntity userEntity);

    /**
     * 改
     * @param userEntity
     * @return
     */
    @Update("update user_email set email=#{email},password=#{password} where id=#{id} ")
    int update(UserEntity userEntity);

    /**
     * 删
     * @param id
     * @return
     */
    @Delete("delete from user_email where id=#{id}")
    int delete(int id);
}

📍业务层

创建com/moming/service/UserService

package com.moming.service;

import com.moming.dao.UserDao;
import com.moming.entity.UserEntity;
import com.moming.entity.UserEntityQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 业务层
 */
@Service
public class UserService {

    @Autowired
    private UserDao userDao;

    /**
     * 查
     * @param id
     * @return
     */
    public List<UserEntity> select(int id){
        UserEntityQuery query = new UserEntityQuery();
        query.setId(id);
        return userDao.select(query);
    }

    /**
     * 增
     * @param userEntity
     * @return
     */
    public int insert(UserEntity userEntity){
        return userDao.insert(userEntity);
    }

    /**
     * 改
     * @param userEntity
     * @return
     */
    public int update(UserEntity userEntity){
        return userDao.update(userEntity);
    }

    /**
     * 删
     * @param id
     * @return
     */
    public int delete(int id){
        return userDao.delete(id);
    }
}

📍接口层

创建com/moming/controller/UserController

package com.moming.controller;

import com.moming.entity.UserEntity;
import com.moming.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 接口层
 */
@RestController
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 查
     * @param id
     * @return
     */
    @GetMapping("/select")
    public List<UserEntity> select(@RequestParam("id") int id){
        return userService.select(id);
    }

    /**
     * 增
     * @param userEntity
     * @return
     */
    @PostMapping("/insert")
    public int insert(@RequestBody UserEntity userEntity){
        int rowNum = userService.insert(userEntity);
        return rowNum;
    }

    /**
     * 改
     * @param userEntity
     * @return
     */
    @PutMapping("/update")
    public int update(@RequestBody UserEntity userEntity){
        return userService.update(userEntity);
    }

    /**
     * 删
     * @param id
     * @return
     */
    @GetMapping("/delete")
    public int delete(@RequestParam("id") int id){
        return userService.delete(id);
    }

}