首页 > 编程语言 >网络编程

网络编程

时间：2024-10-19 16:33:47浏览次数：1  
标签：String 编程 System 网络 new 客户端 Socket socket

第九章——网络编程

1、网络编程概述

计算机网络:
是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。极域
网络编程:
就是用来实现网络互连的不同计算机上运行的程序间可以进行数据交换。

2、网络模型

image-20241019141003861

3、网络通信三要素

1、IP地址:InetAddress
网络中设备的标识，不易记忆，可用主机名
2、端口号
用于标识进程的逻辑地址，不同进程的标识
3、传输协议
通讯的规则
常见协议：TCP，UDP

4、协议UDP和TCP

UDP
将数据源和目的封装成数据包中，不需要建立连接；每个数据报包的大小在限制在64k；因无连接，是不可靠协议；不需要建立连接，速度快
TCP
建立连接，形成传输数据的通道；在连接中进行大数据量传输；通过三次握手完成连接，是可靠协议；必须建立连接，效率会稍低

    
/*
    1:建立客户端的Socket服务,并明确要连接的服务器。
    2:如果连接建立成功,就表明,已经建立了数据传输的通道.就可以在该通道通过IO进行数据的读取和写入.该通道称为Socket流,Socket流中既有读取流,也有写入流.
    3:通过Socket对象的方法,可以获取这两个流
    4:通过流的对象可以对数据进行传输
    5:如果传输数据完毕,关闭资源

 */
public class ClientDemo1 {
    public static void main(String[] args) throws Exception{
        // 1:建立客户端的Socket服务,并明确要连接的服务器。
        //Socket(String host, int port)
        //创建流套接字并将其连接到指定主机上的指定端口号。
        Socket socket = new Socket("192.168.22.15", 12345);
        Scanner sc = new Scanner(System.in);

        // 3:通过Socket对象的方法,可以获取这两个流
        //获取通道中的输出流，将数据发送给服务端
        OutputStream outputStream = socket.getOutputStream();
        //获取通道中的输入流
        InputStream inputStream = socket.getInputStream();

        while (true){
            System.out.print("请输入要发送的内容：");
            String info = sc.nextLine();
            if("886".equals(info)){
                break;
            }

            // 4:通过流的对象可以对数据进行传输
            outputStream.write(info.getBytes());
            outputStream.flush(); // 来自于通道中的类


            byte[] bytes = new byte[1024];
            int length = inputStream.read(bytes);
            String s = new String(bytes, 0, length);
            System.out.println(s);
        }


        // 5:如果传输数据完毕,关闭资源
//        outputStream.close();
        socket.close();

    }
}    
============================================================ /*
    1:建立服务器端的socket服务，需要一个端口
    2:服务端没有直接流的操作,而是通过accept方法获取客户端对象，在通过获取到的客户端对象的流和客户端进行通信
    3:通过客户端的获取流对象的方法,读取数据或者写入数据
    4:如果服务完成,需要关闭客户端,然后关闭服务器，但是,一般会关闭客户端,不会关闭服务器,因为服务端是一直提供服务的

 */
public class ServerDemo1 {
    public static void main(String[] args){
        try {
            // 1:建立服务器端的socket服务，需要一个端口
            //ServerSocket(int port)
            //创建绑定到指定端口的服务器套接字。
            ServerSocket ss = new ServerSocket(12345);

            // 2:服务端没有直接流的操作,而是通过accept方法获取客户端对象，在通过获取到的客户端对象的流和客户端进行通信
            Socket socket = ss.accept();

            while (true){
                InetAddress inetAddress = socket.getInetAddress();
                String hostName = inetAddress.getHostName();

                // 3:通过客户端的获取流对象的方法,读取数据或者写入数据
                // 获取通道中的输入流
                InputStream inputStream = socket.getInputStream();
                byte[] bytes = new byte[1024];
                int length = inputStream.read(bytes);
                String s = new String(bytes, 0, length);
                System.out.println(hostName+": "+s);

                // 获取通道中的输出流
                OutputStream outputStream = socket.getOutputStream();
                outputStream.write("服务器已接收！".getBytes());
                outputStream.flush();
            }
        }catch (Exception e){
            System.out.println("用户已退出。。。");
        }


    }
}   
============================================================ /*
    1:建立客户端的Socket服务,并明确要连接的服务器。
    2:如果连接建立成功,就表明,已经建立了数据传输的通道.就可以在该通道通过IO进行数据的读取和写入.该通道称为Socket流,Socket流中既有读取流,也有写入流.
    3:通过Socket对象的方法,可以获取这两个流
    4:通过流的对象可以对数据进行传输
    5:如果传输数据完毕,关闭资源

 */
public class ClientDemo1 {
    public static void main(String[] args) throws Exception{
        // 1:建立客户端的Socket服务,并明确要连接的服务器。
        //Socket(String host, int port)
        //创建流套接字并将其连接到指定主机上的指定端口号。
        Socket socket = new Socket("192.168.22.15", 12345);
        Scanner sc = new Scanner(System.in);

        // 3:通过Socket对象的方法,可以获取这两个流
        //获取通道中的输出流，将数据发送给服务端
        OutputStream outputStream = socket.getOutputStream();
        //获取通道中的输入流
        InputStream inputStream = socket.getInputStream();

        while (true){
            System.out.print("请输入要发送的内容：");
            String info = sc.nextLine();
            if("886".equals(info)){
                break;
            }

            // 4:通过流的对象可以对数据进行传输
            outputStream.write(info.getBytes());
            outputStream.flush(); // 来自于通道中的类


            byte[] bytes = new byte[1024];
            int length = inputStream.read(bytes);
            String s = new String(bytes, 0, length);
            System.out.println(s);
        }


        // 5:如果传输数据完毕,关闭资源
//        outputStream.close();
        socket.close();

    }
}   

============================================================
    
/*
    1:建立服务器端的socket服务，需要一个端口
    2:服务端没有直接流的操作,而是通过accept方法获取客户端对象，在通过获取到的客户端对象的流和客户端进行通信
    3:通过客户端的获取流对象的方法,读取数据或者写入数据
    4:如果服务完成,需要关闭客户端,然后关闭服务器，但是,一般会关闭客户端,不会关闭服务器,因为服务端是一直提供服务的

 */
public class ServerDemo1 {
    public static void main(String[] args)  throws Exception{
        // 1:建立服务器端的socket服务，需要一个端口
        //ServerSocket(int port)
        //创建绑定到指定端口的服务器套接字。
        ServerSocket ss = new ServerSocket(12345);
        System.out.println("=============== 欢迎进入32期聊天室 ===================");

        while (true){
            // 2:服务端没有直接流的操作,而是通过accept方法获取客户端对象，在通过获取到的客户端对象的流和客户端进行通信
            Socket socket = ss.accept();

            new TCPThread(socket).start();
        }
    }
}

class TCPThread extends Thread{

    Socket socket;

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

    @Override
    public void run() {
        InetAddress inetAddress = socket.getInetAddress();
        String hostName = inetAddress.getHostName();
        System.out.println("用户："+hostName+" 已上线! ");
        try {
            while (true) {
                // 3:通过客户端的获取流对象的方法,读取数据或者写入数据
                // 获取通道中的输入流
                InputStream inputStream = socket.getInputStream();
                byte[] bytes = new byte[1024];
                int length = inputStream.read(bytes);
                String s = new String(bytes, 0, length);
                String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
                System.out.println(time);
                System.out.println(hostName + ": " + s);
                System.out.println();

                // 获取通道中的输出流
                OutputStream outputStream = socket.getOutputStream();
                outputStream.write("服务器已接收！".getBytes());
                outputStream.flush();
            }
        }catch (Exception e){
            System.out.println("-----------------------");
            System.out.println(hostName+" 用户已下线....");
            System.out.println("-----------------------");
        }
    }
}
============================================================
/*
    1:建立客户端的Socket服务,并明确要连接的服务器。
    2:如果连接建立成功,就表明,已经建立了数据传输的通道.就可以在该通道通过IO进行数据的读取和写入.该通道称为Socket流,Socket流中既有读取流,也有写入流.
    3:通过Socket对象的方法,可以获取这两个流
    4:通过流的对象可以对数据进行传输
    5:如果传输数据完毕,关闭资源

 */
public class ClientDemo1 {
    public static void main(String[] args) throws Exception {
        // 1:建立客户端的Socket服务,并明确要连接的服务器。
        //Socket(String host, int port)
        //创建流套接字并将其连接到指定主机上的指定端口号。
        Socket socket = new Socket("192.168.22.15", 12345);
        Scanner sc = new Scanner(System.in);



        // 3:通过Socket对象的方法,可以获取这两个流
        //获取通道中的输出流，将数据发送给服务端
        OutputStream outputStream = socket.getOutputStream();
        //获取通道中的输入流
        InputStream inputStream = socket.getInputStream();

        // E:\\李刚的对象.jpg
        BufferedInputStream bis = null;
        while (true){
            try {
                System.out.print("请输入要上传文件的路径：");
                String address = sc.nextLine();
                bis = new BufferedInputStream(new FileInputStream(address));
                break;
            }catch (Exception e){
                System.out.println("路径不存在！重新输入！");
            }
        }
        if(bis!=null){
            byte[] bytes = new byte[2048];
            int length = 0;
            while ((length = bis.read(bytes))!=-1){
                // 4:通过流的对象可以对数据进行传输
                outputStream.write(bytes,0, length);
                outputStream.flush(); // 来自于通道中的类
            }
        }

        //关闭输出流，通知服务端读取结束
        socket.shutdownOutput();

        // 接收服务端的反馈
        byte[] bytes = new byte[1024];
        int length = inputStream.read(bytes);
        String s = new String(bytes, 0, length);
        System.out.println(s);


        // 5:如果传输数据完毕,关闭资源
//        outputStream.close();
        socket.close();

    }
}
============================================================

/*
    1:建立服务器端的socket服务，需要一个端口
    2:服务端没有直接流的操作,而是通过accept方法获取客户端对象，在通过获取到的客户端对象的流和客户端进行通信
    3:通过客户端的获取流对象的方法,读取数据或者写入数据
    4:如果服务完成,需要关闭客户端,然后关闭服务器，但是,一般会关闭客户端,不会关闭服务器,因为服务端是一直提供服务的

 */
public class ServerDemo1 {
    public static void main(String[] args)  throws Exception{
        // 1:建立服务器端的socket服务，需要一个端口
        //ServerSocket(int port)
        //创建绑定到指定端口的服务器套接字。
        ServerSocket ss = new ServerSocket(12345);

        while (true){
            // 2:服务端没有直接流的操作,而是通过accept方法获取客户端对象，在通过获取到的客户端对象的流和客户端进行通信
            Socket socket = ss.accept();

            new TCPThread(socket).start();
        }
    }
}

class TCPThread extends Thread{

    Socket socket;

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

    @Override
    public void run() {
        InetAddress inetAddress = socket.getInetAddress();
        String hostName = inetAddress.getHostName();
        System.out.println("用户："+hostName+" 已上线! ");

        try {
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\target\\" + hostName + "-" + System.currentTimeMillis() + ".jpg"));
            while (true) {
                // 3:通过客户端的获取流对象的方法,读取数据或者写入数据
                // 获取通道中的输入流
                InputStream inputStream = socket.getInputStream();
                byte[] bytes = new byte[2048];
                int length = 0;
                while ((length = inputStream.read(bytes))!=-1){
                    // 4:通过流的对象可以对数据进行传输
                    bos.write(bytes,0, length);
                    bos.flush(); // 来自于通道中的类
                }

                // 获取通道中的输出流
                OutputStream outputStream = socket.getOutputStream();
                outputStream.write("图片已上传！！".getBytes());
                outputStream.flush();
            }
        }catch (Exception e){
            System.out.println("-----------------------");
            System.out.println(hostName+" 用户已下线....");
            System.out.println("-----------------------");
        }
    }
}
============================================================
/*
    1:建立udp的socket服务.
    2:通过receive方法接收数据
    3:将收到的数据存储到数据包对象中
    4:通过数据包对象的功能来完成对接收到数据进行解析.
    5:可以对资源进行关闭

 */
public class ReceiveDemo1 {
    public static void main(String[] args) throws Exception{
        // 1:建立udp的socket服务
        DatagramSocket socket = new DatagramSocket(10086);

        // 2:通过receive方法接收数据
        //public synchronized void receive(DatagramPacket p)
        byte[] bytes = new byte[1024];
        DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
        socket.receive(packet);

        //4:通过数据包对象的功能来完成对接收到数据进行解析.
        byte[] data = packet.getData();
        int length = packet.getLength();
        String info = new String(data, 0, length);
        System.out.println("发送段发来一条消息："+info);


        // 5:可以对资源进行关闭
        socket.close();

    }
}
============================================================

/*
    1:建立udp的socket服务
    2:将要发送的数据封装成数据包
    3:通过udp的socket服务,将数据包发送出
    4:关闭资源

 */
public class SendDemo1 {
    public static void main(String[] args) throws Exception{
        // 1:建立udp的socket服务
        // DatagramSocket
        //DatagramSocket()
        //构造数据报套接字并将其绑定到本地主机上的任何可用端口。
        DatagramSocket socket = new DatagramSocket();

        // 2:将要发送的数据封装成数据包 DatagramPacket
        //DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        //构造用于发送长度的分组的数据报包 length指定主机上到指定的端口号。
        byte[] bytes = "李刚来了...".getBytes();
        int length = bytes.length;
        InetAddress address = InetAddress.getByName("192.168.22.15");
        DatagramPacket packet = new DatagramPacket(bytes, length, address, 10086);


        // 3:通过udp的socket服务,将数据包发送出
        //public void send(DatagramPacket p)
        socket.send(packet);

        // 4:关闭资源
        socket.close();

    }
}
============================================================
/*
    1:建立udp的socket服务.
    2:通过receive方法接收数据
    3:将收到的数据存储到数据包对象中
    4:通过数据包对象的功能来完成对接收到数据进行解析.
    5:可以对资源进行关闭

 */
public class ReceiveDemo1 {
    public static void main(String[] args) throws Exception{
        // 1:建立udp的socket服务
        DatagramSocket socket = new DatagramSocket(10086);
        System.out.println("=================== 欢迎来到32期大群聊 =======================");

        while (true){
            // 2:通过receive方法接收数据
            //public synchronized void receive(DatagramPacket p)
            byte[] bytes = new byte[1024];
            DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
            socket.receive(packet);

            //4:通过数据包对象的功能来完成对接收到数据进行解析.
            byte[] data = packet.getData();
            int length = packet.getLength();
            String info = new String(data, 0, length);

            InetAddress address = packet.getAddress();
            String hostName = address.getHostName();
            BufferedWriter bw = new BufferedWriter(new FileWriter("java/src/com/shujia/day19/recode/" + hostName + ".txt",true));

            if("886".equals(info)){
                System.out.println("----------- 提示线 -------------");
                System.out.println(hostName+" 用户已离开群聊.....");
                System.out.println("----------- 提示线 -------------");
//                break;
            }else {
                String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
                System.out.println(time);
                System.out.println(hostName+ "："+info);
                bw.write(time);
                bw.newLine();
                bw.write(info);
                bw.newLine();
                bw.flush();

                System.out.println();
            }
        }


        // 5:可以对资源进行关闭
//        socket.close();

    }
}
============================================================
/*
    1:建立udp的socket服务
    2:将要发送的数据封装成数据包
    3:通过udp的socket服务,将数据包发送出
    4:关闭资源

 */
public class SendDemo1 {
    public static void main(String[] args) throws Exception{
        // 1:建立udp的socket服务
        // DatagramSocket
        //DatagramSocket()
        //构造数据报套接字并将其绑定到本地主机上的任何可用端口。
        DatagramSocket socket = new DatagramSocket();
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        while (true){
            System.out.print("请输入要发送的内容：");
            String info = sc.nextLine();


            // 2:将要发送的数据封装成数据包 DatagramPacket
            //DatagramPacket(byte[] buf, int length, InetAddress address, int port)
            //构造用于发送长度的分组的数据报包 length指定主机上到指定的端口号。
            byte[] bytes = info.getBytes();
            int length = bytes.length;
            InetAddress address = InetAddress.getByName("192.168.22.15");
            DatagramPacket packet = new DatagramPacket(bytes, length, address, 10086);

            // 3:通过udp的socket服务,将数据包发送出
            //public void send(DatagramPacket p)
            socket.send(packet);

            if("886".equals(info)){
                break;
            }
        }

        // 4:关闭资源
        socket.close();

    }
}

标签：String,编程,System,网络,new,客户端,Socket,socket
From： https://www.cnblogs.com/snzjz/p/18475832

相关文章

  • java_day19_线程组、线程池、定时器、InetAddress、网络编程、设计模式
    一、线程组：线程组：将属于同一类的线程划分到同一组中，可以直接对线程组进行设置。ThreadGroup构造方法：ThreadGroup(Stringname)构造一个新的线程组。代码案例：classMyThread1extendsThread{publicMyThread1(){}publicMyThread1(ThreadGr......
  • 20222413 2024-2025-1 《网络与系统攻防技术》实验二实验报告
    1.实验内容本周学习的主要内容为缓冲区溢出的shellcode技术，及其RNS、NSR、RS三种缓冲区溢出技术。此外，我还学习了在Linux系统和Windows系统中缓冲区溢出的实例和防范方法。在实验过程中，我初步了解并实践实现了后门原理，能够使用工具生成后门入侵控制其他主机。2.实验目标(1)使用......
  • 网路编程
    UDP将数据源和目的封装成数据包中，不需要建立连接；每个数据报包的大小在限制在64k；因无连接，是不可靠协议；不需要建立连接，速度快UDP传输发送端思路1:建立udp的socket服务2:将要发送的数据封装成数据包3:通过udp的socket服务,将数据包发送出4:关闭资源点击查看代码publiccl......
  • 【计算机毕业设计选题推荐】基于爬虫与文本挖掘的网络舆情监控系统的设计与实现【附源
    ✍✍计算机毕设编程指导师**⭐⭐个人介绍：自己非常喜欢研究技术问题！专业做Java、Python、小程序、安卓、大数据、爬虫、Golang、大屏等实战项目。⛽⛽实战项目：有源码或者技术上的问题欢迎在评论区一起讨论交流！⚡⚡Java、Python、小程序、大数据实战项目集⚡⚡文末获取......
  • 20222419 2024-2025-1 《网络与系统攻防技术》实验二实验报告
    1.实验内容(1)使用netcat获取主机操作Shell，cron启动某项任务（任务自定）PS：cron是linux下用来周期性的执行某种任务或等待处理某些事件的一个守护进程(2)使用socat获取主机操作Shell,任务计划启动(3)使用MSFmeterpreter（或其他软件）生成可执行文件，利用ncat或socat传送到主机并运行......
  • 5步轻松上手！零基础也能掌握Go语言编程
    你是不是经常听到Go语言（Golang）在技术圈的讨论，却不知道如何开始？Go语言凭借其简洁、高效和并发处理能力，成为越来越多开发者和公司的首选。特别是在高并发场景如微服务、分布式系统中，Go的优势尤为突出。作为一门对初学者友好的语言，即便你没有编程基础，也可以通过以下5个简单步骤......
  • AI编程Arduino单片机点亮WS2812灯带彩虹灯效
    引言随着物联网（IoT）和智能家居的迅速发展，LED灯带因其灵活性和多样的显示效果，广泛应用于装饰、广告、舞台等多个领域。WS2812作为一种智能可控的LED灯带，以其独立控制、丰富的色彩和高亮度，成为众多开发者的首选。而在控制WS2812灯带的过程中，编写高效、稳定的单片机代码至关重要。......
  • 在线考试系统/在线考试/考试系统/在线学习/远程教育/电子考试/网络考试/在线测评/在线
    博主介绍......
  • 20222311 2024-2025-1 《网络与系统攻防技术》实验二实验报告
    一、实验内容1.实验目标(1)使用netcat获取主机操作Shell，cron启动某项任务（任务自定）PS：cron是linux下用来周期性的执行某种任务或等待处理某些事件的一个守护进程(2)使用socat获取主机操作Shell,任务计划启动(3)使用MSFmeterpreter（或其他软件）生成可执行文件（后门），利用ncat或soca......
  • 20222305 2024-2025-1 《网络与系统攻防技术》实验二实验报告
    网络攻防实验报告姓名：田青学号：20222305实验日期：2024/10/16—2024/10/23实验名称：后门原理与实践指导教师：王志强1.实验内容本周学习内容总结：：后门概念：不经过正常认证流程而访问系统的通道。后门类型：编译器后门、操作系统后门、应用程序后门、潜伏于操作系统中或伪装为特......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99