Java网络编程学习笔记

网络编程概述

2021-6-10

• Java是Internet上的语言，它从语言级上提供了对网络应用程序的支持，程序员能够很容易开发常见的网络应用程序
• Java提供的网络类库，可以实现无痛的网络连接，联网的底层细节被隐藏在Java的本机安装系统里，由JVM进行控制。并
  且Java实现了一个跨平台的网络库，程序员面对的是一个统一的网络编程环境。
• 网络编程的目的:直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。
• 网络编程中有两个主要的问题:

1. 如何准确地定位网络.上一台或多台主机;定位主机上的特定的应用
2. 找到主机后如何可靠高效地进行数据传输

网络通信要素概述

• IP地址和端口号
• 网络通信协议

/**
 * @auther guawaz
 * @create 2021-06-09-22:50
 */
public class InetAddressTest {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress inet1 = InetAddress.getByName("www.baidu.com");
        System.out.println(inet1);
        System.out.println(inet1.getHostName());
        System.out.println(inet1.getHostAddress());
        InetAddress inet2 = InetAddress.getByName("localhost");
        System.out.println(inet2);
        InetAddress inet3 = InetAddress.getLocalHost();
        System.out.println(inet3);
    }
}

●端口号标识正在计算机上运行的进程( 程序)
➢不同的进程有不同的端口号
➢被规定为一个16位的整数0~65535。
➢端口分类:
➢公认端口: 0~1023。 被预先定义的服务通信占用(如: HTTP占用端口80，FTP 占用端口21，Telnet占用端口23)
➢注册端口: 1024~49151。 分配给用户进程或应用程序。 (如: Tomcat占用端口8080，MySQL占用端口3306，Oracle 占用端口1521等)。
➢动态/私有端口: 49152~65535。
●端口号与IP地址的组合得出一个网络套接字:Socket。

●传输层协议中有两个非常重要的协议:
➢传输控制协议TCP(Transmission Control Protocol)
➢用户数据报协议UDIP(User Datagram Protocol)。
●TCP/IP以其两个主要协议:传输控制协议(TCP)和网络互联协议(IP)而得名，实际上是一组协议，包括多个具有不同功能且互为关联的协议。
●IP(Internet Protocol)协议是网络层的主要协议，支持网间互连的数据通信。
●TCP/IP协议模型从更实用的角度出发，形成了高效的四层体系结构，即物理链路层、IP层、传输层和应用层。

●TCP协议:
➢使用TCP协议前，须先建立TCP连接，形成传输数据通道
➢传输前，采用“三次握手”方式，点对点通信，是可靠的
➢TCP协议进行通信的两个应用进程:客户端、服务端
➢在连接中可进行大数据量的传输
➢传输完毕，需释放已建立的连接，效率低
●UDP协议:
➢将数据、源、目的封装成数据包，不需要建立连接
➢每个数据报的大小限制在64K内
➢发送不管对方是否准备好，接收方收到也不确认，故是不可靠的
➢可以广播发送
➢发送数据结束时无需释放资源，开销小，速度快

TCP网络编程

package guawaz.xyz.net;

import org.junit.Test;

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

/**
 * @auther guawaz
 * @create 2021-06-10-9:05
 */
public class TCPTest {

    //客户端
    @Test
    public void client(){
        Socket socket = null;
        OutputStream os = null;
        try {
            //1.创建socket对象，指明服务器端的ip和端口号
            InetAddress inet = InetAddress.getByName("localhost");
            socket = new Socket(inet,8868);
            //2.使用socket获取一个输出流，用于输出数据
            os = socket.getOutputStream();
            //3.输出数据
            os.write("你好，世界！".getBytes());
        } 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();
                }
            }
        }

    }

    //服务端
    @Test
    public void server(){
        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            //1.创建serverSocket，指明自己的端口号
            ss = new ServerSocket(8868);
            //2.调用accept方法接受来自于客户端的socket
            socket = ss.accept();
            //3.使用接收到的socket获取一个输入流，用于接收数据
            is = socket.getInputStream();
            //4.读取数据
//        byte[] buffer = new byte[20];
//        int len;
//        while((len = is.read(buffer)) != -1){
//            String str = new String(buffer,0,len);
//            System.out.println(str);
//        }//可能会有乱码

            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[5];
            int len;
            while((len = is.read(buffer)) != -1){
               baos.write(buffer,0,len);    //写到baos内部一个数组里了
            }
            System.out.println(baos.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5.关闭资源
            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 (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

package guawaz.xyz.net;

import org.junit.Test;

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

/**
 * @auther guawaz
 * @create 2021-06-10-10:08
 * 例二：客户端发送文件给服务端，服务端将文件保存在本地
 */
public class TCPTest2 {
    @Test
    public void client(){
        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis = null;
        try {
            //1.
            socket = new Socket(InetAddress.getByName("127.0.0.1"),10868);
            //2.
            os = socket.getOutputStream();
            //3.
            fis = new FileInputStream(new File("3.jpg"));
            //4.
            byte[] buffer = new byte[1024];
            int len;
            while((len = fis.read(buffer)) != -1){
                os.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5.
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void server(){

        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            //1.
            ss = new ServerSocket(10868);
            //2.
            socket = ss.accept();
            //3.
            is = socket.getInputStream();
            //4.
            fos = new FileOutputStream(new File("copy3.jpg"));
            //5.
            byte[] buffer = new byte[1024];
            int len;
            while((len = is.read(buffer)) != -1){
                fos.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //6.
            if (fos != null) {
                try {
                    fos.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 (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

package guawaz.xyz.net;

import org.junit.Test;

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

/**
 * @auther guawaz
 * @create 2021-06-10-11:09
 * 例3：客户端发送文件给服务端，服务端保存到本地，并返回“发送成功”给客户端
 */
public class TCPTest3 {
    @Test
    public void client(){
        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis = null;
        InputStream is = null;
        try {
            //1.
            socket = new Socket(InetAddress.getByName("127.0.0.1"),10868);
            //2.
            os = socket.getOutputStream();
            //3.
            fis = new FileInputStream(new File("3.jpg"));
            //4.
            byte[] buffer = new byte[1024];
            int len;
            while((len = fis.read(buffer)) != -1){
                os.write(buffer,0,len);
            }

            socket.shutdownOutput(); //read（）是阻塞式方法，服务端的read一直在等待


            //5.接收服务端的反馈并显示到控制台上
            is = socket.getInputStream();
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buffer1 = new byte[20];
            int len1;
            while((len1 = is.read(buffer1)) != -1){
                baos.write(buffer1,0,len1);
                System.out.println(baos.toString());
            }
            


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //6.
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (is != null ) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void server(){

        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        FileOutputStream fos = null;
        OutputStream os = null;
        try {
            //1.
            ss = new ServerSocket(10868);
            //2.
            socket = ss.accept();
            //3.
            is = socket.getInputStream();
            //4.
            fos = new FileOutputStream(new File("copy3.jpg"));
            //5.
            byte[] buffer = new byte[1024];
            int len;
            while((len = is.read(buffer)) != -1){
                fos.write(buffer, 0, len);
            }

            //6.服务器端给客户端“发送成功”的反馈
            os = socket.getOutputStream();
            os.write("发送成功".getBytes());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //7.
            if (fos != null) {
                try {
                    fos.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 (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (os !=null) {
                try {
                    os.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

• 浏览器访问Tomcat服务器资源操作

客户端---服务端

客户端：
        自定义
        浏览器
服务端：
        自定义
        Tomcat服务器

UDP网络编程

import org.junit.Test;

import java.io.IOException;
import java.net.*;

/**
 * @auther guawaz
 * @create 2021-06-10-13:21
 */
public class UDPTets {
    //发送端
    @Test
    public void sender() throws IOException {
        DatagramSocket socket = new DatagramSocket();

        String str = "我是UDPP方式发送的导弹";
        byte[] data = str.getBytes();

        InetAddress inet = InetAddress.getLocalHost();

        DatagramPacket packet = new DatagramPacket(data, 0,data.length,inet,8866);

        socket.send(packet);
        socket.close();

    }
    //接收端
    @Test
    public void receiver() throws IOException {
        DatagramSocket socket = new DatagramSocket(8866);

        byte[] buffer = new byte[100];
        DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);

        socket.receive(packet);

        System.out.println(new String(packet.getData(),0,packet.getLength()));

        socket.close();
    }
}

URL编程

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

/**
 * @auther guawaz
 * @create 2021-06-10-13:37
 *
 *
 *
 */
public class URLTest {
    public static void main(String[] args) throws IOException {
        HttpURLConnection urlConnection = null;
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            URL url = new URL("http://localhost/examples/beauty.jpg");
            urlConnection = (HttpURLConnection) url.openConnection();
            urlConnection.connect();

            is = urlConnection.getInputStream();
            fos = new FileOutputStream("guawa2106110/beauty.jpg");

            byte[] buffer = new byte[20];
            int len;
            while((len = is.read(buffer)) != -1){
                fos.write(buffer, 0, len);
            }
            System.out.println("下载完成！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
        }
    }
}