SpringBoot API增加version版本号方式

import java.lang.annotation.*;

/**

  * API Version type

  */

@Target ({ElementType.METHOD, ElementType.TYPE})

@Retention (RetentionPolicy.RUNTIME)

@Documented

public @interface ApiVersion {

     /**

      * api version begin 1

      */

     double version() default 1 ;

}

import org.springframework.web.servlet.mvc.condition.RequestCondition;

import javax.servlet.http.HttpServletRequest;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/**

  * API version condition

  * @author w

  * @date 2020-11-16

  */

public class ApiVersionCondition implements RequestCondition<ApiVersionCondition> {

     /**

      * 接口路径中的版本号前缀，如: api/v[1-n]/test

      */

     private final static Pattern VERSION_PREFIX_PATTERN = Pattern.compile( "/v([0-9]+\\.{0,1}[0-9]{0,2})/" );

     /** API VERSION interface **/

     private ApiVersion apiVersion;

     ApiVersionCondition(ApiVersion apiVersion){

         this .apiVersion = apiVersion;

     }

     /**

      * [当class 和 method 请求url相同时，触发此方法用于合并url]

      * 官方解释：

      * - 某个接口有多个规则时，进行合并

      * - 比如类上指定了@RequestMapping的 url 为 root

      * - 而方法上指定的@RequestMapping的 url 为 method

      * - 那么在获取这个接口的 url 匹配规则时，类上扫描一次，方法上扫描一次，这个时候就需要把这两个合并成一个，表示这个接口匹配root/method

      * @param other 相同api version condition

      * @return ApiVersionCondition

      */

     @Override

     public ApiVersionCondition combine(ApiVersionCondition other) {

         // 此处按优先级，method大于class

         return new ApiVersionCondition(other.getApiVersion());

     }

     /**

      * 判断是否成功，失败返回 null；否则，则返回匹配成功的条件

      * @param httpServletRequest http request

      * @return 匹配成功条件

      */

     @Override

     public ApiVersionCondition getMatchingCondition(HttpServletRequest httpServletRequest) {

         // 通过uri匹配版本号

         System.out.println(httpServletRequest.getRequestURI());

         Matcher m = VERSION_PREFIX_PATTERN.matcher(httpServletRequest.getRequestURI());

         if (m.find()) {

             // 获得符合匹配条件的ApiVersionCondition

             System.out.println( "groupCount:" +m.groupCount());

             double version = Double.valueOf(m.group( 1 ));

             if (version >= getApiVersion().version()) {

                 return this ;

             }

         }

         return null ;

     }

     /**

      * 多个都满足条件时，用来指定具体选择哪一个

      * @param other 多个时

      * @param httpServletRequest http request

      * @return 取版本号最大的

      */

     @Override

     public int compareTo(ApiVersionCondition other, HttpServletRequest httpServletRequest) {

         // 当出现多个符合匹配条件的ApiVersionCondition，优先匹配版本号较大的

         return other.getApiVersion().version() >= getApiVersion().version() ? 1 : - 1 ;

     }

     public ApiVersion getApiVersion() {

         return apiVersion;

     }

}

import org.springframework.core.annotation.AnnotationUtils;

import org.springframework.web.servlet.mvc.condition.RequestCondition;

import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import java.lang.reflect.Method;

/**

  * API version setting

  * @author w

  * @date 2020-11-15

  */

public class ApiVersionRequestMappingHandlerMapping extends RequestMappingHandlerMapping {

     /**

      * class condition

      * - 在class上加@ApiVersion注解&url加{version}

      * @param handlerType class type

      * @return ApiVersionCondition

      */

     @Override

     protected RequestCondition<?> getCustomTypeCondition(Class<?> handlerType) {

         ApiVersion apiVersion = AnnotationUtils.findAnnotation(handlerType,ApiVersion. class );

         return null == apiVersion ? super .getCustomTypeCondition(handlerType) : new ApiVersionCondition(apiVersion);

     }

     /**

      * method condition

      * - 在方法上加@ApiVersion注解&url加{version}

      * @param method method object

      * @return ApiVersionCondition

      */

     @Override

     protected RequestCondition<?> getCustomMethodCondition(Method method) {

         ApiVersion apiVersion = AnnotationUtils.findAnnotation(method,ApiVersion. class );

         return null == apiVersion ? super .getCustomMethodCondition(method) : new ApiVersionCondition(apiVersion);

     }

}

import com.panda.common.web.controller.BasicController;

import com.panda.common.web.version.ApiVersion;

import com.panda.core.umc.service.UserInfoService;

import com.panda.core.umc.vo.QueryUsersConditionVo;

import com.panda.face.umc.dto.user.QueryUsersReq;

import org.springframework.beans.BeanUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.*;

/**

  * 用户信息服务

  * @author w

  * @date 2020-11-06

  */

@RequestMapping ( "/api" )

@RestController

public class UserInfoController extends BasicController{

     @Autowired

     private UserInfoService userInfoService;

     /**

      * 查询所有用户信息

      * @param req 查询条件信息

      */

     @ApiVersion

     @RequestMapping (value = "{version}/users" , method = RequestMethod.GET)

     @ResponseBody

     public ResponseEntity getUsers( @PathVariable ( "version" ) String version, QueryUsersReq req){

         QueryUsersConditionVo condition = new QueryUsersConditionVo();

         BeanUtils.copyProperties(req,condition);

         condition.setOrderBy( "CREATE_TIME" );

         condition.setSort( "DESC" );

         return assemble( "1111" );

     }

     /**

      * 查询所有用户信息

      * @param req 查询条件信息

      */

     @ApiVersion (version = 1.1 )

     @RequestMapping (value = "{version}/users" , method = RequestMethod.GET)

     @ResponseBody

     public ResponseEntity getUsersV2( @PathVariable ( "version" ) String version, QueryUsersReq req){

         QueryUsersConditionVo condition = new QueryUsersConditionVo();

         BeanUtils.copyProperties(req,condition);

         condition.setOrderBy( "CREATE_TIME" );

         condition.setSort( "DESC" );

         return assemble( "222" );

     }

     /**

      * 根据用户ID获取用户信息

      * @param userId 用户ID

      */

     @RequestMapping (value = "/users/uid/{userId}" , method = RequestMethod.GET)

     @ResponseBody

     public ResponseEntity getUserInfo( @PathVariable ( "userId" ) String userId){

         return assemble(userInfoService.selectByUserId(userId));

     }

}

@Target ({ElementType.METHOD, ElementType.TYPE})

@Retention (RetentionPolicy.RUNTIME)

@Documented

public @interface ApiVersion {

     /**

      * 标识版本号，从1开始

      */

     int value() default 1 ;

}

@Data

@Slf4j

public class ApiVersionCondition implements RequestCondition<ApiVersionCondition> {

     /**

      * 接口路径中的版本号前缀，如: api/v[1-n]/fun

      */

     private final static Pattern VERSION_PREFIX = Pattern.compile( "/v(\\d+)/" );

     private int apiVersion;

     ApiVersionCondition( int apiVersion) {

         this .apiVersion = apiVersion;

     }

     /**

      * 最近优先原则，方法定义的 @ApiVersion > 类定义的 @ApiVersion

      */

     @Override

     public ApiVersionCondition combine(ApiVersionCondition other) {

         return new ApiVersionCondition(other.getApiVersion());

     }

     /**

      * 获得符合匹配条件的ApiVersionCondition

      */

     @Override

     public ApiVersionCondition getMatchingCondition(HttpServletRequest request) {

         Matcher m = VERSION_PREFIX.matcher(request.getRequestURI());

         if (m.find()) {

             int version = Integer.valueOf(m.group( 1 ));

             if (version >= getApiVersion()) {

                 return this ;

             }

         }

         return null ;

     }

     /**

      * 当出现多个符合匹配条件的ApiVersionCondition，优先匹配版本号较大的

      */

     @Override

     public int compareTo(ApiVersionCondition other, HttpServletRequest request) {

         return other.getApiVersion() - getApiVersion();

     }

}

public class ApiRequestMappingHandlerMapping extends RequestMappingHandlerMapping {

     @Override

     protected RequestCondition<?> getCustomTypeCondition(Class<?> handlerType) {

         // 扫描类上的 @ApiVersion

         ApiVersion apiVersion = AnnotationUtils.findAnnotation(handlerType, ApiVersion. class );

         return createRequestCondition(apiVersion);

     }

     @Override

     protected RequestCondition<?> getCustomMethodCondition(Method method) {

         // 扫描方法上的 @ApiVersion

         ApiVersion apiVersion = AnnotationUtils.findAnnotation(method, ApiVersion. class );

         return createRequestCondition(apiVersion);

     }

     private RequestCondition<ApiVersionCondition> createRequestCondition(ApiVersion apiVersion) {

         if (Objects.isNull(apiVersion)) {

             return null ;

         }

         int value = apiVersion.value();

         Assert.isTrue(value >= 1 , "Api Version Must be greater than or equal to 1" );

         return new ApiVersionCondition(value);

     }

}

@Configuration

public class WebMvcRegistrationsConfig implements WebMvcRegistrations {

     @Override

     public RequestMappingHandlerMapping getRequestMappingHandlerMapping() {

         return new ApiRequestMappingHandlerMapping();

     }

}

@RestController

@RequestMapping ( "/api/{version}" )

public class ApiControler {

     @GetMapping ( "/fun" )

     public String fun1() {

         return "fun 1" ;

     }

     @ApiVersion ( 5 )

     @GetMapping ( "/fun" )

     public String fun2() {

         return "fun 2" ;

     }

     @ApiVersion ( 9 )

     @GetMapping ( "/fun" )

     public String fun3() {

         return "fun 5" ;

     }

}