The java.net package can be roughly divided in two sections:
*A Low Level API, which deals with the * following abstractions:
*Addresses, which are networking identifiers, * like IP addresses.
Sockets, which are basic bidirectional data communication * mechanisms.
Interfaces, which describe network interfaces.
A High Level API, which deals with the following * abstractions:
*URIs, which represent * Universal Resource Identifiers.
URLs, which represent * Universal Resource Locators.
Connections, which represents connections to the resource * pointed to by URLs.
Addresses are used throughout the java.net APIs as either host * identifiers, or socket endpoint identifiers.
*The {@link java.net.InetAddress} class is the abstraction representing an * IP (Internet Protocol) address. It has two subclasses: *
But, in most cases, there is no need to deal directly with the subclasses, * as the InetAddress abstraction should cover most of the needed * functionality.
*Not all systems have support for the IPv6 protocol, and while the Java * networking stack will attempt to detect it and use it transparently when * available, it is also possible to disable its use with a system property. * In the case where IPv6 is not available, or explicitly disabled, * Inet6Address are not valid arguments for most networking operations any * more. While methods like {@link java.net.InetAddress#getByName} are * guaranteed not to return an Inet6Address when looking up host names, it * is possible, by passing literals, to create such an object. In which * case, most methods, when called with an Inet6Address will throw an * Exception.
*Sockets are means to establish a communication link between machines over * the network. The java.net package provides 4 kinds of Sockets:
*Sending and receiving with TCP sockets is done through InputStreams and * OutputStreams which can be obtained via the * {@link java.net.Socket#getInputStream} and * {@link java.net.Socket#getOutputStream} methods.
*The {@link java.net.NetworkInterface} class provides APIs to browse and * query all the networking interfaces (e.g. ethernet connection or PPP * endpoint) of the local machine. It is through that class that you can * check if any of the local interfaces is configured to support IPv6.
*Note, all conforming implementations must support at least one * {@code NetworkInterface} object, which must either be connected to a * network, or be a "loopback" interface that can only communicate with * entities on the same machine.
* *A number of classes in the java.net package do provide for a much higher * level of abstraction and allow for easy access to resources on the * network. The classes are: *
The recommended usage is to use {@link java.net.URI} to identify * resources, then convert it into a {@link java.net.URL} when it is time to * access the resource. From that URL, you can either get the * {@link java.net.URLConnection} for fine control, or get directly the * InputStream. *
Here is an example:
*
* URI uri = new URI("http://java.sun.com/");
* URL url = uri.toURL();
* InputStream in = url.openStream();
*
* By default the protocol handlers are loaded dynamically from the default * location. It is, however, possible to add to the search path by setting * the {@code java.protocol.handler.pkgs} system property. For instance if * it is set to {@code myapp.protocols}, then the URL code will try, in the * case of http, first to load {@code myapp.protocols.http.Handler}, then, * if this fails, {@code http.Handler} from the default location. *
Note that the Handler class has to be a subclass of the abstract * class {@link java.net.URLStreamHandler}.
*