SpringBoot通過注解獲取接口信息
獲取Spring框架的ApplicationContext
相關的方法
案例
案例1 :項目啟動,獲取controller層的接口
案例2:項目啟動,接口寫入數據庫
監聽后台接口

TOC

SpringBoot通過注解獲取接口信息

獲取Spring框架的ApplicationContext

需要修改Application主類

@ComponentScan(basePackages = "com.example.demo.**.**")
@SpringBootApplication
public class DemoApplication implements CommandLineRunner, ApplicationContextAware {//實現接口 CommandLineRunner, ApplicationContextAware

    /**
     * 獲取Spring框架的上下文
     */
    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext arg0) {
        this.applicationContext = arg0;
    }

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);

    }

    /**
     * 調用 applicationContext(不能在main中使用,main是static的,不能調用)
     * @param args
     */
    @Override
    public void run(String... args) {
        //在這里可以調用applicationContext了
        Map<String, Object> controllers = applicationContext.getBeansWithAnnotation(RequestMapping.class);
    }
}

相關的方法

• getBeansWithAnnotation(注解的class) 獲取spring中擁有這個注解的所有類
  

  定義:Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;

比如,通過上面的applicationContext,獲取項目中所有的RestController

//獲取使用RestController注解的所有類
Map<String, Object> controllers = applicationContext.getBeansWithAnnotation(RestController.class);

• 根據對象獲取class:AopUtils.getTargetClass(Object對象)

上面獲取的是Map 的對象,獲取每一個map對應的class；

獲取了class，就可以使用反射的方法了，比如

getDeclaredMethods：獲取當前類的所有方法(包括public、private、protected、默認)

getMethods:獲取當前類和父類的所有的public方法

for (Map.Entry<String, Object> entry : controllers.entrySet()) {//遍歷每個controller層
     //   entry.getValue() 獲取的是 Object對象
    AopUtils.getTargetClass(entry.getValue())
}  

• 判斷一個class/方法中有沒有這個注解isAnnotationPresent
  

  定義:public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)

判斷的是class的注解,所以需要使用上面的AopUtils.getTargetClass(Object對象)獲取到class

AopUtils.getTargetClass(entry.getValue()).isAnnotationPresent(RequestMapping.class) //判斷這個class中有沒有RequestMapping這個注解

• 獲取一個class/方法的某個注解的對象信息getAnnotation或getDeclaredAnnotation
  

  getAnnotation返回的是"直接修飾"注解和繼承的注解的合集，不包括容器注解里包含的注解；

  getDeclaredAnnotation僅僅返回"直接修飾"注解。

RequestMapping annotation = AopUtils.getTargetClass(entry.getValue()).getAnnotation(RequestMapping.class);
或
RequestMapping methodAnno = method.getDeclaredAnnotation(RequestMapping.class);

案例

案例1 :項目啟動,獲取controller層的接口

• controller

@RestController
@RequestMapping(name = "demo1con",value = {"/demo/demo1","/url111"})
public class Demo1Controller {

    @RequestMapping(name = "方法1",value = "/m1")
    public String testDemo1(){
        return "";
    }
}

• 主類設置

@ComponentScan(basePackages = "com.example.demo.**.**")
@SpringBootApplication
public class DemoApplication implements CommandLineRunner, ApplicationContextAware {//實現接口 CommandLineRunner, ApplicationContextAware

    /**
     * 獲取Spring框架的上下文
     */
    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext arg0) {
        this.applicationContext = arg0;
    }

    public static void main(String[] args) {
//        SpringApplication app = new SpringApplication(DemoApplication.class);
//        //程序部署在linux環境，若需要配置成系統服務，使用systemctl（CentOS7系統服務命令）進行程序的啟動、停止、重啟等操作，則需要在程序啟動后，生成一個pid文件，其內容則是該進程的pid。
//        //SpringBoot已經提供了pid文件的生成方式，只需要做簡單的配置即可。
//        //配置文件application.properties文件內容如下，該配置指定了pid文件的位置： 比如 spring.pid.file=/xxx/syb.pid
//        app.addListeners(new ApplicationPidFileWriter());
//        app.run(args);

        SpringApplication.run(DemoApplication.class, args);

    }

    /**
     * 調用 applicationContext(不能在main中使用,main是static的,不能調用)
     * @param args
     */
    @Override
    public void run(String... args) {
        //獲取使用RestController注解的所有controller層類
        Map<String, Object> controllers = applicationContext.getBeansWithAnnotation(RestController.class);//獲取到 demo1Controller -> {Demo1Controller@5595}
        for (Map.Entry<String, Object> entry : controllers.entrySet()) {//遍歷每個controller層
            System.out.println(entry.getKey());//demo1Controller
            Object value = entry.getValue();
            Class<?> aClass = AopUtils.getTargetClass(value);//獲取class
            System.out.println(aClass.isAnnotationPresent(RequestMapping.class));//true
            RequestMapping annotation = aClass.getAnnotation(RequestMapping.class);//獲取注解詳情
            RequestMapping declaredAnnotation = aClass.getDeclaredAnnotation(RequestMapping.class);
            //注解的詳情可以直接調用了
            System.out.println(JSON.toJSONString(annotation));//{"path":[],"headers":[],"method":[],"name":"demo1con","produces":[],"params":[],"value":["/demo/demo1","/url111"],"consumes":[]}
            List<Method> methods = Arrays.asList(aClass.getMethods());//獲取方法
            List<Method> declaredMethods = Arrays.asList(aClass.getDeclaredMethods());//獲取方法
            System.out.println(declaredMethods.get(0).isAnnotationPresent(RequestMapping.class));//判斷這個方法有沒有這個注解
            RequestMapping annotation1 = declaredMethods.get(0).getAnnotation(RequestMapping.class);//獲取方法的注解
            RequestMapping annotation2 = declaredMethods.get(0).getDeclaredAnnotation(RequestMapping.class);
            System.out.println(JSON.toJSONString(annotation1));//{"path":[],"headers":[],"method":[],"name":"方法1","produces":[],"params":[],"value":["/m1"],"consumes":[]}
        }
    }
}

案例2:項目啟動,接口寫入數據庫

項目啟動的時候,檢測所有的controller層,將接口信息寫入數據庫

接口

public class DemoApplication implements CommandLineRunner, ApplicationContextAware {//1.實現了接口CommandLineRunner, ApplicationContextAware

    /**
     * 2.獲取Spring框架的上下文
     */
    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext arg0) {
        this.applicationContext = arg0;
    }

    /**
    后台接口自動導入
    */
    @Autowired
    private BackApiAutoImportInter backApiAutoImportInter;

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(DemoApplication.class);
        app.addListeners(new ApplicationPidFileWriter());
        app.run(args);
    }

    @Override
    public void run(String... args) {
        try {
            if (backApiAutoImportInter != null) {
                backApiAutoImportInter.setApplicationContext(applicationContext);
                backApiAutoImportInter.setIsLocal(false);
                backApiAutoImportInter.setIsOpen(false);

                backApiAutoImportInter.run(BackApiDataSource.UCENTER);
            } else {
                log.error("backApiAutoImportInter is empty", "backApiAutoImportInter inject failed");
            }
        } catch (Exception ex) {
            log.error("error:", ex);
        }
    }

}

監聽后台接口

項目啟動的時候,自動識別項目的所有接口

• 接口層

/**
* 后台接口自動導入
*
* @author huangyutao
* @date 2019-08-16 10:13:54
*/
public interface BackApiAutoImportInter {

    /**
     * 上下文賦值
        *
     * @param applicationContext 參數
     * @return
     * @author huangyutao
     * @date 2019-08-16 10:34:35
        */
      void setApplicationContext(ApplicationContext applicationContext);

    /**
     * 本地錄入標識
        *
     * @param isLocal 參數
     * @return
     * @author huangyutao
     * @date 2019-09-05 18:01:24
        */
      void setIsLocal(boolean isLocal);

    /**
     * 開放標識
        *
     * @param isOpen 參數
     * @return
     * @author huangyutao
     * @date 2019-09-18 11:09:36
        */
      void setIsOpen(boolean isOpen);

    /**
     * 執行導入(用戶中心中url以"/back/"開頭的接口不錄入數據庫)
        *
     * @param dataSource 數據來源
     * @return
     * @author huangyutao
     * @date 2019-08-20 10:13:28
        */
      void run(String dataSource);

}

• 實現層

package net.cc.ucenter.modules.backapi.service;

import com.alibaba.fastjson.JSON;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import net.cc.commons.IdGen;
import net.cc.commons.annotation.User;
import net.cc.commons.web.base.BaseHttpResult;
import net.cc.ucenter.modules.backapi.dto.BackApiAnnoDTO;
import net.cc.ucenter.modules.backapi.entity.BackApiInfo;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.*;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.*;
import java.util.stream.Collectors;

/**
* 后台接口自動導入--將項目中的controller接口寫入數據庫
*/
@Slf4j
@Service
public class BackApiAutoImportImpl implements BackApiAutoImportInter {

    @Autowired
    private BackApiInfoService backApiInfoService;

    /**Spring框架的上下文*/
    private ApplicationContext applicationContext;
    /**本地錄入標識*/
    private boolean isLocal;
    /**開放標識*/
    private boolean isOpen;

    /**
     * 上下文賦值
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    /**
     * 本地錄入標識
     */
    @Override
    public void setIsLocal(boolean isLocal) {
        this.isLocal = isLocal;
    }

    /**
     * 開放標識
     */
    @Override
    public void setIsOpen(boolean isOpen) {
        this.isOpen = isOpen;
    }

    /**
     * 執行導入(用戶中心中url以"/back/"開頭的接口不錄入數據庫)
     */
    @Override
    public void run(String dataSource) {
        List<String> invalidControllers = new ArrayList<>();//沒有注解RequestMapping或RequestMapping注解沒有設置name的所有的類的集合
        List<String> invalidMethods = new ArrayList<>();
        List<String> invalidMethodAnnos = new ArrayList<>();
        List<BackApiInfo> insertParams = new ArrayList<>();
        List<BackApiInfo> updateParams = new ArrayList<>();
        // 獲取數據庫中的接口
        BackApiInfo backApiInfoParam = new BackApiInfo();
        backApiInfoParam.setDataSource(dataSource);
        List<BackApiInfo> backApiInfos = backApiInfoService.findList(backApiInfoParam);//查詢當前數據庫匯總記錄的所有的接口
        // 獲取代碼中所有的controller
        Map<String, Object> controllers = applicationContext.getBeansWithAnnotation(RestController.class);//獲取使用RestController注解的所有controller層類
        // 加工數據
        List<String> apiUrls = backApiInfos.stream().map(p -> p.getApiUrl()).collect(Collectors.toList());//獲取數據庫中所有的接口的路由url
        for (Map.Entry<String, Object> entry : controllers.entrySet()) {//遍歷每個controller層
            //AopUtils.getTargetClass(entry.getValue())  獲取controller的真實的class 比如  com.demo1.controller.Demo1Controller
            //isAnnotationPresent 判斷class的類注解中有沒有這個注解
            //此處為判斷這個controller類有沒有RequestMapping注解(否則是普通的方法)
            if (!AopUtils.getTargetClass(entry.getValue()).isAnnotationPresent(RequestMapping.class)
                    //getAnnotation 返回這個class的這個注解的所有信息
                    //此處判斷的是,給這個controller類設置了name
                    || StringUtils.isBlank(AopUtils.getTargetClass(entry.getValue()).getAnnotation(RequestMapping.class).name())) {
                invalidControllers.add(entry.getKey());
            } else {
                RequestMapping controllerAnno = AopUtils.getTargetClass(entry.getValue()).getAnnotation(RequestMapping.class);//獲取這個controller的RequestMapping注解的信息
                for (String controllerUrl : controllerAnno.value()) {//遍歷controller的接口(value是數組,一個RequestMapping可以設置多個url)
                    // 過濾/back/開頭的接口
                    if (StringUtils.isNotBlank(controllerUrl) && !procPath(controllerUrl).toLowerCase().startsWith("/back/")) {
                        List<String> methodUrls = new ArrayList<>();//這個類的所有的url接口
                        List<Method> methods = Arrays.stream(AopUtils.getTargetClass(entry.getValue()).getDeclaredMethods())//獲取本類的所有的方法(包括public、private、protected、默認)
                                .filter(p -> Modifier.isPublic(p.getModifiers()))//過濾掉public的
                                .collect(Collectors.toList());
                        for (Method method : methods) {
                            //若是這個方法沒有RequestMapping及相關注解,或者注解沒有設置name值
                            if ((!method.isAnnotationPresent(RequestMapping.class) || StringUtils.isBlank(method.getDeclaredAnnotation(RequestMapping.class).name()))
                                    && (!method.isAnnotationPresent(GetMapping.class) || StringUtils.isBlank(method.getDeclaredAnnotation(GetMapping.class).name()))
                                    && (!method.isAnnotationPresent(PostMapping.class) || StringUtils.isBlank(method.getDeclaredAnnotation(PostMapping.class).name()))
                                    && (!method.isAnnotationPresent(PutMapping.class) || StringUtils.isBlank(method.getDeclaredAnnotation(PutMapping.class).name()))
                                    && (!method.isAnnotationPresent(DeleteMapping.class) || StringUtils.isBlank(method.getDeclaredAnnotation(DeleteMapping.class).name()))
                                    && (!method.isAnnotationPresent(PatchMapping.class) || StringUtils.isBlank(method.getDeclaredAnnotation(PatchMapping.class).name()))
                            ) {
                                invalidMethods.add(method.getDeclaringClass().getName() + "." + method.getName());//不需要解析的方法
                            } else {
                                List<BackApiAnnoDTO> backApiAnnoDTOS = getAnnos(method);
                                if (CollectionUtils.isNotEmpty(backApiAnnoDTOS)) {
                                    methodUrls.addAll(backApiAnnoDTOS.stream()
                                            .map(p -> p.getValue())
                                            .collect(Collectors.toList()));
                                }
                            }
                        }
                        List<String> dupliUrls = getDuplicateElements(methodUrls);//獲取url重復的元素列表
                        if (CollectionUtils.isNotEmpty(dupliUrls)) {
                            invalidMethodAnnos.addAll(dupliUrls.stream()
                                    .map(p -> "url:\"" + p + "\"[" + AopUtils.getTargetClass(entry.getValue()).getName() + "]")
                                    .collect(Collectors.toList()));//記錄重復的url
                        }
                        for (Method method : methods) {
                            if (method.isAnnotationPresent(RequestMapping.class)
                                    || method.isAnnotationPresent(GetMapping.class)
                                    || method.isAnnotationPresent(PostMapping.class)
                                    || method.isAnnotationPresent(PutMapping.class)
                                    || method.isAnnotationPresent(DeleteMapping.class)
                                    || method.isAnnotationPresent(PatchMapping.class)
                            ) {//若是這個方法有接口的注解
                                List<BackApiAnnoDTO> backApiAnnoDTOS = getAnnos(method);//獲取所有的接口信息
                                if (CollectionUtils.isNotEmpty(backApiAnnoDTOS)) {
                                    backApiAnnoDTOS.forEach(backApiAnnoDTO -> {
                                        if (!dupliUrls.contains(backApiAnnoDTO.getValue())) {//不是重復的url(spring不允許重復的url,有重復的就該報異常了)
                                            String apiUrl = new StringBuilder() //拼接controller和方法的url
                                                    .append(procPath(controllerUrl))
                                                    .append(procPath(backApiAnnoDTO.getValue()))
                                                    .toString();
                                            if (StringUtils.isNotBlank(apiUrl)) {
                                                if (!apiUrls.contains(apiUrl)) {//數據庫在中不存在這個url
                                                    BackApiInfo backApiInfo = new BackApiInfo();
                                                    backApiInfo.setApiId(IdGen.snowflakeId());
                                                    try {
                                                        Thread.sleep(5);
                                                    } catch (Exception ex) {
                                                        throw new RuntimeException(ex);
                                                    }
                                                    backApiInfo.setApiName(backApiAnnoDTO.getName());
                                                    backApiInfo.setApiUrl(apiUrl);
                                                    backApiInfo.setModuleName(controllerAnno.name());
                                                    backApiInfo.setDataSource(dataSource);
                                                    backApiInfo.setIsOpen(isOpen ? "1" : "0");
                                                    backApiInfo.setIsCheckToken(method.isAnnotationPresent(User.class) ?
                                                            "1" : "0");//是否需要登錄
                                                    backApiInfo.setIsUse("1");
                                                    backApiInfo.setIsSync("1");
                                                    backApiInfo.setCreateBy(-1L);
                                                    backApiInfo.setRemarks("system");
                                                    insertParams.add(backApiInfo); //記錄為插入的url
                                                } else {
                                                    // delete from apiUrls
                                                    apiUrls.remove(apiUrl);
                                                    // update 數據庫中已經存在這個url了,那就更新這個接口的信息
                                                    BackApiInfo backApiInfo = backApiInfos.stream() //獲取數據庫中的信息
                                                            .filter(p -> p.getApiUrl().equals(apiUrl))
                                                            .findFirst().orElse(null);
                                                    if (backApiInfo.getIsSync().equals("1")) {
                                                        if (!backApiInfo.getApiName().equals(backApiAnnoDTO.getName())
                                                                || !backApiInfo.getModuleName().equals(controllerAnno.name())
                                                                || !backApiInfo.getIsCheckToken().equals(
                                                                method.isAnnotationPresent(User.class) ? "1" : "0")) {
                                                            backApiInfo.setApiName(backApiAnnoDTO.getName());
                                                            backApiInfo.setModuleName(controllerAnno.name());
                                                            backApiInfo.setIsCheckToken(method.isAnnotationPresent(User.class) ?
                                                                    "1" : "0");
                                                            updateParams.add(backApiInfo);//記錄為更新的url
                                                        } else {
                                                            // nothing to update
                                                        }
                                                    } else {
                                                        // no sync
                                                    }
                                                }
                                            }
                                        }
                                    });
                                }
                            }
                        }
                    } else {
                        // controller value is empty
                    }
                }
            }
        }
        Map<String, List<Object>> data = new HashMap<>(8);
        data.put("invalidControllers", invalidControllers.stream().map(p -> (Object) p).collect(Collectors.toList()));
        data.put("invalidMethods", invalidMethods.stream().map(p -> (Object) p).collect(Collectors.toList()));
        data.put("invalidMethodAnnos", invalidMethodAnnos.stream().map(p -> (Object) p).collect(Collectors.toList()));
        data.put("insertParams", insertParams.stream().map(p -> (Object) p).collect(Collectors.toList()));
        data.put("updateParams", updateParams.stream().map(p -> (Object) p).collect(Collectors.toList()));
        data.put("deleteParams", apiUrls.stream().map(p -> (Object) p).collect(Collectors.toList()));
        BaseHttpResult<Map<String, List<String>>> result = backApiInfoService.proceedData(data
                , applicationContext.getEnvironment().getActiveProfiles()[0], isLocal);//applicationContext.getEnvironment().getActiveProfiles()[0] 是啟動環境,是application的-之后的環境.
        if (!result.isSuccess()) {
            Map<String, List<String>> resultData = result.getData();
            resultData.forEach((key, value) -> log.error(key + "{}", JSON.toJSONString(value)));
            SpringApplication.exit(applicationContext);
        }
    }

    /**
     * 獲取注解信息列表
     *
     * @param method 方法
     * @return
     * @author huangyutao
     * @date 2019-08-15 17:26:35
     */
    private List<BackApiAnnoDTO> getAnnos(Method method) {
        List<BackApiAnnoDTO> backApiAnnoDTOs = new ArrayList<>();
        String name = "";
        List<String> values = new ArrayList<>();
        if (method.isAnnotationPresent(RequestMapping.class)) {//判斷方法有沒有這個注解
            RequestMapping methodAnno = method.getDeclaredAnnotation(RequestMapping.class);
            name = methodAnno.name();//獲取方法名
            values = Arrays.asList(methodAnno.value());//獲取這個方法的所有的路由url
        } else if (method.isAnnotationPresent(GetMapping.class)) {
            GetMapping methodAnno = method.getDeclaredAnnotation(GetMapping.class);
            name = methodAnno.name();
            values = Arrays.asList(methodAnno.value());
        } else if (method.isAnnotationPresent(PostMapping.class)) {
            PostMapping methodAnno = method.getDeclaredAnnotation(PostMapping.class);
            name = methodAnno.name();
            values = Arrays.asList(methodAnno.value());
        } else if (method.isAnnotationPresent(PutMapping.class)) {
            PutMapping methodAnno = method.getDeclaredAnnotation(PutMapping.class);
            name = methodAnno.name();
            values = Arrays.asList(methodAnno.value());
        } else if (method.isAnnotationPresent(DeleteMapping.class)) {
            DeleteMapping methodAnno = method.getDeclaredAnnotation(DeleteMapping.class);
            name = methodAnno.name();
            values = Arrays.asList(methodAnno.value());
        } else if (method.isAnnotationPresent(PatchMapping.class)) {
            PatchMapping methodAnno = method.getDeclaredAnnotation(PatchMapping.class);
            name = methodAnno.name();
            values = Arrays.asList(methodAnno.value());
        }
        for (String value : values) {//遍歷每一個路由,創建詳情
            BackApiAnnoDTO backApiAnnoDTO = new BackApiAnnoDTO();
            backApiAnnoDTO.setName(name);
            backApiAnnoDTO.setValue(value);
            backApiAnnoDTOs.add(backApiAnnoDTO);
        }
        return backApiAnnoDTOs;
    }

    /**
     * 處理path
     *
     * @param path path
     * @return path
     * @author huangyutao
     * @date 2019-08-12 11:22:59
     */
    private String procPath(String path) {
        path = path.trim();
        if (!path.startsWith("/")) {
            path = "/" + path;
        }
        while (path.endsWith("/")) {
            path = path.substring(0, path.length() - 1);
        }
        return path;
    }

    /**
     * 獲取重復的元素列表
     *
     * @param list 數據源
     * @return
     * @author huangyutao
     * @date 2019-08-19 10:59:29
     */
    private <T> List<T> getDuplicateElements(List<T> list) {
        return list.stream()
                // 獲得元素出現頻率的 Map，鍵為元素，值為元素出現的次數
                .collect(Collectors.toMap(e -> e, e -> 1, Integer::sum))
                // 所有 entry 對應的 Stream
                .entrySet().stream()
                // 過濾出元素出現次數大於 1 的 entry
                .filter(entry -> entry.getValue() > 1)
                // 獲得 entry 的鍵（重復元素）對應的 Stream
                .map(entry -> entry.getKey())
                .collect(Collectors.toList());
    }

}

backApiInfoService

    /**
     * 處理數據
     *
     * @param data    參數
     * @param profile 啟動配置文件
     * @param isLocal profile=local時是否同步數據
     * @return
     * @author huangyutao
     * @date 2019-09-05 10:14:03
     */
    @Transactional(rollbackFor = Exception.class, readOnly = false)
    public BaseHttpResult<Map<String, List<String>>> proceedData(Map<String, List<Object>> data
            , String profile, Boolean isLocal) {
        // 從參數中抽離數據
        List<String> invalidControllers = data.get("invalidControllers").stream()
                .map(p -> objectMapper.convertValue(p, String.class)).collect(Collectors.toList());
        List<String> invalidMethods = data.get("invalidMethods").stream()
                .map(p -> objectMapper.convertValue(p, String.class)).collect(Collectors.toList());
        List<String> invalidMethodAnnos = data.get("invalidMethodAnnos").stream()
                .map(p -> objectMapper.convertValue(p, String.class)).collect(Collectors.toList());
        List<BackApiInfo> insertParams = data.get("insertParams").stream()
                .map(p -> objectMapper.convertValue(p, BackApiInfo.class)).collect(Collectors.toList());
        List<BackApiInfo> updateParams = data.get("updateParams").stream()
                .map(p -> objectMapper.convertValue(p, BackApiInfo.class)).collect(Collectors.toList());
        List<String> deleteParams = data.get("deleteParams").stream()
                .map(p -> objectMapper.convertValue(p, String.class)).collect(Collectors.toList());

        Map<String, List<String>> resultData = new HashMap<>(3);
        if (CollectionUtils.isNotEmpty(invalidControllers)) {
            resultData.put("controllers missing anno: ", invalidControllers);
        }
        if (CollectionUtils.isNotEmpty(invalidMethods)) {
            resultData.put("methods missing anno: ", invalidMethods);
        }
        if (CollectionUtils.isNotEmpty(invalidMethodAnnos)) {
            resultData.put("methods duplicate anno: ", invalidMethodAnnos);
        }
        if (MapUtils.isEmpty(resultData)) {
            // 數據操作
            List<SysParameterInfo> sysParameterInfos = SysParamUtils.getSysParamList("BackApiIgnoreUrl");
            if (CollectionUtils.isNotEmpty(sysParameterInfos) && CollectionUtils.isNotEmpty(insertParams)) {
                List<String> ignoreUrls = sysParameterInfos.stream()
                        .map(p -> p.getParameterKey())
                        .collect(Collectors.toList());
                // 去掉忽略的
                insertParams = insertParams.stream()
                        .filter(p -> !ignoreUrls.contains(p.getApiUrl()))
                        .collect(Collectors.toList());
            }
            switch (profile) {
                case ProfileType.LOCAL:
                    if (isLocal) {
                        if (CollectionUtils.isNotEmpty(insertParams)) {
                            dao.insertBatch(insertParams);
                        }
                        if (CollectionUtils.isNotEmpty(updateParams)) {
                            dao.updateBatch(updateParams);
                        }
                        if (CollectionUtils.isNotEmpty(deleteParams)) {
                            List<BackApiInfo> backApiInfos = dao.selectBatch(deleteParams);
                            // 刪除后台接口信息
                            dao.deleteBatch(deleteParams);
                            // 刪除關聯關系
                            backApiInFuncDao.deleteBatch(backApiInfos.stream().map(p -> p.getApiId())
                                    .collect(Collectors.toList()));
                        }
                    }
                    break;
                case ProfileType.TEST:
                case ProfileType.TEST_STABLE:
                    if (CollectionUtils.isNotEmpty(insertParams)) {
                        dao.insertBatch(insertParams);
                    }
                    if (CollectionUtils.isNotEmpty(updateParams)) {
                        dao.updateBatch(updateParams);
                    }
                    if (CollectionUtils.isNotEmpty(deleteParams)) {
                        List<BackApiInfo> backApiInfos = dao.selectBatch(deleteParams);
                        // 刪除后台接口信息
                        dao.deleteBatch(deleteParams);
                        // 刪除關聯關系
                        backApiInFuncDao.deleteBatch(backApiInfos.stream().map(p -> p.getApiId())
                                .collect(Collectors.toList()));
                    }
                    break;
                case ProfileType.PROD:
                    if (CollectionUtils.isNotEmpty(insertParams)) {
                        dao.insertBatch(insertParams);
                    }
                    break;
                default:
                    break;
            }

            // 清除緩存
            List<String> keys = new ArrayList<>();
            keys.addAll(new ArrayList<>(redisTemplate.keys(CfgProperties.BASEINFO + "*")));
            keys.addAll(new ArrayList<>(redisTemplate.keys(CfgProperties.ACCOUNTURL + "*")));
            keys.add(CfgProperties.NOEXISTURL);
            redisTemplate.delete(keys);

            return success(resultData);
        } else {
            return error(resultData);
        }
    }

來自為知筆記(Wiz)