Достучаться через прокси с помощью сертификата (и прочего)

Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(hostname, port));
 
URL url = new URL(urlString);
HttpsURLConnection conn = (HttpsURLConnection) url.openConnection(proxy);
 
BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
try (in) {
    return in.lines().reduce(new StringBuffer(), StringBuffer::append, null).toString().trim();
} catch (RuntimeException e) {
    e.printStackTrace();
    //throw e;
}

Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(hostname, port));
 
String certt = ReadFlNew("C:\\Users\\qqluser\\Downloads\\cert.txt");
ByteArrayInputStream derInputStream = new ByteArrayInputStream(certt.getBytes());
CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
X509Certificate cert = (X509Certificate) certificateFactory.generateCertificate(derInputStream);
String alias = "alias";//cert.getSubjectX500Principal().getName();
 
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
trustStore.load(null);
trustStore.setCertificateEntry(alias, cert);
KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
kmf.init(trustStore, null);
KeyManager[] keyManagers = kmf.getKeyManagers();
 
TrustManagerFactory tmf = TrustManagerFactory.getInstance("X509");
tmf.init(trustStore);
TrustManager[] trustManagers = tmf.getTrustManagers();
 
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(keyManagers, trustManagers, null);
 
URL url = new URL(urlString);
HttpsURLConnection conn = (HttpsURLConnection) url.openConnection(proxy);
//conn.setSSLSocketFactory(sslContext.getSocketFactory());
 
BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
try (in) {
    return in.lines().reduce(new StringBuffer(), StringBuffer::append, null).toString().trim();
} catch (RuntimeException e) {
    e.printStackTrace();
    //throw e;
}

TrustManager[] trustAllCerts = new TrustManager[] {
        new X509TrustManager() {
          public java.security.cert.X509Certificate[] getAcceptedIssuers() {
           return null;
          }
          @Override
          public void checkClientTrusted(X509Certificate[] arg0, String arg1)
           throws CertificateException {}
 
          @Override
          public void checkServerTrusted(X509Certificate[] arg0, String arg1)
            throws CertificateException {}
          }
     };
 
  SSLContext sc=null;
  try {
   sc = SSLContext.getInstance("SSL");
  } catch (NoSuchAlgorithmException e) {
   e.printStackTrace();
  }
  try {
   sc.init(null, trustAllCerts, new java.security.SecureRandom());
  } catch (KeyManagementException e) {
   e.printStackTrace();
  }
  HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
  // Create all-trusting host name verifier
  HostnameVerifier validHosts = new HostnameVerifier() {
  @Override
  public boolean verify(String arg0, SSLSession arg1) {
   return true;
  }
  };
  // All hosts will be valid
  HttpsURLConnection.setDefaultHostnameVerifier(validHosts);

SSLContext context = SSLContext.getInstance("TLSv1.2");
TrustManager[] trustManager = new TrustManager[] {
    new X509TrustManager() {
       public X509Certificate[] getAcceptedIssuers() {
           return new X509Certificate[0];
       }
       public void checkClientTrusted(X509Certificate[] certificate, String str) {}
       public void checkServerTrusted(X509Certificate[] certificate, String str) {}
    }
};
context.init(null, trustManager, new SecureRandom());
 
HttpsURLConnection.setDefaultSSLSocketFactory(context.getSocketFactory());

//conn.setSSLSocketFactory(sslContext.getSocketFactory());

TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
                public void checkClientTrusted(X509Certificate[] certs, String authType) {}
                public void checkServerTrusted(X509Certificate[] certs, String authType) {}
            } };
            HostnameVerifier allHostsValid = new HostnameVerifier() {
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            };
            SSLContext sc = SSLContext.getInstance("SSL"); 
            sc.init(null, trustAllCerts, new java.security.SecureRandom()); 
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
            HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);

public class DownloadWebService {
    public String createArgumentedUrl(String url, List<Pair<String, String>> args) throws RuntimeException {
        final String PH_QSTN = "?";
        final String PH_EQUAL = "=";
        final String PH_AMPR = "&";
 
        if (args != null) {
            StringBuffer sbf = args.stream().reduce(
                    new StringBuffer().append(url).append(PH_QSTN)
                    , (res, x) -> res.append(x.getLeft()).append(PH_EQUAL).append(x.getRight()).append(PH_AMPR)
                    , StringBuffer::append
            );
            sbf.deleteCharAt(sbf.length() - 1);
            return sbf.toString();
        }
        return url;
    }
 
    protected String send(String url, List<Pair<String, String>> header, HTTPRequestType reqType) {
        try {
            final String hostname = "bcpsg-moscow.headoffice.psbank.local";
            final int port = 8080;
            Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(hostname, port));
 
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null
                    , new TrustManager[]{
                            new X509TrustManager() {
                                @Override
                                public X509Certificate[] getAcceptedIssuers() {
                                    return null;
                                }
 
                                @Override
                                public void checkClientTrusted(X509Certificate[] certs, String authType) {
                                }
 
                                @Override
                                public void checkServerTrusted(X509Certificate[] certs, String authType) {
                                }
                            }
                    }, new java.security.SecureRandom()
            );
 
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
            HttpsURLConnection.setDefaultHostnameVerifier((hostname1, session) -> true);
            HttpsURLConnection conn = (HttpsURLConnection) new URL(url).openConnection(proxy);
            if (header != null) {
                header.forEach(x -> conn.setRequestProperty(x.getLeft(), x.getRight()));
            }
            conn.setRequestMethod(reqType.toString());
 
//            conn.getRequestProperties().forEach((x, l) -> {
//                String res = x + ' ' + l.stream().reduce("", (z, y) -> z + " " + y);
//                System.out.println(res);
//            });
 
            if (conn.getResponseCode() == HttpsURLConnection.HTTP_OK) {
                BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8));
                try (in) {
                    return in.lines().reduce(new StringBuffer(), StringBuffer::append, StringBuffer::append).toString().trim();
                }
            }
            conn.getHeaderFields().entrySet().stream().forEach((x) -> {
                //String res = x + ' ' + l.getValue().stream().reduce("", (z, y) -> z + " " + y);
                System.out.println(x);
            });
            //finally { in.close(); }
        } catch (NoSuchAlgorithmException | KeyManagementException | IOException e) {
            e.printStackTrace();
        }
        return null;
    }
 
    public String sendGet(String url, List<Pair<String, String>> header) {
        return send(url, header, HTTPRequestType.GET);
    }
 
    public String sendPost(String url, List<Pair<String, String>> header) {
        return send(url, header, HTTPRequestType.POST);
    }
 
    public <T> T parseJSON(String json, Class<T> classOfT) {
        try {
            return (
                    new GsonBuilder().registerTypeAdapter(
                            LocalDateTime.class
                            , (JsonDeserializer<LocalDateTime>) (json1, type, jsonDeserializationContext) ->
                                    LocalDateTime.parse(json1.getAsJsonPrimitive().getAsString(), DateTimeFormatter.ISO_LOCAL_DATE_TIME))
            )
                    .create()
                    .fromJson(json, classOfT);
        }
        catch (RuntimeException e){
            e.printStackTrace();
            return null;
        }
    }
}

public enum HTTPRequestType {
    GET("GET"),
    POST("POST");
 
    private String title;
 
    HTTPRequestType(String title) {
        this.title = title;
    }
 
    public String getTitle() {
        return title;
    }
 
    @Override
    public String toString() {
        return this.getTitle();
    }
}

public class Pair<L, R> {
    private final L left;
    private final R right;
 
    public Pair(L left, R right) {
        this.left = left;
        this.right = right;
    }
 
    public L getLeft() {
        return left;
    }
    public R getRight() {
        return right;
    }
 
    @Override
    public int hashCode() {
        return left.hashCode() ^ right.hashCode();
    }
 
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Pair)) return false;
        Pair pairo = (Pair) o;
        return this.left.equals(pairo.getLeft()) &&
                this.right.equals(pairo.getRight());
    }
}

public class GetYMetrics {
    protected final DownloadWebService dws = new DownloadWebService();
    protected final String token = "AgAAAAAUI50UAAXb-rzOPxeSKkoEiWvWngt_GCU"; // token: AgAAAAAUI50UAAXb-rzOPxeSKkoEiWvWngt_GCU
 
    // url: https://api-metrika.yandex.ru/management/v1/counter/{counter}/logrequests
    // https://api-metrika.yandex.ru/management/v1/counter/",counter,"/logrequests?date1=",date.from,"&date2=",date.to,"&fields=",fields,"&source=",source
    public void getYMetric(String url, String counter, LocalDate dFrom, LocalDate dTo, String fields, String source){
        counter = counter == null ? "52380802" : counter;
        url = url == null
                ? "https://api-metrika.yandex.ru/management/v1/counter/{counter}/logrequests".replace("{counter}", counter)
                : url;
        final LocalDate dFromF = dFrom == null ? LocalDate.now().plusDays(-10) : dFrom;
        final LocalDate dToF = dTo == null ? LocalDate.now().plusDays(-1) : dTo;
        final String fieldsF = fields == null
                ? "ym:s:date,ym:s:counterID,ym:s:dateTime,ym:s:isNewUser,ym:s:startURL,ym:s:visitDuration,ym:s:ipAddress,ym:s:referer"
                : fields;
        final String sourceF = source == null ? "visits" : source;
 
        try {
            String argumentedUrl = dws.createArgumentedUrl(url
                    , Arrays.asList(
                            new Pair<>("date1", dFromF.toString())
                            , new Pair<>("date2", dToF.toString())
                            , new Pair<>("fields", fieldsF)
                            , new Pair<>("source", sourceF)
                    )
            );
            System.out.println(argumentedUrl);
            //String res = dws.sendGet(
            String res = dws.sendPost(argumentedUrl
                    , Arrays.asList(
                            new Pair<>("Host", "api-metrika.yandex.net")
                            , new Pair<>("Authorization", "OAuth " + token)
                            , new Pair<>("Content-Type", "application/x-yametrika+json")
                    )
            );
            System.out.println(res);
        } catch (RuntimeException e) {
            e.printStackTrace();
        }
    }
}

public class MyClass {
    public static void main(String args[]) {
      System.out.println(Gaga.Lala);
    }
}
 
enum Gaga { Lala, Tata }

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.URL;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
 
public class Yandex {
    //----vvv
    public static void main(String[] args) {
        new Yandex();
    }
    
    private Yandex() {
        String fields = "ym:s:date,ym:s:counterID,ym:s:dateTime,ym:s:isNewUser,"
                + "ym:s:startURL,ym:s:visitDuration,ym:s:ipAddress,ym:s:referer";
        System.out.println(getResponseString("52380802", "2019-10-01", "2019-10-10", fields, "visits"));
    }
    //код выше для демонтсрации работы, чтобы запускать класс без других
    //----^^^
    public String getResponseString(String counter, String date1, String date2, String fields, String source) {
        String url = buildURL(counter, date1, date2, fields, source);
        return getResponse(url);
    }
    
    private String buildURL(String counter, String date1, String date2, String fields, String source) {
        String baseURL = "https://api-metrika.yandex.net/management/v1/counter/";
        return String.format("%s%s/logrequests?date1=%s&date2=%s&fields=%s&source=%s", baseURL, counter, date1, date2, fields, source);
    }
    
    private String getResponse(String url) {
        String token = ""; //place token here
        try {
            HttpsURLConnection connection = connect(url);
            connection.setRequestProperty("Content-Type", "application/x-yametrika+json");
            connection.setRequestProperty("Authorization", "OAuth " + token);
            //connection.setRequestMethod("POST"); //если не будет работать
            if (connection.getResponseCode() == 200) {
                return inputstreamToString(connection.getInputStream());
                //return IOUtils.toString(inputStream, StandardCharsets.UTF_8); //if use Apache Commons
            } else {
                System.out.println("Response code: " + connection.getResponseCode());
                return "Error1";
            }
        } catch (NoSuchAlgorithmException | KeyManagementException | IOException e) {
            e.printStackTrace();
            return "Error2";
        }
    }
    
    private String inputstreamToString(InputStream is) throws IOException {
        ByteArrayOutputStream result = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int length;
        while ((length = is.read(buffer)) != -1) {
            result.write(buffer, 0, length);
        }
        return result.toString("UTF-8");
    }
    
    private HttpsURLConnection connect(String urlstr) throws NoSuchAlgorithmException, KeyManagementException, IOException {
        String hostname = "bcpsg-moscow.headoffice.psbank.local";
        int port = 8080;
        Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(hostname, port));
        TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };
        SSLContext sc = SSLContext.getInstance("SSL"); 
        sc.init(null, trustAllCerts, new SecureRandom());
        HttpsURLConnection connection =  (HttpsURLConnection)(new URL(urlstr).openConnection(proxy));
        connection.setSSLSocketFactory(sc.getSocketFactory());
        connection.setHostnameVerifier((hostname1, session) -> true);
        return connection;
    }
 
}

HttpsURLConnection.setDefaultSSLSocketFactory();
HttpsURLConnection.setDefaultHostnameVerifier();
//заменил на
connection.setSSLSocketFactory();
connection.setHostnameVerifier();

byte out[] = "".getBytes();
connection.setDoInput(true);
connection.setRequestProperty("Content-Length", out.length + "");
connection.getOutputStream().write(out);