java网络编程学习笔记（参考尚硅谷学习教程，记录重点）

1 网络编程概述

计算机网络：

把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息、共享硬件、软件、数据信息等资源。

网络编程的目的：直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。

网络编程中有两个主要的问题：

1.如何准确地定位网络上一台或多台主机；定位主机上的特定的应用

2.找到主机后如何可靠高效地进行数据传输

2 网络通信要素概述

通信双方地址

1.IP

2.端口号

一定的规则（即：网络通信协议。有两套参考模型）

1.OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广

2.TCP/IP参考模型(或TCP/IP协议)

3 通信要素1：IP和端口号

1. IP:唯一的标识 Internet 上的计算机（通信实体）

2. 在Java中使用InetAddress类代表IP

3. IP分类：IPv4 和 IPv6 ; 万维网 和 局域网

4. 域名: www.baidu.com www.mi.com www.sina.com www.jd.com，域名容易记忆，当在连接网络时输入一个主机的域名后，域名服务器(DNS)负责将域名转化成IP地址，这样才能和主机建立连接。 -------域名解析

5. 本地回路地址：127.0.0.1 对应着：localhost

6. 如何实例化InetAddress:两个方法：静态方法getByName(String host) 、 getLocalHost()，两个常用方法：getHostName() / getHostAddress()

7. 端口号：正在计算机上运行的程序（进程）。要求：不同的进程有不同的端口号。范围：被规定为一个 16 位的整数 0~65535。

8. 端口号与IP地址的组合得出一个网络套接字：Socket

4 通信要素2：网络协议

网络通信协议

计算机网络中实现通信必须有一些约定，即通信协议，对速率、传输代码、代码结构、传输控制步骤、出错控制等制定标准。

问题：网络协议太复杂

计算机网络通信涉及内容很多，比如指定源地址和目标地址，加密解密，压缩解压缩，差错控制，流量控制，路由控制，如何实现如此复杂的网络协议呢？

通信协议分层的思想

在制定协议时，把复杂成份分解成一些简单的成份，再将它们复合起来。最常用的复合方式是层次方式，即同层间可以通信、上一层可以调用下一层，而与再下一层不发生关系。各层互不影响，利于系统的开发和扩展。

传输层协议中有两个非常重要的协议：

传输控制协议TCP(Transmission Control Protocol)

用户数据报协议UDP(User Datagram Protocol)。

TCP 和 UDP协议对比

TCP协议：

1.使用TCP协议前，须先建立TCP连接，形成传输数据通道

2.传输前，采用“三次握手”方式，点对点通信，是可靠的

3.TCP协议进行通信的两个应用进程：客户端、服务端。

4.在连接中可进行大数据量的传输

5.传输完毕，需释放已建立的连接，效率低

UDP协议：

1.将数据、源、目的封装成数据包，不需要建立连接

2. 每个数据报的大小限制在64K内

3.发送不管对方是否准备好，接收方收到也不确认，故是不可靠的

4.可以广播发送

5.发送数据结束时无需释放资源，开销小，速度快

Socket

网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。

通信的两端都要有Socket，是两台机器间通信的端点。

网络通信其实就是Socket间的通信。

Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。

一般主动发起通信的应用程序属客户端，等待通信请求的为服务端。

5 TCP网络编程

代码如下（参考尚硅谷学习资料编写）

/**
 * 实现TCP的网络编程
 * 例子1：客户端发送信息给服务端，服务端将数据显示在控制台上
 *
 */
public class TCPTest1 {
​
    //客户端
    @Test
    public void client()  {
        Socket socket = null;
        OutputStream os = null;
        try {
            //1.创建Socket对象，指明服务器端的ip和端口号
            InetAddress inet = InetAddress.getByName("192.168.14.100");
            socket = new Socket(inet,8899);
            //2.获取一个输出流，用于输出数据
            os = socket.getOutputStream();
            //3.写出数据的操作
            os.write("你好，我是客户端mm".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(8899);
            //2.调用accept()表示接收来自于客户端的socket
            socket = ss.accept();
            //3.获取输入流
            is = socket.getInputStream();
​
            //不建议这样写，可能会有乱码
//        byte[] buffer = new byte[1024];
//        int len;
//        while((len = is.read(buffer)) != -1){
//            String str = new String(buffer,0,len);
//            System.out.print(str);
//        }
            //4.读取输入流中的数据
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[5];
            int len;
            while((len = is.read(buffer)) != -1){
                baos.write(buffer,0,len);
            }
​
            System.out.println(baos.toString());
​
            System.out.println("收到了来自于：" + socket.getInetAddress().getHostAddress() + "的数据");
​
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(baos != null){
                //5.关闭资源
                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();
                }
            }
​
        }
    }
​
}
​
/**
 *
 * 实现TCP的网络编程
 * 例题2：客户端发送文件给服务端，服务端将文件保存在本地。
 */
public class TCPTest2 {
​
    /*
    这里涉及到的异常，应该使用try-catch-finally处理
     */
    @Test
    public void client() throws IOException {
        //1.
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
        //2.
        OutputStream os = socket.getOutputStream();
        //3.
        FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
        //4.
        byte[] buffer = new byte[1024];
        int len;
        while((len = fis.read(buffer)) != -1){
            os.write(buffer,0,len);
        }
        //5.
        fis.close();
        os.close();
        socket.close();
    }
​
    /*
    这里涉及到的异常，应该使用try-catch-finally处理
     */
    @Test
    public void server() throws IOException {
        //1.
        ServerSocket ss = new ServerSocket(9090);
        //2.
        Socket socket = ss.accept();
        //3.
        InputStream is = socket.getInputStream();
        //4.
        FileOutputStream fos = new FileOutputStream(new File("beauty1.jpg"));
        //5.
        byte[] buffer = new byte[1024];
        int len;
        while((len = is.read(buffer)) != -1){
            fos.write(buffer,0,len);
        }
        //6.
        fos.close();
        is.close();
        socket.close();
        ss.close();
​
    }
}
/**
 * 实现TCP的网络编程
 * 例题3：从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给客户端。
 * 并关闭相应的连接。一定记得关闭数据的输出。
 */
public class TCPTest3 {
​
    /*
        这里涉及到的异常，应该使用try-catch-finally处理
         */
    @Test
    public void client() throws IOException {
        //1.
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
        //2.
        OutputStream os = socket.getOutputStream();
        //3.
        FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
        //4.
        byte[] buffer = new byte[1024];
        int len;
        while((len = fis.read(buffer)) != -1){
            os.write(buffer,0,len);
        }
        //关闭数据的输出
        socket.shutdownOutput();
​
        //5.接收来自于服务器端的数据，并显示到控制台上
        InputStream is = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] bufferr = new byte[20];
        int len1;
        while((len1 = is.read(buffer)) != -1){
            baos.write(buffer,0,len1);
        }
​
        System.out.println(baos.toString());
​
        //6.
        fis.close();
        os.close();
        socket.close();
        baos.close();
    }
​
    /*
    这里涉及到的异常，应该使用try-catch-finally处理
     */
    @Test
    public void server() throws IOException {
        //1.
        ServerSocket ss = new ServerSocket(9090);
        //2.
        Socket socket = ss.accept();
        //3.
        InputStream is = socket.getInputStream();
        //4.
        FileOutputStream fos = new FileOutputStream(new File("beauty2.jpg"));
        //5.
        byte[] buffer = new byte[1024];
        int len;
        while((len = is.read(buffer)) != -1){
            fos.write(buffer,0,len);
        }
​
        System.out.println("图片传输完成");
​
        //6.服务器端给予客户端反馈
        OutputStream os = socket.getOutputStream();
        os.write("你好，美女，照片我已收到，非常漂亮！".getBytes());
​
        //7.
        fos.close();
        is.close();
        socket.close();
        ss.close();
        os.close();
    }
}

6 UDP网络编程

流程：

1. DatagramSocket与DatagramPacket

2. 建立发送端，接收端

3. 建立数据包

4. 调用Socket的发送、接收方法

5. 关闭Socket

发送端与接收端是两个独立的运行程序

/**
 * UDPd协议的网络编程
 */
public class UDPTest {
​
    //发送端
    @Test
    public void sender() throws IOException {
​
        DatagramSocket socket = new DatagramSocket();
​
        String str = "我是UDP方式发送的导弹";
        byte[] data = str.getBytes();
        InetAddress inet = InetAddress.getLocalHost();
        DatagramPacket packet = new DatagramPacket(data,0,data.length,inet,9090);
​
        socket.send(packet);
​
        socket.close();
​
    }
    //接收端
    @Test
    public void receiver() throws IOException {
​
        DatagramSocket socket = new DatagramSocket(9090);
​
        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();
    }
}

​

最后

以上就是粗犷咖啡为你收集整理的java网络编程学习笔记（参考尚硅谷学习教程，记录重点）的全部内容，希望文章能够帮你解决java网络编程学习笔记（参考尚硅谷学习教程，记录重点）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。