java网络编程之Socket编程
概念
网络编程分为BIO（传统IO）、NIO、AIO。Socket编程属于BIO这种传统IO。
InetAddress
java.net.InetAddress是JAVA中管理IP地址的类,常用
public static void main(String[] args) throws UnknownHostException { InetAdressDemo.getLocalHost(); System.out.println("---------------------------"); getHostByName("Lenovo-Autumn"); } /** * 获取主机ip和主机名 * @throws UnknownHostException */ public static void getLocalHost() throws UnknownHostException { //根据InetAddress获取主机名和主机ip InetAddress localHost = InetAddress.getLocalHost(); System.out.println(localHost); //打印:Lenovo-Autumn/192.168.56.1 //根据getLocalHost()返回的值获取ip和主机名 String hostName = localHost.getHostName(); String hostAddress = localHost.getHostAddress(); System.out.println(hostName); //打印 Lenovo-Autumn System.out.println(hostAddress); //打印 192.168.56.1 //根据切割获取主机名和ip String[] str = localHost.toString().split("/"); System.out.println(str[0]); //打印 Lenovo-Autumn System.out.println(str[1]); //打印 192.168.56.1 } /** * 根据主机名称获取ip地址 * @param otherName 主机名(可以是局域网中的机器名或者是域名或者是ip) * @throws UnknownHostException */ public static void getHostByName(String otherName) throws UnknownHostException { InetAddress otherHost = InetAddress.getByName(otherName); String hostName = otherHost.getHostName(); String hostAddress = otherHost.getHostAddress(); System.out.println(hostName); //打印 Lenovo-Autumn System.out.println(hostAddress); //打印 192.168.56.1 System.out.println(otherHost); //打印:Lenovo-Autumn/192.168.56.1 }
UDP
发送数据时必须指定接收端的IP地址和端口号，就好像发送货物的集装箱上面必须标明接收人的地址一样。
接收端不需要明确知道数据的来源，只需要接收到数据即可。
java.net.DatagramPackage
构造函数:
第一种是用来接受的数据包,不需要指定IP和端口,第二种是用来发送的数据包需要指定ip和端口
方法:
获取ip地址,获取服务器ip或者客户端ip
返回端口号,获取发送方或者
返回数据缓冲区
返回要发送或接受的数据包大小
java.net.DatagramSocket
DatagramPacket数据包的作用就如同是“集装箱”，可以将发送端或者接收端的数据封装起来。然而运输货物只有“集装箱”是不够的，还需要有码头。在程序中需要实现通信只有DatagramPacket数据包也同样不行，为此JDK中提供的一个DatagramSocket类。DatagramSocket类的作用就类似于码头，使用这个类的实例对象就可以发送和接收DatagramPacket数据包，发送数据的过程如下图所示。
构造函数:
用来创建发送端的DatagramSocket对象
用来创建接收端的DatagramSocket对象
方法:
发送数据报包
接收数据报包
发送端
1, 创建DatagramSocket对象
DatagramSocket()
2，创建DatagramPacket对象，封装数据，并指定ip和端口。
DatagramPacket(byte[] buf, int length, InetAddress address, int port)
3，发送数据
socket.send(DatagramPacket dp)
4，释放流资源
ds.close();
接收端
1，创建DatagramSocket对象，只需要指定端口
DatagramSocket(port)
2，创建DatagramPacket对象
DatagramPacket(byte[] data, int length)
3，接收数据存储到DatagramPacket对象中
receive(DatagramPackage dp)
4，获取DatagramPacket对象的内容
new String(data,0,dp.getLength());
5，释放流资源
ds.close();
/** * 实现udp发送端 * 用java.net.DatagramPackage封装数据 * 用java.net.DatagramSocket发送数据 * * 实现步骤 * 1.用DatagramPackage对象,封装数据,接受的地址和端口 * 2.创建DatagramSocket * 3.调用DatagramSocket对象send方法,发送数据 * 4.关闭资源 * * DatagramPackage构造函数 * DatagramPacket(byte[] buf, int length, InetAddress address, int port) * DatagramSocket构造函数 * DatagramSocket() * 方法:send(DatagramPacket d) * Created by Autumn on 2018/2/5. */ public class UdpSend { public static void main(String[] args) throws Exception { Scanner scanner = new Scanner(System.in); //获取地址 InetAddress inet = InetAddress.getByName("127.0.0.1"); //创建DatagramSocket,负责接受和发送数据 DatagramSocket ds = new DatagramSocket(); while(true){ String msg = scanner.nextLine(); //创建数据包对象对象 byte[] data = msg.getBytes(); //封装数据,接受的地址和端口 DatagramPacket dp = new DatagramPacket(data,data.length,inet,6000); //发送数据包 ds.send(dp); if(msg.equals("exit")){ break; } } //关闭 ds.close(); } } /** * 实现udp接收端 * 用java.net.DatagramPackage 接受数据 * 用java.net.DatagramSocket 接受数据包 * * 步骤 * 1.创建DatagramSocket对象,绑定端口号(要和发送端端口一致) * 2.创建字节数组用来接受数据 * 3.创建数据对象包DatagramPackage * 4.创建DatagramSocket * receive(DatagramPackage dp)接受数据,将数据封装如dp中 * 5.拆包 * 发送端的ip地址(DatagramPackage.get) * 接受到的字节数组 * 发送的端口号 * 6.关闭资源 * Created by Autumn on 2018/2/5. */ public class UdpReceive { public static void main(String[] args) throws IOException { //创建数据包传输的对象,并绑定端口号 DatagramSocket ds = new DatagramSocket(6000); //创建字节数组 byte[] data = new byte[1024]; while(true){ //创建数据包对象,传递字节数组 DatagramPacket dp = new DatagramPacket(data,data.length); //调用ds对象的receive接受数据包,receive()有线程阻塞效果会一直等待接受数据 ds.receive(dp); //获取数据包大小 int len = dp.getLength(); //获取发送端的ip地址 InetAddress sendAddress = dp.getAddress(); String sendHostAddress = sendAddress.getHostAddress(); //System.out.println(sendHostAddress); //获取发送端端口号 int port = dp.getPort(); //System.out.println(port); //System.out.println(new String(data)); //直接打印1024个字节的字符串,有很多空格 System.out.println(sendHostAddress+":"+port+" "+new String(data,0,len)); //这样打印没有多余的空格 if(new String(data,0,len).equals("exit")){ break; } } //关闭 ds.close(); } }
TCP
ServerSocket类，用于表示服务器端，Socket类，用于表示客户端。建立连接后用流进行输入和输出
ServerSocket
实例化一个ServerSocket类，指定端口号
监听并接受此套接字的连接
返回此服务器套接字的本地地址
Socket
实例化一个Socket并指定ip和端口
返回一个输出流，用于客户端发送数据
返回一个输入流，用于服务器端接受数据
返回ip地址（服务器端的地址）
返回端口号
客户端
1，创建客户端的Socket对象，指定服务器IP和端口号
Socket(String host, int port)
2，获取Socket的输出流对象
getOutputStream()；
3，写数据给服务器
out.write("服务器数据".getBytes());
4，关闭流资源
socket.close();
服务器端
1，创建服务器端ServerSocket对象，指定服务器端端口号
ServerSocket(int port)
2，开启服务器，等待着客户端Socket对象的连接，如有客户端连接，返回客户端的Socket对象
accept()
3，通过客户端的Socket对象，获取客户端的输入流，为了实现获取客户端发来的数据
socket.getInputStream();
4，通过客户端的输入流，获取流中的数据
byte[] data = new byte[1024];
int len = inputStream.read(data);
System.out.println(new String(data,0,len));
5，通过客户端的Socket对象，获取客户端的输出流，为了实现给客户端反馈信息
6，通过客户端的输出流，写数据到流中
7，关闭流资源
socket.close();
serverSocket.close();
/** * 实现TCP服务器程序 * 表示服务器程序的类java.net.ServerSocket * 构造方法: * ServerSocket(int port); 传递端口号 * * Important:必须获得客户端的套接字(Socket) * 方法:Socket accept() * 服务器可以获取到客户端的套接字 * Created by Autumn on 2018/2/5. */ public class TCPServer { public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(8888); //调用服务器套接字对象accept()获取客户端套接字,具有线程等待效果 Socket socket = serverSocket.accept(); //这里会阻塞等待连接接入 cmd中telnet 127.0.0.1 8888即可连接 //根据获得的客户端的socket获取输入流 InputStream inputStream = socket.getInputStream(); //根据输入流将数据读入到data中 byte[] data = new byte[1024]; int len = inputStream.read(data); //这里会阻塞,等待数据 cmd中ctrl+]进入到telnet操作模式send value发送数据 System.out.println(new String(data,0,len)); socket.close(); serverSocket.close(); } } /** * 实现TCP客户端,连接到服务器 * 和服务器实现数据交换 * 实现TCP客户端程序的类 java.net.Socket * * 构造方法: * Socket(String host, int port)传递服务器IP和端口号 * 注意:构造方法只要运行,就会和服务器进行连接,连接时报,抛出异常 * * OutputStream getOutputStream() 返回套接字的输出流 * 作用:将数据输出,输出到服务器 * InputStream getInputStream() 返回套接字的输入流 * 作用:从服务器端读取数据 * * 客户端服务器数据交换,必须使用套接字对象Socket中的获取的IO刘,自己new的流不行 * * Created by Autumn on 2018/2/5. */ public class TCPClient { public static void main(String[] args) throws IOException { //创建Socket对象,连接服务器 Socket socket = new Socket("127.0.0.1",8888); //通过客户端的套接字对象Socket方法,获取字节输出流,将数据写向服务器 OutputStream out = socket.getOutputStream(); out.write("这是一条来客户端的数据".getBytes()); socket.close(); } }
用cmd命令telnet实现和SocketServer互动
import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; public class TCPServer { /*同步阻塞*/ public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(8888); System.out.println("服务端启动成功..."); while(true){ /*一次只能处理一个连接,在一个连接没关闭前无法接收第二个连接,在这里开一个框发送数无问题,开放两个框时会出现第二个无反应*/ Socket socket = serverSocket.accept(); //这里会阻塞等待连接接入 cmd中telnet 127.0.0.1 8888即代表连接 System.out.println("新客户端连接成功...."); InputStream inputStream = socket.getInputStream(); while(true) { byte[] data = new byte[1024]; System.out.println("正在等待数据..."); int len = inputStream.read(data); //这里会阻塞,等待数据，如果直接关闭cmd窗口会因为关闭socket通道导致len返回-1 cmd中ctrl+]进入到telnet操作模式send value发送数据 if (len != -1){ System.out.println(new String(data, 0,len, "GBK")); //用GBK是因为CMD窗口命令发送的数据是GBK编码 }else{ break; } } } //socket.close(); //serverSocket.close(); //System.out.println("服务器端关闭...."); } }
连接服务端
向服务端发送数据
再开一个cmd然后telnet发送数据，发现无反应。必须关闭第一个cmd才能连接成功。
线程池改进，能并发访问
用ExecutorService线程池实现每一个连接创建一个新的线程
import java.io.IOException; import java.io.InputStream; import java.io.UnsupportedEncodingException; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class TCPServer { /*异步阻塞*/ public static void main(String[] args) throws IOException { ExecutorService threadPool = Executors.newCachedThreadPool(); //线程池 ServerSocket serverSocket = new ServerSocket(8888); System.out.println("服务端启动成功..."); while(true){ /*一次只能处理一个连接,在一个连接没关闭前无法接收第二个连接,在这里开一个框发送数无问题,开放两个框时会出现第二个无反应*/ System.out.println("等待客户端连接..."); final Socket socket = serverSocket.accept(); //这里会阻塞等待连接接入 cmd中telnet 127.0.0.1 8888即代表连接 threadPool.execute(new Runnable() { //启动一个线程 public void run() { try { System.out.println("新客户端连接成功...."); InputStream inputStream = socket.getInputStream(); while(true) { byte[] data = new byte[1024]; System.out.println("正在等待数据..."); int len = inputStream.read(data); //这里会阻塞,等待数据，如果直接关闭cmd窗口会因为关闭socket通道导致len返回-1 cmd中ctrl+]进入到telnet操作模式send value发送数据 if (len != -1){ System.out.println(Thread.currentThread()+new String(data, 0,len, "GBK")); //用GBK是因为CMD窗口命令发送的数据是GBK编码 }else{ System.out.println("break循环"); break; } } System.out.println("一次Socket连接关闭"); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } }); } //socket.close(); //serverSocket.close(); //System.out.println("服务器端关闭...."); } }
优点：传输质量好（所以BIO适合传输连接少但是数据量大的请求）
缺点：每一个连接都占用一个线程，很占用系统资源。
tip：所有的调优都关联到系统资源（IO、存储、内存、CPU）
