网络编程Based on Java

网络编程Based on Java

1.1 概述

地球村：网络将整个地球上各国之间的时空距离拉近了，使得人们之间的交流更为便捷

---

古老的交流方式——信件：

打电话——链接——接通——通话 这叫TCP

发短信——发送了就完事——接收 这叫UDP

计算机网络：

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

网络编程的目的：

传播交流信息，进行数据交换，通信

想要达到这个效果需要什么？

1. 如何准确定位网络上的一台主机，IP:端口，定位到这个计算机上的某个资源
2. 找到了这个主机，如何传输数据？烽火台，驿站，邮局，网络

1.2 网络通信的要素

如何实现网络的通信？

通信双方的地址：

• IP
• 端口号

规则：网络通信的协议

HTTP,FTP,SFTP,SMTP,TCP,UDP

TCP/IP参考模型：

目前仅针对传输层TCP,UDP进行学习实践

小结：

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

1.3 IP

ip地址：InetAddress

• 唯一定位一台网络上的计算机
• 127.0.0.1 本机localhost
• ip地址分类：
  • 按IPv4/IPv6分类
    • IPv4——4段字节组成，如127.0.0.1，0-255，32位（8*4），总数可达42亿个
    • IPv6——2408:89ed:42:cf2f:fd33:78ec:293d:6c28，128位（16*8），8个无符号整数组成（16进制表示0~E）。
  • 按公网（互联网）/私网分类（局域网）
    • 192.168.XX.XX专门给组织机构使用
    • ABCD类地址
• 域名：记忆IP问题。IP：域名在早期是很值钱的，越早期的域名，如Alibaba，baidu这样的都是很高价格的

package com.netStudy.lesson01;

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

//测试IP
public class Test {
    public static void main(String[] args) {
        try {
            //查询本机地址
            InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress1);
            InetAddress inetAddress3 = InetAddress.getByName("localhost");
            System.out.println(inetAddress3);
            InetAddress inetAddress4 = InetAddress.getLocalHost();
            System.out.println(inetAddress4);
            //查询网络地址
            InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress2);
            //常用方法
            System.out.println(inetAddress2.getAddress());//获得地址byte类型，无用
            System.out.println(inetAddress2.getHostAddress());//获得地址
            System.out.println(inetAddress2.getCanonicalHostName());//获得规范的名字，无用
            System.out.println(inetAddress2.getHostName());//获得IP
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

/127.0.0.1
localhost/127.0.0.1
SKY-20170809ARD/192.168.0.101
www.baidu.com/36.152.44.95
[B@1b6d3586
36.152.44.95
36.152.44.95
www.baidu.com

1.4 端口

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

• 不同的进程有不同的端口号！用来区分软件！
• 被规定端口号范围0~65535
• TCP/UDP的端口号不冲突，因为协议不同，可以用同一个端口号，即单个协议下端口号不能冲突
• 端口分类
  • 公有端口0~1023
    • http：80
    • https：443
    • ftp：21
    • 远程连接：22
    • Telent：23
  • 程序注册端口：1024~49151分配用户或者程序
    • Tomcat : 8080
    • MySQL : 3306
    • Oracle : 1521
  • 动态、私有：
    • IDEA : 63342

常见的关于网络的dos命令

netstat -ano #查看所有的端口
netstat -ano|findstr "63342" #查看指定的端口
tasklist|findstr "63342" #查看指定端口的进程
ctrl+shift+esc  #打开任务管理器快捷键

package com.studyReflection;

import java.net.InetSocketAddress;

public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress inetSocketAddress1 = new InetSocketAddress("127.0.0.1",8080);
        InetSocketAddress inetSocketAddress2 = new InetSocketAddress("localhost",8080);
        System.out.println(inetSocketAddress1.getAddress());
        //C:\Windows\System32\drivers\etc\hosts 可以修改主机对应域名
        System.out.println(inetSocketAddress1.getHostName());//windows中hosts文件配置主机域名
        System.out.println(inetSocketAddress1.getPort());

        System.out.println(inetSocketAddress2.getAddress());
        System.out.println(inetSocketAddress2.getHostName());//地址
        System.out.println(inetSocketAddress2.getPort());//端口
    }
}

/127.0.0.1
www.leoDolphin.com
8080

localhost/127.0.0.1
localhost
8080

1.5 通信协议

协议——约定，如我们约定普通话是国内通用的一种语言

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

TCP/IP协议簇：

• TCP：用户传输协议
• UDP：用户数据报协议
• IP：网络互连协议

TCP和UDP对比：

TCP 类似打电话

• 连接，稳定
• 三次握手，四次挥手

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

A：我要走了！
B：你真的要走了吗？
B：你确定要走了？
A：我真的走了！

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

UD类似发短信

• 不连接，不稳定

• 客户端、服务端，没有明确的界限

• 不管有没有准备好，都可以发给你

1.6 TCP

客户端和服务端连接实现

客户端

1. 连接服务器，通过Socket
2. 发送消息

package com.netStudy.lesson02;


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

//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {
        InetAddress serverIP = null;
        Socket socket = null;
        OutputStream os = null;
        try {
            //1、要知道服务器地址和端口号
            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 (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //4、关闭资源
            if (os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

服务器

1. 建立服务的端口ServerSocket
2. 等待用户的链接accept
3. 接收用户的消息

package com.netStudy.lesson02;

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

//服务端
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);
                //2、等待客户端连接过来
                socket = serverSocket.accept();
                //3、读取客户端的消息
                is = socket.getInputStream();
            /*如果输入中文，可能会出现乱码
            byte[] buffer = new byte[1024];
            int len;
            while ((len= is.read(buffer))!=-1){
                String msg = 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();
                }
            }
        }
    }
}

文件上传

服务器端

package com.netStudy.lesson02;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception {
        //1、创建服务
        ServerSocket serverSocket = new ServerSocket(9090);
        //2、监听客户端的连接
        Socket socket = serverSocket.accept();//阻塞式监听
        //3、获得输入流
        InputStream is = socket.getInputStream();
        //4、文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
        //通知客户端，我已接收完毕
        OutputStream os = socket.getOutputStream();
        os.write("我接收完毕了，你可以断开了".getBytes());


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

客户端

package com.netStudy.lesson02;

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"), 9090);
        //2、创建一个输出流
        OutputStream os = socket.getOutputStream();
        //3、读取文件
        FileInputStream fis = new FileInputStream(new File("JavaStudyBase\\LeoDolphin.jpg"));
        //4、写出文件
        byte[] buffer = new byte[1024];
        int len;
        while((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }
        //通知服务器，我已经写完了
        socket.shutdownOutput();//我已经发生完了

        //确定服务器接收完毕，才能够断开连接
        InputStream is = socket.getInputStream();
        //String byte[]
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int len2;
        while((len2=is.read(buffer2))!=-1){
            baos.write(buffer2,0,len2);
        }
        System.out.println(baos.toString());
        //5、关闭资源
        baos.close();
        is.close();
        fis.close();
        os.close();
        socket.close();
    }
}

我接收完毕了，你可以断开了

Tomcat

是一款用Java编写的网络端服务器

服务端

• 自定义Server
• Tomcat服务器Server

客户端

• 自定义Client
• 浏览器B

因此我们网络就是B/S架构，一般需要安装的客户端的是C/S架构

它的启动目录在bin下，startup.bat表示windows系统启动，startup.sh表示linux系统下启动，当我们启动完成后，就可以在浏览器输入localhost:8080访问到Tomcat自己的一个网页

当我们关闭Tomcat服务器后，网页则会访问不到

Tomcat服务器已有的访问资源目录为：

通过以下配置文件可以更改Tomcat的一些配置信息：

当我们机器上的8080端口被某个程序占用了，在启用Tomcat的时候就会报错。同样当Tomcat使用默认8080端口启用后，本机上其他程序启用8080端口时也会报错。即同一台主机上端口不可被不同的进程使用

1.7 UDP

发短信，不需要连接，但是需要知道对方的地址

---

实现消息的发送和接收

发送消息

package com.netStudy.lesson03;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

//不需要连接服务器
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 =9000;
        //数据，数据的长度起始，要发给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);
        //3、发送包
        socket.send(packet);
        //4、关闭流
        socket.close();
    }
}

接收消息

package com.netStudy.lesson03;

import java.net.DatagramPacket;
import java.net.DatagramSocket;


//还是需要等待发送端的连接
public class UdpReceiveDemo01 {
    public static void main(String[] args) throws Exception {
        //开放端口
        DatagramSocket socket = new DatagramSocket(9000);
        //接收数据包
        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();
    }
}

127.0.0.1
你好啊，接收端！

UDP多线程实现在线咨询

任意一个人既可以是发送方，也可以是接收方

发送方线程

package com.netStudy.chat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class TalkSend implements Runnable{
    DatagramSocket socket = null;
    BufferedReader reader = 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(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    @Override
    public void run() {
        try {
            //准备数据：控制台读取System.in
            while (true){
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress(toIP, toPort));

                socket.send(packet);
                if (data.trim().equals("bye")){
                    break;
                }

            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        socket.close();
    }
}

接收方线程

package com.netStudy.chat;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

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() {
        try {
            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(msgFrom+"："+receiveData);
                if (receiveData.trim().equals("bye")){
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        socket.close();
    }
}

设置聊天对象Student进程

package com.netStudy.chat;

public class TalkStudent {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"")).start();
    }
}

设置聊天对象Teacher进程

package com.netStudy.chat;

public class TalkTeacher {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        new Thread(new TalkReceive(9999,"")).start();
    }
}

TeacherChatWindow：

学生：老师你好
你好呀
学生：麻烦问一下java怎么学习
可以看看B站狂神
学生：好的，谢谢老师
不客气
bye
学生：bye

StudentChatWindow：

老师你好
老师：你好呀
麻烦问一下java怎么学习
老师：可以看看B站狂神
好的，谢谢老师
老师：不客气
老师：bye
bye

1.8 URL

什么是URL？在Java如何体现

URL——统一资源定位符，用于定位互联网上的某一个资源

DNS域名解析，将域名解析成IP

协议://IP地址:端口号/项目名/资源

package com.netStudy.urlDemo01;

import java.net.MalformedURLException;
import java.net.URL;

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

http
localhost
8080
/helloworld/index.jsp
/helloworld/index.jsp?username=leodolphin&password=123
username=leodolphin&password=123

如何通过URL提取资源

例如：开启本地Tomcat，并在其…\apache-tomcat-9.0.41\webapps目录下新建资源SecurityFile.txt

其他Tomcat，然后在Java中通过如下代码即可取得网络资源到本地（虽然这个例子是本地到本地，但是通过的确实是网络）

package com.netStudy.urlDemo01;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;

public class URLDown {
    public static void main(String[] args) throws Exception {
        //1、下载地址
        URL url = new URL("http://localhost:8080/leoDolphin/SecurityFile.txt");
        //2、连接到这个资源 Http
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        //3、用流接收
        InputStream is = connection.getInputStream();
        FileOutputStream fos = new FileOutputStream("SecurityFile.txt");
        byte[] buffer =new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);//写出这个数据
        }
        fos.close();
        is.close();
        connection.disconnect();
    }
}