SpringBoot RestTemplate 设置挡板

项目结构

代码

BaffleConfig

/**
 * @Description 记录配置信息
 * @Author wjx
 * @Date 2024/2/1 14:47
 **/
public interface BaffleConfig {
  
  // 是否开启挡板的开关
  public static boolean SWITCH = true;
  
  // 文件根目录
  public static String ROOT_PATH = "D:\\TIS\\mock";
  
  // http 挡板存在位置的文件名
  public static String HTTP_FILE_NAME = "http";
  
}

BaffleInfos

import java.util.concurrent.ConcurrentHashMap;

/**
 * @Description 存储挡板信息
 * @Author wjx
 * @Date 2024/2/1 11:25
 **/
public interface BaffleInfos {

  // http请求挡板 信息（会将文件中挡板的信息存在该处，用于全局使用）  key fileName  value 挡板内容
  public static ConcurrentHashMap<String, MockClientHttpResponse> HTTP_MOCK = new ConcurrentHashMap<>();
}

InitializeBaffleInfoRunner

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
import java.util.Arrays;

/**
 * @Description 初始化挡板信息
 * @Author wjx
 * @Date 2024/2/1 11:38
 **/
@Slf4j
@Component
public class InitializeBaffleInfoRunner implements ApplicationRunner {
  
  @Autowired
  private BaffleRead[] baffleReads;
  
  @Override
  public void run(ApplicationArguments args) throws Exception {
    // 判断挡板开关是否开启
    if (BaffleConfig.SWITCH){
      log.warn("*****************************挡板功能开启*****************************");
      // 开启。
      Arrays.asList(baffleReads).parallelStream().forEach(e -> e.read());
    }
  }
}

BaffleRead

/**
 * @Description 读取挡板
 * @Author wjx
 * @Date 2024/2/1 14:59
 **/
public interface BaffleRead {
  
  void read();
}

MockClientHttpResponse

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.client.ClientHttpResponse;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

public class MockClientHttpResponse implements ClientHttpResponse {

        private final byte[] body;

        public MockClientHttpResponse(byte[] body) {
            this.body = body;
        }

        @Override
        public HttpStatus getStatusCode() throws IOException {
            return HttpStatus.OK;
        }

        @Override
        public int getRawStatusCode() throws IOException {
            return HttpStatus.OK.value();
        }

        @Override
        public String getStatusText() throws IOException {
            return HttpStatus.OK.getReasonPhrase();
        }

        @Override
        public void close() {
            // Do nothing here
        }

        @Override
        public InputStream getBody() throws IOException {
            return new ByteArrayInputStream(body);
        }

        @Override
        public HttpHeaders getHeaders() {
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            return headers;
        }
    }

HttpBaffleRead

import com.tianqiauto.baffle.BaffleInfos;
import com.tianqiauto.baffle.BaffleConfig;
import com.tianqiauto.baffle.BaffleRead;
import com.tianqiauto.baffle.MockClientHttpResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Arrays;

/**
 * @Description http 挡板读取
 * @Author wjx
 * @Date 2024/2/1 14:59
 **/
@Slf4j
@Component
public class HttpBaffleRead implements BaffleRead {
  @Override
  public void read() {
    // 判断文件夹是否存在
    File file = new File(BaffleConfig.ROOT_PATH + File.separator + BaffleConfig.HTTP_FILE_NAME);
    if (file.exists()){
      // 遍历文件，异步读取，并存储
      File[] files = file.listFiles();
      Arrays.asList(files).parallelStream().forEach(e -> {
        String name = StringUtils.stripFilenameExtension(e.getName());
        byte[] bytes = new byte[0];
        try {
          bytes = Files.readAllBytes(e.toPath());
        } catch (IOException ex) {
          log.error("【挡板建设时发生错误】文件名：{}",name,ex);
        }
        MockClientHttpResponse mockClientHttpResponse = new MockClientHttpResponse(bytes);
        BaffleInfos.HTTP_MOCK.put(name,mockClientHttpResponse);
      });
    }
    
  }
}

MockHttpInterceptor

import com.tianqiauto.baffle.BaffleConfig;
import com.tianqiauto.baffle.BaffleInfos;
import com.tianqiauto.baffle.MockClientHttpResponse;
import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.stereotype.Component;
import java.io.IOException;

/**
 * @Description http 拦截
 * @Author wjx
 * @Date 2024/2/1 16:26
 **/
@Component
public class MockHttpInterceptor implements ClientHttpRequestInterceptor {
  @Override
  public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
    // 判断挡板开关是否开启
    if (BaffleConfig.SWITCH){
      // 开启。读取存储空间是否有对应的挡板
      String requestPart = request.getURI().getSchemeSpecificPart();
      String fileName = RequestFilenameMapping.mapping.get(requestPart);
      // 如果有对应的挡板，将挡板内容填充
      MockClientHttpResponse mockClientHttpResponse = BaffleInfos.HTTP_MOCK.get(fileName);
      if (mockClientHttpResponse != null) return mockClientHttpResponse;
    }
    return execution.execute(request,body);
  }
}

RequestFilenameMapping

import java.util.HashMap;

/**
 * @Description 请求路径和文件名映射
 * @Author wjx
 * @Date 2024/2/1 16:56
 **/
public class RequestFilenameMapping {
  
  // key 请求路径    value 文件名
  public static HashMap<String,String> mapping;
  
  static {
    mapping = new HashMap<String,String>();
    mapping.put("//61.××××:80××/yarn","xdd1");
  }
}

添加拦截器

文件存储位置