Java Socket应用---慕课网笔记

第一章 网络基础知识

1-1 网络基础简介

Java最初是作为网络编程语言出现的，其对网络提供了高度的支持
而在网络编程中使用最多的就是Socket，像QQ，MSN都使用了Socket
相关的技术

Java提供了强大的类，方便网络编程的开发

Socket编程
1. 网络基础知识
2. InetAddress类
3. URL
4. TCP编程
5. UDP编程

两台计算机通过网络进行通信的必备条件：
- 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地址
为实现网路中不同计算机之间的通信，每台机器都必须有一个唯一的
标识–IP地址

IP地址格式：数字型，如：192.168.0.1
IPv4定义了32位2进制的格式

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

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

第2章 Java 中网络相关 API 的应用

2-1 Java 中的 InetAddress 的应用

InetAddress类
1. InetAddress类用于标识网络上的硬件资源，表示互联
网协议（IP）地址。

JDK1.8
Class InetAddress
java.lang.Object
java.net.InetAddress

这个类代表一个互联网协议（IP）地址。

Modifier and Type Method and Description boolean equals(Object obj)
将此对象与指定的对象进行比较。 byte[] getAddress()
返回该对象的 InetAddress原IP地址。 static InetAddress[] getAllByName(String host)
给定一个主机的名称，返回其IP地址的数组，基于系统上的配置的名称服务。 static InetAddress getByAddress(byte[] addr)
返回给定的原始IP地址 InetAddress对象。 static InetAddress getByAddress(String host, byte[] addr)
它创造了一个基于所提供的主机名和IP地址。 static InetAddress getByName(String host)
确定主机的IP地址，给定主机名。 String getCanonicalHostName()
获取此IP地址的完全限定的域名。 String getHostAddress()
返回文本表示中的IP地址字符串。 String getHostName()
获取此IP地址的主机名。 static InetAddress getLocalHost()
返回本地主机的地址。 static InetAddress getLoopbackAddress()
返回回送地址。 int hashCode()
返回该IP地址的hash码。 boolean isAnyLocalAddress()
实用程序来检查是否一个通配符解决它。 boolean isLinkLocalAddress()
实用程序检查，如果它是一个链路本地地址。 boolean isLoopbackAddress()
实用程序来检查它是环回地址。 boolean isMCGlobal()
实用程序，检查多播地址是否具有全局范围。 boolean isMCLinkLocal()
实用程序，检查多播地址是否有连接范围。 boolean isMCNodeLocal()
实用程序，检查多播地址是否有节点范围。 boolean isMCOrgLocal()
实用程序，检查多播地址是否有组织范围。 boolean isMCSiteLocal()
实用程序，检查多播地址是否有网站范围。 boolean isMulticastAddress()
实用程序检查，如果它是一个IP多播地址。 boolean isReachable(int timeout)
测试是否该地址是可到达的。 boolean isReachable(NetworkInterface netif, int ttl, int timeout)
测试是否该地址是可到达的。 boolean isSiteLocalAddress()
实用程序检查，如果它是一个站点本地地址。 String toString()
将这个IP地址到一个 String。

/* * InetAddress类 */public class Test01 {    public static void main(String[] args) throws UnknownHostException {        // 获取本机的InetAddress实例        InetAddress address = InetAddress.getLocalHost();        System.out.println("计算名：" + address.getHostName());        System.out.println("IP地址：" + address.getHostAddress());        byte[] bytes = address.getAddress();// 获取字节数组形式的IP地址        System.out.println("字节数组形式的IP：" + Arrays.toString(bytes));        System.out.println(address);// 直接输出InetAddress对象        // 根据机器名获取InetAddress实例        InetAddress address2 = InetAddress.getByName("Sc-201411281008");        System.out.println("计算名：" + address2.getHostName());        System.out.println("IP地址：" + address2.getHostAddress());    }}

2-2 Java 中的 URL 的应用

URL
1. URL(Uniform Resource Locator)统一资源定位符，表示Internet上某一资源的地址。
2. URL由两部分组成：协议名称和资源名称，中间用冒号隔开。
- http://www.imooc.com
- 协议名称：http
- 资源名称：www.imooc.com
3. 在java.net包中，提供了URL类来表示URL。

Class URL
java.lang.Object
java.net.URL

类 URL代表统一资源定位符，指向“万维网上的资源”。一个资源可以是简单的作为一个文件或一个目录，或者它可以是一个更复杂的对象的参考，如查询到数据库或搜索引擎。

构造方法 Constructor and Description URL(String spec) 创建于 String表示 URL对象。 URL(String protocol, String host, int port, String file) 创建从指定的 protocol， host，一 URL对象 port数，和 file。 URL(String protocol, String host, int port, String file, URLStreamHandler handler) 创建从指定的 protocol， host， port数， file一 URL对象，和 handler。 URL(String protocol, String host, String file) 创建一个URL指定的 protocol名字， host名字，和 file名称。 URL(URL context, String spec) 通过在指定的上下文中解析给定的规范，创建一个网址。 URL(URL context, String spec, URLStreamHandler handler) 通过在指定的上下文中解析给定的规范与指定的处理程序创建一个链接。 Modifier and Type Method and Description boolean equals(Object obj)
将此网址与另一个对象进行比较。 String getAuthority()
得到这 URL权威部分。 Object getContent()
获取此网址的内容。 Object getContent(类[] classes)
获取此网址的内容。 int getDefaultPort()
得到这个 URL相关协议的默认端口号。 String getFile()
得到这 URL文件名。 String getHost()
得到这 URL主机名称，如适用。 String getPath()
得到这 URL路径的一部分。 int getPort()
得到这 URL端口号。 String getProtocol()
得到这 URL协议名称。 String getQuery()
得到这 URL查询的一部分。 String getRef()
得到锚（也被称为“参考”）这 URL。 String getUserInfo()
得到这 URL用户信息部分。 int hashCode()
创建一个适用于哈希表索引的整数。 URLConnection openConnection()
返回一个 URLConnection实例表示的远程对象的连接被称为 URL。 URLConnection openConnection(Proxy proxy)
同 openConnection()，除了连接将通过指定的代理进行；协议处理程序不支持proxing将忽略代理参数，使正常的连接。 InputStream openStream()
打开一个连接到这 URL和返回的连接阅读 InputStream。 boolean sameFile(URL other)
比较两个网址，不包括片段组件。 static void setURLStreamHandlerFactory(URLStreamHandlerFactory fac)
设置应用程序的 URLStreamHandlerFactory。 String toExternalForm()
构建该 URL字符串表示形式。 String toString()
构建该 URL字符串表示形式。 URI toURI()
返回一个 URI相当于这个URL。

/* * URL常用方法 */public class Test02 {    public static void main(String[] args) {        try {            //创建一个URL实例            URL imooc=new URL("http://www.imooc.com");            //?后面表示参数，#后面表示锚点            URL url=new URL(imooc, "/index.html?username=tom#test");            System.out.println("协议："+url.getProtocol());            System.out.println("主机："+url.getHost());            //如果未指定端口号，则使用默认的端口号，此时getPort()方法返回值为-1            System.out.println("端口："+url.getPort());            System.out.println("文件路径："+url.getPath());            System.out.println("文件名："+url.getFile());            System.out.println("相对路径："+url.getRef());            System.out.println("查询字符串："+url.getQuery());        } catch (MalformedURLException e) {            e.printStackTrace();        }    }}

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

/* * 使用URL读取网页内容 */public class Test03 {    public static void main(String[] args) {        try {            //创建一个URL实例            URL url = new URL("http://www.baidu.com");            //通过URL的openStream方法获取URL对象所表示的资源的字节输入流            InputStream is = url.openStream();            //将字节输入流转换为字符输入流            InputStreamReader isr = new InputStreamReader(is, "utf-8");            //为字符输入流添加缓冲            BufferedReader br = new BufferedReader(isr);            String data = br.readLine();//读取数据            while (data != null) {//循环读取数据                System.out.println(data);//输出数据                data = br.readLine();            }            br.close();            isr.close();            is.close();        } catch (MalformedURLException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }    }}

第3章 通过 Socket 实现 TCP 编程

3-1 Socket 简介

Socket通信
TCP协议是面向连接、可靠的、有序的，以字节流的方式发送数据
基于TCP协议实现的网络通信的类
- 客户端的Socket类
- 服务端的ServerSocket类

Socket通信模型
1. 建立连接
- Server
- 建立服务端侦听socket
- 等待并接收连接请求
- 接收请求后创建socket
- Client
- 创建连接socket向服务端发送请求
2. 开始通信
- Server
- InputStream
- OutputStream
- Client
- OutputStream
- InputStream
3. 结束通信
- Server
- 关闭socket及相关资源
- Client
- 关闭socket及相关资源

Socket通信实现步骤
1. 创建ServerSocket和Socket
2. 打开连接到Socket的输入/输出流
3. 按照协议对Socket进行读/写操作
4. 关闭输入输出流、关闭Socket

Class ServerSocket

java.lang.Object
java.net.ServerSocket

这个类实现了服务器套接字。服务器套接字等待来自网络的请求。它基于该请求执行某些操作，然后可能向请求者返回结果。

构造方法 Constructor and Description ServerSocket() 创建一个绑定服务器套接字。 ServerSocket(int port) 创建一个服务器套接字，绑定到指定的端口。 ServerSocket(int port, int backlog) 创建一个服务器套接字，并将其绑定到指定的本地端口号，并使用指定的积压。 ServerSocket(int port, int backlog, InetAddress bindAddr) 用指定的端口创建一个服务器，听积压，和本地IP地址绑定到。 Modifier and Type Method and Description Socket accept()
监听要对这个套接字作出的连接并接受它。 void bind(SocketAddress endpoint)
ServerSocket绑定到一个特定的地址（IP地址和端口号）。 void bind(SocketAddress endpoint, int backlog)
ServerSocket绑定到一个特定的地址（IP地址和端口号）。 void close()
关闭这个套接字。 ServerSocketChannel getChannel()
返回与此套接字关联的独特的 ServerSocketChannel对象，如果任何。 InetAddress getInetAddress()
返回此服务器套接字的本地地址。 int getLocalPort()
返回此套接字正在侦听的端口号。 SocketAddress getLocalSocketAddress()
返回此套接字绑定到的端点的地址。 int getReceiveBufferSize()
得到这个 ServerSocket的 SO_RCVBUF期权的价值，即该缓冲区的大小，将用于接受来自这 ServerSocket插座。 boolean getReuseAddress()
如果 SO_REUSEADDR启用。 int getSoTimeout()
检索设置 SO_TIMEOUT。 protected void implAccept(Socket s)
子类使用此方法重载ServerSocket（）返回自己的子类的插座。 boolean isBound()
返回的ServerSocket绑定状态。 boolean isClosed()
返回的ServerSocket关闭状态。 void setPerformancePreferences(int connectionTime, int latency, int bandwidth)
设置此ServerSocket性能偏好。 void setReceiveBufferSize(int size)
设置一个默认值为提出接受这 ServerSocket插座 SO_RCVBUF选项。 void setReuseAddress(boolean on)
启用/禁用 SO_REUSEADDR套接字选项。 static void setSocketFactory(SocketImplFactory fac)
设置服务器套接字实现工厂为应用程序。 void setSoTimeout(int timeout)
启用/禁用 SO_TIMEOUT以指定的超时时间，以毫秒为单位。 String toString()
返回此套接字作为 String实现的地址与端口。

Class Socket
java.lang.Object
java.net.Socket

这个类实现了客户端套接字（也被称为“套接字”）。套接字是两台机器之间的通信的一个端点。

构造方法 Constructor and Description Socket() 创建一个连接的套接字，与socketimpl系统默认的类型。 Socket(InetAddress address, int port) 创建一个流套接字，并将其与指定的IP地址中的指定端口号连接起来。 Socket(InetAddress host, int port, boolean stream) 过时的。 使用UDP传输DatagramSocket。 Socket(InetAddress address, int port, InetAddress localAddr, int localPort) 创建一个套接字，并将其与指定的远程端口上的指定的远程地址连接起来。 Socket(Proxy proxy) 创建一个连接的套接字类型，指定代理，如果有，应该使用无论任何其他设置。 Socket(SocketImpl impl) 创建一个用户指定的socketimpl连接插座。 Socket(String host, int port) 创建一个流套接字，并将其与指定的主机上的指定端口号连接起来。 Socket(String host, int port, boolean stream) 过时的。 使用UDP传输DatagramSocket。 Socket(String host, int port, InetAddress localAddr, int localPort) 创建一个套接字，并将其连接到指定的远程端口上的指定的远程主机上。 Modifier and Type Method and Description void bind(SocketAddress bindpoint)
将套接字绑定到本地地址。 void close()
关闭这个套接字。 void connect(SocketAddress endpoint)
将此套接字连接到服务器。 void connect(SocketAddress endpoint, int timeout)
将此套接字与指定的超时值连接到服务器。 SocketChannel getChannel()
返回与此套接字关联的独特的 SocketChannel对象，如果任何。 InetAddress getInetAddress()
返回套接字连接的地址。 InputStream getInputStream()
返回此套接字的输入流。 boolean getKeepAlive()
如果 SO_KEEPALIVE启用。 InetAddress getLocalAddress()
获取绑定的套接字的本地地址。 int getLocalPort()
返回此套接字绑定的本地端口号。 SocketAddress getLocalSocketAddress()
返回此套接字绑定到的端点的地址。 boolean getOOBInline()
如果 SO_OOBINLINE启用。 OutputStream getOutputStream()
返回此套接字的输出流。 int getPort()
返回此套接字连接的远程端口号。 int getReceiveBufferSize()
得到这个 Socket的 SO_RCVBUF选项的值，是由平台用于该 Socket输入缓冲区的大小。 SocketAddress getRemoteSocketAddress()
返回此套接字连接的端点的地址，或如果它是无关的 null。 boolean getReuseAddress()
如果 SO_REUSEADDR启用。 int getSendBufferSize()
得到这个 Socket的 SO_SNDBUF期权价值，即缓冲区的大小由平台用于输出在这 Socket。 int getSoLinger()
返回设置 SO_LINGER。 int getSoTimeout()
返回设置 SO_TIMEOUT。 boolean getTcpNoDelay()
如果 TCP_NODELAY启用。 int getTrafficClass()
获取从这个套接字发送的数据包的IP头中的业务类或服务类型 boolean isBound()
返回套接字的绑定状态。 boolean isClosed()
返回套接字的关闭状态。 boolean isConnected()
返回套接字的连接状态。 boolean isInputShutdown()
返回套接字连接的读半是否关闭。 boolean isOutputShutdown()
返回套接字连接的写是否关闭的是否关闭。 void sendUrgentData(int data)
在套接字上发送一个字节的紧急数据。 void setKeepAlive(boolean on)
启用/禁用 SO_KEEPALIVE。 void setOOBInline(boolean on)
启用/禁用 SO_OOBINLINE（TCP紧急数据收据）默认情况下，此选项是禁用TCP套接字上接收紧急数据是默默丢弃。 void setPerformancePreferences(int connectionTime, int latency, int bandwidth)
设置此套接字的性能首选项。 void setReceiveBufferSize(int size)
集 SO_RCVBUF选项，这 Socket指定值。 void setReuseAddress(boolean on)
启用/禁用 SO_REUSEADDR套接字选项。 void setSendBufferSize(int size)
设置这个 Socket指定值的 SO_SNDBUF选项。 static void setSocketImplFactory(SocketImplFactory fac)
设置客户端套接字实现工厂的应用程序。 void setSoLinger(boolean on, int linger)
启用/禁用 SO_LINGER与指定的逗留的时间秒。 void setSoTimeout(int timeout)
启用/禁用 SO_TIMEOUT以指定的超时时间，以毫秒为单位。 void setTcpNoDelay(boolean on)
启用/禁用 TCP_NODELAY（禁用/启用Nagle的算法）。 void setTrafficClass(int tc)
集交通类或从该套接字发送数据包的IP报头字节型服务。 void shutdownInput()
将此套接字的输入流放在“流结束”中。 void shutdownOutput()
禁用此套接字的输出流。 String toString()
将这一 String插座。

3-2 编程实现基于 TCP 的 Socket 通信之服务器端

• 服务器端

  1. 创建ServerSocket对象，绑定监听端口
  2. 通过accept()方法监听客户端请求
  3. 连接建立后，通过输入流读取客户端发送的请求信息
  4. 通过输出流向客户端发送请求
  5. 关闭相关资源

• 客户端

  1. 创建Socket对象，指明需要连接的服务器的地址和端口号
  2. 连接建立后，通过输出流向服务器端发送请求信息
  3. 通过输入流获取服务器响应的信息
  4. 关闭相关资源

/** * 基于TCP协议的socket通信，实现用户登录 * 服务器端 */public class Server {    public static void main(String[] args) {        try {            //1.创建一个服务器端Socket,即ServerSocket,指定绑定的端口            ServerSocket serverSocket = new ServerSocket(8888);            //2.调用accept()方法开始监听，等待客户端 的连接            System.out.println("***服务器即将启动，等待客户端的连接***");            Socket socket = serverSocket.accept();            //3.获取输入流，并读取客户端信息            InputStream is = socket.getInputStream();//字节输入流            InputStreamReader isr = new InputStreamReader(is);//将字节输入流转换为字符流            BufferedReader br = new BufferedReader(isr);//为输入流添加缓冲            String info = null;            while((info=br.readLine())!=null) {//循环读取客户端的信息                System.out.println("我是服务器，客户端说："+info);            }            socket.shutdownInput();//关闭输入流            //4.关闭资源            br.close();            isr.close();            is.close();            socket.close();            serverSocket.close();        } catch (IOException e) {            e.printStackTrace();        }    }}

3-3 编程实现基于 TCP 的 Socket 通信之客户端

/** * 客户端 */public class Client {    public static void main(String[] args) {        try {            //1.创建客户端Socket,指定服务器端地址和端口            Socket socket = new Socket("localhost",8888);            //2.获取输出流，向服务器端发送信息            OutputStream os = socket.getOutputStream();//字节输出流            PrintWriter pw = new PrintWriter(os);//将输出流包装为打印流            pw.write("用户名：admin;密码：123");            pw.flush();            socket.shutdownOutput();//关闭输出流            //3.关闭资源            pw.close();            os.close();            socket.close();        } catch (UnknownHostException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }    }}

3-4 完善用户登陆之服务器响应客户端

/** * 基于TCP协议的socket通信，实现用户登录 * 服务器端 */public class Server {    public static void main(String[] args) {        try {            //1.创建一个服务器端Socket,即ServerSocket,指定绑定的端口            ServerSocket serverSocket = new ServerSocket(8888);            //2.调用accept()方法开始监听，等待客户端 的连接            System.out.println("***服务器即将启动，等待客户端的连接***");            Socket socket = serverSocket.accept();            //3.获取输入流，并读取客户端信息            InputStream is = socket.getInputStream();//字节输入流            InputStreamReader isr = new InputStreamReader(is);//将字节输入流转换为字符流            BufferedReader br = new BufferedReader(isr);//为输入流添加缓冲            String info = null;            while((info=br.readLine())!=null) {//循环读取客户端的信息                System.out.println("我是服务器，客户端说："+info);            }            socket.shutdownInput();//关闭输入流            //4.获取输出流，响应客户端请求            OutputStream op = socket.getOutputStream();            PrintWriter pw = new PrintWriter(op);//包装为打印流            pw.write("欢迎您！");            pw.flush();            //5.关闭资源            pw.close();            op.close();            br.close();            isr.close();            is.close();            socket.close();            serverSocket.close();        } catch (IOException e) {            e.printStackTrace();        }    }}

/** * 客户端 */public class Client {    public static void main(String[] args) {        try {            //1.创建客户端Socket,指定服务器端地址和端口            Socket socket = new Socket("localhost",8888);            //2.获取输出流，向服务器端发送信息            OutputStream os = socket.getOutputStream();//字节输出流            PrintWriter pw = new PrintWriter(os);//将输出流包装为打印流            pw.write("用户名：admin;密码：123");            pw.flush();            socket.shutdownOutput();//关闭输出流            //3.获取输入流，并读取服务器的响应信息            InputStream is = socket.getInputStream();            BufferedReader br = new BufferedReader(new InputStreamReader(is));            String info = null;            while((info = br.readLine()) != null) {                System.out.println("我是客户端，服务器端说："+info);            }            //4.关闭资源            br.close();            is.close();            pw.close();            os.close();            socket.close();        } catch (UnknownHostException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }    }}

3-5 使用多线程实现多客户端的通信

/* * 服务器线程处理类 */public class ServerThread extends Thread {    // 和本线程相关的Socket    Socket socket = null;    public ServerThread(Socket socket) {        this.socket = socket;    }    //线程执行的操作，响应客户端的请求    public void run(){        InputStream is=null;        InputStreamReader isr=null;        BufferedReader br=null;        OutputStream os=null;        PrintWriter pw=null;        try {            //获取输入流，并读取客户端信息            is = socket.getInputStream();            isr = new InputStreamReader(is);            br = new BufferedReader(isr);            String info=null;            while((info=br.readLine())!=null){//循环读取客户端的信息                System.out.println("我是服务器，客户端说："+info);            }            socket.shutdownInput();//关闭输入流            //获取输出流，响应客户端的请求            os = socket.getOutputStream();            pw = new PrintWriter(os);            pw.write("欢迎您！");            pw.flush();//调用flush()方法将缓冲输出        } catch (IOException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }finally{            //关闭资源            try {                if(pw!=null)                    pw.close();                if(os!=null)                    os.close();                if(br!=null)                    br.close();                if(isr!=null)                    isr.close();                if(is!=null)                    is.close();                if(socket!=null)                    socket.close();            } catch (IOException e) {                e.printStackTrace();            }        }    }}

/* * 基于TCP协议的Socket通信，实现用户登陆 * 服务器端 */public class Server {    public static void main(String[] args) {        try {            //1.创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口            ServerSocket serverSocket=new ServerSocket(8888);            Socket socket=null;            //记录客户端的数量            int count=0;            System.out.println("***服务器即将启动，等待客户端的连接***");            //循环监听等待客户端的连接            while(true){                //调用accept()方法开始监听，等待客户端的连接                socket=serverSocket.accept();                //创建一个新的线程                ServerThread serverThread=new ServerThread(socket);                //启动线程                serverThread.start();                count++;//统计客户端的数量                System.out.println("客户端的数量："+count);                InetAddress address=socket.getInetAddress();                System.out.println("当前客户端的IP："+address.getHostAddress());            }        } catch (IOException e) {            e.printStackTrace();        }    }}

/* * 客户端 */public class Client {    public static void main(String[] args) {        try {            //1.创建客户端Socket，指定服务器地址和端口            Socket socket=new Socket("localhost", 8888);            //2.获取输出流，向服务器端发送信息            OutputStream os=socket.getOutputStream();//字节输出流            PrintWriter pw=new PrintWriter(os);//将输出流包装为打印流            pw.write("用户名：admin;密码：123");            pw.flush();            socket.shutdownOutput();//关闭输出流            //3.获取输入流，并读取服务器端的响应信息            InputStream is=socket.getInputStream();            BufferedReader br=new BufferedReader(new InputStreamReader(is));            String info=null;            while((info=br.readLine())!=null){                System.out.println("我是客户端，服务器说："+info);            }            //4.关闭资源            br.close();            is.close();            pw.close();            os.close();            socket.close();        } catch (UnknownHostException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }    }}

第4章 通过 Socket 实现 UDP 编程

4-1 DatagramPacket

UDP编程
- UDP协议（用户数据报协议）是无连接的、不可靠的，无序的
- UDP协议以数据报作为数据传输的载体
- 进行数据传输时，首先需要将要传输的数据定义成
数据报（Datagram），在数据报中指明数据所要达到的
Socket（主机地址和端口号），然后在将数据报发送出去

相关操作类
- DatagramPacket:表示数据报包
- DatagramSocket:进行端到端通信的类

Class DatagramPacket
java.lang.Object
java.net.DatagramPacket

这类表示一个数据报包。

构造方法 Constructor and Description DatagramPacket(byte[] buf, int length) 接收数据包长度 length DatagramPacket构建。 DatagramPacket(byte[] buf, int length, InetAddress address, int port) 指定主机上的指定端口发送数据包的长度 length数据报包结构。 DatagramPacket(byte[] buf, int offset, int length) 接收数据包长度 length DatagramPacket结构，指定一个偏移量到缓冲区。 DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port) 发送有偏置 ioffsetto指定端口号指定主机上的数据包长度 length数据报包结构。 DatagramPacket(byte[] buf, int offset, int length, SocketAddress address) 发送有偏置 ioffsetto指定端口号指定主机上的数据包长度 length数据报包结构。 DatagramPacket(byte[] buf, int length, SocketAddress address) 指定主机上的指定端口发送数据包的长度 length数据报包结构。 Modifier and Type Method and Description InetAddress getAddress()
返回的IP地址的机器，这个数据包被发送或从收到的数据报。 byte[] getData()
返回数据缓冲区。 int getLength()
返回要发送的数据的长度或收到的数据的长度。 int getOffset()
返回所要发送的数据的偏移量或所接收的数据的偏移量。 int getPort()
返回远端端口号，这个数据包被发送或从收到的数据报。 SocketAddress getSocketAddress()
获取SocketAddress（通常是IP地址+端口号）的远程主机，数据包被发送到或来自。 void setAddress(InetAddress iaddr)
设置本机的IP地址，这个数据包被发送。 void setData(byte[] buf)
为这个数据包设置数据缓冲区。 void setData(byte[] buf, int offset, int length)
为这个数据包设置数据缓冲区。 void setLength(int length)
为这个数据包设置长度。 void setPort(int iport)
设置远端端口号，这个数据包被发送。 void setSocketAddress(SocketAddress address)
集SocketAddress（通常是IP地址+端口号）的远程主机的数据报发送。

Class DatagramSocket
java.lang.Object
java.net.DatagramSocket

这类代表一个发送和接收数据包的插座。

构造方法 Modifier Constructor and Description DatagramSocket() 构建一个数据报套接字绑定到本地主机的任何可用的端口。 DatagramSocket(DatagramSocketImpl impl) 创建一个绑定的数据报套接字与指定的datagramsocketimpl。 DatagramSocket(int port) 构建一个数据报套接字绑定到本地主机的指定端口。 DatagramSocket(int port, InetAddress laddr) 创建一个数据报套接字，绑定到指定的本地地址。 DatagramSocket(SocketAddress bindaddr) 创建一个数据报套接字，绑定到指定的本地套接字地址。 Modifier and Type Method and Description void bind(SocketAddress addr)
结合这个DatagramSocket到特定的地址和端口。 void close()
关闭该数据报套接字。 void connect(InetAddress address, int port)
将套接字连接到这个套接字的远程地址。 void connect(SocketAddress addr)
将此套接字连接到远程套接字地址（IP地址+端口号）。 void disconnect()
断开插座。 boolean getBroadcast()
如果so_broadcast启用。 DatagramChannel getChannel()
返回与此数据报套接字相关的独特的 DatagramChannel对象，如果任何。 InetAddress getInetAddress()
返回此套接字连接的地址。 InetAddress getLocalAddress()
获取绑定的套接字的本地地址。 int getLocalPort()
返回此套接字绑定的本地主机上的端口号。 SocketAddress getLocalSocketAddress()
返回此套接字绑定到的端点的地址。 int getPort()
返回此套接字连接的端口号。 int getReceiveBufferSize()
得到这个 DatagramSocket的so_rcvbuf期权价值，即通过平台用于该 DatagramSocket输入缓冲区的大小。 SocketAddress getRemoteSocketAddress()
返回此套接字连接的端点的地址，或如果它是无关的 null。 boolean getReuseAddress()
如果so_reuseaddr启用。 int getSendBufferSize()
得到这个 DatagramSocket的so_sndbuf期权价值，即缓冲区的大小由平台用于输出在这 DatagramSocket。 int getSoTimeout()
检索设置so_timeout。 int getTrafficClass()
获取交通类或类型的服务在IP数据报头的DatagramSocket发送的数据包。 boolean isBound()
返回套接字的绑定状态。 boolean isClosed()
返回套接字是否关闭或不关闭的。 boolean isConnected()
返回套接字的连接状态。 void receive(DatagramPacket p)
接收数据报包从这个插座。 void send(DatagramPacket p)
从这个套接字发送数据报包。 void setBroadcast(boolean on)
启用/禁用so_broadcast。 static void setDatagramSocketImplFactory(DatagramSocketImplFactory fac)
集的数据报套接字实现工厂的应用。 void setReceiveBufferSize(int size)
集so_rcvbuf选项，这 DatagramSocket指定值。 void setReuseAddress(boolean on)
启用/禁用so_reuseaddr套接字选项。 void setSendBufferSize(int size)
集so_sndbuf选项，这 DatagramSocket指定值。 void setSoTimeout(int timeout)
启用/禁用so_timeout以指定的超时时间，以毫秒为单位。 void setTrafficClass(int tc)
集交通类或从这个DatagramSocket发送数据报的IP数据报头字节型服务。

4-2 编程实现基于 UDP的 Socket 通信之服务器端

• 服务端实现步骤

  1. 创建DatagramSocket，指定端口号
  2. 创建DatagramPacket
  3. 接收客户端发送的数据信息
  4. 读取信息

• 客户端实现步骤

  1. 定义发送信息
  2. 创建DatagramPacket，包含将要发送的信息
  3. 创建DatagramSocket
  4. 发送数据

/* * 服务器端，实现基于UDP的用户登录 */public class UDPServer {    public static void main(String[] args) throws IOException {        //1.创建服务端DatagramSocket，指定端口        DatagramSocket socket = new DatagramSocket(8800);        //2.创建数据报，用于接收客户端发送的数据        byte[] data = new byte[1024];        DatagramPacket packet = new DatagramPacket(data,data.length);        //3.接收客户端发送的数据        socket.receive(packet);//此方法在接收数据报之前会一直阻塞        //4.读取数据        String info = new String(data,0,packet.getLength());        System.out.println("我是服务器，客户端说："+info);    }}

4-3 编程实现基于 UDP 的 Socket 通信之客户端

/* * 客户端 */public class UDPClient0 {    public static void main(String[] args) throws IOException {        //1.定义服务器的地址、端口号、数据        InetAddress address = InetAddress.getByName("localhost");        int port = 8800;        byte[] data = "用户名：admin;密码：123".getBytes();        //2.创建数据报，包含发送的数据信息        DatagramPacket packet = new DatagramPacket(data, data.length,address,port);        //3.创建DatagramSocket对象        DatagramSocket socket = new DatagramSocket();        //4.向服务器端发送数据报        socket.send(packet);    }}

/* * 服务器端，实现基于UDP的用户登陆 */public class UDPServer {    public static void main(String[] args) throws IOException {        /*         * 接收客户端发送的数据         */        //1.创建服务器端DatagramSocket，指定端口        DatagramSocket socket=new DatagramSocket(8800);        //2.创建数据报，用于接收客户端发送的数据        byte[] data =new byte[1024];//创建字节数组，指定接收的数据包的大小        DatagramPacket packet=new DatagramPacket(data, data.length);        //3.接收客户端发送的数据        System.out.println("****服务器端已经启动，等待客户端发送数据");        socket.receive(packet);//此方法在接收到数据报之前会一直阻塞        //4.读取数据        String info=new String(data, 0, packet.getLength());        System.out.println("我是服务器，客户端说："+info);        /*         * 向客户端响应数据         */        //1.定义客户端的地址、端口号、数据        InetAddress address=packet.getAddress();        int port=packet.getPort();        byte[] data2="欢迎您!".getBytes();        //2.创建数据报，包含响应的数据信息        DatagramPacket packet2=new DatagramPacket(data2, data2.length, address, port);        //3.响应客户端        socket.send(packet2);        //4.关闭资源        socket.close();    }}

/* * 客户端 */public class UDPClient {    public static void main(String[] args) throws IOException {        /*         * 向服务器端发送数据         */        //1.定义服务器的地址、端口号、数据        InetAddress address=InetAddress.getByName("localhost");        int port=8800;        byte[] data="用户名：admin;密码：123".getBytes();        //2.创建数据报，包含发送的数据信息        DatagramPacket packet=new DatagramPacket(data, data.length, address, port);        //3.创建DatagramSocket对象        DatagramSocket socket=new DatagramSocket();        //4.向服务器端发送数据报        socket.send(packet);        /*         * 接收服务器端响应的数据         */        //1.创建数据报，用于接收服务器端响应的数据        byte[] data2=new byte[1024];        DatagramPacket packet2=new DatagramPacket(data2, data2.length);        //2.接收服务器响应的数据        socket.receive(packet2);        //3.读取数据        String reply=new String(data2, 0, packet2.getLength());        System.out.println("我是客户端，服务器说："+reply);        //4.关闭资源        socket.close();    }}

第5章 Socket 总结

5-1 Socket 总结

重点
- Socket通信原理
- 基于TCP的Socket通信

1. 多线程的优先级
   未设置优先级可能会导致运行速度非常慢，可降低优先级
2. 是否关闭输入流和输出流
   对于同一个socket，如果关闭了输出流，则与该输出流关联的
   socket也会被关闭，所有一般不用关闭流，直接关闭socket即可
3. 使用TCP通信传输对象
   ObjectOutputStream oos = new ObjectOutputStream(os);
   oos.writeObject(user);
4. socket编程传递文件
   BufferedOutputStream fos new BufferedOutputStream(new FileOutputStream(filename));

第6章 综合练习

6-1 综合练习—问题描述

6-2 综合练习—实现分析

---

Java Socket应用—通信是这样练成的视频地址