socket编程学习笔记

socket编程：

1、网络基础知识

　　两台计算机通过网络进行通信，首先两台计算机要有唯一的标识，即唯一的IP地址。其次他们要有共同的语言用来交流即协议。再者，每套主机要有相应的端口号。　

　　TCP/IP协议：
　　--TCP/IP协议是目前世界上应用最为广泛的协议，是以TCP和IP为基础的不同层次上多个协议的集合，也称：TCP/IP协议族或 TCP/IP协议栈
　　--TCP的全称：Transmission Control Protocol 传输控制协议
　　--IP的全称：Internet Protocol 互联网协议

　　TCP/IP模型
　　　　一般分为五层：
　　　　　　5-应用层：HTTP 超文件传输协议 FTP 文件传输协议 SMTP 简单邮件传送协议 Telnet远程登录服务
　　　　　　4-传输层：TCP/IP协议
　　　　　　3-网络层
　　　　　　2-数据链路层
　　　　　　1-物理层：网线，双绞线，网卡　

　　IP地址---《探索Linux的网络世界》为实现网络中不同计算机之间的通信，每台机器都必须有一个唯一的标识---IP地址　　　
　　IP地址格式：数字型，如：192.168.0.1
　　IP地址的长度：32位的二进制　　

端口
　　端口号
　　　　1、用于区分不同应用程序
　　　　2、端口号范围为0~65535，其中0~1023为系统所保留
　　　　3、IP地址和端口号就组成了所谓的Socket，Socket是网络上运行的程序之间双向通信链路的终结点，是TCP和UDP的基础。
　　　　4、常见的一些协议使用的端口号
　　　　　　http：80 ftp：21 telnet：23

　　Java中的网络支持
　　针对网络通信的不同层次，Java提供的网络功能有四大类：
　　　　1、InetAddress类：用于标识网络上的硬件资源。
　　　　2、URL：统一资源定位符通过URL可以直接读取或写入网络上的数据。
　　　　3、Sockets（TCP编程）：使用TCP协议实现网络通信的Socket相关的类。
　　　　4、Datagram（UDP编程）：使用UDP协议，将数据保存在数据报中，通过网络进行通信。

2、InetAdress类
　　java.net.InetAddress
　　所有已实现的接口：Serializable
　　直接已知子类：Inet4Address,Inet6Address
　　没有构造方法。
(1)InetAddress类用于标识网络上的硬件资源，表示互联网协议（IP）地址。
栗子又来啦！！！

 1 import java.net.InetAddress;
 2 import java.net.UnknownHostException;
 3 import java.util.Arrays;
 4 
 5 public class Inet{
 6     public static void main(String[] args)throws UnknownHostException{
 7         //获取本机的InetAddress实例
 8         InetAddress address=InetAddress.getLocalHost();
 9         System.out.println("计算机名："+address.getHostName());
10         System.out.println("IP地址："+address.getHostAddress());
11         byte[] bytes=address.getAddress();//获取字节数组形式的IP地址
12         System.out.println("字节数组形式的IP："+Arrays.toString(bytes));
13         System.out.println(address);//直接输出InetAdress对象
14 
15         //根据机器名获取InetAddress实例
16         //InetAddress address2=InetAddress.getByName("MyTeam");
17         //根据IP地址获取相应的实例信息
18         InetAddress address2=InetAddress.getByName("192.16.54.161");
19         System.out.println("计算机名："+address2.getHostName());
20         System.out.println("IP地址："+address2.getHostAddress());
21     }
22 }

会输出计算机名，IP地址，以及字节数组形式的IP。

输出：（计算机名纯属自己杜撰，如有雷同，纯属巧合，IP地址也是）

计算机名：MyTeam
IP地址：192.16.54.161
字节数组形式的IP：[-80,16,54,-70]
MyTeam/192.16.54.161
计算机名：MyTeam.it2102.fhjd.com.cn
IP地址：192.16.54.161

3、URL
　　3-1、URL(Uniform Resource Locator)统一资源定位符，表示Internet上某一资源的地址
小栗子来理解url的常用方法：

 1 import java.net.URL;
 2     import java.net.MalformedURLException;
 3     //URL的常用方法
 4     public class UURL{
 5         public static void main(String[] args){
 6             try{
 7                 //创建一个URL实例
 8                 URL study=new URL("http://www.study.com");
 9                 //?后面表示参数，#后面表示锚点
10                 URL url=new URL(study,"/index.html?username=tom#test");
11                 System.out.println("协议："+url.getProtocol());//输出：协议：http
12                 System.out.println("主机："+url.getHost());
13                 //如果未指定端口号，则根据协议的不同，使用默认的端口号，此时getPort()方法的返回值为-1.
14                 System.out.println("端口："+url.getPort());
15                 System.out.println("文件路径："+url.getPath());//输出：文件路径：/index.html
16                 System.out.println("文件名："+url.getFile());//输出：/index.html?username=tom
17                 System.out.println("相对路径："+url.getRef());//输出：test
18                 System.out.println("查询字符串："+url.getQuery());//输出：username=tom
19             }catch(MalformedURLException e){
20                 e.printStackTrace();
21             }
22             
23         }
24     }

3-2、使用URL读取网页内容
　　1、通过URL对象的openStream()方法可以得到指定资源的输入流。
　　2、通过流来读取、访问网络上的数据。
！！！看这里

 1 import java.net.MalformedURLException;
 2     import java.net.URL;
 3     import java.io.InputStream;
 4     import java.io.InputStreamReader;
 5     import java.io.BufferedReader;
 6     import java.io.IOException;
 7     public class Test{
 8         public static void main(String[] args){
 9             try{
10                 //创建一个URL实例
11                 URL url=new URL("http://www.baidu.com");
12                 //通过URL的openStream方法获取URL对象所表示的资源的字节输入
13                 InputStream is=url.openStream();
14                 //将字节输入流转换为字符输入流
15                 InputStreamReader isr=new InputStreamReader(is,"utf-8");
16                 //为流添加缓冲，提高读取的效率
17                 BufferedReader br =new BufferedReader(isr);
18                 String data=br.readLine();//读取数据
19                 while(data!=null){//循环读取数据
20                     System.out.println(data);//输出数据
21                     data=br.readLine();
22                     }
23                     br.close();
24                     isr.close();
25                     is.close();
26             }catch(MalformedUrlException e){
27                 e.printStackTrace();
28             }catch(IOException e){
29                 e.printStackTrace();
30             }
31         }
32     }

4、Socket通信
　　TCP协议是面向连接、可靠的、有序的、以字节流的方式发送数据。
　　基于TCP协议实现网络通信的类：客户端的Socket类，服务器端的ServerSocket类
Socket通信模型
　　　　Server
建立服务器倾听socket Client
等待并接收连接请求------------建立连接---------创建连接socket向服务端发送请求
接收请求后创建连接socket
--------------------------------------------------------------------------------------------------------------------
InputStream----------------------------------------------OutputStream
开始通信
OutputStream-------------------------------------------InputStream
-------------------------------------------------------------------------------------------------------------------
关闭socket及相关资源--------结束通信-------------关闭socket及相关资源

Socket通信实现步骤
　　1、分别在服务器端和客户端创建ServerSocket和Socket
　　2、打开连接到Socket的输入/输出流，进行数据通信
　　3、按照协议对Socket进行读/写操作
　　4、关闭输入输出流，关闭Socket

ServerSocket：
　　ServerSocket类位于java.net包中，直接已知子类是SQLServerSocket,此类实现服务器套接字。
　　服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。
　　服务器套接字的实际工作由SocketImpl类的实例执行。应用程序可以更改创建套接字实现的套接字工厂来配置它自身，从而创建适合本地防火墙的套接字。

构造方法：
　　ServerSocket(int port)----创建绑定到特定端口的服务器套接字。
方法摘要：
　　accept()-----侦听并接受到此套接字的连接。
　　bind()-------将ServerSocket绑定到特定地址（IP地址和端口号）
　　close()------关闭此套接字。
　　getChannel()------返回与此套接字关联的唯一ServerSocketChannel对象(如果有)
　　getInetAddress()------返回此服务器套接字的本地地址。
　　getLocalPort()--------返回此套接字在其上侦听的端口。
　　getLocalSocketAddress()----返回此套接字绑定的端点的地址，如果尚未绑定则返回null。
　　getReceiveBufferSize()---获取此ServerSocket的SO_RCVBUF选项的值，该值是将用于从此ServerSocket接受的套接字的建议缓冲区大小。

Socket：
　　位于java.net包中，直接已知子类是：SSLSocket，此类实现客户端套接字(也可以就叫“套接字”)。套接字
是两台机器间通信的端点。
　　套接字的实际工作由SocketImpl类的实例执行。应用程序通过更改创建套接字实现的套接字工厂可以配置它自身，创建适合本地防火墙的套接字。

构造方法：
　　Socket(InetAddress address，int port)----创建一个流套接字并将其连接到指定IP地址的指定端口号。
　　Socket(String host,int port)-----创建一个流套接字并将其连接到指定主机上的指定端口号。
方法摘要：
　　bind(SocketAddress bindpoint)---将套接字绑定到本地地址。
　　close()-----关闭此套接字。
　　connect(SocketAddress endpoint,int timeout)------将此套接字连接至服务器，并制定一个超时值。
　　getChannel()--------返回与此数据报套接字关联的唯一的SocketChannel对象(如果有)。
　　getInetAddress()-----返回套接字连接的地址。
　　getInputStream()-----返回此套接字的输入流。
　　getKeepAlive()-------测试是否启用SO_KEEPALIVE.
　　shutdownInput()------此套接字的输入流置于“流的末尾”。
　　shutdownOutput()------禁用此套接字的输出流。

实现用户登录的步骤：
　　基于TCP协议的Socket通信，实现用户登录
服务器端：

 1 import java.net.ServerSocket;
 2     import java.net.Socket;
 3     import java.io.InputStream;
 4     import java.io.InputStreamReader;
 5     import java.io.IOException;
 6     import java.io.OutputStream;
 7     import java.io.PrintWriter;
 8     public class Server{
 9         public static void main(String[] args){
10             try{
11                 //1、创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口
12                 ServerSocket serverSocket=new ServerSocket(8888);
13                 //2、调用accept()方法开始监听，等待客户端的连接
14                 System.out.println("***服务器即将启动，等待客户端的连接***");
15                 serverSocket.accept();
16                 Socket socket=serverSocket.accept();
17                 //3、获取输入流，并读取客户端信息
18                 InputStream is=socket.getInputStream();//字节输入流
19                 InputStreamReader isr=new InputStreamReader(is);//将字节流转换为字符流
20                 BufferedReader br=new BufferedReader(isr);//为输入流添加缓冲
21                 String info=null;
22                 while((info=br.readLine())!=null){//循环读取客户端的信息
23                     System.out.println("我是服务器，客户端说："+info);
24                 }
25                 socket.shutdownInput();//关闭输入流
26                 //4、获取输出流，响应客户端的请求
27                 OutputStream os=socket.getOutputStream();
28                 PrintWriter pw=new PrintWriter(os);//包装为打印流
29                 pw.write("欢迎您！");
30                 pw.flush();//调用flush()方法将缓冲输出
31                 //5、关闭相关资源
32                 br.close();
33                 isr.close();
34                 is.close();
35                 pw.close();
36                 os.close();
37                 socket.close();
38                 serverSocket.close();
39             }catch(IOException e){
40                 e.printStackTrace();
41             }
42         }
43     }

客户端：

 1 import java.net.Socket; 
 2     import java.net.IOException;
 3     import java.io.BufferedReader;
 4     import java.io.InputStreamReader;
 5     import java.io.InputStream;
 6     import java.io.OutputStream;
 7     import java.io.PrintWriter;
 8     import java.net.UnknownHostException;
 9     public class Client{
10         public static void main(String[] args){
11             try{
12                 //1、创建客户端Socket，指定服务器地址和端口
13                 Socket socket=new Socket("localhost",8888);
14                 //2、获取输出流，向服务器端发送信息
15                 OutputStream os=socket.getOutputStream();//字节输出流
16                 PrintWriter pw=new PrintWriter(os);//将输出流包装为打印流
17                 pw.write("用户名：admin;密码：123")；
18                 pw.flush();
19                 socket.shutdownOutput();//关闭输出流
20                 //3、获取输入流，并读取服务器端的响应信息
21                 InputStream is=socket.getInputStream();
22                 BufferedReader br=new BufferedReader(new InputStreamReader(is));//将字节流包装为字符流
23                 String info=null;
24                 while((info=br.readLine())!=null){
25                     System.out.println("我是客户端，服务器说："+info);
26                 }
27                 //4、关闭资源
28                 br.close();
29                 is.close();
30                 pw.close();
31                 os.close();
32                 socket.close();
33             }catch(UnknownHostException e){
34                 e.printStackTrace();
35             }catch(IOException e){
36                 e.printlnStackTrace();
37             }
38         }
39     }

注：服务器必须早于客户端启动

5、使用多线程实现多客户端的通信
基本步骤：
　　1、服务器端创建ServerSocket，循环调用accept()等待客户端连接
　　2、客户端创建一个socket并请求和服务器端连接
　　3、服务器端接受客户端请求，创建socket与该客户建立专线连接
　　4、创建连接的两个socket在一个单独的线程上对话
　　5、服务器端继续等待新的连接
服务器线程处理类：

 1 import java.net.Socket;
 2     import java.io.InputStream;
 3     import java.io.IOException;
 4     import java.io.BufferedReader;
 5     import java.io.InputStreamReader;
 6     import java.io.OutputStream;
 7     import java.io.PrintWriter;
 8 
 9     public class ServerThread extends Thread{
10         //与本线程相关的Socket
11         Socket socket=null;
12 
13         public ServerThread(Socket socket){
14             this.socket=socket;
15         }
16 
17         //线程执行的操作，响应客户端的请求
18         public void run(){
19             InputStream is=null;
20             InputStreamReader isr=null;
21             BufferedReader br=null;
22             OutputStream os=null;
23             PrintWriter pw=null;
24             try{
25                 //获取输入流，读取客户端的信息
26                 is=socket.getInputStream();//字节输入流
27                 isr=new InputStreamReader(is);//将字节流转换为字符流
28                 br=new BufferedReader(isr);//为输入流添加缓冲
29                 String info=null;
30                 while((info=br.readLine())!=null){//循环读取客户端的信息
31                     System.out.println("我是服务器，客户端说："+info);
32                 }
33                 socket.shutdownInput();//关闭输入流
34                 //获取输出流，响应客户端的请求
35                 os=socket.getOutputStream();
36                 pw=new PrintWriter(os);//包装为打印流
37                 pw.write("欢迎您！");
38                 pw.flush();//调用flush()方法将缓冲输出
39             }catch(IOException e){
40                 e.printStrackTrace();
41             }finally{
42                 //关闭相关资源
43                 try{
44                     if(pw!=null) pw.close();
45                     if(os!=null) os.close();
46                     if(br!=null) br.close();
47                     if(isr!=null) isr.close();
48                     if(is!=null) is.close();
49                     if(socket!=null) socket.close();
50                 }catch(IOException e){
51                     e.printStrackTrace();
52                 }
53             }
54         }
55     }

服务器端：

 1     import java.net.ServerSocket;
 2     import java.net.Socket;
 3     import java.io.InputStream;
 4     import java.io.InputStreamReader;
 5     import java.io.IOException;
 6     import java.io.OutputStream;
 7     import java.io.PrintWriter;
 8     public class Server{
 9         public static void main(String[] args){
10             try{
11                 //1、创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口
12                 ServerSocket serverSocket=new ServerSocket(8888);
13                 Socket socket=null;
14                 //记录客户端的数量
15                 int count=0;
16                 System.out.println("***服务器即将启动，等待客户端的连接***");
17                 //循环监听等待客户端的连接
18                 while(true){
19                 //调用accept()方法开始监听，等待客户端的连接
20                 socket=serverSocket.accept();
21                 //启动一个线程，通过当前线程与客户端进行通信
22                 ServerThread serverThread=new ServerThread(socket);
23                 //启动线程
24                 serverThread.start();
25 
26                 count++;//统计客户端的数量
27                 System.out.println("客户端的数量："+count);
28                 InetAddress address=socket.getInetAddress();
29                 System.out.println("当前客户端的IP:")+address.getHostAddress());
30                 }
31             }catch(IOException e){
32                 e.printStackTrace();
33             }
34         }
35     }

客户端：

 1 import java.net.Socket; 
 2     import java.net.IOException;
 3     import java.io.BufferedReader;
 4     import java.io.InputStreamReader;
 5     import java.io.InputStream;
 6     import java.io.OutputStream;
 7     import java.io.PrintWriter;
 8     import java.net.UnknownHostException;
 9     public class Client{
10         public static void main(String[] args){
11             try{
12                 //1、创建客户端Socket，指定服务器地址和端口
13                 Socket socket=new Socket("localhost",8888);
14                 //2、获取输出流，向服务器端发送信息
15                 OutputStream os=socket.getOutputStream();//字节输出流
16                 PrintWriter pw=new PrintWriter(os);//将输出流包装为打印流
17                 //模拟多客户端同时登录
18                 pw.write("用户名：admin;密码：123");
19                 //pw.write("用户名：er;密码：456");
20                 pw.flush();
21                 socket.shutdownOutput();//关闭输出流
22                 //3、获取输入流，并读取服务器端的响应信息
23                 InputStream is=socket.getInputStream();
24                 BufferedReader br=new BufferedReader(new InputStreamReader(is));//将字节流包装为字符流
25                 String info=null;
26                 while((info=br.readLine())!=null){
27                     System.out.println("我是客户端，服务器说："+info);
28                 }
29                 //4、关闭资源
30                 br.close();
31                 is.close();
32                 pw.close();
33                 os.close();
34                 socket.close();
35             }catch(UnknownHostException e){
36                 e.printStackTrace();
37             }catch(IOException e){
38                 e.printlnStackTrace();
39             }
40         }
41     }

6、基于UDP的socket编程
　　UDP协议（用户数据报协议）是无连接的、不可靠的、无序的。
　　UDP协议以数据报作为数据传输的载体
　　使用UDP进行数据传输时，首先需要将要传输的数据定义成数据报(Datagram),在数据报中指明数据所要达到的Socket(主机地址和端口号)，然后再将数据报发送出去。
　　相关操作类：
　　DatagramPacket:表示数据报包，数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由器。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序传递做出保证。

构造方法摘要：
　　DatagramPacket(byte[] buf, int length):构造DatagramPacket,用来接收长度为length的数据包。
　　DatagramPacket(byte[] buf,int length,InetAddress address,int port):构造数据报包，用来将长度为length的包发送至指定主机上的指定端口号。
　　DatagramPacket(byte[] buf,int offset,int length):构造DatagramPacket,用来接收长度为length的包，在缓冲区指定了偏移量为offset
　　DatagramSocket:进行端到端通信的类，表示用来发送和接收数据报包的套接字。
　　数据报套接字是包投递服务的发送或接收点。每个在数据报套接字上发送或接收的包都是自由的。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序。

构造方法摘要：
　　DatagramSocket():构造数据报套接字并将其绑定到本地主机上任何可用的端口。
　　DatagramSocket(DatagramSocketImpl impl):创建带有指定DatagramSocketImpl的未绑定数据报套接字。
　　DatagramSocket(int port,InetAddress laddr):创建数据报套接字，将其绑定到指定的本地地址。
方法摘要：
　　close():关闭此数据报套接字。
　　bind():将此DatagramSocket绑定到特定的地址和端口。
　　getLocalAddress():返回此套接字连接的地址
　　getpPort():返回此套接字的端口
　　send():从此套接字发送数据报包
　　receive():从此套接字接收数据报包

基于UDP的用户登录：
服务器端实现步骤：

 1 import java.io.IOException;
 2     import java.net.DatagramPacket;
 3     import java.net.DatagramSocket;
 4     import java.net.InetAddress;
 5 
 6     public class UDPServer{
 7         public static void main(String[] args) throws IOException{
 8         /*
 9          *接受客户端发送的数据
10          */
11         //1、创建服务器端DatagramSocket,指定端口
12         DatagramSocket socket=new DatagramSocket(8800);
13         //2、创建数据报，用于接收客户端发送的数据
14         byte[] data=new byte[1024];//创建字节数组，指定接收的数据包的大小
15         DatagramPacket packet=new DatagramPacket(data,data.length);
16         //3、接收客户端发送的数据
17         System.out.println("****服务器端已经启动，等待客户端发送数据");
18         socket.receive(packet);//此方法在接收到数据报之前会一直阻塞
19         //4、读取数据
20         String info=new String(data,0,packet.getLength());
21         System.out.println("我是服务器，客户端说："+info);
22         /*
23          *向客户端响应数据
24          */
25         //1、定义客户端的地址、端口号、数据
26         InetAddress address=packet.getAddress();
27         int port=packet.getPort();
28         byte[] data2="欢迎您！".getBytes();
29         //2、创建数据报、包含响应的数据信息
30         DatagramPacket packet=new DatagramPacket(data2,data2.length,address,port)
31         //3、响应客户端
32         socket.send(packet2);
33         //4、关闭资源
34         socket.close();
35         }
36     }

客户端实现步骤：

 1 import java.net.DatagramSocket;
 2     import java.net.DatagramPacket;
 3     import java.net.InetAddress;
 4     import java.io.IOException;
 5 
 6     public class UDPClient{
 7         /*
 8          *向服务器端发送请求
 9          */
10         public static void main(String[] args) throws IOException{
11             //1、定义服务器的地址、端口号、数据
12             InetAddress address=InetAddress.getByName("localhost");
13             int port=8800;
14             byte[] data="用户名：admin;密码：123".getBytes();
15             //2、创建数据报，包含发送的数据信息
16             DatagramPacket packet packet=new DatagramPacket(data,data.length,address,port)
17             //3、创建DatagramSocket对象
18             DatagramSocket socket=new DatagramSocket();
19             //4、向服务器端发送数据报
20             socket.send(packect);
21 
22             /*
23              *接收服务器端响应的数据
24              */
25             //1、创建数据报，用于接收服务器端响应的数据
26             byte[] data2=new byte[1024];
27             DatagramPacket packet2=new DatagramPacket(data2,data.length);
28             //2、接受服务器响应的数据
29             socket.receive(packet2);
30             //3、读取数据
31             String reply=new String(data2,0,packet2.getLength());
32             System.out.println("我是客户端，服务器说："+reply);
33             //4、关闭资源
34             socket.close();
35         }
36     }