利用spring写一个反向代理

让spring服务器做为一个反向代理，将一些请求转发给其他的服务来完成响应。实现类似于nginx的功能。

思路：
1、写一个Filter来判断路径来转发符合规则的请求(只转发后端请求且符合特定规则的请求)
2、需要判断后端的服务是否存活
3、转发需要将表单之间的&转为最初的&
HTML中的&用& 来表示,转发过程中需要用
StringEscapeUtils.unescapeHtml3(queryString)来反解，将& 还原为&

代码:

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.List;

import org.apache.commons.text.StringEscapeUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.annotation.Order;
import org.springframework.http.ContentDisposition;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.HttpStatusCode;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StreamUtils;
import org.springframework.web.client.RestTemplate;

import jakarta.annotation.Resource;
import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Component
@Order(2)
@Slf4j
public class ForwardFilter implements Filter {

    @Value("${ha.service.host:}")
    private String masterServiceHost;

    @Value("${server.servlet.context-path}")
    private String apiBasePath;

    @Resource
    private HighAvailableService highAvailableService;

    @Override
    public void doFilter(ServletRequest servletRequest,
                         ServletResponse servletResponse,
                         FilterChain filterChain)
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        if (request.getRequestURI().startsWith(apiBasePath) &&
            highAvailableService.isMasterAlive()) {
            // 转发请求
            try {
                final ResponseEntity<byte[]> responseEntity =
                        forward(request, response, masterServiceHost);
                HttpStatusCode statusCode = responseEntity.getStatusCode();
                if (statusCode.isError()) {
                    // get from self
                    filterChain.doFilter(servletRequest, servletResponse);
                } else {
                    // transfer response information
                    response.setContentType(
                            responseEntity.getHeaders().getContentType()
                                          .toString());
                    response.setContentLengthLong(
                            responseEntity.getHeaders().getContentLength());
                    response.setCharacterEncoding(
                            StandardCharsets.UTF_8.name());
                    response.setStatus(responseEntity.getStatusCodeValue());

                    final ContentDisposition contentDisposition =
                            responseEntity.getHeaders().getContentDisposition();
                    response.setHeader("Content-Disposition",
                                       contentDisposition.toString());

                    ServletOutputStream outputStream = response.getOutputStream();
                    outputStream.write(responseEntity.getBody());
                    outputStream.flush();
                    outputStream.close();
                }
            } catch (Exception e) {
                log.error("{}", e);
                response.setStatus(400);
                PrintWriter writer = response.getWriter();
                writer.write(e.getClass().getName());
                writer.flush();
            }
        } else {
            filterChain.doFilter(servletRequest, servletResponse);
        }
    }

    public ResponseEntity<byte[]> forward(HttpServletRequest request,
                                          HttpServletResponse response,
                                          String routeUrl) {
        try {
            // build up the forward URL
            String forwardUrl = createForwardUrl(request, routeUrl);
            RequestEntity requestEntity =
                    createRequestEntity(request, forwardUrl);
            return route(requestEntity);
        } catch (Exception e) {
            return new ResponseEntity("FORWARD ERROR",
                                      HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    private String createForwardUrl(HttpServletRequest request,
                                    String routeUrl) {
        String queryString = request.getQueryString();
        final String decode = StringEscapeUtils.unescapeHtml3(queryString);
        String requestURI = request.getRequestURI();
        return routeUrl + requestURI + (decode != null ?
                                                "?" + decode : "");
    }

    private RequestEntity createRequestEntity(HttpServletRequest request,
                                              String url)
            throws URISyntaxException, IOException {
        String method = request.getMethod();
        HttpMethod httpMethod = HttpMethod.valueOf(method);
        MultiValueMap<String, String> headers = parseRequestHeader(request);
        byte[] body = parseRequestBody(request);
        return new RequestEntity<>(body, headers, httpMethod, new URI(url));
    }

    private ResponseEntity<byte[]> route(RequestEntity requestEntity) {
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate.exchange(requestEntity, byte[].class);
    }

    private byte[] parseRequestBody(HttpServletRequest request)
            throws IOException {
        InputStream inputStream = request.getInputStream();
        return StreamUtils.copyToByteArray(inputStream);
    }

    private MultiValueMap<String, String> parseRequestHeader(
            HttpServletRequest request) {
        HttpHeaders headers = new HttpHeaders();
        List<String> headerNames = Collections.list(request.getHeaderNames());
        for (String headerName : headerNames) {
            List<String> headerValues =
                    Collections.list(request.getHeaders(headerName));
            for (String headerValue : headerValues) {
                headers.add(headerName, headerValue);
            }
        }
        return headers;
    }

}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161