Java基础14（网络编程）

河边啃母鸡

已于 2023-05-29 21:40:41 修改

阅读量39

点赞数

分类专栏： java基础文章标签： java socket 网络协议网络

于 2021-07-29 15:49:21 首次发布

本文链接：https://blog.csdn.net/qq_43671768/article/details/119179850

版权

java基础专栏收录该内容

17 篇文章 0 订阅

订阅专栏

网络编程入门

网络编程三要素

IP地址，网络中设备的唯一标识，为了方便我们对IP地址的获取和操作，Java提供了一个类InetAddress供我们使用
InetAddress：此类表示Internet协议（IP）地址
端口，设备上应用程序的唯一标识。端口号：用两个字节表示的整数，它的取值范围是0-65535。其中0-1223之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前应用程序启动失败
协议，TCP/UDP。计算机网络中通信的规则被称为网络协议。UDP，面向非连接的通信协议，可以用于音频，视频，普通数据的传输。TCP，面向连接的通信协议，三次握手：
客户端主动打开连接，服务器端被动打开连接进入LISTEN状态，第一次握手，客户端向服务端发送连接请求，进入SYN-SENT状态等待服务端确认。
第二次握手，服务器端向客户端发送一个响应，进入SYN-RCVD状态通知客户端收到了请求。
第三次握手，客户端向服务端发送确认信息，进入ESTABLISHED状态，客户端收到确认信息后也进入ESTABLISHED状态，连接建立。TCP协议可以保证传输数据的安全，广泛应用于上传下载文件，浏览网页。

public static void main(String[] args) throws UnknownHostException {
        InetAddress address = InetAddress.getByName("localhost");
        String name = address.getHostName();
        String ip = address.getHostAddress();
        System.out.println(name);
        System.out.println(ip);
    }

方法名	说明
`static InetAddress getByNames(String host)`	确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
`String getHostName()`	返回此IP地址的主机名
`String getHostAddress()`	返回文本显示中的IP地址字符串

UDP通信程序

UDP是一种不可靠的网络协议，它在通信的两端各建立一个Socket对象，但是这两个Socket只是发送，接收数据的对象，因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器的概念，Java提供了DatagramSocket类作为基于UDP协议的Socket

UDP发送数据的步骤

创建发送端的Socket对象（DatagramSocket）
创建数据，并把数据打包
调用DatagramSocket对象的方法发送数据
关闭发送端

/*发送端*/
public class Sender {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象（DatagramSocket）
        DatagramSocket datagramSocket = new DatagramSocket();
        //创建数据，并把数据打包
        byte[] arr = "hello".getBytes();
        //public DatagramPacket(byte buf[], int length,InetAddress address, int port)
        DatagramPacket datagramPacket = new DatagramPacket(arr,arr.length, InetAddress.getByName("192.168.6.219"),10086);
        //调用DatagramSocket对象的方法发送数据
        datagramSocket.send(datagramPacket);
        //关闭发送端
        datagramSocket.close();
    }
}

UDP接收数据的步骤

创建接收端的Socket对象（DatagramSocket）
创建数据包，用于接收数据
调用DatagramSocket对象的方法接收数据
解析数据包，并处理
关闭发送端

/*接收端*/
public class Receiver {
    public static void main(String[] args) throws IOException {
        //创建接收端的Socket对象（DatagramSocket）
        DatagramSocket datagramSocket = new DatagramSocket(10086);
        //创建数据包，用于接收数据
        byte[] rcvArray = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(rcvArray,rcvArray.length);
        //调用DatagramSocket对象的方法接收数据
        datagramSocket.receive(datagramPacket);
       //解析数据包，并处理
        //数据缓冲区数组
        byte[] rcvdArray = datagramPacket.getData();
        //数据长度
        int len = datagramPacket.getLength();
        String s = new String(rcvdArray,0,len);
        System.out.println(s);
        //关闭发送端
        datagramSocket.close();
    }
}

UDP通信程序练习

/*发送消息*/
    public static void sent() throws IOException {
        //创建DatagramSocket对象
        DatagramSocket datagramSocket = new DatagramSocket();
        //封装从键盘读取的数据
        String line;
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        while ((line = bufferedReader.readLine()) != null) {
            //读取到#字符就结束读取
            if (line.equals("#")) {
                break;
            } else {
                //创建数据并打包
                byte[] sentArray = line.getBytes();
                DatagramPacket datagramPacket = new DatagramPacket(sentArray, sentArray.length, InetAddress.getByName("192.168.6.219"), 12345);
                //发送数据
                datagramSocket.send(datagramPacket);
            }
        }
        //关闭发送端
        datagramSocket.close();
    }
    /*接收消息*/
    public static void receive() throws IOException {
//DatagramSocket创建对象
        DatagramSocket datagramSocket = new DatagramSocket(12345);
        //创建数据包，用于接收对象
        byte[] rcvArray = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(rcvArray, rcvArray.length);
        //接收数据
        while (true) {
            datagramSocket.receive(datagramPacket);
            //解析数据包，处理数据
            byte[] data = datagramPacket.getData();
            int length = datagramPacket.getLength();
            String s = new String(data, 0, length);
            System.out.println("来自对方的消息：" + s);
        }
    }

TCP通信程序

TCP发送数据

发送数据的步骤

创建客户端的Socket对象（Socket）
获取输出流，写数据
释放资源

TCP接收数据

接收数据的步骤

创建服务端Socket对象（ServerSocket）
监听客户端连接，得到一个Socket对象，serverSocket.accept()
获取输入流，读数据，处理数据
释放资源

TCP通信程序联系1（服务器给出反馈）

/*客户端发送数据，并接收反馈*/
public class Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("192.168.6.219",10000);
        if (sent(socket)){
            waitFeedback(socket);
        }
        socket.close();
    }
    private static boolean sent(Socket socket) throws IOException{
        //获取输出流
        OutputStream outputStream = socket.getOutputStream();
        //写数据
        outputStream.write("来自客户端的消息：hello,are you ready?".getBytes());
        return true;
    }
    private static void waitFeedback(Socket socket) throws IOException{
        //获取输入流,接收反馈
        InputStream inputStream = socket.getInputStream();
        byte[] rcvFeedbackArray = new byte[1024];
        int len;
        while ((len = inputStream.read(rcvFeedbackArray)) != -1){
            System.out.println(new String(rcvFeedbackArray,0,len));
        }
    }
}

/*服务器收到信息，给出反馈*/
public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(10000);
        Socket accept = serverSocket.accept();
        if (receive(accept)){
            feedback(accept);
        }
        accept.close();
    }
    private static void feedback(Socket accept) throws IOException{
        //获取输出流，发送反馈
        OutputStream outputStream = accept.getOutputStream();
        outputStream.write("来自服务器的回复：yeah，I am Ok".getBytes());
    }
    private static boolean receive(Socket accept) throws IOException{
        //获取输入流
        InputStream inputStream = accept.getInputStream();
        byte[] rcvMessageArray = new byte[1024];
        int len = inputStream.read(rcvMessageArray);
        System.out.println(new String(rcvMessageArray,0,len));
        return true;
    }
}

TCP通信程序联系2（客户端数据来自键盘录入）

public class Sent {
    public static void main(String[] args) throws IOException {
        //创建Socket对象
        Socket socket = new Socket("192.168.6.219",12345);
        //将键盘录入的数据封装
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        //封装字符输出流,获取输出流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        String line;
        while ((line = bufferedReader.readLine()) != null){
            //如果读取到#就结束
            if (line.equals("#")){
                break;
            }else {
                //发送数据
                bufferedWriter.write(line);
                //写一个换行符
                bufferedWriter.newLine();
                //刷新缓冲区数据到输出流
                bufferedWriter.flush();
            }
        }
        //释放资源
        socket.close();
    }
}

public class Receive {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(12345);
        Socket accept = serverSocket.accept();
        //封装输入流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(accept.getInputStream()));
        String line;
        while ((line = bufferedReader.readLine()) != null){
            System.out.println(line);
        }
    }
}

TCP通信程序联系3（服务器数据写入文本文件）

public class Receive {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(12345);
        Socket accept = serverSocket.accept();
        //封装输入流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(accept.getInputStream()));
        //封装输出流
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:\\IODemo\\tcp.txt"));
        String line;
        while ((line = bufferedReader.readLine()) != null){
            //将读取到的每行数据按行写入文本文件
            bufferedWriter.write(line);
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
        bufferedWriter.close();
        serverSocket.close();
    }
}

TCP通信程序联系4（客户端数据来自文本文件）

public class Sent {
    public static void main(String[] args) throws IOException {
        //创建Socket对象
        Socket socket = new Socket("192.168.6.219",12345);
        //将键盘录入的数据封装
        BufferedReader bufferedReader = new BufferedReader(new FileReader("D:\\IODemo\\hi.txt"));
        //封装字符输出流,获取输出流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        String line;
        while ((line = bufferedReader.readLine()) != null){
            //如果读取到#就结束
            if (line.equals("#")){
                break;
            }else {
                //发送数据
                bufferedWriter.write(line);
                //写一个换行符
                bufferedWriter.newLine();
                //刷新缓冲区数据到输出流
                bufferedWriter.flush();
            }
        }
        //释放资源
        bufferedReader.close();
        socket.close();
    }
}

TCP通信程序联系5（文件上传服务器给出反馈）

public class Receive {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(12345);
        Socket accept = serverSocket.accept();
        //封装输入流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(accept.getInputStream()));
        //封装输出流
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:\\IODemo\\tcp.txt"));
        String line ;
        while ((line = bufferedReader.readLine()) != null){//等待读取数据
            //将读取到的每行数据按行写入文本文件
            bufferedWriter.write(line);
            bufferedWriter.newLine();
            bufferedWriter.flush();

        }
        //给出反馈
        BufferedWriter bufferedWriter1 = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
        bufferedWriter1.write("来自服务器的反馈：文件上传成功");
        bufferedWriter1.newLine();
        bufferedWriter1.flush();

        bufferedWriter.close();
        serverSocket.close();
    }
}

public class Sent {
    public static void main(String[] args) throws IOException {
        //创建Socket对象
        Socket socket = new Socket("192.168.6.219",12345);
        //将键盘录入的数据封装
        BufferedReader bufferedReader = new BufferedReader(new FileReader("D:\\IODemo\\hi.txt"));
        //封装字符输出流,获取输出流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        String line;
        while ((line = bufferedReader.readLine()) != null){
            //如果读取到#就结束
            if (line.equals("#")){
                break;
            }else {
                //发送数据
                bufferedWriter.write(line);
                //写一个换行符
                bufferedWriter.newLine();
                //刷新缓冲区数据到输出流
                bufferedWriter.flush();
            }
        }
        //关闭输出流
        socket.shutdownOutput();
        //接收反馈
        BufferedReader bufferedReader1 = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String s  = bufferedReader1.readLine();//等待读取数据
        System.out.println(s);
        //释放资源
        bufferedReader.close();
        socket.close();
    }
}

TCP通信程序联系6（多线程实现文件上传）

public class RunnableImpl implements Runnable {
    private Socket socket;

    public RunnableImpl(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            //封装输入流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //封装输出流
            StringBuilder stringBuilder = new StringBuilder();
            int count = 0;
            File file = new File("D:\\IODemo\\tcp["+count+"].txt");
            while (file.exists()){
                count++;
                file = new File("D:\\IODemo\\tcp["+count+"].txt");
            }
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
            String line ;
            while ((line = bufferedReader.readLine()) != null){//等待读取数据
                //将读取到的每行数据按行写入文本文件
                bufferedWriter.write(line);
                bufferedWriter.newLine();
                bufferedWriter.flush();

            }
            //给出反馈
            BufferedWriter bufferedWriter1 = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            bufferedWriter1.write("来自服务器的反馈：文件上传成功");
            bufferedWriter1.newLine();
            bufferedWriter1.flush();
            bufferedWriter.close();
            socket.close();
        }catch (IOException e){
            e.printStackTrace();
        }

    }
}

public class Receive {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(12345);
        while (true){
            Socket socket = serverSocket.accept();
            new Thread(new RunnableImpl(socket)).start();
        }
    }
}

河边啃母鸡

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础14（网络编程）

网络编程入门网络编程三要素IP地址，网络中设备的唯一标识，为了方便我们对IP地址的获取和操作，Java提供了一个类InetAddress供我们使用InetAddress：此类表示Internet协议（IP）地址端口，设备上应用程序的唯一标识。端口号：用两个字节表示的整数，它的取值范围是0-65535。其中0-1223之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前应用程序启动失败协议，TCP/UDP。计算机网
复制链接

扫一扫