day13--网络编程

网络编程

一、概述

信件

对方的邮编

对方的地址

对方的姓名

自己的地址

自己的名字

自己的邮编

打电话——》TCP

发短信——》UDP

地理位置不同

通过通信线路连接

网络通信协议

实现资源共享和信息传递

二、网络通信的要素

如何实现网络的通信

通信双方的地址

ip
端口号

规则：网络通信的协议

TCP/IP参考模型

小结：

网络编程中有两个主要问题
- 如何准确的定位到网络上的一台或者多台主机
- 找到主机之后如何进行通信
网络编程中的要素
- IP和端口号
- 网络通信协议
万物皆对象

三、 Ip

ip地址：InetAddress

唯一定位一台网络上计算机
127.0.0.1：本机localhost
ip地址的分类
- ipv4/ipv6
  - ipv4 4个字节组成。0-255 42亿
  - ipv6 128位，8个无符号整数
```
2901:0bb2:aaaa:0015:0000:0000:1aaa:1212
```
- 公网私网
  - ABCD类地址
  - 192.168.XX.XX，专门给组织内部使用的
域名：记忆ip问题

查询本机地址

InetAddress.getByName("127.0.0.1")

InetAddress.getByName("localhost")

getLocalHost()

查询网站地址

InetAddress.getByName("www.baidu.com")

getCanonicalHostname

getHostAddress

getHostName

四、端口

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

不同的进程有不同的端口号，用来区分软件的
被规定0-65535
TCP/UDP ：65535*2 单个协议下端口号不能冲突
端口分类
- 公有端口 0 - 1023
  - http：80
  - https: 443
  - ftp: 21
  - telnet:23
- 程序注册端口：1024-49151 分配用户或者程序
  - tomcat:8080
  - mysql:3306
  - Oracle:1521
- 动态、私有：49152-65535
```
netstat -ano #查看所有的端口
netstat -ano|findstr "5900" #查看指定的端口
tasklist|findstr "8696" #查看指定端口的进程
```

InetSocketAddress("127.0.0.1",8080)

五、通信协议

协议：约定

网络通信协议：速率、传输码率、代码结构、传输控制。。。

TCP/IP协议簇

重要：

tcp:用户传输协议

udp:用户数据报协议

tcp udp 对比

TCP:打电话

连接、稳定

三次握手，四次挥手

最少需要三次，保证稳定连接
A:你瞅啥？
B:瞅你咋地？
A:干一场

A:我要走了
B:你真的要走了吗？
B:你真的要走了吗
A:我真的要走了

客户端、服务端
传输完成、释放连接、效率低

UDP：发短信

不连接、不稳定
客户端、服务端，没有明确的界限
不管有没有准备好，都可以发给你
导弹
DDOS：洪水攻击、饱和攻击

六、TCP

客户端

要知道服务端的地址
InetAddress.getByName("127.0.0.1")
port
创建一个socket连接 new Socket(ip,port)
发送消息 IO流 socket.getOutputStream() os.write()

public class TcpClient {
    public static void main(String[] args) {

        InetAddress ip = null;
        Socket socket = null;
        OutputStream outputStream = null;
        try {
            //1.给我一个服务端地址
            ip = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //2.创建一个socket连接
            try {
                socket = new Socket(ip,port);
                //3.发送消息到服务端
                outputStream = socket.getOutputStream();
                outputStream.write(("我是客户端消息").getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            }

        } catch (UnknownHostException e) {
            e.printStackTrace();
        }finally {
            if (outputStream != null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

服务器

我的有一个地址 new ServerSocket(port)
等待客户端连接过来 serverSocket.accept()
读取客户端的消息 socket.getInputStream()
管道流 ByteArrayOutputStream()

public class TcpServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket accept = null;
        InputStream inputStream = null;
        ByteArrayOutputStream bos = null;
        try {
            //1.创建服务端地址
            serverSocket = new ServerSocket(9999);
            //2.等待客户端连接过来
            accept = serverSocket.accept();
            //3.接收客户端消息
            inputStream = accept.getInputStream();
            //4.管道流
            bos = new ByteArrayOutputStream();
            //5.读取消息
            byte[] buffer = new byte[1024];
            int len;
            while (-1 != (len = inputStream.read(buffer))){
                bos.write(buffer,0,len);
            }
            System.out.println(bos.toString());

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

七、文件上传

读取一个文件，以流的形式传出去

客户端

创建socket连接
创建一个输出流
读取文件
写出文件

socket.shutdownOutput()

服务端

创建服务端口
监听客户端的连接
获取输入流
文件输出

八、Tomcat

服务端和客户端

服务端

Tomcat服务端

客户端

浏览器

九、UDP

发送端

建立socket DatagramSocket
发送给谁 InetAddress.getByname port
建个包 new DategramPacket(msg.getBytes(),0,len,)
发送包 socket.send()

public class UdpSend {
    public static void main(String[] args) throws IOException {

        //1.创建连接
        DatagramSocket socket = new DatagramSocket();
        //获取主机,接收端的ip和端口
        InetAddress ip = InetAddress.getByName("127.0.0.1");
        int port = 9090;
        //准备消息
        String msg = "你好啊，世界";
        byte[] bytes = msg.getBytes();
        DatagramPacket p = new DatagramPacket(bytes,0,bytes.length,ip,port);
        //2.发送消息
        socket.send(p);

        //结束关闭
        socket.close();
    }
}

接收端

开放端口 DategramSocket(9090)
准备接收 new DategramPacket(buffer,0,lent)
接收数据包 socket.receive(packet)

public class UdpReceive {
    public static void main(String[] args) throws IOException {
        //1.创建主机端口
        DatagramSocket socket = new DatagramSocket(9090);


        //2.接收消息
        byte[] buffer = new byte[1024];
        DatagramPacket p = new DatagramPacket(buffer,0,buffer.length);
        socket.receive(p);
        System.out.println(p.getAddress());
        System.out.println(p.getPort());
        byte[] data = p.getData();
        String s = new String(data,0,p.getLength());
        System.out.println(s);
        //3.接收完关闭
        socket.close();
    }
}

十、UDP聊天

public class ChatSend {
    public static void main(String[] args) throws IOException {

        DatagramSocket socket = new DatagramSocket(9090);

        while (true) {
            InputStreamReader inputStreamReader = new InputStreamReader(System.in);
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
            String s = bufferedReader.readLine();
            DatagramPacket packet = new DatagramPacket(s.getBytes(),
                    0,
                    s.length(),
                    InetAddress.getByName("localhost"),
                    9091);
            socket.send(packet);
            if (s.equals("bye")){
                break;
            }
        }

        socket.close();
    }
}

public class ChatReceive {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(9091);


        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
        while (true) {
            socket.receive(packet);
            String s = new String(packet.getData(), 0, packet.getLength());
            System.out.println(s);
            if (s.equals("bye")){
                break;
            }
        }
        socket.close();
    }
}

多线程

public class TalkSend implements Runnable{

    private DatagramSocket socket = null;
    private BufferedReader bufferedReader = null;
    private int fromPort;
    private String toIp;
    private int toPort;

    public TalkSend(int fromPort, String toIp, int toPort) {
        this.fromPort = fromPort;
        this.toIp = toIp;
        this.toPort = toPort;

        try {
            socket = new DatagramSocket(this.fromPort);
            bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }



    @Override
    public void run() {
        try {
            while (true) {
                String msg = bufferedReader.readLine();
                DatagramPacket packet = new DatagramPacket(msg.getBytes(),
                        0,
                        msg.length(),
                        InetAddress.getByName(toIp),
                        toPort);
                socket.send(packet);
                if (msg.equals("bye")){
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        if (socket != null) {
            socket.close();
        }
    }
}

public class TalkReceive implements Runnable{

    private DatagramSocket socket = null;
    private byte[] buffer;
    private DatagramPacket packet = null;

    private int port;
    private String name;

    public TalkReceive(int port, String name) {
        this.port = port;
        this.name = name;
        buffer = new byte[1024];
        packet = new DatagramPacket(buffer, 0, buffer.length);
        try {
            this.socket = new DatagramSocket(this.port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

        try {
            while (true) {
                socket.receive(packet);
                String msg = new String(packet.getData(), 0, packet.getLength());
                System.out.println(name+":"+msg);
                if (msg.equals("bye")){
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (socket!= null) {
            socket.close();
        }
    }
}

十一、 URL

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

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

url.openconnection

HttpURLConnection

public class TestUrl {
    public static void main(String[] args) throws IOException {
        URL url = new URL("http://www.baidu.com:80/appname/path/file?param1=1&param2=2");

        System.out.println(url.getAuthority());
        System.out.println(url.getHost());
        System.out.println(url.getPort());
        System.out.println(url.getPath());
        System.out.println(url.getFile());
        System.out.println(url.getProtocol());
        System.out.println(url.getQuery());


        //1.下载地址
//        URL url1 = new URL("http://localhost:8080/zlm/readme.txt");
        URL url1 = new URL("https://m701.music.126.net/20220429175658/2376191cdfa9519978266596c97fbdf6/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/14096404680/f17f/39e3/19c2/6400927acc86f0c60e434a099372bc6c.m4a");
        //2.打开连接
        URLConnection urlConnection = url1.openConnection();
        //输入流
        InputStream inputStream = urlConnection.getInputStream();
        //文件流
        FileOutputStream fileOutputStream = new FileOutputStream("rsj.m4a");

        byte[] buffer = new byte[1024];
        int len;
        while ((len = inputStream.read(buffer,0,buffer.length)) != -1){
            fileOutputStream.write(buffer,0,len);
        }

        fileOutputStream.close();
        inputStream.close();


    }
}

posted @ 2022-04-29 17:37 LukeZhang_sz 阅读(40) 评论(0) 收藏举报

刷新页面返回顶部

lukezhangsz