java_网络编程

概述

网络编程目的
无线电台…传播交流信息，数据交换，通信
1.如何准确的定位网络上的一台主机： 192.168.16.124：端口，定位到这个计算机上的某个资源
2.找到了这个主机，如何传输数据了

javaWeb：网页编程 B/S
网络编程：Tcp/ip C/S

1.2 网络通信的要素

人工智能：智能汽车：工厂，人少！ ？
伦理：
如何实现网络的通信，通信双方的地址

1. ip 192.168.1.1
2. 端口号

规则：网络通信的协议
http , ftp 上传文件，smtp 发送文件，tcp ,udp,
Tcp/IP 参考模型

HTTP:超文本传输协议，FTP：文本上传协议，SMTP:发送邮件，Telnet 远程登录

小结：
1.网络编程中有两个主要的问题
如何准备的定位到网络上的一台或者多台主机
找到主机之后如何进行通信
2.网络编程中的要素
> IP 和端口号
> 网络通信协议
2.万物接对象

1.3 IP

ip 地址：InetAddress

1. 唯一定位一台网络计算机

2. 127.0.0.1：本机localhost

3. IP地址的分类
   -ipv4/ipv6
   1.IPV4: 127.0.0.1 有4个字节组成，0-255，大概是有42 亿个；30 亿都在北美，亚洲4亿，2011 年就用完了，10进制
   2. IPV6: 240e:3b5:309d:e5b0:4966:b40f:6c40:f674,128 位， 8个无符号的整数！

4. 公网（互联网）-私网（局域网）

ABCD 类地址

192.168.xx.xx 局域网 ,专门给组织内部使用的

5. 域名: 记忆IP 问题！
   1.www.jd.com 域名上千万

package com.kuang.wlxy;


import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * net 包就封装网络地址的
 */
public class IPTest {


    
    public static void main(String[] args) {
        try {
            //查询本机地址
            InetAddress inetAddress1 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress1);

            //查询网站ip 地址
            InetAddress localHost = InetAddress.getLocalHost();
            System.out.println(localHost);

            //常用方法
           // System.out.println(inetAddress1.getAddress());
            //获取规范的名字
            System.out.println(inetAddress1.getCanonicalHostName());//规范的名字
            System.out.println(inetAddress1.getHostAddress());//获取IP
            System.out.println(inetAddress1.getHostName());//获取域名
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }


    }
}

端口

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

1. 不同的进程有不同的端口号！用来区分软件！
2. 被规定0-65535
3. Tcp,UDP: ,65535 X 2 tcp 用了80 ，udp 也用80 是可以的，单个协议下面端口号不能冲突
4. 端口分类
   公有端口 0-1023

• HTTP:80
• HTTPS:443
• FTP:21
• Telnet :23
  程序注册端口：2014-29151，分配用户或者程序

5. tomcat：8080
6. Mysql : 3306
7. Oralce :1521

动态端口：私有 49151-65535

netstat -ano
//查看具体某个端口
netstat -ano|findstr “5900” @ 查看指定的端口
tasklist|findstr “8696” # 查看端口的进程
打开任务管理器快捷键：Ctrl+shift+esc

通信协议

协议：约定，就好比我们现在说的普通话

网络通信协议：速率，传输码率，代码结构，传输控制。。。
问题：非常的复杂大事化小：分层
TCP/IP 协议簇 ，实际上是一组协议
重要：
1.tcp: 用户传输协议
2.udp: 用户数据报协议 发短信，写邮件

出名的协议：
TCP:
ip:网络互联协议

应用层：好比qq,微信
传输层：好比通信
网络层：封包发出去
数据链路层，光纤啊，无线网

TCP和UDP 对比
TCP:打电话

1. 连接，稳定
2. 三次握手，4次挥手

最少需要三次稳定连接

1. A:你愁啥
2. B：瞅你咋地
3. A: 干一场
   

A:我要断开了
B：我知道你要断开了
B：你真的断开了吗
A：我的真的要走了

4. 客户端，服务端
5. 传输完成，释放连接，效率低

UDP:发短信
6. 不连接，不稳定
7. 客户端，服务端，没有明确的界限
8. 不管有没有准备好，都发给你
9. 导弹
10. DDOS:洪水攻击！ 饱和攻击

TCP

客户端

1. 连接服务端Socket
2. 发送消息

package com.kuang.lesson2;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

//客户端
public class TcpClientDemo1 {
    public static void main(String[] args) {
        Socket socket =null;
        OutputStream outputStream = null;
        try {
            //1.要知道服务器的地址
            InetAddress serverIp = InetAddress.getByName("127.0.0.1");
            //端口号
            int port=9999;
            //2.创建一个socket 连接
            socket = new Socket(serverIp,port);
            //3.发送消息
             outputStream = socket.getOutputStream();
             outputStream.write("你好，欢迎学习狂神说Java".getBytes());

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


    }
}

服务器
3. 建立服务端ServerSoket
4. 等待用户连接accept
5. 接收用户的消息

package com.kuang.lesson2;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

//服务端
public class TcpServerDemo1 {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream bos = null;

        try {
            //1.我得有一个地址，开启一个服务端的插槽
            serverSocket = new ServerSocket(9999);
            while (true) {
                //2.等待客户端连接过来
                socket = serverSocket.accept();
                //3.读取客户端的消息
                is = socket.getInputStream();
                //管道流
                bos = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len = is.read(buffer)) != -1) {
                    bos.write(buffer, 0, len);
                }
                System.out.println(bos.toString());
            }


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            try {
                if (null != socket) {
                    socket.close();
                }
                if (null != bos) {
                    bos.close();
                }
                if (null != is) {
                    is.close();
                }
                if (null != serverSocket) {
                    serverSocket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

文件上传

1. 服务端

package com.kuang.lesson2;

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

public class TcpServerDemo02 {


    public static void main(String[] args) throws Exception {
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);

         //2.监听客户端的连接
        Socket socket = serverSocket.accept();//阻塞式监听，会一直等待客户端连接

        //3.获取输入流
        InputStream is = socket.getInputStream();

        //4.文件输出
        FileOutputStream fos = new FileOutputStream(new File("resice.jpg"));

        byte[] buffer = new byte[1024];

        int len;
        while((len =is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
        //通知客户端我接受完毕了
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("我接受完毕了，可以断开了".getBytes());


        //关闭资源
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();


    }
}

客户端

package com.kuang.lesson2;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception {
        //1. 创建一个socket 连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9000);
        //2.创建一个输出流
        OutputStream os = socket.getOutputStream();

        //3.文件流
        FileInputStream fis = new FileInputStream(new File("test.jpg"));

        //4.写出文件
        byte[] buffer = new byte[1024];

        int len;

        while ((len =fis.read()) != -1 ){
            os.write(buffer,0,len);
        }
        //通知服务器，我已经结束了
        socket.shutdownOutput();//我已经传输完了


        //确定服务器接收完毕,才能够断开连接
        InputStream inputStream = socket.getInputStream();
        //String byte[]
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        byte[] bytes = new byte[1024];

        int len2;

        while((len2=inputStream.read(bytes))!= -1){
            baos.write(bytes,0,len2);
        }

        System.out.println(baos.toString());

        //关闭资源
        fis.close();
        os.close();
        socket.close();
    }
}

1.先启动服务端代码，服务端处于监听状态，accpet
2.客户端启动，发送信息，发送信息完毕
3.服务端等待后接收信息，处理完信息后告诉客户端已处理完毕
4.客户端确定服务器接收完毕，才能够断开连接