文档章节

网络编程(Socket)

architect刘源源
 architect刘源源
发布于 2018/01/20 14:57
字数 1728
阅读 17
收藏 2

网络编程

概述

用Socket来达到进程间的数据传输的编程的就是网络编程。

网络参考模型

概述:描述网络的结构原理和工作原理。

  • 1.OSI参考模型:有七层分别是应用层、表示层、会话层、传输层、网络层、数据链路层、物理层。

  • 2.TCP/IP参考模型:有四层分别是应用层、传输层、网际层、数据链路层。

网络通讯要素

1.IP地址:网络中设备的标识,互联网的协议地址,是IP协议提供的一种统一的地址格式,它为互联网上的每一个网络和每一台主机分配一个逻辑地址,以此来屏蔽物理地址的差异。

本地回环地址:127.0.0.1。

2.端口:用于标识进程的逻辑地址,不同进程的标识,不同进程进行通信时会通过端口要找与其通信的程序,程序和端口是一对一的关系。

有效端口:0~65535,0~1024系统使用或保留端口。

3.网络协议:指定层上进行数据交换的规则,在网络中的设备(服务器、计算机、交换机、路由器)都能遵守的通信规则。

网络层协议:IP协议、DNS协议(辅助协议)。

传输层协议:TCP、UDP。

UDP:UDP是OSI参考模型中的一种无连接的传输层协议,是一个分包发送的协议。
特点:

1.先将数据及源和目的封装成数据包中,不需要简历连接。

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

3.不可靠协议。

4.传输速度快。

TCP:TCP是面向连接的基于IP地址的传输层协议。
特点:

1.要建立连接,形成传输数据的通道。

2.在连接中可以进行大数据传输。

3.可靠协议。

4.传输效率稍低。

TCP的三次握手图:

 

 

Socket
概述
Socket也称为"套接字",是描述IP地址和和端口,是通信链的句柄,程序通过"套接字"向网络发出请求或者应答网络请求。

Socke类型:

1.ServerSocket:用于服务端的套接字。(TCP协议)

2.Socket:用于客户端的套接字。(TCP协议)

3.DatagramSocket:用于UDP协议的套接字。

UDP传输
UDP套接字:DatagramSocket
数据包:DatagramPacket

步骤:

  • 1.建立发送端,和接受端。

  • 2.封装数据包。

  • 3.分别调用发送端、接受端的发送、接受方法。

  • 4.关闭Socket。

实例:制作一个聊天室,可以发送信息,也可以接收消息。

 

[java] view plain copy

  1. /** 
  2.  * 创建一个聊天室,可以接收和发送数据。 
  3.  * 思路: 
  4.  * 1.因为要能接收又能发送,就会需要接收端和发送端同时运行。 
  5.  * 2.创建一个专门发送的线程,一个发送的线程。 
  6.  * 3.同时运行这两个线程。 
  7.  * */  
  8. //package SocketDemo;  
  9. import java.io.*;  
  10. import java.net.*;  
  11. class Send implements Runnable //发送线程,实现Runnable接口。  
  12. {  
  13.     private DatagramSocket ds;  
  14.     public Send(DatagramSocket ds)  
  15.     {  
  16.         this.ds = ds;  
  17.     }  
  18.     public void run()  
  19.     {  
  20.         try  
  21.         {  
  22.             BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); //获取键盘对象并转为字符输入流。  
  23.             String line = null;  
  24.             while((line=br.readLine()) != null)  
  25.             {  
  26.                 if(line.equals("over"))  
  27.                     break;  
  28.                 DatagramPacket dp = new DatagramPacket  
  29.                         (line.getBytes(), line.length(), InetAddress.getByName("127.0.0.1"), 30000); //创建数据包,把数据,接收的IP地址、端口装包  
  30.                 ds.send(dp); //发送数据包。  
  31.             }  
  32.         }  
  33.         catch (Exception e)  
  34.         {  
  35.             throw new RuntimeException("发送数据失败!");  
  36.         }  
  37.         finally  
  38.         {  
  39.             ds.close(); //关闭套接字。  
  40.         }  
  41.     }  
  42. }  
  43. class Rece implements Runnable //接收线程。  
  44. {  
  45.     DatagramSocket ds;  
  46.     public Rece(DatagramSocket ds)  
  47.     {  
  48.         this.ds = ds;  
  49.     }  
  50.     public void run()  
  51.     {  
  52.         try  
  53.         {  
  54.             while(true)  
  55.             {  
  56.                 byte[] buf = new byte[1024];  
  57.                 DatagramPacket dp = new DatagramPacket(buf, buf.length); //定义空的数据包用来接收数据。  
  58.                 ds.receive(dp);  
  59.                 String ip = dp.getAddress().getHostAddress(); //获取发送方的IP地址。  
  60.                 int port = dp.getPort(); //获取发送方的端口。  
  61.                 String data = new String(dp.getData(),0,dp.getLength()); //取出数据包中的数据。  
  62.                 System.out.println(ip+":"+port+"发来消息:"+data);  
  63.             }  
  64.         }  
  65.         catch (Exception e)  
  66.         {  
  67.             throw new RuntimeException("接收数据失败!");  
  68.         }  
  69.         finally  
  70.         {  
  71.             ds.close(); //关闭套接字。  
  72.         }  
  73.     }  
  74. }  
  75. public class UDPDemo  
  76. {  
  77.   
  78.     public static void main(String[] args) throws Exception  
  79.     {  
  80.         DatagramSocket send = new DatagramSocket(); //创建发送套接字。  
  81.         DatagramSocket rece = new DatagramSocket(30000); //创建接收套接字。  
  82.         new Thread(new Send(send)).start(); //创建并开启发送线程。  
  83.         new Thread(new Rece(rece)).start(); //创建并开启接收线程。  
  84.     }  
  85. }  

 

TCP传输
TCP套接字:SocketServerSocket

步骤:

  • 1.建立客户端,和服务端。

  • 2.通过Socket的IO流进行数据传说。

  • 3.关闭Socket。

实例:制作一个能多连接客户端的服务端

服务端:

 

[java] view plain copy

  1. /**制作一个能多连接客户端的服务端 
  2.  * 思路: 
  3.  * 1.需要创建ServerSocket。 
  4.  * 2.每个客户端请求连接都要产生Socket,但是产生以后主线程又会accept阻塞状态,所以我们需要每个客户端有其处理的线程。 
  5.  * 3.因为会多个连接,必须对循环accept方法。 
  6.  * 4.创建客户端处理线程类。 
  7.  * 5.通过线程while保持客户端和服务端的数据传输。 
  8.  * 6.当客户端断开连接时需要关闭其的Socket。 
  9.  * */  
  10. import java.io.*;  
  11. import java.net.*;  
  12. class SocketThread implements Runnable //处理每个客户端的线程  
  13. {  
  14.     private Socket s;  
  15.     public SocketThread(Socket s)  
  16.     {  
  17.         this.s = s;    //把Socket私有。  
  18.     }  
  19.     public void run()  
  20.     {  
  21.             System.out.println(s.getInetAddress().getHostAddress()+":"+s.getPort()+"已连接"); //打印连接的客户端信息。  
  22.             try  
  23.             {  
  24.                 while(true)  
  25.                 {  
  26.                     byte[] buff = new byte[1024];  
  27.                     s.getInputStream().read(buff);  
  28.                     if(new String(buff,0,buff.length).equals("over")) //如果客户端发来over,就跳出循环。  
  29.                         break;  
  30.                     if(buff.toString()!=null) //判断客户端是否发来消息。  
  31.                     {  
  32.                         System.out.println(s.getInetAddress().getHostAddress()  
  33.                                 +":"+s.getPort()+"发来消息"+new String(buff,0,buff.length)); //打印客户端发来的消息。  
  34.                     }  
  35.                 }  
  36.             }  
  37.             catch (Exception e)  
  38.             {  
  39.                 System.out.println(s.getInetAddress().getHostAddress()+":"+s.getPort()+"断开连接");   
  40.             }  
  41.             finally  
  42.             {  
  43.                 try  
  44.                 {  
  45.                     s.close(); //关闭Socket。  
  46.                 }  
  47.                 catch (IOException e)  
  48.                 {  
  49.                     e.printStackTrace();  
  50.                 }  
  51.             }  
  52.     }  
  53. }  
  54. public class ServerDemo  
  55. {  
  56.     public static void main(String[] args) throws Exception  
  57.     {  
  58.         ServerSocket s = new ServerSocket(20000); //建议ServerSocket服务。  
  59.         try  
  60.         {  
  61.             while(true)  
  62.             {  
  63.                 Socket socket = s.accept(); //阻塞监听端口,有客户端连入时就返回一个Socket对象。  
  64.                 new Thread(new SocketThread(socket)).start(); //把返回的Socket对象传入创建好的Socket处理线程中,  
  65.                                                               //每个客户端与服务端连接的产生的Socket都会专门处理  
  66.                                                               //这个连接的线程。  
  67.             }  
  68.         }  
  69.         catch (Exception e)  
  70.         {  
  71.             throw new RuntimeException("建立连接失败!");  
  72.         }  
  73.     }  
  74. }  

 

客户端:

 

[java] view plain copy

  1. import java.net.*;  
  2. import java.io.*;  
  3. public class ClinetDemo  
  4. {  
  5.     public static void main(String[] args)   
  6.     {  
  7.         try  
  8.         {  
  9.             Socket s = new Socket(InetAddress.getByName("127.0.0.1"),20000); //建立能连接指定服务器地址和端口的Socket。  
  10.             try  
  11.             {  
  12.                 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); //获取键盘对象。  
  13.                 String line = null;  
  14.                 byte[] buff = new byte[1024];  
  15.                 while(true)  
  16.                 {  
  17.                     line = br.readLine(); //读取键盘输入的数据。  
  18.                     if(line!=null)  
  19.                     {  
  20.                         if(line.equals("over")) //判断键盘输入的数据是否为over,是的话跳出循环。  
  21.                             break;  
  22.                         s.getOutputStream().write(line.getBytes()); //通过Socket的输出流写入数据。  
  23.                     }  
  24.                 }  
  25.             }  
  26.             catch (Exception e)  
  27.             {  
  28.                 throw new RuntimeException("发送数据失败!");  
  29.             }  
  30.         }  
  31.         catch (Exception e)  
  32.         {  
  33.             throw new RuntimeException("连接不上服务端或与服务端失去连接!");  
  34.         }  
  35.     }  
  36. }  

© 著作权归作者所有

上一篇: JDBC
下一篇: IO(输入输出)
architect刘源源

architect刘源源

粉丝 169
博文 564
码字总数 941209
作品 0
浦东
程序员
私信 提问
C#网络编程系列文章(六)之Socket实现同步UDP服务器

原创性声明 本文作者:小竹zz 本文地址http://blog.csdn.net/zhujunxxxxx/article/details/44258719 转载请注明出处 文章系列目录 C#网络编程系列文章(一)之Socket实现异步TCP服务器 C#网络编...

zhujunxxxxx
2015/03/16
0
0
C#网络编程系列文章(五)之Socket实现异步UDP服务器

原创性声明 本文作者:小竹zz 本文地址http://blog.csdn.net/zhujunxxxxx/article/details/44258719 转载请注明出处 文章系列目录 C#网络编程系列文章(一)之Socket实现异步TCP服务器 C#网络编...

zhujunxxxxx
2015/03/15
0
0
Linux网络编程:什么是Linux下的网络编程?

想知道Linux下的网络编程培训×××?先来了解一下什么是Linux下的网络编程吧!Linux下的网络编程指的是socket套接字编程,入门比较简单。在学校里学过一些皮毛,平时就是自学玩,没有见识过...

长沙千锋
2018/05/23
0
0
C#网络编程系列文章(二)之Socket实现同步TCP服务器

原创性声明 本文作者:小竹zz 本文地址http://blog.csdn.net/zhujunxxxxx/article/details/44258719 转载请注明出处 文章系列目录 C#网络编程系列文章(一)之Socket实现异步TCP服务器 C#网络编...

zhujunxxxxx
2015/03/14
0
0
C#网络编程系列文章(一)之Socket实现异步TCP服务器

原创性声明 本文作者:小竹zz 本文地址http://blog.csdn.net/zhujunxxxxx/article/details/44258719 转载请注明出处 文章系列目录 C#网络编程系列文章(一)之Socket实现异步TCP服务器 C#网络编...

zhujunxxxxx
2015/03/14
0
0

没有更多内容

加载失败,请刷新页面

加载更多

OSChina 周四乱弹 —— 干啥啥不行,吃饭第一名。

Osc乱弹歌单(2019)请戳(这里) 【今日歌曲】 @巴拉迪维 : 李白到杜甫家吃饭。杜甫洗菜,发现只有青瓜和萝卜,心中愧疚。这时,他看见了邻居家的鸡,杜甫一时心酸,忍不住喃喃自语:我希望...

小小编辑
18分钟前
75
7
Java描述设计模式(08):桥接模式

本文源码:GitHub·点这里 || GitEE·点这里 一、桥接模式简介 1、基础描述 桥梁模式是对象的结构模式。又称为柄体(Handle and Body)模式或接口(Interface)模式。桥梁模式的用意是“将抽象化...

知了一笑
18分钟前
4
0
C++ 函数指针的用法

天王盖地虎626
32分钟前
1
0
白话比原链跨链技术

随着Bystack的主侧链架构的推出,主侧链之间的跨链问题也成为比原链团队的主要攻克工程难题,当前比原链已经推出了两种跨链的机制,各有不同的侧重点,可能因为本身的跨链技术比较晦涩,本篇...

比原链Bytom
40分钟前
2
0
PostgreSQL参数search_path影响及作用

search_path稍微熟悉PG就会用到,用法这里就不必讲,本篇主要讲它在程序里怎样处理。 1、GUC参数定义 这是个 config_string 参数 {{"search_path", PGC_USERSET, CLIENT_CONN_STATEMENT,...

有理想的猪
今天
9
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部