网络编程内容详解

灰太狼 2022-10-21 12:57 139阅读 0赞

## 网络编程 ##

> 1、概念：  
> 地球村：表示现代科技的迅速发展，缩小了地球上的空间距离。  
> TCP:需要对方确认；建立连接  
> UDP：发送就可以，不用管对方

**1.计算机网络：**

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

> 2.网络编程的目的：  
> 传播交流信息，数据交换。

> 3.想达到这个效果需要什么  
> 如何准确的定位网络上的一台主机？  
> 192.168.1.1：端口，定位到这个计算机上的某个资源。  
> 找到了这个主机，如何传输数据呢？  
> javaweb：网页编程——->B/S架构  
> 网络编程：TCP/IP———>C/S架构

**2、网络通信的要素**

*  2.1如何实现网络的通信？  
    通信双方的地址：  
    IP  
    端口号  
    规则：网络通信的协议  
    TCP/IP参考模型：七层传输协议.png  
    ARP————————>发送广播

小结：

> 1.网络编程中有两个主要问题  
> 如何准确地定位到网络上的一台或者多台主机？  
> dos命令中使用ping命令查询  
> 找到主机之后如何进行通信  
> 2.网络编程中的要素  
> IP和端口号  
> 网络通信协议  
> 3.万物皆对象

**3、IP**  
IP地址：java中inteAddress类

> 唯一定位一台网络上计算机  
> 127.0.0.1：本机localhost  
> IP地址的分类  
> ipv4/ipv6  
> IPV4：127.0.0.1 , 4个字节组成。 ， 每个字节长度0~255，全球有42亿；30亿在北美，亚洲4亿；2011年就用尽了。  
> IPV6： 128位.8个无符号整数！  
> 公网/私网  
> 公网：互联网使用—->ABCD类IP  
> 私网：局域网使用 192.168.xx.xx，专门给组织用的  
> 域名：记忆IP问题  
> IP：例如：www.jd.com

代码：

//测试IP
    public class TestInetAddress {
        
        public static void main(String[] args) {
        
            try {
        
                //查询本机ip地址
                InetAddress inetAddress1=InetAddress.getByName("172.0.0.1");
                System.out.println(inetAddress1);
                InetAddress inetAddress3=InetAddress.getByName("locathost");
                System.out.println(inetAddress3);
                InetAddress inetAddress4=InetAddress.getLocalHost();
                System.out.println(inetAddress4);
    
    
                //查询网站ip地址
                InetAddress inetAddress2=InetAddress.getByName("www.baidu.com");
                System.out.println(inetAddress2);
    
    
                //常用方法
                //System.out.println(inetAddress2.getAddress());//将某个语句加入输出语句中，后面.sout
                System.out.println(inetAddress2.getCanonicalHostName());//规范的名字
                System.out.println(inetAddress2.getHostAddress());//ip
                System.out.println(inetAddress2.getHostName());//域名，或者自己的名字
    
    
            } catch (UnknownHostException e) {
        
                e.printStackTrace();
            }
        }
    }

**4、端口**

> 端口表示计算机上的一个程序的进程；  
> 不同的进程有不同的端口号！用来区分软件！  
> 端口被规定：0~65535  
> TCP/UDP:，每一个都有65535个端口。 TCP使用80端口，UDP也可以使用80端口。这两个协议不冲突。  
> 单个协议下端口不能冲突。

***端口分类***

公有端口：0~1023（尽量不要占用，一般会被内置程序占用）

*  HTTP：默认端口80
 *  HTTPS：默认端口443
 *  FTP:默认端口21

程序注册端口：1024~49151，分配给用户或者程序。

*  Tomcat:默认端口8080
 *  MySQL:默认端口3306
 *  Oracle:默认端口1521

> 动态、私有端口：49152~65535（尽量不要使用）  
> netstat -ano： 查看本机所有端口  
> netstat -ano|findstr “5900”: 查看指定的端口  
> tasklist|findstr “8696”: 查看指定端口的进程  
> ctrl+shift+esc：打开任务管理器

代码：

//端口
    public class TestInetSocketAddress {
        
        public static void main(String[] args) {
        
            InetSocketAddress socketAddress1 = new InetSocketAddress("127.0.0.1", 8080);
            InetSocketAddress socketAddress2 = new InetSocketAddress("localhost", 8080);
            System.out.println(socketAddress1);
            System.out.println(socketAddress2);
            System.out.println(socketAddress1.getAddress());
            System.out.println(socketAddress1.getHostName());//地址
            System.out.println(socketAddress1.getPort());// 端口
        }
    }

**5、通信协议**  
协议：约定，就好比我们现在说的是普通话。

网络通信协议：速率，传输码率，代码结构，传输控制…..（非常的复杂）
        TCP/IP协议簇：实际上是一组协议
            TCP:用户传输协议
            UDP：用户数据报协议
            IP：网络互联协议
        TCP与UDP对比：
            TCP：
                连接，稳定
                三次握手，四次挥手
            三次握手：
                最少需要三次，保证稳定连接！
                A:你瞅啥?
                B:瞅你咋地？
                A：干一场！
            四次挥手：
                A:我不发了（关闭发送）
                B:好，那我不收了（关闭接收）
                B：我也不发了（关闭发送）
                A：好，那我也不收了（关闭接收）
            客户端、服务端
            传输完成，释放连接，效率低
        UDP：
            不连接，不稳定
            客户端、服务端：没有明确的界限
            不管准没准备好，都可以发给你。
            DDOS：洪水攻击！（饱和攻击）

**6、TCP实现聊天**  
客户端：

> 连接服务器Socket  
> 发送消息

代码：

// 客户端
    public class TCPClientDemo01 {
        
        public static void main(String[] args) {
        
            Socket socket =null;
            OutputStream os =null;
            try {
        
                // 1、要知道服务器的地址，端口号
                InetAddress serverIP = InetAddress.getByName("127.0.0.1");
                int port = 9999;
                // 2.建立一个socket连接
                socket = new Socket(serverIP,port);
                // 3.发送消息 IO流
                os = socket.getOutputStream();
                os.write("你好，我给你发消息了".getBytes());
            } catch (Exception e) {
        
                e.printStackTrace();
            }finally {
        
                // 先开的后关，后开的先关
                if(os!=null){
        
                    try {
        
                        os.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
                if(socket!=null){
        
                    try {
        
                        socket.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

服务器：

> 建立服务的端口ServerSocket  
> 等待用户的连接accept  
> 接受用户消息

代码：

// 服务器端
    public class TCPServerDemo01 {
        
        public static void main(String[] args) {
        
            ServerSocket serverSocket =null;
            Socket socket =null;
            InputStream is =null;
            ByteArrayOutputStream baos =null;
            try {
        
                // 1.我得有一个地址
                serverSocket = new ServerSocket(9999);
                while (true){
        
                    // 2.等待客户端连接过来(监听方法，返回客户端连接的Socket对象)
                    socket = serverSocket.accept();
                    // 3.读取客户端的消息
                    is = socket.getInputStream();
      /* 建立一个缓冲区，从缓冲区读取。（这种写法有问题，如果有中文，在传输过程中
              超过1024断开了，那个中文就会乱码）
              byte[] buffer = new byte[1024];
              int len;
              while ((len=is.read(buffer)!=-1)){
                  String meg = new String(buffer,0,len);
                  System.out.println(msg);
              }
              */
                    // 管道流(接头)
                    baos = new ByteArrayOutputStream();
                    byte[] buffer = new byte[1024];
                    int len;
                    while ((len = is.read(buffer)) != -1){
        
                        baos.write(buffer,0,len);
                    }
                    System.out.println(baos.toString());
                }
            } catch (IOException e) {
        
                e.printStackTrace();
            }finally {
        
                // 关闭流
                if(baos!=null){
        
                    try {
        
                        baos.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
                if(is!=null){
        
                    try {
        
                        is.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();
                    }
                }
            }
        }
    }

**7、TCP实现文件上传**  
客户端代码：

//客户端
    //上传文件
    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("gui.jpg"));
            //4.写出文件
            byte[] buffer = new byte[1024];
            int len;
            while ((len=fis.read(buffer))!=-1){
        
                os.write(buffer,0,len);
            }
            // 5.通知服务器，我已经结束
            socket.shutdownOutput();//我已经传输完了
            // 6.确定服务器接收完毕才能断开连接
            InputStream inputStream = socket.getInputStream();
            // String byte[]
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buffer2 = new byte[1024];
            int len2;
            while ((len2=inputStream.read(buffer2))!=-1){
        
                baos.write(buffer2,0,len2);
            }
            System.out.println(baos.toString());
            // 7.关闭流
            baos.close();
            inputStream.close();
            fis.close();
            os.close();
            socket.close();
        }
    }

服务器端代码：

//服务端
    // 读取文件
    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("gui.jpg"));
            byte[] buffer = new byte[1024];
            int len;
            while ((len=is.read(buffer))!=-1){
        
                fos.write(buffer,0,len);
            }
            // 5.通知客户端我接受完毕了
            OutputStream os = socket.getOutputStream();
            os.write("我接受完毕了，可以断开".getBytes());
            // 6.关闭资源
            fos.close();
            is.close();
            socket.close();
            serverSocket.close();
        }
    }

**8、初始tomcat服务器**  
服务端  
自定义S  
tomcat服务器S：java后台开发！  
客户端  
自定义C  
浏览器B  
**9、UDP消息发送**

> 不用连接，需要对方的地址！  
> 需要用到的两个类：  
> DatagramPacket（发送包）  
> DatagramSocket（接收包）  
> UDP发送消息

发送端：  
代码：

// 不需要建立服务器
    public class UdpClientDemo01 {
        
        public static void main(String[] args) throws Exception {
        
            // 1.建立一个Socket
            DatagramSocket socket = new DatagramSocket();
            // 2.建个包
            String msg = "你好啊，服务器！";
            // 发送给谁
            InetAddress localhost = InetAddress.getByName("localhost");
            int port = 9090;
            // 数据，数据的长度，要发送给谁
            DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);
            // 3.发送包
            socket.send(packet);
            // 4.关闭流
            socket.close();
        }
    }

接受端：  
代码：

// 还是要等待客户端的连接
    public class UdpServerDemo01 {
        
        public static void main(String[] args) throws Exception {
        
            // 开放端口
            DatagramSocket socket = new DatagramSocket(9090);
            // 接收数据包
            byte[] buffer = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
            socket.receive(packet);// 阻塞接收
            System.out.println(packet.getAddress().getHostAddress());// 包地址
            System.out.println(new String(packet.getData(),0,packet.getLength()));
            // 关闭连接
            socket.close();
        }
    }

**10、UDP聊天实现** chat  
循环发送消息：  
代码：

public class UdpSenderDemo01 {
        
        public static void main(String[] args) throws Exception {
        
            DatagramSocket socket = new DatagramSocket(8888);
            // 准备数据: 控制台读取 System.in
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            while (true){
        
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",6666));
                socket.send(packet);
                if(data.equals("bye")){
        
                    break;
                }
            }
            socket.close();
        }
    }

循环接收消息：  
代码：

public class UdpReceiveDemo01 {
        
        public static void main(String[] args) throws Exception {
        
            DatagramSocket socket = new DatagramSocket(6666);
            while (true){
        
                // 准备接收包裹
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container,0,container.length);
                // 接收
                socket.receive(packet);// 阻塞式接收包裹
                // 断开连接 bye
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, data.length);
                System.out.println(receiveData);
                if(receiveData.equals("bye")){
        
                    break;
                }
            }
            socket.close();
        }
    }

**11、UDP多线程在线咨询**  
聊天：双方都可以发送消息  
发送通用类  
代码：

public class TalkSend implements Runnable{
        
        DatagramSocket socket = null;
        BufferedReader reader = null;
        // 哪个端接口发送
        private int fromPort;
        // 发送至哪个IP地址
        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(fromPort);
                // 准备数据: 控制台读取 System.in
                reader = new BufferedReader(new InputStreamReader(System.in));
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
        @Override
        public void run() {
        
            while (true){
        
                String data = null;
                try {
        
                    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 (IOException e) {
        
                    e.printStackTrace();
                }
            }
            socket.close();
        }
    }

接收通用类  
代码：

public class TalkReceive implements Runnable{
        
        DatagramSocket socket = null;
        // 端口号
        private int Port;
        // 消息是谁发送的
        private String msgFrom;
        public TalkReceive(int port,String msgFrom) {
        
            this.Port = port;
            this.msgFrom = msgFrom;
            try {
        
                socket = new DatagramSocket(port);
            }catch (Exception e){
        
                e.printStackTrace();
            }
        }
        @Override
        public void run() {
        
            while (true){
        
                try {
        
                    // 准备接收包裹
                    byte[] container = new byte[1024];
                    DatagramPacket packet = new DatagramPacket(container,0,container.length);
                    // 接收
                    socket.receive(packet);// 阻塞式接收包裹
                    // 断开连接 bye
                    byte[] data = packet.getData();
                    String receiveData = new String(data, 0, data.length);
                    System.out.println(msgFrom+":"+receiveData);
                    if(receiveData.equals("bye")){
        
                        break;
                    }
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            }
            socket.close();
        }
    }

学生：

public class TalkStudent {
        
        public static void main(String[] args) {
        
            // 开启两个线程
            // 启动发送端（学生要给老师9999端口发消息，）
            new Thread(new TalkSend(7777,"localhost",9999)).start();
            // 启动接收端（学生8888端口等待老师发送消息）
            new Thread(new TalkReceive(8888,"老师")).start();
        }
    }

老师：

public class TalkTeacher {
        
        public static void main(String[] args) {
        
            // 启动发送端（老师要给学生8888端口发消息，）
            new Thread(new TalkSend(5555,"localhost",8888)).start();
            // 启动接收端（老师9999端口等待学生发送消息）
            new Thread(new TalkReceive(9999,"学生")).start();
        }
    }

***在线咨询：两个人都可以是发送方，也都可以是接收方***

**12、URL下载网络资源**

> 统一资源定位符：定位资源的，定位互联网上的某一个资源  
> DNS域名解析： www.baidu.com xxx.x.x.x…  
> 协议://ip地址：端口/项目名/资源

URL代码：

public class URLDemo01 {
        
        public static void main(String[] args) throws MalformedURLException {
        
            URL url = new URL("http://localhost:8080/helloworld/index.jsp?username=1&password=123");
            System.out.println(url.getProtocol());// 协议
            System.out.println(url.getHost());// 主机ip
            System.out.println(url.getPort());// 端口
            System.out.println(url.getPath());// 全路径
            System.out.println(url.getFile());// 文件
            System.out.println(url.getQuery());// 参数
        }
    }

URL下载：

public class URLDown {
        
        public static void main(String[] args) throws Exception{
        
            // 1.下载地址
            URL url = new URL("需要下载的资源");
            // 2.连接到这个资源HTTP
            HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
            // 输入流
            InputStream inputStream = urlConnection.getInputStream();
            // 定义一个文件类输出
            FileOutputStream fos = new FileOutputStream("下载的资源名称");
            byte[] buffer = new byte[1024];
            int len;
            while ((len=inputStream.read(buffer))!=-1){
        
                fos.write(buffer,0,len);
            }
            fos.close();
            inputStream.close();
            urlConnection.disconnect();
        }
    }