Authenticator class in Java

java.net.Authenticator

The class Authenticator represents an object that knows how to obtain authentication for a network connection. Usually, it will do this by prompting the user for information.

Applications use this class by overriding getPasswordAuthentication() in a sub-class. This method will typically use the various getXXX() accessor methods to get information about the entity requesting authentication. It must then acquire a username and password either by interacting with the user or through some other non-interactive means. The credentials are then returned as a PasswordAuthentication return value.

All methods that request authentication has a default implementation that fails.

Declaration

public abstract class Authenticator {

    private static volatile Authenticator theAuthenticator;

    private String requestingHost;
    private InetAddress requestingSite;
    private int requestingPort;
    private String requestingProtocol;
    private String requestingPrompt;
    private String requestingScheme;
    private URL requestingURL;
    private RequestorType requestingAuthType;
    private final String key = AuthenticatorKeys.computeKey(this);

    public enum RequestorType {

        PROXY,

        SERVER
    }

    private void reset() {
        requestingHost = null;
        requestingSite = null;
        requestingPort = -1;
        requestingProtocol = null;
        requestingPrompt = null;
        requestingScheme = null;
        requestingURL = null;
        requestingAuthType = RequestorType.SERVER;
    }

    public static synchronized void setDefault(Authenticator a) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            NetPermission setDefaultPermission = new NetPermission("setDefaultAuthenticator");
            sm.checkPermission(setDefaultPermission);
        }

        theAuthenticator = a;
    }

    public static Authenticator getDefault() {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            NetPermission requestPermission = new NetPermission("requestPasswordAuthentication");
            sm.checkPermission(requestPermission);
        }
        return theAuthenticator;
    }

    public static PasswordAuthentication requestPasswordAuthentication(InetAddress addr, int port, String protocol,
            String prompt, String scheme) {

        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            NetPermission requestPermission = new NetPermission("requestPasswordAuthentication");
            sm.checkPermission(requestPermission);
        }

        Authenticator a = theAuthenticator;
        if (a == null) {
            return null;
        } else {
            synchronized (a) {
                a.reset();
                a.requestingSite = addr;
                a.requestingPort = port;
                a.requestingProtocol = protocol;
                a.requestingPrompt = prompt;
                a.requestingScheme = scheme;
                return a.getPasswordAuthentication();
            }
        }
    }

    public static PasswordAuthentication requestPasswordAuthentication(String host, InetAddress addr, int port,
            String protocol, String prompt, String scheme) {

        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            NetPermission requestPermission = new NetPermission("requestPasswordAuthentication");
            sm.checkPermission(requestPermission);
        }

        Authenticator a = theAuthenticator;
        if (a == null) {
            return null;
        } else {
            synchronized (a) {
                a.reset();
                a.requestingHost = host;
                a.requestingSite = addr;
                a.requestingPort = port;
                a.requestingProtocol = protocol;
                a.requestingPrompt = prompt;
                a.requestingScheme = scheme;
                return a.getPasswordAuthentication();
            }
        }
    }

    public static PasswordAuthentication requestPasswordAuthentication(String host, InetAddress addr, int port,
            String protocol, String prompt, String scheme, URL url, RequestorType reqType) {

        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            NetPermission requestPermission = new NetPermission("requestPasswordAuthentication");
            sm.checkPermission(requestPermission);
        }

        Authenticator a = theAuthenticator;
        if (a == null) {
            return null;
        } else {
            synchronized (a) {
                a.reset();
                a.requestingHost = host;
                a.requestingSite = addr;
                a.requestingPort = port;
                a.requestingProtocol = protocol;
                a.requestingPrompt = prompt;
                a.requestingScheme = scheme;
                a.requestingURL = url;
                a.requestingAuthType = reqType;
                return a.getPasswordAuthentication();
            }
        }
    }

    public static PasswordAuthentication requestPasswordAuthentication(Authenticator authenticator, String host,
            InetAddress addr, int port, String protocol, String prompt, String scheme, URL url, RequestorType reqType) {

        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            NetPermission requestPermission = new NetPermission("requestPasswordAuthentication");
            sm.checkPermission(requestPermission);
        }

        Authenticator a = authenticator == null ? theAuthenticator : authenticator;
        if (a == null) {
            return null;
        } else {
            return a.requestPasswordAuthenticationInstance(host, addr, port, protocol, prompt, scheme, url, reqType);
        }
    }

    public PasswordAuthentication requestPasswordAuthenticationInstance(String host, InetAddress addr, int port,
            String protocol, String prompt, String scheme, URL url, RequestorType reqType) {
        synchronized (this) {
            this.reset();
            this.requestingHost = host;
            this.requestingSite = addr;
            this.requestingPort = port;
            this.requestingProtocol = protocol;
            this.requestingPrompt = prompt;
            this.requestingScheme = scheme;
            this.requestingURL = url;
            this.requestingAuthType = reqType;
            return this.getPasswordAuthentication();
        }
    }

    protected final String getRequestingHost() {
        return requestingHost;
    }

    protected final InetAddress getRequestingSite() {
        return requestingSite;
    }

    protected final int getRequestingPort() {
        return requestingPort;
    }

    protected final String getRequestingProtocol() {
        return requestingProtocol;
    }

    protected final String getRequestingPrompt() {
        return requestingPrompt;
    }

    protected final String getRequestingScheme() {
        return requestingScheme;
    }

    protected PasswordAuthentication getPasswordAuthentication() {
        return null;
    }

    protected URL getRequestingURL() {
        return requestingURL;
    }

    protected RequestorType getRequestorType() {
        return requestingAuthType;
    }

    static String getKey(Authenticator a) {
        return a.key;
    }

    static {
        AuthenticatorKeys.setAuthenticatorKeyAccess(Authenticator::getKey);
    }
}

Some methods of Authenticator class

getDefault(): This method gets the default authenticator.

Authenticator.requestPasswordAuthentication(InetAddress, int, String, String, String): This method asks the authenticator that has been registered with the system for a password.

Authenticator.requestPasswordAuthentication(String, InetAddress, int, String, String, String): This method asks the authenticator that has been registered with the system for a password. This is the preferred method for requesting a password because the hostname can be provided in cases where the InetAddressis not available.

Authenticator.requestPasswordAuthentication(String, InetAddress, int, String, String, String, URL, RequestorType): This method asks the authenticator that has been registered with the system for a password.

Authenticator.requestPasswordAuthentication(Authenticator, String, InetAddress, int, String, String, String, URL, RequestorType): This method asks the given authenticator for a password. If the given authenticator is null, the authenticator, if any, that has been registered with the system using setDefault is used.

Authenticator.requestPasswordAuthenticationInstance(String, InetAddress, int, String, String, String, URL, RequestorType): This method asks this authenticator for a password.

setDefault(Authenticator): This method sets the authenticator that will be used by the networking code when a proxy or an HTTP server asks for authentication.

Some other classes/interfaces of java.net

Authenticator: The class Authenticator represents an object that knows how to obtain authentication for a network connection.

BindException: Signals that an error occurred while attempting to bind a socket to a local address and port. 

CacheRequest: Represents channels for storing resources in the ResponseCache.

CacheResponse: Represent channels for retrieving resources from the ResponseCache.

ConnectException: Signals that an error occurred while attempting to connect a socket to a remote address and port.

ContentHandler: The abstract class ContentHandler is the superclass of all classes that read an Object from a URLConnection.

ContentHandlerFactory: This interface defines a factory for content handlers. Implementing this interface should map a MIME type into an instance of ContentHandler.

CookieHandler: A CookieHandler object provides a callback mechanism to hook up an HTTP state management policy implementation into the HTTP protocol handler.

CookieManager: CookieManager provides a concrete implementation of CookieHandler, which separates the storage of cookies from the policy surrounding accepting and rejecting cookies. 

CookiePolicy: CookiePolicy implementations decide which cookies should be accepted and which should be rejected.

CookieStore: A CookieStore object represents storage for cookies. Can store and retrieve cookies.

DatagramPacket: This class represents a datagram packet.