14javaSocket应用(慕课笔记)

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();
    }
}