socket通信

 

IP地址和端口号组成了所谓的Socket，Socket是网络上运行的程序之间双向通信链路的终结点，是TCP和UDP的基础。

 

Java中对于网络通信的支持主要包含以下四大类：

 

    1.InetAddress：用于标识网络上的硬件资源。说白了就是标识IP等。

 

    2.URL：统一资源定位符，通过URL可以直接读取或写入网络上的数据。

 

    3.Sockets：使用TCP协议实现网络通信的Socket相关的类。

 

    4.Datagram：使用UDP协议，将数据保存在数据报中，通过网络进行通信。

 

    简单的两个DEMO，介绍java中的InetAddress类和URL类。

    介绍InetAddress类：

1. package com.wang;
2. import java.net.InetAddress;
3. import java.net.UnknownHostException;
4. import java.util.Arrays;
7. publicclassInetAddressTest{
8. publicstaticvoid main(String[] args)throwsUnknownHostException{
9. InetAddress localhost =InetAddress.getLocalHost();
10. System.out.println("localhost:"+ localhost);
12. InetAddress address =InetAddress.getByName("wangdaye-PC");
13. System.out.println(address.getHostAddress()+"="+ address.getHostName());
14. byte[] bytes = address.getAddress();
15. System.out.println("字节数组："+Arrays.toString(bytes));
16. System.out.println(address);
17. }
18. }

    介绍URL类：

    

1. package com.wang;
3. import java.io.BufferedReader;
4. import java.io.InputStream;
5. import java.io.InputStreamReader;
6. import java.net.URL;
7. /**
8. * 端口号未指定，默认为80，getPort()函数返回值为-1
9. * @author wangdaye
10. */
11. publicclassURLTest{
12. publicstaticvoid main(String[] args)throwsException{
13. URL testUrl =new URL("http://www.sina.com:80/sb/index.jsp");
14. // System.out.println(testUrl.getPort());
15. URL url =new URL(testUrl,"wang");
16. System.out.println("协议："+ url.getProtocol());
17. System.out.println("主机名："+ url.getHost());
18. System.out.println("端口："+ url.getPort());
19. System.out.println("文件路径："+ url.getPath());
20. System.out.println("文件名称："+ url.getFile());
21. System.out.println("相对路径："+ url.getRef());
22. System.out.println("查询字符串："+ url.getQuery());
24. //读取网络资源的内容
25. URL baidu =new URL("http://www.baidu.com:80/sb/index.jsp");
26. InputStream inputStream = baidu.openStream();
27. InputStreamReader reader =newInputStreamReader(inputStream);
28. BufferedReader br =newBufferedReader(reader);
29. while(br.ready()){
30. String sb = br.readLine();
31. System.out.println(sb);
32. }
34. }
35. }

 

基于TCP的socket通信的Demo：

    服务端：

1. package com.wangdaye.socketIO;
3. import java.io.BufferedReader;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.io.InputStreamReader;
7. import java.net.ServerSocket;
8. import java.net.Socket;
10. /**
11. * 基于TCP通信的socket服务器端
12. * @author wangdaye
13. *
14. */
15. publicclassTCPServer{
16. publicstaticvoid main(String[] args){
17. try{
18. //1.创建服务器端socket，即serverSocket，指定绑定端口，并监听此端口。
19. ServerSocket serverSocket =newServerSocket(8888);
20. System.out.println("*************服务器即将启动，等待客户端链接*******************");
21. //2.调用accept()方法开始监听，等待客户端连接，此时处于阻塞状态。
22. Socket socket = serverSocket.accept();
23. //3.获取输入流，读取客户端信息
24. InputStream inputStream = socket.getInputStream();
25. InputStreamReader reader =newInputStreamReader(inputStream);
26. BufferedReader br =newBufferedReader(reader);
27. String sb =null;
28. while((sb = br.readLine())!=null){
29. System.out.println("客户端说："+ sb);
30. }
31. socket.shutdownInput();//关闭输入流
32. //4.关闭资源
33. br.close();
34. reader.close();
35. inputStream.close();
36. socket.close();
37. serverSocket.close();
38. }catch(IOException e){
39. // TODO Auto-generated catch block
40. e.printStackTrace();
41. }
42. }
43. }

    客户端：

1. package com.wangdaye.socketIO;
3. import java.io.IOException;
4. import java.io.OutputStream;
5. import java.io.PrintWriter;
6. import java.net.Socket;
7. import java.net.UnknownHostException;
9. /**
10. * 基于TCP通信的socket客户端
11. * @author wangdaye
12. *
13. */
14. publicclassTCPClient{
15. publicstaticvoid main(String[] args){
16. try{
17. //1.创建客户端socket，并指定服务器地址和端口
18. Socket socket =newSocket("localhost",8888);
19. //2.获取输出流，向服务器端发送信息
20. OutputStream outputStream = socket.getOutputStream();//字节输出流
21. PrintWriter pw =newPrintWriter(outputStream);//将输出流打包成打印流
22. pw.write("用户名：sb，密码：123");
23. pw.flush();
24. socket.shutdownOutput();
25. //3.关闭资源
26. outputStream.close();
27. socket.close();
29. }catch(UnknownHostException e){
30. e.printStackTrace();
31. }catch(IOException e){
32. e.printStackTrace();
33. }
34. }
35. }

多线程服务端：

1. package com.wangdaye.socketIO;
3. import java.net.ServerSocket;
4. import java.net.Socket;
6. publicclassTCPThreadServer{
7. publicstaticvoid main(String[] args)throwsException{
8. ServerSocket serverSocket =newServerSocket(8888);
9. System.out.println("***********************服务器启动成功，正在等待客户端连接*********************");
10. Socket socket =null;
11. int count =0;
12. while(true){
13. socket = serverSocket.accept();
14. count++;
15. System.out.println("当前客户端连接数量："+ count);
16. System.out.println("当前客户端IP地址是："+ socket.getInetAddress()+",主机名:"+socket.getInetAddress().getHostAddress()+":"+ socket.getPort());
17. ServerThread serverThread =newServerThread(socket);
18. serverThread.run();
19. }
20. }
21. }

基于UDP的Socket通信的Demo:

服务端：

1. package com.wangdaye.socketIO.udp;
3. import java.net.DatagramPacket;
4. import java.net.DatagramSocket;
5. import java.net.InetAddress;
7. publicclassServerUdp{
8. publicstaticvoid main(String[] args)throwsException{
9. System.out.println("***************服务端已经启动，正在等待客户端发送数据*************");
10. //接收客户端发送的数据
11. //1.创建服务器端DatagramSocket，指定端口号
12. DatagramSocket datagramSocket =newDatagramSocket(8800);
13. //2.创建数据报，接收客户端发送的数据,指定数据包大小
14. byte[] b =newbyte[1024];
15. DatagramPacket datagramPacket =newDatagramPacket(b,b.length);
16. //3.接收客户端发送的数据
17. datagramSocket.receive(datagramPacket);//此方法在接收到数据之前会一直阻塞
18. //4.查看客户端发送的信息,读取数据
19. String str =newString(b,0, datagramPacket.getLength());
20. System.out.println("我是服务器，客户端说:"+ str);
22. //向客户端响应数据
23. //1.获取客户端地址和端口
24. InetAddress clientAddress=datagramPacket.getAddress();
25. int clientPort = datagramPacket.getPort();
26. String sb ="欢迎你，客户端";
27. byte[] bytes = sb.getBytes();
28. //2.创建要向客户端发送的数据
29. DatagramPacket dp =newDatagramPacket(bytes,bytes.length,clientAddress,clientPort);
30. //3.响应客户端
31. datagramSocket.send(dp);
32. //4.关闭连接
33. datagramSocket.close();
34. }
35. }

 

客户端：

1. package com.wangdaye.socketIO.udp;
3. import java.net.DatagramPacket;
4. import java.net.DatagramSocket;
5. import java.net.InetAddress;
7. publicclassClientUdp{
8. publicstaticvoid main(String[] args)throwsException{
9. //向服务器端发送数据
10. //1.定义服务器的地址、端口号
11. InetAddress inetAddress =InetAddress.getByName("localhost");
12. int port =8800;
13. String msg ="我是客户端，我了个去~";
14. byte[] bytes = msg.getBytes();
15. //2.创建数据报，包含发送的消息
16. DatagramPacket packet =newDatagramPacket(bytes,bytes.length,inetAddress,port);
17. //3.创建DatagramSocket对象
18. DatagramSocket socket =newDatagramSocket();
19. //4.发送数据
20. socket.send(packet);
22. //接收服务端响应数据
23. //1.创建数据包，接收服务端响应数据
24. byte[] receivedBytes =newbyte[1024];
25. DatagramPacket dp =newDatagramPacket(receivedBytes,receivedBytes.length);
26. //2.接收服务器端响应数据
27. socket.receive(dp);
28. //3.读取数据
29. String reply =newString(receivedBytes,0,receivedBytes.length);
30. System.out.println(reply);
31. //4.关闭资源
32. socket.close();
33. }
34. }

 

 

注意：

    1.生产环境下，对线程的优先级做一个控制，否则会效率低下

    2.输入输出流的关闭问题，关闭了socket，流也就关闭了

    3.传递对象，平时都是以字符串传递的

    4.传递文件

 

来自为知笔记(Wiz)