基于SpringBoot 的rest接口开发流程

作者: 清_晨_ | 来源:发表于2018-12-06 22:58 被阅读53次

基于SpringBoot 的rest接口开发流程
SpringBoot笔记2：Rest页面及数据库
接口管理规范
SpringBoot系列教程web篇之Freemaker环境搭建
spring boot 2 security 403 无权
SpringBoot使用快速构建restful应用，你学废了吗
基于liferay7开发Rest接口
Springboot2.X集成Swagger2方案
大数据研发相关-面试拾遗（备战积累的知识点）
SpringBoot2.x【六】整合 Rest API 接口规范

项目中用到接口开发，所以记录一下，方便以后使用。
本教程主要分为三个部分：
1.利用geneator自动生成相关实体及mapper.xml，相关教程可参考之前写的Spring Boot 集成Mybatis Generator和通用Mapper自动生成代码;
2.书写rest接口,包括相关校验;
3.配置druid数据源；

1.完整的pom配置代码如下：

<?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.geneator.test</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.10.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- 打war包 依赖tomcat api -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>

        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>

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

        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.1.0</version>
        </dependency>
       <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.8</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.45</version>
        </dependency>
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0.1.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!--mybatis-generator包-->
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.5</version>
        </dependency>
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>persistence-api</artifactId>
            <version>1.0</version>
        </dependency>
        <!-- 通用 Mapper -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.0.4</version>
        </dependency>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper</artifactId>
            <version>4.0.4</version>
        </dependency>

    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.js</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*</include>
                </includes>
            </resource>

        </resources>
        <plugins>
            <!--mybatis 自动生成dao,model,mapper,generaotr插件-->
            <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>
                <version>1.3.2</version>

                <dependencies>
                    <dependency>
                        <groupId>tk.mybatis</groupId>
                        <artifactId>mapper</artifactId>
                        <version>4.0.4</version>
                    </dependency>
                    <dependency>
                        <groupId>com.oracle</groupId>
                        <artifactId>ojdbc6</artifactId>
                        <version>11.2.0.1.0</version>
                    </dependency>
                </dependencies>
                <configuration>
                    <configurationFile>
                        ${basedir}/src/main/resources/generatorConfig.xml
                    </configurationFile>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2.利用geneator自动生成mapper接口的配置如下，这里使用通用mapper来生成代码。

1.geneatorConfig.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>
    <!--引入配置文件-->
    <properties resource="db-config.properties"></properties>
    <!-- 引入数据库驱动 -->
    <classPathEntry location="${jdbc.driverClassLocation}"/>
    <context id="baseset" targetRuntime="MyBatis3" defaultModelType="flat">
        <property name="javaFileEncoding" value="UTF-8"/>
        <property name="useMapperCommentGenerator" value="true"/>
        <!-- 通用mapper插件 -->
        <plugin type="tk.mybatis.mapper.generator.MapperPlugin">
            <!-- 此处的 MyMapper注意一定不能被扫描到-->
            <property name="mappers" value="${generator.mappers}"/>
            <!-- caseSensitive 是否区分大小写，默认值 false。如果数据库区分大小写，这里就需要配置为 true，这样当表名为 USER 时，
             会生成 @Table(name = "USER") 注解，否则使用小写 user 时会找不到表。-->
            <property name="caseSensitive" value="true"/>
            <!--forceAnnotation 是否强制生成注解，默认 false，如果设置为 true，不管数据库名和字段名是否一致，都会生成注解（包含 @Table 和 @Column）。-->
            <property name="forceAnnotation" value="true"/>
        </plugin>
        <commentGenerator>
            <property name="suppressDate" value="true"/><!-- 是否生成注释代时间戳-->
            <property name="suppressAllComments" value="true"/><!-- 是否取消注释 -->
        </commentGenerator>
        <jdbcConnection
                driverClass="${jdbc.driverClass}"
                connectionURL="${jdbc.connectionURL}"
                userId="${jdbc.username}"
                password="${jdbc.password}">
        </jdbcConnection>

        <javaModelGenerator targetPackage="${generator.javaModel-targetPackage}" targetProject="${generator.targetProject}"/>
        <sqlMapGenerator targetPackage="${generator.sqlMap-targetPackage}" targetProject="${generator.targetProject}"/>
        <javaClientGenerator targetPackage="${generator.javaClient-targetPackage}" targetProject="${generator.targetProject}"
                             type="XMLMAPPER"/>

        <!--数据库中对应的表名，多个表可以写多个tableName-->

        <table tableName="t_person_base_info"
               enableInsert="false"  enableUpdateByPrimaryKey="false"
               enableDeleteByExample="false" enableSelectByExample="false"
               selectByExampleQueryId="false">
            <generatedKey column="c_id" sqlStatement="select SEQ_{1}.nextval from dual" identity="false" type="pre"/>
        </table>

    </context>
</generatorConfiguration>

2.db-config.properties

#jdbc 连接对象
#oracle jar文件位置
jdbc.driverClassLocation=D:/tools/ojdbc6-11.2.0.1.0.jar
jdbc.driverClass=oracle.jdbc.OracleDriver
jdbc.connectionURL=jdbc:oracle:thin:@localhost:1521:orcl
jdbc.username=system
jdbc.password=123456

# Generator
generator.targetProject=src/main/java
generator.mappers=tk.mybatis.mapper.common.BaseMapper
#generator.mappers=com.geneator.test.demo.mapper.IBaseMapper
generator.javaModel-targetPackage=com.geneator.test.demo.bean
generator.sqlMap-targetPackage=com.geneator.test.demo.xml
generator.javaClient-targetPackage=com.geneator.test.demo.mapper

3.生成的实体

package com.geneator.test.demo.bean;

import java.util.Date;
import javax.persistence.*;

@Table(name = "T_PERSON_BASE_INFO")
public class TPersonBaseInfo {
    @Id
    @Column(name = "C_ID")
    @GeneratedValue(strategy = GenerationType.IDENTITY, generator = "select SEQ_T_PERSON_BASE_INFO.nextval from dual")
    private String cId;

    @Column(name = "HEALTH_RECORD_CODE")
    private String healthRecordCode;

    @Column(name = "ORG_CODE")
    private String orgCode;

    @Column(name = "FAMILY_CODE")
    private String familyCode;

    @Column(name = "NAME")
    private String name;

    @Column(name = "SEX")
    private String sex;

    @Column(name = "BIRTHDAY")
    private Date birthday;

    @Column(name = "ID_NO")
    private String idNo;

    @Column(name = "INSURANCE_NO")
    private String insuranceNo;

    @Column(name = "SOCIAL_RELATIONS")
    private String socialRelations;

    @Column(name = "TOWNS")
    private String towns;

    @Column(name = "NC_CODE")
    private String ncCode;

 //省略中间代码

    /**
     * @param sourceflag
     */
    public void setSourceflag(String sourceflag) {
        this.sourceflag = sourceflag;
    }
}

4.生成的mapper接口

package com.geneator.test.demo.mapper;

import com.geneator.test.demo.bean.TPersonBaseInfo;
import com.geneator.test.demo.bean.TPersonBaseInfoExample;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import tk.mybatis.mapper.common.BaseMapper;
import tk.mybatis.mapper.common.Mapper;

import java.util.List;
import java.util.Map;

@org.apache.ibatis.annotations.Mapper
@Repository
public interface TPersonBaseInfoMapper extends Mapper<TPersonBaseInfo> {
    List<Map<String, String>> query(String var1);

    Integer getCountByCid(String var1);
 
}

5.mapper.xml


    <!-- 查询部分信息，注意：默认情况下，当resultType=“java.util.Map”时，返回的key值都是大写的。-->
    <!-- 现在想key改成自己想要的，只需为查询出来的字段增加个别名即可。as 后的双引号很关键，否则不起作用。-->
    <select id="query" parameterType="string" resultType="java.util.Map">
    select a.c_id as "cId", b.orgnamepath as "orgnamepath", a.emigration as "emigration" from t_person_base_info a, taorg b
    where a.org_code = b.costomno and a.id_no = #{idNo} and b.destory is null and a.cancel_flag = '0'
  </select>
    <!-- 通过主键查询数据库里面是否有数据，并返回统计结果。-->
    <select id="getCountByCid" parameterType="string" resultType="int">
    select count(*) from t_person_base_info where c_id = #{cId}
  </select>

</mapper>

3.书写业务层，控制层。

1.service

package com.geneator.test.demo.service;

public interface TestService {
    String invoke (String req);
}

2.实现类

package com.geneator.test.demo.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.geneator.test.demo.bean.Rest;
import com.geneator.test.demo.service.TestService;
import com.geneator.test.demo.trade.TradeStrategy;
import com.geneator.test.demo.util.ErrorUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

@Service("testService")
public class TestServiceImpl implements TestService,ApplicationContextAware {

    private static final Logger log = LoggerFactory.getLogger("testService");
    private static ApplicationContext context;
    public TestServiceImpl(){

    }


    @Override
    public String invoke(String req) {
        try {
            Rest checkRest = this.checkJson(req);
           if("0".equals(checkRest.getErrorCode())){
               return JSON.toJSONString(checkRest, new SerializerFeature[]{SerializerFeature.WriteMapNullValue});
           }else{
               JSONObject json = JSONObject.parseObject(req);
               JSONObject head = json.getJSONObject("head");
               String code = head.getString("code");
               TradeStrategy strategy = getStrategy(code);
               if (strategy == null) {
                   return JSONObject.toJSONString(ErrorUtil.getErrorInfo("004"), new SerializerFeature[]{SerializerFeature.WriteMapNullValue});
               } else {
                   Rest result = strategy.call(code, json);
                   return JSON.toJSONString(result, new SerializerFeature[]{SerializerFeature.WriteMapNullValue});
               }
           }
        } catch (Exception var8) {
            var8.printStackTrace();
            return JSONObject.toJSONString(ErrorUtil.getErrorInfo("9999"), new SerializerFeature[]{SerializerFeature.WriteMapNullValue});
        }

    }
    public Rest checkJson(String req){
        JSONObject json = null;
      try {
          json =  JSONObject.parseObject(req);
        }catch(Exception var9){
      log.error("请求的参数格式不为一个json！");
      return ErrorUtil.getErrorInfo("001");
       }
        JSONObject head = null;
        System.out.println(json.toJSONString());
        String version;
        try {
            version = json.getString("head").trim();
            head = JSONObject.parseObject(version);
            if (head == null) {
                return ErrorUtil.getErrorInfo("010");
            }
        }catch (Exception var8) {
            log.error("请求的参数head格式不为一个json！");
            return ErrorUtil.getErrorInfo("010");
        }
        version = head.getString("version");

        if (!"1.0.0".equals(version)){
            return ErrorUtil.getErrorInfo("011");
        }else {
            String code = null;
            try {
                code = head.getString("code");
                if(StringUtils.isEmpty(code)){
                    return ErrorUtil.getErrorInfo("003");
                }
            }catch (Exception var11) {
                return ErrorUtil.getErrorInfo("003");
            }
        }
        JSONObject body = null;
        try {
            String bodyText = json.getString("body").trim();
            body = JSONObject.parseObject(bodyText);
            if (body == null) {
                return ErrorUtil.getErrorInfo("002");
            }
        }catch (Exception var10) {
            log.error("请求的参数格式不为一个json！" + json.getString("body"));
            return ErrorUtil.getErrorInfo("002");
        }
        return ErrorUtil.getCheckSuccess();
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        context = applicationContext;
    }
    public static TradeStrategy getStrategy(String code) {
        TradeStrategy strategy = null;

        try {
            strategy = (TradeStrategy)context.getBean("tradeStrategy" + code);
        } catch (Exception var3) {
            log.error("找不到" + code + "对应的策略类。。");
        }

        return strategy;
    }
}

3.交易类

package com.geneator.test.demo.trade;

import com.alibaba.fastjson.JSONObject;
import com.geneator.test.demo.bean.Rest;

public interface TradeStrategy {
    Rest call(String var1, JSONObject var2);
    Rest checkJSON(JSONObject var1, String var2);
}

4.交易实现类

package com.geneator.test.demo.trade.impl;

import com.alibaba.fastjson.JSONObject;
import com.geneator.test.demo.bean.Rest;
import com.geneator.test.demo.mapper.TPersonBaseInfoMapper;
import com.geneator.test.demo.trade.TradeStrategy;
import com.geneator.test.demo.util.ErrorUtil;
import com.geneator.test.demo.util.IDCardUtil;
import com.geneator.test.demo.validate.ValidateBody;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

@Service("tradeStrategy0200")
public class TradeStrategy0200 implements TradeStrategy {
    @Autowired
    TPersonBaseInfoMapper tPersonBaseInfoMapper;
    public TradeStrategy0200() {
    }

    @Override
    public Rest call(String code, JSONObject json) {
        try {
            return this.exec(code, json);
        } catch (Exception var6) {
            String errMsg = var6.getMessage();
            if (errMsg == null) {
                errMsg = "JSON 数据转换为 JavaBean 出现异常，请检查数据格式是否正确。如有些本应该是 int 类型的，但却传入了 string 类型。";
            }

            Rest rest = new Rest();
            rest.setErrorCode("0");
            rest.setMessage("程序异常错误！错误信息为：" + errMsg);
            return rest;
        }

    }

    @Override
    public Rest checkJSON(JSONObject json, String code) {
        System.out.println(json.toJSONString());
        Rest rest = ValidateBody.validate(json, code);
        return rest;
    }

    private Rest exec(String code, JSONObject json)throws Exception {
        JSONObject body = json.getJSONObject("body");
        Rest rest =  this.checkJSON(body, code);
        if("0".equals(rest.getErrorCode())){
            return  rest;
        } else {
                String idNo = body.getString("idNo");
                if (idNo != null && !IDCardUtil.isIDCard(idNo)) {
                rest = ErrorUtil.getErrorInfo("1002-2");
                return rest;
                 } else {
                        List<Map<String, String>> list = this.tPersonBaseInfoMapper.query(idNo);
                        rest.setBody(list);
                        return rest;
            }
        }
    }
}

接口中相关校验代码，由于代码比较长，在此省略。

5.书写controller类

package com.geneator.test.demo.controller;

import com.geneator.test.demo.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping({"/api"})
public class TestController {
    @Autowired
    TestService testService;
    public  TestController(){

    }
    @RequestMapping({"/invoke"})
    public String invoke(@RequestBody String req) {
        return this.testService.invoke(req);
    }
}

4.配置druid数据源

1.DruidConfig

package com.geneator.test.demo.config;

import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ServletComponentScan
public class DruidConfig {
    public DruidConfig() {
    }
    @Bean
    public ServletRegistrationBean druidServlet() {
       // ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(), new String[]{"/druid/*"});
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean();

        servletRegistrationBean.setServlet(new StatViewServlet());
        servletRegistrationBean.addUrlMappings(new String[]{"/druid/*"});
        servletRegistrationBean.addInitParameter("allow","127.0.0.1");
        servletRegistrationBean.addInitParameter("loginUsername", "admin");
        servletRegistrationBean.addInitParameter("loginPassword", "123456");
       //允许HTML页面上的“Reset All”功能
        servletRegistrationBean.addInitParameter("resetEnable", "false");
        return servletRegistrationBean;
    }

    @Bean
    public FilterRegistrationBean filterRegistrationBean() {

       // FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter(), new ServletRegistrationBean[0]);
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new WebStatFilter());
        filterRegistrationBean.addUrlPatterns(new String[]{"/*"});
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        filterRegistrationBean.addInitParameter("profileEnable", "true");
        return filterRegistrationBean;
    }
}

2.DruidSource

package com.geneator.test.demo.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;
import java.sql.SQLException;

@Configuration
public class DruidSource {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Value("${spring.datasource.url}")
    private String dbUrl;
    @Value("${spring.datasource.username}")
    private String username;
    @Value("${spring.datasource.password}")
    private String password;
    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;
    @Value("${spring.datasource.initialSize}")
    private int initialSize;
    @Value("${spring.datasource.minIdle}")
    private int minIdle;
    @Value("${spring.datasource.maxActive}")
    private int maxActive;
    @Value("${spring.datasource.maxWait}")
    private int maxWait;
    @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;
    @Value("${spring.datasource.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;
    @Value("${spring.datasource.validationQuery}")
    private String validationQuery;
    @Value("${spring.datasource.testWhileIdle}")
    private boolean testWhileIdle;
    @Value("${spring.datasource.testOnBorrow}")
    private boolean testOnBorrow;
    @Value("${spring.datasource.testOnReturn}")
    private boolean testOnReturn;
    @Value("${spring.datasource.poolPreparedStatements}")
    private boolean poolPreparedStatements;
    @Value("${spring.datasource.filters}")
    private String filters;

    public DruidSource() {}
    @Bean
    @Primary
    public DataSource druidDataSource() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(this.dbUrl);
        datasource.setUsername(this.username);
        datasource.setPassword(this.password);
        datasource.setDriverClassName(this.driverClassName);
        datasource.setInitialSize(this.initialSize);
        datasource.setMinIdle(this.minIdle);
        datasource.setMaxActive(this.maxActive);
        datasource.setMaxWait((long)this.maxWait);
        datasource.setTimeBetweenEvictionRunsMillis((long)this.timeBetweenEvictionRunsMillis);
        datasource.setMinEvictableIdleTimeMillis((long)this.minEvictableIdleTimeMillis);
        datasource.setValidationQuery(this.validationQuery);
        datasource.setTestWhileIdle(this.testWhileIdle);
        datasource.setTestOnBorrow(this.testOnBorrow);
        datasource.setTestOnReturn(this.testOnReturn);
        datasource.setPoolPreparedStatements(this.poolPreparedStatements);

        try {
            datasource.setFilters(this.filters);
        } catch (SQLException var3) {
            this.logger.error("druid configuration initialization filter", var3);
        }

        return datasource;
    }

    @Bean
    @Primary
    public DataSourceTransactionManager masterTransactionManager() throws SQLException {
        return new DataSourceTransactionManager(this.druidDataSource());
    }
}

3.WebCorsConfigurerAdapter

package com.geneator.test.demo.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class WebCorsConfigurerAdapter extends WebMvcConfigurerAdapter {
    @Value("${cors.allowedOrigins}")
    private String[] allowedOrigins;

    public WebCorsConfigurerAdapter() {
    }
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**").allowedOrigins(this.allowedOrigins).allowedHeaders(new String[]{"*"}).allowedMethods(new String[]{"POST"});
    }
}

5.相关配置文件如下：

1.application

mybatis.config-location=classpath:mybatis-config.xml
mybatis.mapper-locations=classpath*:com/geneator/**/*Mapper.xml
#实体类包名
mybatis.typeAliasesPackage=com.geneator.test.demo.bean
mapper.before=true
mapper.b-e-f-o-r-e=true

cors.allowedOrigins = http://127.0.0.1:8881/jkda,http://127.0.0.1:8881/asd


##########################  oracle   ##########################
spring.datasource.url=jdbc:oracle:thin:@localhost:1521:orcl
spring.datasource.username=system
spring.datasource.password=123456
spring.datasource.driver-class-name=oracle.jdbc.OracleDriver

logging.level.com.geneator.test.demo.mapper=info
logging.level.com.geneator.test.demo.trade=info
logging.file=log\testInterface.log
logging.pattern.file=%d{yyyy/MM/dd-HH:mm} [%thread] %-5level %logger- %msg%n


##########################  druid\u914D\u7F6E   ##########################
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=40
spring.datasource.maxWait=60000
spring.datasource.timeBetweenEvictionRunsMillis=60000
spring.datasource.minEvictableIdleTimeMillis=300000
spring.datasource.validationQuery=SELECT 1 FROM DUAL
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
spring.datasource.poolPreparedStatements=true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
spring.datasource.filters=stat,wall,log4j
spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
spring.datasource.useGlobalDataSourceStat=true


spring.http.encoding.charset=UTF-8
spring.http.encoding.force=true
spring.http.encoding.enabled=true

2.DemoApplication

package com.geneator.test.demo;

import org.apache.ibatis.annotations.Mapper;
import org.mybatis.spring.annotation.MapperScan;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.builder.SpringApplicationBuilder;

import org.springframework.boot.web.support.SpringBootServletInitializer;

@SpringBootApplication
@MapperScan(
        basePackages = {"com.geneator.test.demo"},
        annotationClass = Mapper.class)

public class DemoApplication extends SpringBootServletInitializer {
    public DemoApplication() {
    }
    public static void main(String[] args) {
        (new SpringApplicationBuilder(new Object[]{DemoApplication.class})).web(true).run(args);
    }

    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        SpringApplicationBuilder rest = builder.sources(new Class[]{DemoApplication.class});
        return rest;
    }
}

最后用postman进行测试

postman

地址栏输入：http://localhost:8080/druid/login.html，查看druid数据源

基于SpringBoot 的rest接口开发流程
项目中用到接口开发，所以记录一下，方便以后使用。本教程主要分为三个部分：1.利用geneator自动生成相关实体及...
SpringBoot笔记2：Rest页面及数据库
SpringBoot Rest风格接口使用Spring Tool Suite工具选择Web Starter开发R...
接口管理规范
接口管理基于 YApi 的接口设计与开发流程 https://starter.zhigui.com/docs/d...
SpringBoot系列教程web篇之Freemaker环境搭建
现在的开发现状比较流行前后端分离，使用springboot搭建一个提供rest接口的后端服务特别简单，引入spri...
spring boot 2 security 403 无权
公司项目Springboot2 + security REST 风格接口，权限不足时，返回security ...
SpringBoot使用快速构建restful应用，你学废了吗
本篇要点 Spring Data REST的基本介绍。 SpringBoot快速构建restful风格接口。 Sp...
基于liferay7开发Rest接口
1、创建 Liferay Workspace project 命名demo(自定义)，Build type默认Gr...
Springboot2.X集成Swagger2方案
背景说明 Springboot2.X暴露REST接口可以通过Swagger方式进行暴露方便接口调试。解决方案父...
大数据研发相关-面试拾遗（备战积累的知识点）
REST（representational state transfer）接口开发接口规范幂等：无论操作多...
SpringBoot2.x【六】整合 Rest API 接口规范
SpringBoot2.x【六】整合 Rest API 接口规范 Spring Boot通过提供开箱即用的默认依赖...