java网络编程(套接字)（学习笔记）

---

前言

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、TCPClient

TCP通信的客户端：向服务器发送连接请求，给服务器发送数据，读取服务器回写的数据
表示客户端的类：
java.net.Socket:此类实现客户端套接字（也可以叫"套接字"）。套接字是两台机器间的通信的端点
套接字：包含了IP地址和端口号的网络单位

构造方法：
Socket(String host,int port) 创建一个流套接字将其连接到指定主机上的指定端口号。
参数：
String host：服务器主机的名称/服务器的IP地址
int port:服务器的端口号

成员方法：
OutoutStream getOutputStream() 返回此套接字的输出流
InputStream getInputStream() 返回此套接字的输入流
void close() 关闭此套接字。

实现步骤：
1.创建一个客户端对象Socket,构造方法绑定服务器的IP地址和端口号
2.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
3.使用网络字节输出流OutputStream对象中的方法write,给服务器发送数据
4.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream()
5.使用网络字节输入流InputStream对象中的方法read，读取服务器回写的数据
6.释放资源（Socket）
注意：
1.客户端和服务器进行交互，必须使用Socket中提供的网络流，不能使用自己创建的流对象
2.当我们创建客户端对象Socket的时候，就会去请求服务器和服务器经过3此握手建立连接通路
这时如果服务器没有启动，那么就会抛出异常
如果服务器已经启动，那么就可以进行交互了

package net;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPClient {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//1.创建一个客户端对象Socket,构造方法绑定服务器的IP地址和端口号
		Socket socket=new Socket("127.0.0.1",8888);
		//2.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
		OutputStream output=socket.getOutputStream();
		//3.使用网络字节输出流OutputStream对象中的方法write,给服务器发送数据
		output.write("你好，服务器".getBytes());
		//4.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream()
		InputStream input=socket.getInputStream();
		//5.使用网络字节输入流InputStream对象中的方法read，读取服务器回写的数据
		byte []bytes=new byte[1024];
		int len=input.read(bytes);
		System.out.println(new String(bytes,0,len));
		//6.释放资源（Socket）
		socket.close();

	}
}
/*
 * TCP通信的客户端：向服务器发送连接请求，给服务器发送数据，读取服务器回写的数据
 * 表示客户端的类：
 * 		java.net.Socket:此类实现客户端套接字（也可以叫"套接字"）。套接字是两台机器间的通信的端点
 * 		套接字：包含了IP地址和端口号的网络单位
 *
 * 构造方法：
 * 		Socket(String host,int port) 创建一个流套接字将其连接到指定主机上的指定端口号。
 * 		参数：
 * 			String host：服务器主机的名称/服务器的IP地址
 * 			int port:服务器的端口号
 *
 * 成员方法：
 * 			OutoutStream getOutputStream() 返回此套接字的输出流
 * 			InputStream getInputStream() 返回此套接字的输入流
 * 			void close() 关闭此套接字。
 *
 * 实现步骤：
 * 		1.创建一个客户端对象Socket,构造方法绑定服务器的IP地址和端口号
 * 		2.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
 * 		3.使用网络字节输出流OutputStream对象中的方法write,给服务器发送数据
 * 		4.使用Socket对象中的方法getOInputStream()获取网络字节输入流InputStream()
 * 		5.使用网络字节输入流InputStream对象中的方法read，读取服务器回写的数据
 * 		6.释放资源（Socket）
 * 注意：
 * 		1.客户端和服务器进行交互，必须使用Socket中提供的网络流，不能使用自己创建的流对象
 * 		2.当我们创建客户端对象Socket的时候，就会去请求服务器和服务器经过3此握手建立连接通路
 * 			这时如果服务器没有启动，那么就会抛出异常
 * 			如果服务器已经启动，那么就可以进行交互了
 */

二、TCPServer

TCP的通信的服务器端：接收客户端的请求，读取客户端发送的数据，给客户端回写数据
表示服务器的类：
java.net.ServerSocket:此类实现服务器的套接字。
构造方法：
ServerSocket(int port)创建绑定到特定端口的服务器套接字
服务器端必明确一件事情，必须的知道是哪个客户端请求的服务器
所以可以使用accept,获取到请求的客户端对象Scoket
成员方法：
Socket accept()侦听并接受到此套接字的连接
服务器的实现步骤：
1.创建服务器ServerSocket对象和系统要指定的端口号
2.使用服务器ServerSocket对象中的方法accept，获取到请求的客户端对象Socket
3.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
4.使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据
5.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
6.使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
7.释放资源(Socket,serverSocket)
代码如下（示例）：

package net;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPServer {
    
    
	public static void main(String[] args) throws IOException {
    
    
		//1.创建服务器ServerSocket对象和系统要指定的端口号
		ServerSocket server=new ServerSocket(8888);
		//2.使用服务器ServerSocket对象中的方法accept，获取到请求的客户端对象Socket
		Socket socket=server.accept();
		//3.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
		InputStream input=socket.getInputStream();
		//4.使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据
		byte []bytes=new byte[1024];
		int len=input.read(bytes);
		System.out.println(new String(bytes,0,len));
		//5.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
		OutputStream output=socket.getOutputStream();
		//6.使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
		output.write("收到谢谢".getBytes());
		//7.释放资源(Socket,serverSocket)
		socket.close();
		server.close();
	}
}
/* TCP的通信的服务器端：接收客户端的请求，读取客户端发送的数据，给客户端回写数据
 * 表示服务器的类：
 * 		java.net.ServerSocket:此类实现服务器的套接字。
 * 构造方法：
 * 		ServerSocket(int port)创建绑定到特定端口的服务器套接字
 * 服务器端必明确一件事情，必须的知道是哪个客户端请求的服务器
 * 所以可以使用accept,获取到请求的客户端对象Scoket
 * 			成员方法：
 * 				Socket accept()侦听并接受到此套接字的连接
 * 服务器的实现步骤：
 * 			1.创建服务器ServerSocket对象和系统要指定的端口号
 * 			2.使用服务器ServerSocket对象中的方法accept，获取到请求的客户端对象Socket
 * 			3.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
 * 			4.使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据
 * 			5.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
 * 			6.使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
 * 			7.释放资源(Socket,serverSocket)
 */

三、文件上传TCPClient

文件上传案例的客户端：读取本地文件，上传到服务器，读取服务器回写的数据
明确：
数据源：c:\1.jpg
目的地：服务器
实现步骤：
1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的文件
2.创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
3.使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream
4.使用本地字节输入流FileInputStream对象中的read读取本地文件
5.使用网络字节输出流OutputStream对象中的方法write，把读取的文件上传到服务器
6.使用Socket中的方法getInputStream，获取网络字节输出流InputStream
7.使用网络字节输入流InputStream对象中的方法read读取服务回写的数据
8.释放资源（InputStream,Socket）

package wenjianshangchuan;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class TCPClient {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的文件
        FileInputStream fis = new FileInputStream("D:\\vscodebackground\\20210503092811.jpg");
        //2.创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1", 8888);
        //3.使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream
        OutputStream os = socket.getOutputStream();
        //4.使用本地字节输入流FileInputStream对象中的read读取本地文件
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = fis.read(bytes)) != -1) {
    
    
            //5.使用网络字节输出流OutputStream对象中的方法write，把读取的文件上传到服务器
            os.write(bytes, 0, len);
        }
        //写一个结束标记给服务器
        socket.shutdownOutput();
        //6.使用Socket中的方法getInputStream，获取网络字节输出流InputStream
        InputStream is = socket.getInputStream();
        //7.使用网络字节输入流InputStream对象中的方法read读取服务回写的数据
        while((len=is.read(bytes))!=-1){
    
    
            System.out.println(new String(bytes,0,len));
        }
        //8.释放资源（InputStream,Socket）
        fis.close();
        socket.close();
    }
}
/*
    文件上传案例的客户端：读取本地文件，上传到服务器，读取服务器回写的数据
    明确：
        数据源：c:\\1.jpg
        目的地：服务器
    实现步骤：
           1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的文件
           2.创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
           3.使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream
           4.使用本地字节输入流FileInputStream对象中的read读取本地文件
           5.使用网络字节输出流OutputStream对象中的方法write，把读取的文件上传到服务器
           6.使用Socket中的方法getInputStream，获取网络字节输出流InputStream
           7.使用网络字节输入流InputStream对象中的方法read读取服务回写的数据
           8.释放资源（InputStream,Socket）
 */

四、文件上传TCPServer

文件上传案例服务器端：读取客户端上传的文件，保存到服务器的硬盘，给客户端回写“上传成功”

扫描二维码关注公众号，回复： 13290288 查看本文章

明确：
数据源：客户端上传的文件
目的地：服务器的硬盘 d:\upload\20210503092811.jpg

实现步骤：
1.创建一个服务器ServerSocket对象，和系统要指定的端口号
2.使用ServerSocket对象中的方法accpet，获取到请求的客户端Scoket对象
3.使用Socket对象中的方法getInputStream，获取到网络字节输入流
4.判断d:\upload文件夹是否存在，不存在就创建一个
5.创建一个本地字节输出流FileOutputStream对象，构造放大中绑定要输出目的地
6.使用网络字节输入流InputStream对象重中的方法read，读取客户端上传的文件
7.使用本地输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器硬盘
8.使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
9.使用网络字节输出流OutputStream对象中的方法write，给客户端回写“上传成功”
10.释放资源（FileOutyputStream,Socket,ServerSocket）

package wenjianshangchuan;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class TCPServer {
    
    
    public static void main(String[] args) throws IOException {
    
    
       //1.创建一个服务器ServerSocket对象，和系统要指定的端口号
        ServerSocket server=new ServerSocket(8888);
       //2.使用ServerSocket对象中的方法accpet，获取到请求的客户端Scoket对象
        Socket socket = server.accept();
        //3.使用Socket对象中的方法getInputStream，获取到网络字节输入流
        InputStream is = socket.getInputStream();
        //4.判断d:\\upload文件夹是否存在，不存在就创建一个
        File file=new File("d:\\upload");
        if(!file.exists()){
    
    
            file.mkdirs();
        }
       //5.创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出目的地
        FileOutputStream fos=new FileOutputStream(file+"\\20210503092811.jpg");
       //6.使用网络字节输入流InputStream对象重中的方法read，读取客户端上传的文件
        int len=0;
        byte []bytes=new byte[1024];
        while((len=is.read(bytes))!=-1) {
    
    
            //7.使用本地输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器硬盘
            fos.write(bytes,0,len);
        }
       //8.使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
       //9.使用网络字节输出流OutputStream对象中的方法write，给客户端回写“上传成功”
        socket.getOutputStream().write("上传成功".getBytes(StandardCharsets.UTF_8));
        //10.释放资源（FileOutyputStream,Socket,ServerSocket）
        fos.close();
        socket.close();
        server.close();
    }
}
/*
    文件上传案例服务器端：读取客户端上传的文件，保存到服务器的硬盘，给客户端回写“上传成功”

    明确：
        数据源：客户端上传的文件
        目的地：服务器的硬盘 d:\\upload\\20210503092811.jpg

    实现步骤：
         1.创建一个服务器ServerSocket对象，和系统要指定的端口号
         2.使用ServerSocket对象中的方法accpet，获取到请求的客户端Scoket对象
         3.使用Socket对象中的方法getInputStream，获取到网络字节输入流
         4.判断d:\\upload文件夹是否存在，不存在就创建一个
         5.创建一个本地字节输出流FileOutputStream对象，构造放大中绑定要输出目的地
         6.使用网络字节输入流InputStream对象重中的方法read，读取客户端上传的文件
         7.使用本地输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器硬盘
         8.使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
         9.使用网络字节输出流OutputStream对象中的方法write，给客户端回写“上传成功”
         10.释放资源（FileOutyputStream,Socket,ServerSocket）
 */

五、文件上传案例阻塞和多线程优化

TCPClient

package wenjianshangchuan2;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Random;

public class TCPServer {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //1.创建一个服务器ServerSocket对象，和系统要指定的端口号
        ServerSocket server = new ServerSocket(8888);
        //2.使用ServerSocket对象中的方法accpet，获取到请求的客户端Scoket对象
        /*
        让服务器一直处于监听状态（死循环accept()）
        有一个客户端上传文件就保存一个文件
         */
        while (true) {
    
    
            Socket socket = server.accept();
        /*
        使用多线程技术，提高程序的效率
        有一个客户端上传文件，就开启一个线程，完成文件上传
         */
            new Thread(new Runnable() {
    
    
                @Override
                public void run() {
    
    
                    try {
    
    
                        //3.使用Socket对象中的方法getInputStream，获取到网络字节输入流
                        InputStream is = socket.getInputStream();
                        //4.判断d:\\upload文件夹是否存在，不存在就创建一个
                        File file = new File("d:\\upload");
                        if (!file.exists()) {
    
    
                            file.mkdirs();
                        }
        /*
        自定义一个文件的命名规则
        规则：域名+毫秒值+随机数
         */
                        String filename = "itcast" + System.currentTimeMillis() + new Random().nextInt(99999) + ".jpg";
                        //5.创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出目的地
                        FileOutputStream fos = new FileOutputStream(file + "\\" + filename);
                        //6.使用网络字节输入流InputStream对象重中的方法read，读取客户端上传的文件
                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while ((len = is.read(bytes)) != -1) {
    
    
                            //7.使用本地输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器硬盘
                            fos.write(bytes, 0, len);
                        }
                        //8.使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
                        //9.使用网络字节输出流OutputStream对象中的方法write，给客户端回写“上传成功”
                        socket.getOutputStream().write("上传成功".getBytes(StandardCharsets.UTF_8));
                        //10.释放资源（FileOutyputStream,Socket,ServerSocket）
                        fos.close();
                        socket.close();
                    } catch (IOException e) {
    
    
                        System.out.println(e);
                    }
                }
            }).start();
                //服务器不用关闭了
                // server.close();
        }
    }
}
/*
    文件上传案例服务器端：读取客户端上传的文件，保存到服务器的硬盘，给客户端回写“上传成功”

    明确：
        数据源：客户端上传的文件
        目的地：服务器的硬盘 d:\\upload\\20210503092811.jpg

    实现步骤：
         1.创建一个服务器ServerSocket对象，和系统要指定的端口号
         2.使用ServerSocket对象中的方法accpet，获取到请求的客户端Scoket对象
         3.使用Socket对象中的方法getInputStream，获取到网络字节输入流
         4.判断d:\\upload文件夹是否存在，不存在就创建一个
         5.创建一个本地字节输出流FileOutputStream对象，构造放大中绑定要输出目的地
         6.使用网络字节输入流InputStream对象重中的方法read，读取客户端上传的文件
         7.使用本地输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器硬盘
         8.使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
         9.使用网络字节输出流OutputStream对象中的方法write，给客户端回写“上传成功”
         10.释放资源（FileOutyputStream,Socket,ServerSocket）
 */

TCPServer

package wenjianshangchuan2;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class TCPClient {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的文件
        FileInputStream fis = new FileInputStream("D:\\vscodebackground\\20210503092811.jpg");
        //2.创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1", 8888);
        //3.使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream
        OutputStream os = socket.getOutputStream();
        //4.使用本地字节输入流FileInputStream对象中的read读取本地文件
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = fis.read(bytes)) != -1) {
    
    
            //5.使用网络字节输出流OutputStream对象中的方法write，把读取的文件上传到服务器
            os.write(bytes, 0, len);
        }
        //写一个结束标记给服务器
        socket.shutdownOutput();
        //6.使用Socket中的方法getInputStream，获取网络字节输出流InputStream
        InputStream is = socket.getInputStream();
        //7.使用网络字节输入流InputStream对象中的方法read读取服务回写的数据
        while((len=is.read(bytes))!=-1){
    
    
            System.out.println(new String(bytes,0,len));
        }
        //8.释放资源（InputStream,Socket）
        fis.close();
        socket.close();
    }
}
/*
    文件上传案例的客户端：读取本地文件，上传到服务器，读取服务器回写的数据
    明确：
        数据源：c:\\1.jpg
        目的地：服务器
    实现步骤：
           1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的文件
           2.创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
           3.使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream
           4.使用本地字节输入流FileInputStream对象中的read读取本地文件
           5.使用网络字节输出流OutputStream对象中的方法write，把读取的文件上传到服务器
           6.使用Socket中的方法getInputStream，获取网络字节输出流InputStream
           7.使用网络字节输入流InputStream对象中的方法read读取服务回写的数据
           8.释放资源（InputStream,Socket）
 */

六、BSTCP浏览器实例

package lx1;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/*
    创建BS版本TCP服务器
 */
public class TCPServerThread {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //创建一个服务器ServerSocket，和系统要指定的端口号
        ServerSocket server = new ServerSocket(8888);
        /*
        浏览器解析服务器回写的html页面，页面中如果有图片，那么浏览器就会单独开一个线程，读取服务器的图片
        我们就的让服务器一直处于监听状态，客户端请求一次，服务器就回写一次
         */
        while (true) {
    
    
            //使用accept方法获取到请求的客户端（浏览器）
            Socket socket = server.accept();
            new Thread(new Runnable() {
    
    
                @Override
                public void run() {
    
    
                    try {
    
    
                        InputStream is = socket.getInputStream();
                        //使用网络字节输入流InputStream对象中的方法read读取客户端的请求信息
       /* byte []bytes=new byte[1024];
        int len=0;
        while((len= is.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }*/
                        //把is网络字节输入流对象，转换为字符缓冲输入流
                        BufferedReader br = new BufferedReader(new InputStreamReader(is));
                        //把客户端请求信息的第一行读取出来GET /lx1/web/index.html HTTP/1.1
                        String line = br.readLine();
                        System.out.println(line);
                        //把读取的信息进行切割，只要中间部分lx1/web/index.html
                        String[] arr = line.split(" ");
                        //再把路径前的/去掉，进行截取
                        String htmlpath = arr[1].substring(1);
                        //创建一个本地字节输入流，html路径
                        FileInputStream fis = new FileInputStream(htmlpath);
                        //使用Socket中的方法getOutputStream获取网络字节输出流OutStream对象
                        OutputStream os = socket.getOutputStream();
                        //写入HTTP协议响应，固定写法
                        os.write("HTTP/1.1 200 OK\r\n".getBytes());
                        os.write("Content-Type:text/html\r\n".getBytes());
                        os.write("\r\n".getBytes());

                        //一读一写复制文件，把服务器读取的html文件回写到客户端
                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while ((len = fis.read(bytes)) != -1) {
    
    
                            os.write(bytes, 0, len);
                        }
                        //释放资源
                        fis.close();
                        socket.close();
                    }catch (IOException e){
    
    
                        e.printStackTrace();
                    }
                }
            }).start();
            //使用Socket对象中的方法getInputStream，获取到网络字节输入InputStream对象

            //server.close();
        }
    }
}

该程序所需的资源
链接：https://pan.baidu.com/s/1Vv4512kKCzHNrNjT82GB6g
提取码：cckf
复制这段内容后打开百度网盘手机App，操作更方便哦