Java语法基础学习DayTwentyOne（网络编程）

一、IP地址和端口号

1.作用

　　通过IP地址，唯一的定位互联网上一台主机。

　　端口号标识正在计算机上运行的进程，不同进程有不同的端口号，被规定为一个16位的整数0~65535，其中0~1023被预先定义的服务通信占用。

　　端口号和IP地址的组合得出一个网络套接字（socket）。

2.InetAddress类

　　位于java.net包下，用来代表IP地址，一个InetAddress的对象就代表着一个IP地址。

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

public class Test{
    public static void main(String[] args) throws Exception{
        //如何创建InetAddress的对象：getByName(String host)
        InetAddress inet = InetAddress.getByName("www.baidu.com");
        //inet = InetAddress.getByName("14.215.177.38");
        System.out.println(inet);//www.baidu.com/14.215.177.38
        
        //getHostName(): 获取IP地址对应的域名
        //getHostAddress():获取IP地址
        System.out.println(inet.getHostName());//www.baidu.com
        System.out.println(inet.getHostAddress());//14.215.177.38
        
        //获取本机的IP:getLocalHost()
        InetAddress inet1 = InetAddress.getLocalHost();
        System.out.println(inet1);
    }
}

二、网络通信协议

1.TCP传输控制协议（Transmission Control Protocol）

　　使用TCP协议前，须先建立TCP连接，形成传输数据通道
　　传输前，采用“三次握手”方式，是可靠的
　　TCP协议进行通信的两个应用进程：客户端、服务端
　　在连接中可进行大数据量的传输
　　传输完毕，需释放已建立的连接，效率低

2.UDP用户数据报协议（User Datagram Protocol）

　　将数据、源、目的封装成数据包，不需要建立连接
　　每个数据报的大小限制在64K内
　　因无需连接，故是不可靠的
　　发送数据结束时无需释放资源，速度快

3.Socket套接字

　　利用套接字(Socket)开发网络应用程序早已被广泛的采用，以至于成为事实上的标准。
　　通信的两端都要有Socket，是两台机器间通信的端点
　　网络通信其实就是Socket间的通信。
　　Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
　　一般主动发起通信的应用程序属客户端，等待通信请求的为服务端。

4.基于Socket的TCP编程

客户端Socket的工作过程包含以下四个基本的步骤：
　　创建 Socket：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。
　　打开连接到 Socket 的输入/出流： 使用 getInputStream()方法获得输入流，使用 getOutputStream()方法获得输出流，进行数据传输
　　按照一定的协议对 Socket 进行读/写操作：通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线程。
　　关闭 Socket：断开客户端到服务器的连接，释放线路

服务器程序的工作过程包含以下四个基本的步骤：
　　调用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。
　　调用 accept()：监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象。
　　调用 该Socket类对象的 getOutputStream() 和 getInputStream ()：获取输出流和输入流，开始网络数据的发送和接收。
　　关闭ServerSocket和Socket对象：客户端访问结束，关闭通信套接字。

TCP编程示例1：客户端给服务端发送信息。服务端输出此信息到控制台上(注意要先运行服务器端来监听连接请求)

package com.java;

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

import org.junit.Test;

public class TestTCP1 {
    //TCP编程示例1：客户端给服务端发送信息。服务端输出此信息到控制台上(注意要先运行服务器端来监听连接请求)
    //客户端
    @Test
    public void client(){
        Socket socket = null;
        OutputStream os = null;
        try{
            // 1.创建一个Socket的对象，通过构造器指明服务端的IP地址，以及其接收程序的端口号
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
            // 2.getOutputStream()：发送数据，方法返回OutputStream的对象
            os = socket.getOutputStream();
            // 3.具体的输出过程
            os.write("客户端发送信息，请多关照".getBytes());
        }catch(IOException e){
            e.printStackTrace();
        }finally {
            // 4.关闭相应的流和Socket对象
            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 s = null;
        InputStream is = null;
        try {
            // 1.创建一个ServerSocket的对象，通过构造器指明自身的端口号
            ss = new ServerSocket(9090);
            // 2.accept()方法:等待客户端的连接请求，返回与该客户端通信用的Socket的对象
            s = ss.accept();
            // 3.调用Socket对象的getInputStream()获取一个从客户端发送过来的输入流
            is = s.getInputStream();
            // 4.对获取的输入流进行的操作
            int len;
            byte[] b = new byte[20];
            while((len = is.read(b)) != -1){
                String str = new String(b,0,len);
                System.out.print(str);
            }
            System.out.println();
            System.out.println("接收到来自于"+s.getInetAddress().getHostAddress()+"的连接");
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(s != null){
                try {
                    s.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(ss != null){
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
    }
}

TCP编程例二：客户端给服务端发送信息，服务端将信息打印到控制台上，同时发送“已收到信息”给客户端

package com.java;

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

import org.junit.Test;

public class TestTCP2 {
    //客户端
    @Test
    public void client(){
        Socket s = null;
        OutputStream os = null;
        InputStream is = null;
        try {
            s = new Socket(InetAddress.getByName("127.0.0.1"),8989);
            os = s.getOutputStream();
            os.write("我是客户端发出的信息".getBytes());
            //shutdownOutput():执行此方法，显式的告诉服务端发送完毕！否则服务器端的read方法会陷入阻塞
            s.shutdownOutput();
            is = s.getInputStream();
            byte[] b = new byte[20];
            int len;
            while((len = is.read(b)) != -1){
                String str = new String(b, 0, len);
                System.out.print(str);
            }
        }catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(s != null){
                try {
                    s.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    //服务器端
    @Test
    public void server(){
        ServerSocket ss = null;
        Socket s = null;
        InputStream is = null;
        OutputStream os = null;
        try {
            ss = new ServerSocket(8989);
            s = ss.accept();
            is = s.getInputStream();
            byte[] b = new byte[20];
            int len;
            while((len = is.read(b)) != -1){
                String str = new String(b, 0, len);
                System.out.print(str);
            }
            System.out.println();
            os = s.getOutputStream();
            os.write("我已收到客户端你的情意".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(s != null){
                try {
                    s.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(ss != null){
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
        
    }
}

TCP编程例三：从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给客户端。并关闭相应的连接。

package com.java;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

import org.junit.Test;

//如下的程序，处理异常时，要使用try-catch-finally!!本例仅为了书写方便~
public class TestTCP3 {
    @Test
    public void client() throws Exception{
        //1.创建Socket的对象
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9898);
        //2.从本地获取一个文件发送给服务端
        FileInputStream fis = new FileInputStream("1.jpg");
        OutputStream os = socket.getOutputStream();
        int len;
        byte[] b = new byte[1024];
        while((len = fis.read(b)) != -1){
            os.write(b,0,len);
        }
        socket.shutdownOutput();
        //3.接收来自于服务端的信息
        InputStream is = socket.getInputStream();
        byte[] b1 = new byte[20];
        int len1;
        while((len1 = is.read(b1)) != -1){
            String str = new String(b1,0,len1);
            System.out.print(str);
        }
        //4.关闭相应的流和Socket对象
        is.close();
        os.close();
        fis.close();
        socket.close();
    }
    
    @Test
    public void server() throws Exception{
        //1.创建一个ServerSocket的对象
        ServerSocket ss = new ServerSocket(9898);
        //2.调用其accept()方法，返回一个Socket的对象
        Socket s = ss.accept();
        //3.将从客户端发送来的信息保存到本地
        InputStream is = s.getInputStream();
        FileOutputStream fos = new FileOutputStream("2.jpg");
        int len;
        byte[] b = new byte[1024];
        while((len = is.read(b)) != -1){
            fos.write(b,0,len);
        }
        System.out.println("接收到来自"+s.getInetAddress().getHostAddress()+"的文件");
        //4.发送"接收成功"的信息反馈给客户端
        OutputStream os = s.getOutputStream();
        os.write("你发的文件我已接收到！".getBytes());
        //5.关闭相应的流和Socket及ServerSocket的对象
        os.close();
        fos.close();
        is.close();
        s.close();
        ss.close();
    }
}

5.UDP网络通信

特点：

　　类 DatagramSocket 和 DatagramPacket 实现了基于 UDP 协议网络程序。
　　UDP数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。
　　DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。
　　UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接

代码实现

package com.java;

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

import org.junit.Test;

public class TestUDP {
    
    // 发送端
    @Test
    public void send(){
        DatagramSocket ds =null;
        try {
            ds = new DatagramSocket();
            byte[] b = "泥嚎，我是要发送的数据报".getBytes();
            //创建一个数据报：每一个数据报不能大于64k，都记录着数据信息，发送端的IP、端口号,以及要发送到
            //的接收端的IP、端口号。
            DatagramPacket pack = new DatagramPacket(b,0,b.length,
                    InetAddress.getByName("127.0.0.1"),9090);
            ds.send(pack);
        }catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(ds != null){
                ds.close();
            }
        }
    }
    
    // 接收端
    @Test
    public void receive(){
        DatagramSocket ds = null;
        try {
            ds = new DatagramSocket(9090);
            byte[] b = new byte[1024];
            DatagramPacket pack = new DatagramPacket(b,0,b.length);
            ds.receive(pack);
            
            String str = new String(pack.getData(),0,pack.getLength());
            System.out.println(str);
        }catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(ds != null){
                ds.close();
            }
        }
    }

}

三、URL编程

1.定义

　　URL(Uniform Resource Locator)：统一资源定位符，它表示 Internet 上某一资源的地址。通过 URL 我们可以访问 Internet 上的各种网络资源，比如最常见的 www，ftp 站点。浏览器通过解析给定的 URL 可以在网络上查找相应的文件或其他资源。

　　URL的基本结构由5部分组成：

　　　　<传输协议>://<主机名>:<端口号>/<文件名>

2.常用方法　

　　public String getProtocol( ) 获取该URL的协议名
　　public String getHost( ) 获取该URL的主机名
　　public String getPort( ) 获取该URL的端口号
　　public String getPath( ) 获取该URL的文件路径
　　public String getFile( ) 获取该URL的文件名
　　public String getRef( ) 获取该URL在文件中的相对位置
　　public String getQuery( ) 获取该URL的查询名

3.代码案例

//创建一个URL的对象
        URL url = new URL("http://127.0.0.1:8080/examples/HelloWorld.txt");

openStream：URL类的方法，能从网络读取数据

        InputStream is = url.openStream();
        byte[] b = new byte[20];
        int len;
        while((len = is.read(b)) != -1){
            String str = new String(b,0,len);
            System.out.print(str);
        }
        is.close();

URLConnection：表示到URL所引用的远程对象的连接。当与一个URL建立连接时，首先要在一个 URL 对象上通过方法 openConnection() 生成对应的 URLConnection 对象。

//如果既有数据的输入，又有数据的输出，则考虑使用URLConnection
        URLConnection urlConn = url.openConnection();
        InputStream is1 = urlConn.getInputStream();
        FileOutputStream fos = new FileOutputStream(new File("abc.txt"));
        byte[] b1 = new byte[20];
        int len1;
        while((len1 = is1.read(b1)) != -1){
            fos.write(b1, 0, len1);
        }
        fos.close();
        is1.close();