Java网络编程

概述

• 信件
  

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

• 网络编程的目的
  无线电台，传播交流信息，数据交换、通信

1. 如何准确定位网络上的一台主机 IP地址:端口，定位到这个计算机上的某个资源
2. 找到了这个主机，如何传输数据
   javaweb：网页编程 B/S
   网络编程：ICP/IP C/S

网络通信的要素

• 如何实现网络的通信
  通信双方地址
  ip
  端口号
  192.168.16.124:5900
  规则：网络通信协议
  

网络编程：重点时传输层，TCP、UDP

• 小结

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

IP

• ip地址：InetAddress
• 唯一定位一台网络上计算机
• 127.0.0.1：本地 localhost
• ip的分类

1. ipv4/ipv6：ipv4：127.0.0.1，4个字节组成，0-255，42亿个，2011年用尽了；
   ipv6：fe80::183c:9bcb:1848:a115%14，128位，8个无符号整数，16^32个
2. 公网（互联网）/私网（局域网）
   

公网：ABCD类
私网：192.168.xx.xx

• 域名
  记忆IP

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

public class TestInetAddress {
    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);

            //查询网站ip地址
            InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress2);

            //常用方法
            //System.out.println(inetAddress2.getAddress()); //没卵用
            System.out.println(inetAddress2.getCanonicalHostName()); //规范的名字
            System.out.println(inetAddress2.getHostAddress()); //ip
            System.out.println(inetAddress2.getHostName()); //域名，或自己电脑的名字

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

输出

/127.0.0.1
localhost/127.0.0.1
DESKTOP-OKLJ610/192.168.1.104
www.baidu.com/220.181.38.149
220.181.38.149
220.181.38.149
www.baidu.com

端口

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

1. 不同的进程有不同的端口号！用来区分软件
2. 被规定0-65535
3. TCP,UDP：各有65535，两个协议，端口号不冲突
4. 分类：
   公有端口 0-1023
   HTTP 80
   HTTPS 443
   FTP 21
   Telent 23
   程序注册端口 1024-49151，分配用户或者程序
   Tomcat 8080
   MySQL 3306
   Oracle 1521
   动态、私有 49152-65535

#cmd命令 
netstat -ano #查看所有端口
netstat -ano|findstr "5900" #查看指定端口
tasklist|findstr "2244" #查看指定端口的进程

import java.net.InetSocketAddress;

public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1",8080);
        InetSocketAddress socketAddress2 = new InetSocketAddress("localhost",8080);
        System.out.println(socketAddress);
        System.out.println(socketAddress2);

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

输出

/127.0.0.1:8080
localhost/127.0.0.1:8080
/127.0.0.1
127.0.0.1
8080

• 端口对应
  两台电脑应用的通信要找到对应的端口

通信协议

• 协议：约定，普通话
• 网络通信协议
  速率，传输码率，代码结构，传输控制...
  问题：非常的复杂
  大事化小：分层！
  TCP/IP协议簇：实际上是一组协议
  TCP：用户传输协议，打电话
  UDP：用户数据报协议，发短信
  出名的协议
  TCP
  IP：网络互连协议
• TCP UDP 对比
  TCP：打电话；连接，稳定；三次握手，四次挥手；客户端、服务端；传输完成释放连接，效率低
  UDP：不连接，不稳定；客户端和服务端没有明确的界限；导弹；DDOS洪水攻击，饱和攻击
• 三次握手
  A：想连接
  B：可以，你还在吗
  A：在，连吧
• 四次挥手
  A：我要断开了
  B：你要走了吗
  B：真的要走了吗
  A：真的走了

TCP

• 客户端

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

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.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("hello".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();
                }
            }
        }
    }
}

• 服务器

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

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);

            while (true){
                //2.等待客户端连接过来
                socket = serverSocket.accept();
                //3.读取客户端的消息
                is = socket.getInputStream();

                //管道流
                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();
                }
            }
        }
    }
}

文件上传

传输一个图片

• 客户端

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

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("jia.jpg"));
        //4.写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }

        //通知服务器，我已经结束了
        socket.shutdownOutput(); //我已经传输完了

        //确定服务器接收完毕，才能断开连接
        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());

        //5.关闭资源  先写的后关
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();
    }
}

• 服务器

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

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("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();
    }
}

Tomcat

• 服务端
  自定义 S
  Tomcat服务器 S java开发
• 客户端
  自定义 C
  浏览器 B

UDP

发短信：不用连接，

• 发消息

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 = "你好a";

        //发送给谁
        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();
    }
}

• 接收端

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

//还是等待客户端的连接
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();
    }
}

实现聊天

• 发送方

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

public class UdpSenderDemo01 {
    public static void main(String[] args) throws Exception{
        DatagramSocket socket = new DatagramSocket(8080);

        //准备数据
        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",666));

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

        socket.close();
    }
}

• 接收方

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

public class UdpReceiverDemo01 {
    public static void main(String[] args) throws Exception{
        DatagramSocket socket = new DatagramSocket(666);

        while (true){
            //准备接收包裹
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container,0,container.length);
            socket.receive(packet); //阻塞式接收

            //显示消息
            byte[] data = packet.getData();
            String receiveData = new String(data,0,data.length);
            System.out.println(receiveData);

            //断开连接
            if (receiveData.equals("bye")){
                break;
            }
        }

        socket.close();
    }
}

输出有点问题，1024位都出来了

解决
String receiveData = new String(data,0,data.length);
String去掉空格，改成
String receiveData = new String(data,0,data.length).trim();

多线程在线咨询

• 两个人都同时是发送方和接收方
  写两个类 Send(fromPort,toIP,toPort) Reveice(port)
  每个用户都有两个线程，分别用来发送和接收

URL

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

import java.net.URL;

public class URLDemo01 {
    public static void main(String[] args) throws Exception{
        URL url = new URL("http://localhost:8080/hello/index.jsp?username=peng");
        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()); //参数
    }
}

• 下载文件

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

/**
 * Created by peng on 2020/5/7.
 */
public class URLDown {
    public static void main(String[] args) throws Exception {
        //1.下载地址
        URL url = new URL("https://www.baidu.com/project/name.txt"); //随便输入的

        //2.连接到这个资源 HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("name.txt");

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

        fos.close();
        inputStream.close();
        urlConnection.disconnect();
    }
}