java_网络编程


网络模型

      OSI参考模型

      TCP/IP参考模型


　　计算机网络是指由通信线路互相连接的许多自主工作的计算机构成的集合体，各个部件之间以何种规

　　则进行通信，就是网络模型研究的问题。网络模型一般是指OSI七层参考模型和TCP/IP四层参考模

　　型。这两个模型在网络中应用最为广泛。



网络通讯要素


IP地址：InetAddress

       网络设备的标识。

       不易记忆，可用主机名

       本地回环地址：127.0.0.1   主机名：localhost

端口号

        用于标识进程的逻辑标识，不同的进程标识

        有效的端口：0~65535，其中0~1024为系统使用或保留端口号。

传输协议

        通讯的协议

        常见协议：TCP，UDP    



　　　当网络中的多台主机要进行通讯时，要进行以下步骤：

　　　1，找到对方IP

　　　2，数据要发生到对方指定的引用程序上。为了标识这些引用程序所以给这些网络应用程序都用数

　　　　字进行标识。为了方便称呼这个数字，叫做端口。逻辑端口。

　　　3，定义通讯规则。这个通讯规则称为协议。国际组织定义了通用规则TCP/IP。



TCP和UDP


UDP

　将数据及源和目的封装成数据包，不需要建立连接

　每个数据包的大小限制在64k内

　因无连接，是不可靠协议

　不需要建立连接，速度快

TCP

　建立连接，形成传输数据的通道

　在连接中进行大量数据传输

　通过三次握手完成连接，是可靠协议

　必须建立连接，效率会稍低





Socket

　Socket是为网络服务提供的一种机制。

　通信的两端都有Socket。

　网络通信其实就是Socket间的通信。

　数据在两个Socket间通过IO传输。



UDP传输


定义一个udp发送端。

思路：

　　1，建立updsocket服务。

　　2，提供数据，并将数据封装到数据包中。

　　3，通过socket服务的发送功能，将数据包发出去。

　　4，关闭资源。


定义udp的接收端。

思路：

　　　1，定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。

　　　　　方便于明确哪些数据过来该应用程序可以处理。

　　　2，定义一个数据包，因为要存储接收到的字节数据。

　　　　　因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。

　　　3，通过socket服务的receive方法将收到的数据存入已定义好的数据包中。

　　　4，通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。

　　　5，关闭资源。


Java代码

  1. import java.net.*;  

  3. /*

  4. 需求：通过udp传输方式，将一段文字数据发送出去。，

  5. 定义一个udp发送端。

  6. 思路：

  7. 1，建立updsocket服务。

  8. 2，提供数据，并将数据封装到数据包中。

  9. 3，通过socket服务的发送功能，将数据包发出去。

  10. 4，关闭资源。

  12. */

  15. class  UdpSend  

  16. {  

  17. publicstaticvoid main(String[] args) throws Exception  

  18.    {  

  19. //1，创建udp服务。通过DatagramSocket对象。

  20.        DatagramSocket ds = new DatagramSocket(8888);  

  22. //2，确定数据，并封装成数据包。DatagramPacket(byte[] buf, int length, InetAddress address, int port)

  24. byte[] buf = "udp ge men lai le ".getBytes();  

  25.        DatagramPacket dp =  

  26. new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.254"),10000);  

  28. //3，通过socket服务，将已有的数据包发送出去。通过send方法。

  29.        ds.send(dp);  

  31. //4，关闭资源。

  33.        ds.close();  

  35.    }  

  36. }  

  38. /*

  39. 需求：

  40. 定义一个应用程序，用于接收udp协议传输的数据并处理的。

  43. 定义udp的接收端。

  44. 思路：

  45. 1，定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。

  46.    方便于明确哪些数据过来该应用程序可以处理。

  48. 2，定义一个数据包，因为要存储接收到的字节数据。

  49. 因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。

  50. 3，通过socket服务的receive方法将收到的数据存入已定义好的数据包中。

  51. 4，通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。

  52. 5，关闭资源。

  54. */

  57. class  UdpRece  

  58. {  

  59. publicstaticvoid main(String[] args) throws Exception  

  60.    {  

  61. //1,创建udp socket，建立端点。

  62.        DatagramSocket ds = new DatagramSocket(10000);  

  63. while(true)  

  64.        {  

  65. //2,定义数据包。用于存储数据。

  66. byte[] buf = newbyte[1024];  

  67.        DatagramPacket dp = new DatagramPacket(buf,buf.length);  

  69. //3，通过服务的receive方法将收到数据存入数据包中。

  70.        ds.receive(dp);//阻塞式方法。

  73. //4，通过数据包的方法获取其中的数据。

  74.        String ip = dp.getAddress().getHostAddress();  

  76.        String data = new String(dp.getData(),0,dp.getLength());  

  78. int port = dp.getPort();  

  80.        System.out.println(ip+"::"+data+"::"+port);  

  82.        }  

  83. //5，关闭资源

  84. //ds.close();

  86.    }  

  87. }  


TCP传输

　　Socket和ServerSocket

　　建立客服端和服务端

　　建立连接后，通过Socket中的IO流进行数据的传输

     关闭Socket

     同样，客服端与服务端是两个独立的应用程序。


Java代码

  1. /*

  2. 演示tcp传输。

  5. 1,tcp分客户端和服务端。

  6. 2，客户端对应的对象是Socket。

  7.    服务端对应的对象是ServerSocket。

  10. */

  13. /*

  14. 客户端，

  15. 通过查阅socket对象，发现在该对象建立时，就可以去连接指定主机。

  16. 因为tcp是面向连接的。所以在建立socket服务时，

  17. 就要有服务端存在，并连接成功。形成通路后，在该通道进行数据的传输。

  20. 需求：给服务端发送给一个文本数据。

  22. 步骤：

  23. 1，创建Socket服务。并指定要连接的主机和端口。

  25. */

  26. import java.io.*;  

  27. import java.net.*;  

  28. class  TcpClient  

  29. {  

  30. publicstaticvoid main(String[] args) throws Exception  

  31.    {  

  32. //创建客户端的socket服务。指定目的主机和端口

  33.        Socket s = new Socket("192.168.1.254",10003);  

  35. //为了发送数据，应该获取socket流中的输出流。

  36.        OutputStream out = s.getOutputStream();  

  38.        out.write("tcp ge men lai le ".getBytes());  

  41.        s.close();  

  42.    }  

  43. }  

  46. /*

  47. 需求：定义端点接收数据并打印在控制台上。

  49. 服务端:

  50. 1，建立服务端的socket服务。ServerSocket();

  51.    并监听一个端口。

  52. 2，获取连接过来的客户端对象。

  53.    通过ServerSokcet的 accept方法。没有连接就会等，所以这个方法阻塞式的。

  54. 3，客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据。

  55.    并打印在控制台。

  57. 4，关闭服务端。（可选）

  60. */

  61. class  TcpServer  

  62. {  

  63. publicstaticvoid main(String[] args) throws Exception  

  64.    {  

  65. //建立服务端socket服务。并监听一个端口。

  66.        ServerSocket ss = new ServerSocket(10003);  

  68. //通过accept方法获取连接过来的客户端对象。

  69. while(true)  

  70.        {  

  71.        Socket s = ss.accept();  

  73.        String ip = s.getInetAddress().getHostAddress();  

  74.        System.out.println(ip+".....connected");  

  76. //获取客户端发送过来的数据，那么要使用客户端对象的读取流来读取数据。

  77.        InputStream in = s.getInputStream();  

  79. byte[] buf = newbyte[1024];  

  80. int len = in.read(buf);  

  82.        System.out.println(new String(buf,0,len));  

  84.        s.close();//关闭客户端.

  85.        }  

  86. //ss.close();

  87.    }  

  88. }  



TCP模式中客服端和服务端可以进行互访


Java代码

  1. import java.io.*;  

  2. import java.net.*;  

  3. /*

  4. 演示tcp的传输的客户端和服务端的互访。

  6. 需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。

  8. */

  10. /*

  11. 客户端：

  12. 1，建立socket服务。指定要连接主机和端口。

  13. 2，获取socket流中的输出流。将数据写到该流中。通过网络发送给服务端。

  14. 3，获取socket流中的输入流，将服务端反馈的数据获取到，并打印。

  15. 4，关闭客户端资源。

  17. */

  18. class TcpClient2  

  19. {  

  20. publicstaticvoid main(String[] args)throws Exception  

  21.    {  

  22.        Socket s = new Socket("192.168.1.254",10004);  

  24.        OutputStream out = s.getOutputStream();  

  26.        out.write("服务端，你好".getBytes());  

  29.        InputStream in = s.getInputStream();  

  31. byte[] buf = newbyte[1024];  

  33. int len = in.read(buf);  

  35.        System.out.println(new String(buf,0,len));  

  37.        s.close();  

  38.    }  

  39. }  

  42. class TcpServer2  

  43. {  

  44. publicstaticvoid main(String[] args) throws Exception  

  45.    {  

  46.        ServerSocket ss = new ServerSocket(10004);  

  48.        Socket s = ss.accept();  

  50.        String ip = s.getInetAddress().getHostAddress();  

  51.        System.out.println(ip+"....connected");  

  52.        InputStream in = s.getInputStream();  

  54. byte[] buf = newbyte[1024];  

  56. int len = in.read(buf);  

  58.        System.out.println(new String(buf,0,len));  

  61.        OutputStream out = s.getOutputStream();  

  64.        Thread.sleep(10000);  

  65.        out.write("哥们收到,你也好".getBytes());  

  67.        s.close();  

  69.        ss.close();  

  70.    }  

  71. }  


客户端给服务端发送文本，服务单会将文本转成大写在返回给客户端。


Java代码

  1. /*

  3. 需求：建立一个文本转换服务器。

  4. 客户端给服务端发送文本，服务单会将文本转成大写在返回给客户端。

  5. 而且客户度可以不断的进行文本转换。当客户端输入over时，转换结束。

  7. 分析：

  8. 客户端：

  9. 既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。

  10. 源：键盘录入。

  11. 目的：网络设备，网络输出流。

  12. 而且操作的是文本数据。可以选择字符流。

  14. 步骤

  15. 1，建立服务。

  16. 2，获取键盘录入。

  17. 3，将数据发给服务端。

  18. 4，后去服务端返回的大写数据。

  19. 5，结束，关资源。

  21. 都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。

  24. */

  25. import java.io.*;  

  26. import java.net.*;  

  28. class  TransClient  

  29. {  

  30. publicstaticvoid main(String[] args) throws Exception  

  31.    {  

  32.        Socket s = new Socket("192.168.1.254",10005);  

  35. //定义读取键盘数据的流对象。

  36.        BufferedReader bufr =  

  37. new BufferedReader(new InputStreamReader(System.in));  

  40. //定义目的，将数据写入到socket输出流。发给服务端。

  41. //BufferedWriter bufOut =

  42. //new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

  43.        PrintWriter out = new PrintWriter(s.getOutputStream(),true);  

  47. //定义一个socket读取流，读取服务端返回的大写信息。

  48.        BufferedReader bufIn =  

  49. new BufferedReader(new InputStreamReader(s.getInputStream()));  

  51.        String line = null;  

  53. while((line=bufr.readLine())!=null)  

  54.        {  

  55. if("over".equals(line))  

  56. break;  

  58.            out.println(line);  

  59. //          bufOut.write(line);

  60. //          bufOut.newLine();

  61. //          bufOut.flush();

  63.            String str =bufIn.readLine();  

  64.            System.out.println("server:"+str);  

  66.        }  

  68.        bufr.close();  

  69.        s.close();  

  72.    }  

  73. }  

  74. /*

  76. 服务端：

  77. 源：socket读取流。

  78. 目的：socket输出流。

  79. 都是文本，装饰。

  83. */

  85. class  TransServer  

  86. {  

  87. publicstaticvoid main(String[] args) throws Exception  

  88.    {  

  89.        ServerSocket ss = new ServerSocket(10005);  

  91.        Socket s = ss.accept();  

  92.        String ip = s.getInetAddress().getHostAddress();  

  93.        System.out.println(ip+"....connected");  

  95. //读取socket读取流中的数据。

  96.        BufferedReader bufIn =  

  97. new BufferedReader(new InputStreamReader(s.getInputStream()));  

  99. //目的。socket输出流。将大写数据写入到socket输出流，并发送给客户端。

  100. //BufferedWriter bufOut =

  101. //new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

  103.        PrintWriter out = new PrintWriter(s.getOutputStream(),true);  

  105.        String line = null;  

  106. while((line=bufIn.readLine())!=null)  

  107.        {  

  109.            System.out.println(line);  

  111.            out.println(line.toUpperCase());  

  112. //          bufOut.write(line.toUpperCase());

  113. //          bufOut.newLine();

  114. //          bufOut.flush();

  115.        }  

  117.        s.close();  

  118.        ss.close();  

  120.    }  

  121. }  

  122. /*

  123. 该例子出现的问题。

  124. 现象：客户端和服务端都在莫名的等待。

  125. 为什么呢？

  126. 因为客户端和服务端都有阻塞式方法。这些方法么没有读到结束标记。那么就一直等

  127. 而导致两端，都在等待。

  130. */