网络编程1

Clyde·

已于 2022-12-07 17:09:21 修改

阅读量28

点赞数

文章标签：网络网络通信

于 2021-04-01 22:55:21 首次发布

本文链接：https://blog.csdn.net/qq_31650157/article/details/115385844

版权

网络编程

1.1概述

百度

计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

目的：传播信息，数据交换，通信
java web：网页编程 B/S
网络编程：TCP/IP C/S

1.2网络通信的要素

人工智能：智能汽车，工厂
如何实现网络通信？
- 通信双方地址
  - ip
  - 端口号
  - xxx.xxx.xx.xx:8080
- 规则：网络通信的协议 http,ftp,smtp,tcp,udp
TCP/IP参考模型

在这里插入图片描述

1.3IP

JAVA.NET.InetAddress

唯一定位一台网络上的计算机
127.0.0.1 自己电脑
ip地址分类
- ipv4/ipv6
  - ipv4 127.0.0.1 ,4个字节组成， 0-255，30亿走在北美，亚洲4亿；2011年就用尽；
  - ipv6 fe80::608e:8c8a:7d5a:d746%6 ，:128位 8个无符号整数。
- 公网（互联网）-私网（局域网）
  - 192.168.xx.xx 专门给组织内部使用
  - ABCD类地址
域名：记忆ip问题
- ip：www.vip.com

public class test2 {

    public static void main(String[] args) throws UnknownHostException {
        InetAddress byName = InetAddress.getByName("127.0.0.1");
        System.out.print(byName);
        InetAddress byName2 = InetAddress.getByName("www.baidu.com");
        System.out.print(byName2);
        //gethostname
        //gethostaddress
    }
}

1.4端口

端口表示计算机上一个程序的进程

不同的进程有不同的端口号用来区分软件
被规定0-65535
tcp,udp:65535*2，单个协议不能冲突

端口分布

公有端口0-1023
- http：80
- https：443
- ftp：21
- telent：23
程序注册端口1024-49151
- tomcat：8080
- mysql：3306
- orcale：1521

动态、私有端口49152-65535

netstat -ano | findstr "5900" //查看端口
tasklist|findstr "8696" //查看指定端口的进程

public class test2 {

    public static void main(String[] args) throws UnknownHostException {
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.127.0.1",8080);
        System.out.print(inetSocketAddress);
        System.out.println(inetSocketAddress.getHostName());
        System.out.println(inetSocketAddress.getAddress());
    }
}

1.5通信协议

好比是语言
网络通信协议：速率，传输码率，代码结构，传输控制、、、（非常复杂，分层）
TCP/IP协议簇（实际上是一组协议）
- 传输层：TCP用户传输协议
- 传输层：UDP用户数据报协议
- 网络层（封包传输）IP：网络互连协议
TCP udp对比
- TCP：打电话
  - 连接，稳定
  - 三次握手四次挥手
    - ```
    A-B-A/ A-B-B-A
```
- 客户端服务端
- 传输完成释放连接，效率低
- udp：发短信
  - 不连接，不稳定
  - 客户端服务端没有明确界限
  - 不管有没有准备好，都可以发送
  - DDOS：洪水攻击，饱和攻击

1.6TCP

客户端
- 连接服务器Socket
- 发送消息
服务器
- 建立服务端口serverSocket
- 等待用户的连接accept

public class TcpClinet {

    public static void main(String[] args) throws UnknownHostException {

        try {
            //要知道服务器地址
            InetAddress localhost = InetAddress.getByName("127.0.0.1");
            int port=9999;
            //创建一个scoket连接
            Socket socket=new Socket(localhost,port);
            //发送消息 io流
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write("你好".getBytes());

        }catch (IOException e){
            e.printStackTrace();
        }


    }
}

public class TcpServer {

    public static void main(String[] args) throws UnknownHostException {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream inputStream = null;
        ByteArrayOutputStream byteArrayOutputStream = null;

        //设置地址
        try {
            serverSocket = new ServerSocket(9999);
            //等待客户端连接
            socket = serverSocket.accept();
            //读取消息
            inputStream = socket.getInputStream();
            //管道流
            byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len = inputStream.read(buffer)) != -1) {
                byteArrayOutputStream.write(buffer, 0, len);
            }
            System.out.println(byteArrayOutputStream.toString());


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (byteArrayOutputStream!=null){
                try {
                    byteArrayOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }


    }
}

文件上传

public class TcpClinet {

    public static void main(String[] args) throws UnknownHostException {

        try {
            //要知道服务器地址
            InetAddress localhost = InetAddress.getByName("127.0.0.1");
            int port=9999;
            //创建一个scoket连接
            Socket socket=new Socket(localhost,port);
            //发送消息 io流
            OutputStream outputStream = socket.getOutputStream();

            FileInputStream fis=new FileInputStream(new File("xx.jpg"));
            //写出文件
            byte[] buffer=new byte[1024];
            int len;
            while ((len=fis.read(buffer))!=-1){
                outputStream.write(buffer,0,len);
            }
            //通知服务器传输完成
            socket.shutdownOutput();
            //确定接收完毕才能断开
            InputStream is=socket.getInputStream();
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len2;
            while ((len2 = inputStream.read(buffer)) != -1) {
                byteArrayOutputStream.write(buffer, 0, len);
            }
            System.out.println(byteArrayOutputStream.toString());
            //关闭            

        }catch (IOException e){
            e.printStackTrace();
        }


    }
}

public class TcpServer {

    public static void main(String[] args) throws UnknownHostException {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream inputStream = null;
        ByteArrayOutputStream byteArrayOutputStream = null;

        //设置地址
        try {
            serverSocket = new ServerSocket(9999);
            //等待客户端连接
            socket = serverSocket.accept();
            //读取消息
            inputStream = socket.getInputStream();
            //文件输出
            FileOutputStream fos=new FileOutputStream(new File("xxx.jpg"));
            byte[] buffer = new byte[1024];
            int len;
            while ((len = inputStream.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
			//通知客户端接收完毕
            OutputStream os =socket.getOutputStream();
            os.write("接收完毕");

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (byteArrayOutputStream!=null){
                try {
                    byteArrayOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }


    }
}

1.7Tomcat

服务端
- 自定义 s
- tomcat s
客户端
- 自定义 c
- 浏览器 b

1.8 UDP

发送短信：不用连接，需要知道对方地址

public class UdpClinet {

    public static void main(String[] args) throws IOException {
        //建立一个连接
        DatagramSocket datagramSocket = new DatagramSocket();
        //简历一个包
        String msg = "message";
        //发送给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;
        //数据 数据长度
        DatagramPacket datagramPacket = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);
        //发送包
        datagramSocket.send(datagramPacket);

    }
}

```java

public class UdpServer {

public static void main(String[] args) throws IOException {
    //开放端口
    DatagramSocket socket = new DatagramSocket(9090);
    //接受数据包
    byte[] buffer = new byte[1024];
    DatagramPacket datagramPacket = new DatagramPacket(buffer, 0, buffer.length);
    socket.receive(datagramPacket);
    System.out.print(datagramPacket.getAddress().getHostAddress());
    System.out.print(new String(datagramPacket.getData(), 0, datagramPacket.getLength()));
    socket.close();
}

}
```

聊天

public class UdpClinet {

    public static void main(String[] args) throws IOException {
        //建立一个连接
        DatagramSocket datagramSocket = new DatagramSocket(6666);
        //准备接受包裹
        while (true){
            byte[] container=new byte[1024];
            DatagramPacket packet=new DatagramPacket(container,0,container.length);

            byte[] data=packet.getData();
            String receiveData=new String(data,0,data.length);
            if (receiveData.equals("bye")){
                break;
            }
            datagramSocket.receive(packet);//阻塞式接受包裹
        }

        datagramSocket.close();
    }
}

public class UdpServer {

    public static void main(String[] args) throws IOException {
        //开放端口
        DatagramSocket socket = new DatagramSocket(8888);
        //准备数据：控制台system.in
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        String data = reader.readLine();
        byte[] datas = data.getBytes();
        DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 6666));
        socket.send(packet);

    }
}

多线程聊天

public class TaskSend implements Runnable {
    DatagramSocket socket=null;
    BufferedReader reader = null;
    private String toIp;
    private int toPort;
    private String fromIp;
    private int fromPort;

    public TaskSend(String toIp, int toPort, String fromIp, int fromPort) {
        this.toIp = toIp;
        this.toPort = toPort;
        this.fromIp = fromIp;
        this.fromPort = fromPort;
        try {
            socket=new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }

    }

    @Override
    public void run() {

        while (true) {
            try {
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress(this.toIp, this.toPort));
                socket.send(packet);
                if (data.equals("bye")) {
                    break;
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }

        socket.close();

    }
}

public class TaskReceive implements Runnable {
    DatagramSocket datagramSocket = null;
    private int port;
    private String msgFrom;

    public TaskReceive(int port, String msgFrom) {
        this.port = port;
        this.msgFrom = msgFrom;

        try {
            datagramSocket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        //准备接受包裹
        try {
            while (true) {
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);

                byte[] data = packet.getData();
                String receiveData = new String(data, 0, data.length);
                System.out.print(msgFrom+":" + receiveData);
                if (receiveData.equals("bye")) {
                    break;
                }
                datagramSocket.receive(packet);//阻塞式接受包裹
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        datagramSocket.close();
    }
}

public class UdpServer {

    public static void main(String[] args) throws IOException {
        new Thread(new TaskSend("localhost", 8888, 5555)).start();
        new Thread(new TaskReceive(9999, "学生"));
    }
}

public class UdpClinet {

    public static void main(String[] args) throws IOException {
        new Thread(new TaskSend("localhost", 7777, 9999)).start();
        new Thread(new TaskReceive(8888, "老师"));
    }
}

1.9URL

统一资源定位符：定位资源，定位互联网上某一个资源

DNS域名解析 (把www.baidu.com解析成 xxx.xx.xx.x 的ip)

协议：// ip地址:端口/项目名/资源

public class UrlServer {

    public static void main(String[] args) throws IOException {
        URL url = new URL("http://localhost:8080/hello/index.jsp?username=test");
        System.out.print(url.getProtocol());//协议
        System.out.print(url.getHost());//主机
        System.out.print(url.getPort());//端口
        System.out.print(url.getPath());//文件
        System.out.print(url.getFile());//全路径
        System.out.print(url.getQuery());//参数

        //连接到对应资源
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();
        FileOutputStream outputStream = new FileOutputStream("test.text");
        byte[] buffer = new byte[1024];
        int len;
        while ((len = inputStream.read(buffer)) != -1) {
            outputStream.write(buffer, 0, len);
        }
        outputStream.close();
        inputStream.close();
        urlConnection.connect();
    }
}

Clyde·

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
网络编程1

网络编程1.1概述百度计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。目的：传播信息，数据交换，通信java web：网页编程 B/S网络编程：TCP/IP C/S1.2网络通信的要素人工智能：智能汽车，工厂如何实现网络通信？通信双方地址ip端口号xxx.xxx.xx.xx:8080规则：网络通信的协议 http,
复制链接

扫一扫