我能'；t使用java以302响应登录弹性搜索，但它与postman一起工作

事实上，我想在没有kibana的情况下直接访问ElasticSearch。我使用Java来设计这个过程。当我使用postman测试登录步骤时，在标题中使用token和

kbnxsrf

（这里显示的图片：） ，我可以从邮递员那里得到结果。 然而，当我使用Java设计这个过程时，302失败了。我尝试了

RequestEntity

方法和

WebClient

方法，两种方法都失败了（如图所示）。任何人都可以帮助解决这个问题，非常感谢

package com.sap.ngom.collection.client;

import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLEncoder;

import org.cloudfoundry.uaa.tokens.AbstractToken;
import org.cloudfoundry.uaa.tokens.GetTokenByPasswordResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestOperations;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;


@Service
public class ElasticSearchClient {

    private static final String CF_TOKEN_URL = "https://uaa.cf.us10.hana.ondemand.com";
    private static final String CF_LOGS_URL = "https://logs.cf.us10.hana.ondemand.com";
    private static ObjectMapper mapper = new ObjectMapper();

    String username = System.getenv("USER");
    String password = System.getenv("PWD");
    String token = "";

    @Autowired
    private RestOperations restOperations;

    public JsonNode getLogsByElasticSearch() throws JsonParseException, JsonMappingException, IOException{

        String query = mapper.readValue(new File(getFileURI("/query.json")), JsonNode.class).toString();
        String index = mapper.readValue(new File(getFileURI("/index.json")), JsonNode.class).toString();        
        String queryBody = index + "\n" + query + "\n" + index + "\n" + query;      

        ResponseEntity responseEntity = retrieveLog(queryBody);

        if (responseEntity.getStatusCode() == HttpStatus.FOUND){

            dealWithRedirect(responseEntity);
        }

        return null;
    }

    private void dealWithRedirect(ResponseEntity responseEntity){
        HttpHeaders responseHeaders = responseEntity.getHeaders();
        String loction = responseHeaders.get("Location").toString();
        String loginUrl = loction.substring(1, loction.length()-1);

        String setCookie = responseHeaders.get("Set-Cookie").toString();
        setCookie = setCookie.substring(1, loction.length()-1);

        HttpHeaders loginHeaders = new HttpHeaders();
        loginHeaders.set("Cookie", setCookie);
        loginHeaders.set(HttpHeaders.AUTHORIZATION, "Basic Y2Y6");
        loginHeaders.setContentType(MediaType.APPLICATION_FORM_URLENCODED); 

        String body = "grant_type=password&username=jane.wang03@sap.com&password="+ System.getenv("PWD") + "&response_type=user_token";

        RequestEntity<String> loginRequestEntity = new RequestEntity<>(body, loginHeaders, HttpMethod.POST, URI.create(loginUrl));
        ResponseEntity loginResponse = restOperations.exchange(loginRequestEntity, Object.class);

        String temp = "";
    }

    private void passAuthentication(String state){
        String url = CF_TOKEN_URL + "/oauth/authorize?grant_type=authorization_code&client_id=sleeve-app-logs&response_type=code&state=" + state;

        HttpHeaders headers = new HttpHeaders();
        headers.set(HttpHeaders.AUTHORIZATION, "bearer " + token);

        RequestEntity<String> requestEntity = new RequestEntity<>(headers, HttpMethod.GET, URI.create(url));

        HttpStatus responseEntity = restOperations.exchange(requestEntity, Object.class).getStatusCode();        
    }


    private ResponseEntity retrieveLog(String queryBody){

        if (token == ""){
            token = getToken();
        }

        HttpHeaders headers = new HttpHeaders();
        headers.set(HttpHeaders.AUTHORIZATION, "bearer " + token);
        headers.set("kbn-xsrf", "reporting");  

        String url = CF_LOGS_URL + "/elasticsearch/_msearch";
        RequestEntity<String> requestEntity = new RequestEntity<>(queryBody, headers, HttpMethod.POST, URI.create(url));
        ResponseEntity responseEntity = restOperations.exchange(requestEntity, Object.class);

        return responseEntity;
    }


    private String getToken() {

        String body = "grant_type=password";
        try {
            body += "&username=" + URLEncoder.encode(username, "UTF-8");
            body += "&password=" + URLEncoder.encode(password, "UTF-8");
            body += "&response_type=user_token";
        } catch (UnsupportedEncodingException ex) {
            throw new RuntimeException(ex);
        }

        HttpHeaders headers = new HttpHeaders();
        headers.set(HttpHeaders.AUTHORIZATION, "Basic Y2Y6");
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);       

        RequestEntity<String> requestEntity = new RequestEntity<>(body, headers, HttpMethod.POST, URI.create(CF_TOKEN_URL + "/oauth/token"));
        ResponseEntity<GetTokenByPasswordResponse> responseEntity = restOperations.exchange(requestEntity, GetTokenByPasswordResponse.class);
        AbstractToken token = responseEntity.getBody();              

        return token.getAccessToken();
    }


    private URI getFileURI(String path) {        
        URL ruleURL = ElasticSearchClient.class.getResource(path);
        URI uri = null;

        try {
            uri = ruleURL.toURI();
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
        return uri;
    }
}

package com.sap.ngom.collection.client；
导入java.io.File；
导入java.io.IOException；
导入java.io.UnsupportedEncodingException；
导入java.net.URI；
导入java.net.URISyntaxException；
导入java.net.URL；
导入java.net.urlcoder；
导入org.cloudfoundry.uaa.tokens.AbstractToken；
导入org.cloudfoundry.uaa.tokens.GetTokenByPasswordResponse；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.http.HttpHeaders；
导入org.springframework.http.HttpMethod；
导入org.springframework.http.HttpStatus；
导入org.springframework.http.MediaType；
导入org.springframework.http.RequestEntity；
导入org.springframework.http.ResponseEntity；
导入org.springframework.stereotype.Service；
导入org.springframework.web.client.rest操作；
导入com.fasterxml.jackson.core.JsonParseException；
导入com.fasterxml.jackson.databind.JsonMappingException；
导入com.fasterxml.jackson.databind.JsonNode；
导入com.fasterxml.jackson.databind.ObjectMapper；
@服务
公共类ElasticSearchClient{
私有静态最终字符串CF_TOKEN_URL=”https://uaa.cf.us10.hana.ondemand.com";
私有静态最终字符串CF_LOGS_URL=”https://logs.cf.us10.hana.ondemand.com";
私有静态ObjectMapper mapper=新ObjectMapper（）；
字符串username=System.getenv（“用户”）；
字符串密码=System.getenv（“PWD”）；
字符串标记=”；
@自动连线
私人经营；
public JsonNode getLogsByElasticSearch（）抛出JsonParseException、JsonMappingException、IOException{
String query=mapper.readValue（新文件（getFileURI（“/query.json”）），JsonNode.class.toString（）；
String index=mapper.readValue（新文件（getFileURI（“/index.json”）），JsonNode.class.toString（）；
字符串queryBody=index+“\n”+query+“\n”+index+“\n”+query；
ResponseEntity ResponseEntity=检索速度（查询体）；
if（responseEntity.getStatusCode（）==HttpStatus.FOUND）{
处理重定向（responseEntity）；
}
返回null；
}
私有无效处理重定向（ResponseEntity ResponseEntity）{
HttpHeaders responseHeaders=responseEntity.getHeaders（）；
字符串位置=responseHeaders.get（“位置”）.toString（）；
String loginUrl=loction.substring（1，loction.length（）-1）；
字符串setCookie=responseHeaders.get（“Set Cookie”）.toString（）；
setCookie=setCookie.substring（1，location.length（）-1）；
HttpHeaders loginHeaders=新的HttpHeaders（）；
loginHeaders.set（“Cookie”，setCookie）；
loginHeaders.set（HttpHeaders.AUTHORIZATION，“基本Y2Y6”）；
loginHeaders.setContentType（MediaType.APPLICATION\u FORM\u URLENCODED）；
String body=“grant\u type=password&username=jane。wang03@sap.com&password=“+System.getenv（“PWD”）+”&response\u type=user\u token”；
RequestEntity loginRequestEntity=新的RequestEntity（主体、登录头、HttpMethod.POST、URI.create（loginUrl））；
ResponseEntity loginResponse=restOperations.exchange（loginRequestEntity，Object.class）；
字符串temp=“”；
}
私有无效身份验证（字符串状态）{
字符串url=CF_TOKEN_url+“/oauth/authorize？grant_type=authorization_code&client_id=sleeve app logs&response_type=code&state=“+state；
HttpHeaders=新的HttpHeaders（）；
headers.set（HttpHeaders.AUTHORIZATION，“承载者”+令牌）；
RequestEntity RequestEntity=新的RequestEntity（headers，HttpMethod.GET，URI.create（url））；
HttpStatus responseEntity=restOperations.exchange（requestEntity，Object.class）.getStatusCode（）；
}
私有响应性检索（字符串查询体）{
如果（令牌==“”）{
token=getToken（）；
}
HttpHeaders=新的HttpHeaders（）；
headers.set（HttpHeaders.AUTHORIZATION，“承载者”+令牌）；
标题集（“kbn xsrf”、“报告”）；
字符串url=CF_LOGS_url+“/elasticsearch/_msearch”；
RequestEntity RequestEntity=newRequestEntity（queryBody，headers，HttpMethod.POST，URI.create（url））；
ResponseEntity ResponseEntity=restOperations.exchange（requestEntity，Object.class）；
返回响应性；
}
私有字符串getToken（）{
String body=“授权类型=密码”；
试一试{
body+=“&username=“+urlcoder.encode（用户名，“UTF-8”）；
body+=“&password=“+urlcoder.encode（密码，“UTF-8”）；
body+=“&response\u type=user\u-token”；
}捕获（不支持DencodingException ex）{
抛出新的运行时异常（ex）；
}
HttpHeaders=新的HttpHeaders（）；
headers.set（HttpHeaders.AUTHORIZATION，“基本Y2Y6”）；
headers.setContentType（MediaType.APPLICATION\u FORM\u URLENCODED）；
RequestEntity RequestEntity=新的RequestEntity（正文、标题、HttpMethod.POST、URI.create（CF_TOKEN_URL+“/oauth/TOKEN”）；
ResponseEntity ResponseEntity=restOperations.exchange（requestEntity，GetTokenByPasswordResponse.class）；
AbstractToken-token=responseEntity.getBody（）；
返回token.getAccessToken（）；
}
私有URI getFileURI（字符串路径）{
URL ruleURL=ElasticSearchClient.class.getResource（路径）；
URI=null；
试一试{
uri=ruleURL.toURI（）；
}捕捉