Java网络编程总结

1.1 概述

信件：

计算机网络：
计算机网络是指将 地理位置不同 的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统、网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。
网络编程的目的：
无线电台…传播交流信息，数据交换，通信
想要达到这个效果需要什么：
1.如何准确的定位网络上的一台主机 192.168.16.24 ：端口 ，定位到这个计算机上的某个资源
2.找到了这个主机，如何传输数据呢？
javaweb： 网页编程 B/S 浏览器/服务器
网络编程：TCP/IP C/S 客户端/服务器

1.2 网络通信的要素

如何实现网络通信？
通信双方地址：

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

1.3 IP

ip地址：InetAddress

• 唯一定位一台网络上计算机
• 127.0.0.1：本机localhost
• ip地址的分类
  • ipv4/ipv6
    • ipv4 127.0.0.1 4个字节组成。0-255 42亿~；
    • ipv6：128位 。8个无符号整数！
  • 公网（互联网）-私网（局域网）
    • ABCD类地址
    • 192.168.xx.xx，专门给组织内部使用
• 域名：记忆IP问题！
  • IP：www.vip.com

public static void main(String[] args) throws UnknownHostException {
        //查询本机地址
        InetAddress inetAddress1=InetAddress.getByName("127.0.0.1");
        System.out.println(inetAddress1);
        InetAddress inetAddress2=InetAddress.getLocalHost();
        System.out.println(inetAddress2);
        InetAddress inetAddress3=InetAddress.getByName("localhost");
        System.out.println(inetAddress3);
        //查询网站的ip地址
        InetAddress inetAddress4=InetAddress.getByName("www.baidu.com");
        System.out.println(inetAddress4);
        //常用的方法
        //System.out.println(inetAddress4.getAddress());
        System.out.println(inetAddress4.getCanonicalHostName());
        System.out.println(inetAddress4.getHostAddress());//ip
        System.out.println(inetAddress4.getHostName());//域名，或者自己电脑的名字
    }

1.4 端口

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

• 不同的进程有不同的端口！用来区分软件
• 被规定0-65535
• TCP，UDP：65535*2 tcp：80 ，UDP：80 在单个协议下端口号不能冲突
• 端口分类
  • 公有端口0-1023
    • HTTP 80
    • HTTPS 443
    • FTP 21
    • Telent 23
  • 程序注册端口：1024-49151，分配用户或者程序
    • Tomcat： 8080
    • Mysql： 3306
    • Oracle：1521
  • 动态、私有：49152-65535

    netstat -ano #查看所有的端口
    netstat -ano|findstr ”5900“ #查看指定的端口
    tasklist|findstr "8696" #查看指定端口的进程
    

public class javaPractice {
    public static void main(String[] args) throws UnknownHostException {
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress inetSocketAddress0 = new InetSocketAddress("localhost", 8080);
        System.out.println(inetSocketAddress);
        System.out.println(inetSocketAddress0);
        System.out.println(inetSocketAddress.getAddress());
        System.out.println(inetSocketAddress.getHostName());
        System.out.println(inetSocketAddress.getPort());
    }
}

1.5通信协议

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

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

问题：非常复杂？

TCP/IP协议簇：实际上是一组协议

重要：

• TCP ：用户传输协议
• UDP：用户数据报协议

出名的协议：

• TCP ：
• IP：网络互连协议

TCP UDP对比：

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

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

• 客户端、服务端
• 传输完成，释放连接，效率低
  UDP：发短信
• 不连接，不稳定
• 客户端，服务端：没有明确的界限
• 不管有没有准备好，都可以发给你
• 导弹
• DDOS：洪水攻击！(饱和攻击)

1.6 TCP

客户端：
1. 连服务器Socket
2. 发送消息

//客户端
public class javaPractice {
    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();
               }
           }
        }

    }
}

服务器

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

//服务端
public class TcpSeverDemo {
    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();
                }
            }

        }
    }
}

文件上传

服务器端

//服务端
public class TcpSeverDemo {
    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();
    }
}

客户端

//客户端
public class javaPractice {
    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("tx.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.toString();
        fis.close();
        os.close();
        socket.close();

    }
}

Tomcat

服务端

• 自定义S
• Tomcat服务器S ：Java后台开发
  客户端
• 自定义C
• 浏览器B

1.7 UDP

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

发送消息

//不需要连接服务器
public class javaPractice {
    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 TcpSeverDemo {
    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();
    }
}

咨询

• 循环发送消息

public class javaPractice {
    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 TcpSeverDemo {
    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();
    }
}

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

• 发送端的类

  //发送端
  public class javaPractice implements  Runnable{
      DatagramSocket socket =null;
      BufferedReader reader =null;
      private int fromPort;
      private String toIP;
      private int toPort;
      public javaPractice(int fromPort, String toIP, int toPort) {
          this.fromPort = fromPort;
          this.toIP = toIP;
          this.toPort = toPort;
          try{
              reader = new BufferedReader(new InputStreamReader(System.in));
              socket = new DatagramSocket(fromPort);
          }catch (Exception e){
              e.printStackTrace();
          }
      }
  
      @Override
      public void run() {
          while (true){
              try {
                  String 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 (Exception e){
                  e.printStackTrace();
              }
          }
          socket.close();
      }
  }
  
  

• 接收端的类

//接受线程
public class TcpSeverDemo implements Runnable{
    DatagramSocket socket =null;
    private int port;
    private String msgFrom;
    public TcpSeverDemo(int port,String msgFrom) {
        this.port = port;
        this.msgFrom=msgFrom;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException 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) {
        //开启两个线程
        new Thread(new javaPractice(7777,"localhost",9989)).start();
        new Thread(new TcpSeverDemo(8877,"老师")).start();
    }
}

• 老师多线程

public class TalkTeacher {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new javaPractice(5555,"localhost",8877)).start();
        new Thread(new TcpSeverDemo(9989,"学生")).start();
    }
}

1.8 、URL

https://www.baidu.com/
统一资源定位符：定位资源的，定位互联网上的某一个资源
DNS域名解析 将www.baidu.com解析成xxx.xxx.xxx.xxx

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

• URL类

public class javaPractice  {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/helloword/index.jsp?username=zhangqi&password=123546");
        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());  //参数
    }
}

• 互联网的文件下载

public class javaPractice  {
    public static void main(String[] args) throws Exception {
        //下载地址
        URL url = new URL("https://m801.music.126.net/20210518165914/a0fcdd2d4eba3014c00a1f548d299cd2/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/8617892023/21fe/6066/9da3/a3d134a4c7bf945e89601f6dd5cf7e08.m4a");
        //连接资源
        HttpURLConnection urlConnection=(HttpURLConnection)url.openConnection();
        InputStream inputStream=urlConnection.getInputStream();
        FileOutputStream fos=new FileOutputStream("8.m4a");
        byte[] buffer=new byte[1024];
        int len;
        while ((len=inputStream.read(buffer))!=-1){
            fos.write(buffer,0,len);//写出这个数据
        }
        fos.close();
        inputStream.close();
        urlConnection.disconnect();
    }
}