本文共 19284 字，大约阅读时间需要 64 分钟。

Socket编程

1基础知识

协议 端口号(辨别不同应用)

TCP/IP协议

是目前世界上应用最广泛的协议

是以TCP为基础的不同层次上多个协议的集合

也称：TCP/IP协议族 或 TCP/IP协议栈

TCP:Transmission Control Protocol 传输控制协议

IP: Internet Protocol 互联网协议

IP地址

为实现网络中不同计算机之间的通信，每台机器都必须有唯一的标识—-IP地址

IP地址格式：数字型：192.168.1.10

端口

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、Socket:使用TCP协议实现网络通信的Socket相关的类

4、Datagram:使用UDP协议，将数据保留在数据报中，通过网络进行通信

2.InetAddress类

1、InetAddress类用于标识网络上的硬件资源，表示互联网协议(IP)地址

public void inetAddressTest() throws Exception{        //获取本机的InetAddressTest实例        InetAddress localHost = InetAddress.getLocalHost();        System.out.println("计算机名："+localHost.getHostName());        System.out.println("ip地址："+localHost.getHostAddress());        //获取字节数组形式的IP地址        System.out.println(Arrays.toString(localHost.getAddress()));        System.out.println(localHost);        //根据机器名 获取InetAddress实例        InetAddress byName = InetAddress.getByName("SONGPC");        System.out.println(byName);        //根据ip地址获取实例信息        InetAddress address = InetAddress.getByName("192.168.43.52");        System.out.println(address);    }

3.URL

1.URL(Uniform Resource Location) 统一资源定位符，表示Internet上某一资源的地址

2.URL由两部分组成:协议名称和资源名称，中间用冒号隔开。

​ http: //127.0.0.1:8080/index.jsp

3.在java.net包中，提供了URL类来表示URL.

/**     * URL的常用方法     */    public void testUrl() throws Exception{        //1.创建一个URL实例        URL url=new URL("http://www.imooc.com");        //？后面表示参数 #号后面表示锚点        URL url2 = new URL(url, "/index.html?Username=tom#test");        System.out.println("协议："+url2.getProtocol());        System.out.println("主机："+url2.getHost());        //如果未指定端口号 根据协议的不同使用默认端口号        System.out.println("端口号："+url2.getPort());        System.out.println("文件路径："+url2.getPath());        System.out.println("文件名："+url2.getFile());        System.out.println("相对路径："+url2.getRef());        System.out.println("查询字符串："+url2.getQuery());           }

4.使用URL读取网页内容

1.通过URL对象的openSteam()方法可以得到指定资源的输入流

2.通过流来读取和访问网络上的内容

5.Socket编程

TCP协议是面向连接、可靠的、有序的，以字节流的方式发送数据

基于TCP协议实现网络通信的类

>客户端的Socket类>>服务器端的ServerSocket类

Socket通讯的模型

Socket通信实现步骤

1.创建ServerSocket和Socket

2.打开连接到Socket的输入/输出流

3.按照协议对Socket进行读/写操作

4.关闭输入输出流、关闭Socket

服务器端：

1.创建ServerSocket对象，绑定监听端口

2.通过accept()方法监听客户端请求

3.连接通过后，通过输入流读取客户端发送的请求信息

4.通过输出流向客户端发送相应信息

5.关闭相关资源

//1.创建服务器端的Socket,指定绑定的端口，并监听此端口        ServerSocket serverSocket=new  ServerSocket(8000);        //2.调用accept()监听，等待客户端的连接          System.out.println("服务器:启动，等待客户端的连接***");            //连接成功后创建socket        Socket socket = serverSocket.accept();        System.out.println("服务器:客户端已经连接成功！");        //3.获取输入流，用来读取客户端发送信息        InputStream is = socket.getInputStream();        OutputStream outputStream = socket.getOutputStream();        //包装成高效字符流        BufferedReader br=new BufferedReader(new InputStreamReader(is));        String  len="";        while((len=br.readLine())!=null){            System.out.println("服务端："+len);        }        (用完一个关闭一个  不然回阻塞)        socket.shutdownInput();        //4.获取输出流相应客户端请求        PrintWriter pw=new PrintWriter(outputStream);//包装成打印了        pw.write("欢迎你。。。");        pw.flush();        socket.shutdownOutput();        //关闭资源        pw.close();        outputStream.close();        br.close();        is.close();        socket.close();        serverSocket.close();

客户端：

1.创建Socket对象，指定需要连接的服务器的地址和端口号

2.连接建立后，通过输出流向服务器端发送请求信息

3.通过输入流获取服务器端响应的信息

4.关闭相关资源

//1.创建客户端Socket,指定服务器端的地址和端口号        Socket socket=new Socket("localhost", 8000);        //2.获取输出流，用来向服务器端发送信息        OutputStream outputStream = socket.getOutputStream();        PrintWriter pw=new PrintWriter(outputStream);        //3.获取输入流获取服务器端的相应        InputStream inputStream = socket.getInputStream();        pw.write("用户名：admin;密码：123");        pw.flush();        //关闭输出流(用完一个关闭一个  不然回阻塞)        socket.shutdownOutput();          BufferedReader br=new BufferedReader(new InputStreamReader(inputStream));        String len="";        while((len=br.readLine())!=null){            System.out.println("客户端:"+len);        }        socket.shutdownInput();        //关闭资源        br.close();        pw.close();        outputStream.close();        socket.close();

多线程服务器

应用多线程来实现服务器与多客户端之间的通信

基本步骤

1.服务器创建ServerSocket，循环调用accept()等待客户端连接

2.客户端创建一个socket并请求和服务器端连接

3.服务器端接受客户端请求，创建socket与该客户端建立专线连接

4.建立连接两个socket在一个单独的线程上对话

5.服务器端继续等待新的连接

服务器线程类ServerThread

package com.andgo.多线程服务器;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.PrintWriter;import java.net.ServerSocket;import java.net.Socket;/** * 服务器线程处理类 * @author Administrator */public class ServerThread extends Thread {
       //和本线程相关的Socket    Socket socket=null;    //初始化socket    public ServerThread(Socket socket) {        this.socket=socket;    }    //线程执行操作,响应客户端的请求    @Override    public void run(){                InputStream is=null;                OutputStream outputStream=null;                BufferedReader br=null;                PrintWriter pw = null;                try {                    System.out.println("服务器:客户端已经连接成功！");                               //3.获取输入流，用来读取客户端发送信息                    is = socket.getInputStream();                    outputStream = socket.getOutputStream();                    //包装成高效字符流                    br=new BufferedReader(new InputStreamReader(is));                    String  len="";                    while((len=br.readLine())!=null){                        System.out.println("服务端："+len);                    }                    socket.shutdownInput();                    //4.获取输出流相应客户端请求                    pw=new PrintWriter(outputStream);//包装成打印了                    pw.write("欢迎你。。。");                    pw.flush();//刷新缓冲流                    socket.shutdownOutput();                } catch (Exception e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }finally {                    //关闭资源                    try {                        if(pw!=null){                            pw.close();                        }                        if(outputStream!=null){                            outputStream.close();                        }                        if(br!=null){                            br.close();                        }                        if(is!=null){                            is.close();                        }                        if(socket!=null){                            socket.close();                        }                    } catch (IOException e) {                        // TODO Auto-generated catch block                        e.printStackTrace();                    }                               }               }}

服务器端

package com.andgo.多线程服务器;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.PrintWriter;import java.net.InetAddress;import java.net.ServerSocket;import java.net.Socket;/** * 实现基于TCP协议的Socket通信，实现用户登录 * 服务器端 * @author Administrator */public class Server {
       public static void main(String[] args) throws IOException {        //1.创建服务器端的Socket,指定绑定的端口，并监听此端口        ServerSocket serverSocket=new  ServerSocket(8000);        Socket socket=null;        System.out.println("服务器:启动，等待客户端的连接***");        //记录客户端的数量        int count=0;        //循环监听等待客户端的连接        while(true){            //2.调用accept()监听，等待客户端的连接   。连接成功后创建socket                   socket = serverSocket.accept();            //3.创建一个新的线程             ServerThread serverThread=new ServerThread(socket);             //启动线程             serverThread.start();             count++;             System.out.println("客户端的数量："+count);             InetAddress address=socket.getInetAddress();             System.out.println("当前客户端的IP:"+address.getHostAddress());        }        //serverSocket.close();    }}

客户端

package com.andgo.多线程服务器;import java.io.BufferedReader;import java.io.InputStream;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.PrintWriter;import java.net.Socket;import org.junit.runner.notification.RunListener.ThreadSafe;/** * 实现基于TCP协议的Socket通信，实现用户登录 * 客户端 * @author Administrator */public class Client {
       public static void main(String[] args) throws Exception {        //1.创建客户端Socket,指定服务器端的地址和端口号        Socket socket=new Socket("localhost", 8000);        //2.获取输出流，用来向服务器端发送信息        OutputStream outputStream = socket.getOutputStream();        PrintWriter pw=new PrintWriter(outputStream);        //3.获取输入流获取服务器端的相应        InputStream inputStream = socket.getInputStream();        pw.write("用户名：admin;密码：123");        pw.flush();        //关闭输出流(用完一个关闭一个  不然回阻塞)        socket.shutdownOutput();          BufferedReader br=new BufferedReader(new InputStreamReader(inputStream));        String len="";        while((len=br.readLine())!=null){            System.out.println("客户端:"+len);        }        socket.shutdownInput();        //关闭资源        br.close();        pw.close();        outputStream.close();        socket.close();    }}

6.UDP编程

UDP协议(用户数据报协议)是无连接、不可靠、无序的

UDP协议以数据报作为数据传输的载体

进行数据传输时，首先需要将要传输的数据定义成数据报（Datagram），在数据报中指明数据要达到的Socket(主机地址和端口号)，然后再将数据报发送出去

相关操作类

DatagramPacket:表示数据报包

DatagramSocket:进行端到端通信的类

服务器端实现步骤

1.创建DatagramSocket,指定端口号

2.创建DatagramPacket

3.接受客户端发送的数据信息

4.读取数据

package com.andgo.udp通信;import java.net.DatagramPacket;import java.net.DatagramSocket;import java.net.InetAddress;import java.net.SocketException;import java.net.UnknownHostException;/** * UDP服务端 * @author Administrator */public class UDPServer {
       /**     *  1.创建DatagramSocket,指定端口号        2.创建DatagramPacket        3.接受客户端发送的数据信息        4.读取数据     * @param args     * @throws UnknownHostException      * @throws SocketException      */    public static void main(String[] args) throws Exception {        /*         *实现了接收数据          */        //0.创建本机的address        //InetAddress address = InetAddress.getLocalHost();        // 1.创建DatagramSocket,指定端口号        DatagramSocket socket=new DatagramSocket(8888);        //2.创建DatagramPacket，用于接收客户端发送来的数据        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[] bs="欢迎。。。。".getBytes();        //2.创建数据报，包含响应的数据信息        DatagramPacket packet2=new DatagramPacket(bs, bs.length, address, port);        //3.向客户端发送数据        socket.send(packet2);               //4.关闭资源        socket.close();    }}

客户端实现步骤

1.定义发送数据

2.创建DatagramPacket,包含将要发送的信息

3.创建DatagramSocket

4.发送数据

package com.andgo.udp通信;import java.net.DatagramPacket;import java.net.DatagramSocket;import java.net.InetAddress;import java.net.UnknownHostException;/** * UDP客户端 * @author Administrator * */public class UDPClient {
       /**     *  1.定义发送数据        2.创建DatagramPacket,包含将要发送的信息        3.创建DatagramSocket        4.发送数据     * @param args     * @throws Exception      */    public static void main(String[] args) throws Exception {        /*         *向服务器端发送数据          */        //1.定义服务器的地址，端口号、数据        InetAddress address=InetAddress.getByName("localhost");        int port=8888;        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.创建DatagramPacket，用于接收服务器端响应的数据        byte[] bs=new byte[1024];        DatagramPacket packet2=new DatagramPacket(bs, bs.length);        //2.接收服务器端响应的数据        socket.receive(packet2);        //3.读取数据        String reply=new String(bs, 0, packet2.getLength());        System.out.println("客户端："+reply);           //4.关闭资源        socket.close();    }}

多线程UDP服务器

UDPServerThread

package com.andgo.udp通信多线程实现;import java.io.IOException;import java.net.DatagramPacket;import java.net.DatagramSocket;import java.net.InetAddress;import java.net.Socket;public class UDPServerThread extends Thread{
       private byte[] data;    private DatagramPacket packet;    private DatagramSocket socket;    public UDPServerThread(byte[] data, DatagramPacket packet, DatagramSocket socket) {        this.data = data;        this.packet = packet;        this.socket = socket;    }    @Override    public void run() {        //4.读取数据        String info=new String(data, 0, packet.getLength());        System.out.println("服务器接收到："+info);        /*         *向客户端响应数据          */        //1.定义客户端的地址、端口号、数据        InetAddress address=packet.getAddress();        int port=packet.getPort();        byte[] bs="欢迎。。。。".getBytes();        //2.创建数据报，包含响应的数据信息        DatagramPacket packet2=new DatagramPacket(bs, bs.length, address, port);        //3.向客户端发送数据        try {            socket.send(packet2);        } catch (IOException e) {            System.out.println("数据发送异常");            e.printStackTrace();        }        //4.关闭资源        //socket.close();  //UDP中用同一个socket发送和接受数据 ，datagramPaket包含了数据、端口、地址信息(用于区分和发送到哪里)    }}

UDPServer

package com.andgo.udp通信多线程实现;import java.net.DatagramPacket;import java.net.DatagramSocket;import java.net.InetAddress;import java.net.SocketException;import java.net.UnknownHostException;/** * UDP服务端 * @author Administrator * */public class UDPServer {
       /**     *  1.创建DatagramSocket,指定端口号        2.创建DatagramPacket        3.接受客户端发送的数据信息        4.读取数据     * @param args     * @throws UnknownHostException      * @throws SocketException      */    public static void main(String[] args) throws Exception {        /*         *实现了接收数据          */        //0.创建本机的address        //InetAddress address = InetAddress.getLocalHost();        // 1.创建DatagramSocket,指定端口号        DatagramSocket socket=new DatagramSocket(8888);        //2.创建DatagramPacket，用于接收客户端发送来的数据        byte[] data=new byte[1024];        DatagramPacket packet=new DatagramPacket(data, data.length);        //3.接收客户端发送的数         System.out.println("服务器端已经启动，等待接收数据");        while(true){            socket.receive(packet);//此方法在接收到数据报之前会一直阻塞            UDPServerThread thread=new UDPServerThread(data, packet, socket);            thread.run();        }    }}

UDPClient

package com.andgo.udp通信多线程实现;import java.net.DatagramPacket;import java.net.DatagramSocket;import java.net.InetAddress;import java.net.UnknownHostException;/** * UDP客户端 * @author Administrator * */public class UDPClient {
       /**     *  1.定义发送数据        2.创建DatagramPacket,包含将要发送的信息        3.创建DatagramSocket        4.发送数据     * @param args     * @throws Exception      */    public static void main(String[] args) throws Exception {        /*         *向服务器端发送数据          */        //1.定义服务器的地址，端口号、数据        InetAddress address=InetAddress.getByName("localhost");        int port=8888;        byte[] data="用户名：admissn;密码：123sssss".getBytes();        //2.创建数据报，包含发送的数据        DatagramPacket packet=new DatagramPacket(data, data.length, address, port);        //3.创建DatagramSocket        DatagramSocket socket=new DatagramSocket();        //4.向服务器端发送数据        socket.send(packet);        /*         *接收服务器端响应的数据          */        //1.创建DatagramPacket，用于接收服务器端响应的数据        byte[] bs=new byte[1024];        DatagramPacket packet2=new DatagramPacket(bs, bs.length);        //2.接收服务器端响应的数据        socket.receive(packet2);        //3.读取数据        String reply=new String(bs, 0, packet2.getLength());        System.out.println("客户端："+reply);        //4.关闭资源        socket.close()    }}

7.Socket总结

​ Socket通信原理

​ 基于TCP的Socket通信

多线程的优先级

未设置优先级可能会导致运行是速度非常慢，可以降低优先级

是否关闭输入和输出流

对应同一个socket,如果关闭了输出流，则与该输出流关联的socket也会被关闭，所以一般不用关闭流，直接关闭socket即可

使用TCP通信传输对象

//使用ObjectOutputStream对象序列化，传递对象 ObjectOutputStream oos=new ObjectOutputStream(); User user =new User("aaa","111");//封装成对象 oos.writeObject(user);//序列化

socket传递文件

1.client

package com.andgo.文件传输;import java.io.BufferedReader;import java.io.File;import java.io.FileInputStream;import java.io.InputStream;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.PrintWriter;import java.net.Socket;import java.text.FieldPosition;import org.junit.runner.notification.RunListener.ThreadSafe;/** * 实现基于TCP协议的Socket通信，实现用户登录 * 客户端 * @author Administrator * */public class Client {
       @SuppressWarnings("resource")    public static void main(String[] args) throws Exception {        //1.创建客户端Socket,指定服务器端的地址和端口号        Socket socket=new Socket("localhost", 8000);        //2.获取输出流，用来向服务器端发送信息        OutputStream outputStream = socket.getOutputStream();        //PrintWriter pw=new PrintWriter(outputStream);        //3.获取输入流获取服务器端的相应        InputStream inputStream = socket.getInputStream();        FileInputStream fis = new FileInputStream(new File("C://Users/Administrator/Desktop/imgs/1.png"));        byte[] b=new byte[2024];        int n=0;        while((n=fis.read(b))!=-1){            outputStream.write(b, 0, n);        }        //关闭输出流(用完一个关闭一个  不然回阻塞)        socket.shutdownOutput();          BufferedReader br=new BufferedReader(new InputStreamReader(inputStream));        String len="";        while((len=br.readLine())!=null){            System.out.println("客户端:"+len);        }        socket.shutdownInput();        //关闭资源        br.close();        outputStream.close();        socket.close();     }}

2.server

package com.andgo.文件传输;import java.io.BufferedReader;import java.io.File;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.PrintWriter;import java.net.ServerSocket;import java.net.Socket;/** * 实现基于TCP协议的Socket通信，实现用户登录 * 服务器端 * @author Administrator * */public class Server {
       public static void main(String[] args) throws IOException {        //1.创建服务器端的Socket,指定绑定的端口，并监听此端口        ServerSocket serverSocket=new  ServerSocket(8000);        //2.调用accept()监听，等待客户端的连接          System.out.println("服务器:启动，等待客户端的连接***");            //连接成功后创建socket        Socket socket = serverSocket.accept();        System.out.println("服务器:客户端已经连接成功！");        //3.获取输入流，用来读取客户端发送信息        InputStream is = socket.getInputStream();        OutputStream outputStream = socket.getOutputStream();        //输出到文件        FileOutputStream fos =new FileOutputStream(new File("d://test/1.png"));        byte[] b=new byte[2024];        int len=0;        while((len=is.read(b))!=-1){            fos.write(b, 0, len);        }        socket.shutdownInput();        //4.获取输出流相应客户端请求        PrintWriter pw=new PrintWriter(outputStream);//包装成打印了        pw.write("文件传输完成！");        pw.flush();        socket.shutdownOutput();        //关闭资源        pw.close();        outputStream.close();        is.close();        socket.close();        serverSocket.close();    }}