Herstellen einer Verbindung zu einer Remote-URL, für die eine Authentifizierung mit Java erforderlich ist

Wie verbinde ich mich mit einer Remote-URL in Java, für die eine Authentifizierung erforderlich ist? Ich versuche einen Weg zu finden, den folgenden Code zu ändern, um programmgesteuert einen Benutzernamen / ein Passwort eingeben zu können, damit kein 401 ausgelöst wird.

URL url = new URL(String.format("http://%s/manager/list", _host + ":8080"));
HttpURLConnection connection = (HttpURLConnection)url.openConnection();

Sie können den Standardauthentifizierer für http-Anforderungen wie folgt festlegen:

Authenticator.setDefault (new Authenticator() {
    protected PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication ("username", "password".toCharArray());
    }
});

Wenn Sie mehr Flexibilität benötigen, können Sie sich auch den Apache HttpClient ansehen , der Ihnen mehr Authentifizierungsoptionen (sowie Sitzungsunterstützung usw.) bietet.

Es gibt eine native und weniger aufdringliche Alternative, die nur für Ihren Anruf funktioniert.

URL url = new URL(“location address”);
URLConnection uc = url.openConnection();
String userpass = username + ":" + password;
String basicAuth = "Basic " + new String(Base64.getEncoder().encode(userpass.getBytes()));
uc.setRequestProperty ("Authorization", basicAuth);
InputStream in = uc.getInputStream();

Sie können auch Folgendes verwenden, für das keine externen Pakete erforderlich sind:

URL url = new URL(“location address”);
URLConnection uc = url.openConnection();

String userpass = username + ":" + password;
String basicAuth = "Basic " + javax.xml.bind.DatatypeConverter.printBase64Binary(userpass.getBytes());

uc.setRequestProperty ("Authorization", basicAuth);
InputStream in = uc.getInputStream();

Wenn Sie die normale Anmeldung verwenden, während Sie den Benutzernamen und das Kennwort zwischen dem Protokoll und der Domäne eingeben, ist dies einfacher. Es funktioniert auch mit und ohne Login.

Beispiel-URL: http: // user: [email protected]/url

URL url = new URL("http://user:[email protected]/url");
URLConnection urlConnection = url.openConnection();

if (url.getUserInfo() != null) {
    String basicAuth = "Basic " + new String(new Base64().encode(url.getUserInfo().getBytes()));
    urlConnection.setRequestProperty("Authorization", basicAuth);
}

InputStream inputStream = urlConnection.getInputStream();

Bitte beachten Sie im Kommentar von valerybodak unten, wie es in einer Android-Entwicklungsumgebung gemacht wird.

Da ich hierher gekommen bin, um eine Android-Java-Antwort zu suchen, werde ich eine kurze Zusammenfassung machen:

1. Verwenden Sie java.net.Authenticator, wie von James van Huis gezeigt
2. Verwenden Sie den Apache Commons HTTP-Client wie in dieser Antwort
3. Verwenden Sie die grundlegende java.net.URLConnection und setzen Sie den Authentifizierungs-Header manuell wie hier gezeigt

Wenn Sie java.net.URLConnection mit Standardauthentifizierung in Android verwenden möchten, versuchen Sie diesen Code:

URL url = new URL("http://www.mywebsite.com/resource");
URLConnection urlConnection = url.openConnection();
String header = "Basic " + new String(android.util.Base64.encode("user:pass".getBytes(), android.util.Base64.NO_WRAP));
urlConnection.addRequestProperty("Authorization", header);
// go on setting more request headers, reading the response, etc

Konnte die Authentifizierung über die HttpsURLConnection einstellen

           URL myUrl = new URL(httpsURL);
            HttpsURLConnection conn = (HttpsURLConnection)myUrl.openConnection();
            String userpass = username + ":" + password;
            String basicAuth = "Basic " + new String(Base64.getEncoder().encode(userpass.getBytes()));
            //httpsurlconnection
            conn.setRequestProperty("Authorization", basicAuth);

Einige der Änderungen wurden aus diesem Beitrag abgerufen. und Base64 stammt aus dem Paket java.util.

Seien Sie sehr vorsichtig mit dem Ansatz "Base64 (). Encode ()". Mein Team und ich haben 400 Probleme mit fehlerhaften Apache-Anforderungen, da am Ende der generierten Zeichenfolge ein \ r \ n hinzugefügt wird.

Wir fanden es dank Wireshark, Pakete zu schnüffeln.

Hier ist unsere Lösung:

import org.apache.commons.codec.binary.Base64;

HttpGet getRequest = new HttpGet(endpoint);
getRequest.addHeader("Authorization", "Basic " + getBasicAuthenticationEncoding());

private String getBasicAuthenticationEncoding() {

        String userPassword = username + ":" + password;
        return new String(Base64.encodeBase64(userPassword.getBytes()));
    }

Ich hoffe es hilft!

Verwenden Sie diesen Code für die Basisauthentifizierung.

URL url = new URL(path);
String userPass = "username:password";
String basicAuth = "Basic " + Base64.encodeToString(userPass.getBytes(), Base64.DEFAULT);//or
//String basicAuth = "Basic " + new String(Base64.encode(userPass.getBytes(), Base64.No_WRAP));
HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();
urlConnection.setRequestProperty("Authorization", basicAuth);
urlConnection.connect();

Ich möchte eine Antwort für den Fall geben, dass Sie keine Kontrolle über den Code haben, der die Verbindung öffnet. Wie ich es getan habe, als ich URLClassLoadereine JAR-Datei von einem passwortgeschützten Server geladen habe.

Die AuthenticatorLösung würde funktionieren, hat jedoch den Nachteil, dass zuerst versucht wird, den Server ohne Kennwort zu erreichen, und erst, nachdem der Server nach einem Kennwort gefragt hat, eines bereitgestellt wird. Dies ist eine unnötige Rundreise, wenn Sie bereits wissen, dass der Server ein Kennwort benötigt.

public class MyStreamHandlerFactory implements URLStreamHandlerFactory {

    private final ServerInfo serverInfo;

    public MyStreamHandlerFactory(ServerInfo serverInfo) {
        this.serverInfo = serverInfo;
    }

    @Override
    public URLStreamHandler createURLStreamHandler(String protocol) {
        switch (protocol) {
            case "my":
                return new MyStreamHandler(serverInfo);
            default:
                return null;
        }
    }

}

public class MyStreamHandler extends URLStreamHandler {

    private final String encodedCredentials;

    public MyStreamHandler(ServerInfo serverInfo) {
        String strCredentials = serverInfo.getUsername() + ":" + serverInfo.getPassword();
        this.encodedCredentials = Base64.getEncoder().encodeToString(strCredentials.getBytes());
    }

    @Override
    protected URLConnection openConnection(URL url) throws IOException {
        String authority = url.getAuthority();
        String protocol = "http";
        URL directUrl = new URL(protocol, url.getHost(), url.getPort(), url.getFile());

        HttpURLConnection connection = (HttpURLConnection) directUrl.openConnection();
        connection.setRequestProperty("Authorization", "Basic " + encodedCredentials);

        return connection;
    }

}

Dadurch wird ein neues Protokoll registriert, mydas httpbeim Hinzufügen von Anmeldeinformationen ersetzt wird. So bei der Erstellung der neuen URLClassLoaderersetzen Sie einfach httpmit myund alles ist in Ordnung. Ich weiß, URLClassLoaderdass ein Konstruktor bereitgestellt wird, der eine verwendet, URLStreamHandlerFactoryaber diese Factory wird nicht verwendet, wenn die URL auf eine JAR-Datei verweist.

Seit Java 9 können Sie dies tun

URL url = new URL("http://www.example.com");
HttpURLConnection connection = (HttpURLConnection)url.openConnection();
connection.setAuthenticator(new Authenticator() {
    protected PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication ("USER", "PASS".toCharArray());
    }
});

ANDROD-UMSETZUNG Eine vollständige Methode zum Anfordern einer Daten- / Zeichenfolgenantwort vom Webdienst, der eine Autorisierung mit Benutzername und Kennwort anfordert

public static String getData(String uri, String userName, String userPassword) {
        BufferedReader reader = null;
        byte[] loginBytes = (userName + ":" + userPassword).getBytes();

        StringBuilder loginBuilder = new StringBuilder()
                .append("Basic ")
                .append(Base64.encodeToString(loginBytes, Base64.DEFAULT));

        try {
            URL url = new URL(uri);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.addRequestProperty("Authorization", loginBuilder.toString());

            StringBuilder sb = new StringBuilder();
            reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            while ((line = reader.readLine())!= null){
                sb.append(line);
                sb.append("\n");
            }

            return  sb.toString();

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            if (null != reader){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

Ich habe das so gemacht, dass du es tun musst, einfach kopieren, einfügen, glücklich sein

    HttpURLConnection urlConnection;
    String url;
 //   String data = json;
    String result = null;
    try {
        String username ="[email protected]";
        String password = "12345678";

        String auth =new String(username + ":" + password);
        byte[] data1 = auth.getBytes(UTF_8);
        String base64 = Base64.encodeToString(data1, Base64.NO_WRAP);
        //Connect
        urlConnection = (HttpURLConnection) ((new URL(urlBasePath).openConnection()));
        urlConnection.setDoOutput(true);
        urlConnection.setRequestProperty("Content-Type", "application/json");
        urlConnection.setRequestProperty("Authorization", "Basic "+base64);
        urlConnection.setRequestProperty("Accept", "application/json");
        urlConnection.setRequestMethod("POST");
        urlConnection.setConnectTimeout(10000);
        urlConnection.connect();
        JSONObject obj = new JSONObject();

        obj.put("MobileNumber", "+97333746934");
        obj.put("EmailAddress", "[email protected]");
        obj.put("FirstName", "Danish");
        obj.put("LastName", "Hussain");
        obj.put("Country", "BH");
        obj.put("Language", "EN");
        String data = obj.toString();
        //Write
        OutputStream outputStream = urlConnection.getOutputStream();
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream, "UTF-8"));
        writer.write(data);
        writer.close();
        outputStream.close();
        int responseCode=urlConnection.getResponseCode();
        if (responseCode == HttpsURLConnection.HTTP_OK) {
            //Read
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(urlConnection.getInputStream(), "UTF-8"));

        String line = null;
        StringBuilder sb = new StringBuilder();

        while ((line = bufferedReader.readLine()) != null) {
            sb.append(line);
        }

        bufferedReader.close();
        result = sb.toString();

        }else {
        //    return new String("false : "+responseCode);
        new String("false : "+responseCode);
        }

    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (JSONException e) {
        e.printStackTrace();
    }