Java Language
Networking
Ricerca…
Sintassi
- nuovo Socket ("localhost", 1234); // Si connette a un server all'indirizzo "localhost" e alla porta 1234
- nuovo SocketServer ("localhost", 1234); // Crea un server socket in grado di ascoltare nuovi socket all'indirizzo localhost e sulla porta 1234
- socketServer.accept (); // Accetta un nuovo oggetto Socket che può essere utilizzato per comunicare con il client
Comunicazione client e server di base tramite socket
Server: avviare e attendere le connessioni in entrata
//Open a listening "ServerSocket" on port 1234.
ServerSocket serverSocket = new ServerSocket(1234);
while (true) {
// Wait for a client connection.
// Once a client connected, we get a "Socket" object
// that can be used to send and receive messages to/from the newly
// connected client
Socket clientSocket = serverSocket.accept();
// Here we'll add the code to handle one specific client.
}
Server: gestione dei client
Gestiremo ciascun client in un thread separato in modo che più client possano interagire con il server contemporaneamente. Questa tecnica funziona bene fino a quando il numero di client è basso (<< 1000 client, a seconda dell'architettura del sistema operativo e del carico previsto di ogni thread).
new Thread(() -> {
// Get the socket's InputStream, to read bytes from the socket
InputStream in = clientSocket.getInputStream();
// wrap the InputStream in a reader so you can read a String instead of bytes
BufferedReader reader = new BufferedReader(
new InputStreamReader(in, StandardCharsets.UTF_8));
// Read text from the socket and print line by line
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
}).start();
Client: connettersi al server e inviare un messaggio
// 127.0.0.1 is the address of the server (this is the localhost address; i.e.
// the address of our own machine)
// 1234 is the port that the server will be listening on
Socket socket = new Socket("127.0.0.1", 1234);
// Write a string into the socket, and flush the buffer
OutputStream outStream = socket.getOutputStream();
PrintWriter writer = new PrintWriter(
new OutputStreamWriter(outStream, StandardCharsets.UTF_8));
writer.println("Hello world!");
writer.flush();
Socket di chiusura e eccezioni di gestione
Gli esempi di cui sopra hanno lasciato alcune cose per renderli più facili da leggere.
Proprio come i file e altre risorse esterne, è importante che comunichiamo al sistema operativo quando abbiamo finito con loro. Quando abbiamo finito con un socket, chiama
socket.close()per chiuderlo correttamente.Gli zoccoli gestiscono le operazioni di I / O (ingresso / uscita) che dipendono da una varietà di fattori esterni. Ad esempio, cosa succede se l'altro lato si disconnette improvvisamente? Cosa succede se ci sono errori di rete? Queste cose sono fuori dal nostro controllo. Questo è il motivo per cui molte operazioni socket possono generare eccezioni, in particolare
IOException.
Un codice più completo per il cliente sarebbe quindi qualcosa del genere:
// "try-with-resources" will close the socket once we leave its scope
try (Socket socket = new Socket("127.0.0.1", 1234)) {
OutputStream outStream = socket.getOutputStream();
PrintWriter writer = new PrintWriter(
new OutputStreamWriter(outStream, StandardCharsets.UTF_8));
writer.println("Hello world!");
writer.flush();
} catch (IOException e) {
//Handle the error
}
Server e client di base: esempi completi
Server:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
public class Server {
public static void main(String args[]) {
try (ServerSocket serverSocket = new ServerSocket(1234)) {
while (true) {
// Wait for a client connection.
Socket clientSocket = serverSocket.accept();
// Create and start a thread to handle the new client
new Thread(() -> {
try {
// Get the socket's InputStream, to read bytes
// from the socket
InputStream in = clientSocket.getInputStream();
// wrap the InputStream in a reader so you can
// read a String instead of bytes
BufferedReader reader = new BufferedReader(
new InputStreamReader(in, StandardCharsets.UTF_8));
// Read from the socket and print line by line
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
}
catch (IOException e) {
e.printStackTrace();
} finally {
// This finally block ensures the socket is closed.
// A try-with-resources block cannot be used because
// the socket is passed into a thread, so it isn't
// created and closed in the same block
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
}
}
catch (IOException e) {
e.printStackTrace();
}
}
}
Cliente:
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
public class Client {
public static void main(String args[]) {
try (Socket socket = new Socket("127.0.0.1", 1234)) {
// We'll reach this code once we've connected to the server
// Write a string into the socket, and flush the buffer
OutputStream outStream = socket.getOutputStream();
PrintWriter writer = new PrintWriter(
new OutputStreamWriter(outStream, StandardCharsets.UTF_8));
writer.println("Hello world!");
writer.flush();
} catch (IOException e) {
// Exception should be handled.
e.printStackTrace();
}
}
}
Caricamento di TrustStore e KeyStore da InputStream
public class TrustLoader {
public static void main(String args[]) {
try {
//Gets the inputstream of a a trust store file under ssl/rpgrenadesClient.jks
//This path refers to the ssl folder in the jar file, in a jar file in the same directory
//as this jar file, or a different directory in the same directory as the jar file
InputStream stream = TrustLoader.class.getResourceAsStream("/ssl/rpgrenadesClient.jks");
//Both trustStores and keyStores are represented by the KeyStore object
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
//The password for the trustStore
char[] trustStorePassword = "password".toCharArray();
//This loads the trust store into the object
trustStore.load(stream, trustStorePassword);
//This is defining the SSLContext so the trust store will be used
//Getting default SSLContext to edit.
SSLContext context = SSLContext.getInstance("SSL");
//TrustMangers hold trust stores, more than one can be added
TrustManagerFactory factory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
//Adds the truststore to the factory
factory.init(trustStore);
//This is passed to the SSLContext init method
TrustManager[] managers = factory.getTrustManagers();
context.init(null, managers, null);
//Sets our new SSLContext to be used.
SSLContext.setDefault(context);
} catch (KeyStoreException | IOException | NoSuchAlgorithmException
| CertificateException | KeyManagementException ex) {
//Handle error
ex.printStackTrace();
}
}
}
L'intestazione di un KeyStore funziona allo stesso modo, tranne sostituire la parola Trust in un nome oggetto con Key . Inoltre, l'array KeyManager[] deve essere passato al primo argomento di SSLContext.init . Questo è SSLContext.init(keyMangers, trustMangers, null)
Esempio di socket: lettura di una pagina Web utilizzando un socket semplice
import java.io.*;
import java.net.Socket;
public class Main {
public static void main(String[] args) throws IOException {//We don't handle Exceptions in this example
//Open a socket to stackoverflow.com, port 80
Socket socket = new Socket("stackoverflow.com",80);
//Prepare input, output stream before sending request
OutputStream outStream = socket.getOutputStream();
InputStream inStream = socket.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(inStream));
PrintWriter writer = new PrintWriter(new BufferedOutputStream(outStream));
//Send a basic HTTP header
writer.print("GET / HTTP/1.1\nHost:stackoverflow.com\n\n");
writer.flush();
//Read the response
System.out.println(readFully(reader));
//Close the socket
socket.close();
}
private static String readFully(Reader in) {
StringBuilder sb = new StringBuilder();
int BUFFER_SIZE=1024;
char[] buffer = new char[BUFFER_SIZE]; // or some other size,
int charsRead = 0;
while ( (charsRead = rd.read(buffer, 0, BUFFER_SIZE)) != -1) {
sb.append(buffer, 0, charsRead);
}
}
}
Dovresti ricevere una risposta che inizi con HTTP/1.1 200 OK , che indica una normale risposta HTTP, seguita dal resto dell'intestazione HTTP, seguita dalla pagina Web non elaborata in formato HTML.
Nota che il metodo readFully() è importante per prevenire un'eccezione EOF prematura. L'ultima riga della pagina web può mancare un ritorno, per segnalare la fine della riga, quindi readLine() si lamenterà, quindi è necessario leggerlo a mano o utilizzare i metodi di utilità da Apache commons-io IOUtils
Questo esempio è inteso come una semplice dimostrazione di connessione a una risorsa esistente utilizzando un socket, non è un modo pratico per accedere alle pagine Web. Se è necessario accedere a una pagina Web utilizzando Java, è preferibile utilizzare una libreria client HTTP esistente come il client HTTP di Apache o il client HTTP di Google
Comunicazione client / server di base tramite UDP (Datagram)
Client.java
import java.io.*;
import java.net.*;
public class Client{
public static void main(String [] args) throws IOException{
DatagramSocket clientSocket = new DatagramSocket();
InetAddress address = InetAddress.getByName(args[0]);
String ex = "Hello, World!";
byte[] buf = ex.getBytes();
DatagramPacket packet = new DatagramPacket(buf,buf.length, address, 4160);
clientSocket.send(packet);
}
}
In questo caso, passiamo all'indirizzo del server, tramite un argomento ( args[0] ). La porta che stiamo utilizzando è 4160.
Server.java
import java.io.*;
import java.net.*;
public class Server{
public static void main(String [] args) throws IOException{
DatagramSocket serverSocket = new DatagramSocket(4160);
byte[] rbuf = new byte[256];
DatagramPacket packet = new DatagramPacket(rbuf, rbuf.length);
serverSocket.receive(packet);
String response = new String(packet.getData());
System.out.println("Response: " + response);
}
}
Sul lato server, dichiarare un DatagramSocket sulla stessa porta che abbiamo inviato il nostro messaggio a (4160) e attendere una risposta.
multicasting
Il multicasting è un tipo di socket Datagram. A differenza dei datagrammi regolari, Multicasting non gestisce singolarmente ciascun client ma lo invia a un indirizzo IP e tutti i client sottoscritti riceveranno il messaggio.
Codice di esempio per un lato server:
public class Server {
private DatagramSocket serverSocket;
private String ip;
private int port;
public Server(String ip, int port) throws SocketException, IOException{
this.ip = ip;
this.port = port;
// socket used to send
serverSocket = new DatagramSocket();
}
public void send() throws IOException{
// make datagram packet
byte[] message = ("Multicasting...").getBytes();
DatagramPacket packet = new DatagramPacket(message, message.length,
InetAddress.getByName(ip), port);
// send packet
serverSocket.send(packet);
}
public void close(){
serverSocket.close();
}
}
Codice di esempio per un lato client:
public class Client {
private MulticastSocket socket;
public Client(String ip, int port) throws IOException {
// important that this is a multicast socket
socket = new MulticastSocket(port);
// join by ip
socket.joinGroup(InetAddress.getByName(ip));
}
public void printMessage() throws IOException{
// make datagram packet to recieve
byte[] message = new byte[256];
DatagramPacket packet = new DatagramPacket(message, message.length);
// recieve the packet
socket.receive(packet);
System.out.println(new String(packet.getData()));
}
public void close(){
socket.close();
}
}
Codice per l'esecuzione del server:
public static void main(String[] args) {
try {
final String ip = args[0];
final int port = Integer.parseInt(args[1]);
Server server = new Server(ip, port);
server.send();
server.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
Codice per l'esecuzione di un cliente:
public static void main(String[] args) {
try {
final String ip = args[0];
final int port = Integer.parseInt(args[1]);
Client client = new Client(ip, port);
client.printMessage();
client.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
Esegui prima il cliente: il cliente deve iscriversi all'IP prima che possa iniziare a ricevere qualsiasi pacchetto. Se si avvia il server e si chiama il metodo send() , quindi si crea un client (e si chiama printMessage() ). Non succederà nulla perché il client si è connesso dopo che il messaggio è stato inviato.
Disattiva temporaneamente la verifica SSL (a scopo di test)
A volte in un ambiente di sviluppo o di test, la catena di certificati SSL potrebbe non essere stata ancora completamente stabilita (ancora).
Per continuare a sviluppare e testare, puoi disattivare la verifica SSL a livello di codice installando un gestore di fiducia "all-trust":
try {
// Create a trust manager that does not validate certificate chains
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) {
}
}
};
// Install the all-trusting trust manager
SSLContext sc = SSLContext.getInstance("SSL");
sc.init(null, trustAllCerts, new java.security.SecureRandom());
HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
// Create all-trusting host name verifier
HostnameVerifier allHostsValid = new HostnameVerifier() {
public boolean verify(String hostname, SSLSession session) {
return true;
}
};
// Install the all-trusting host verifier
HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);
} catch (NoSuchAlgorithmException | KeyManagementException e) {
e.printStackTrace();
}
Download di un file utilizzando il canale
Se il file esiste già, verrà sovrascritto!
String fileName = "file.zip"; // name of the file
String urlToGetFrom = "http://www.mywebsite.com/"; // URL to get it from
String pathToSaveTo = "C:\\Users\\user\\"; // where to put it
//If the file already exists, it will be overwritten!
//Opening OutputStream to the destination file
try (ReadableByteChannel rbc =
Channels.newChannel(new URL(urlToGetFrom + fileName).openStream()) ) {
try ( FileChannel channel =
new FileOutputStream(pathToSaveTo + fileName).getChannel(); ) {
channel.transferFrom(rbc, 0, Long.MAX_VALUE);
}
catch (FileNotFoundException e) { /* Output directory not found */ }
catch (IOException e) { /* File IO error */ }
}
catch (MalformedURLException e) { /* URL is malformed */ }
catch (IOException e) { /* IO error connecting to website */ }
Gli appunti
- Non lasciare i blocchi di cattura vuoti!
- In caso di errore, controllare se il file remoto esiste
- Questa è un'operazione di blocco, può richiedere molto tempo con file di grandi dimensioni
