Java 网络编程

说道网络编程，了解socket编程，分为TCP和UPD,对于具体实现细节，就不知道。希望学完这一块，自己能够独立完成一个socket的编写。

 关于互联网WEB相关的知识点，后面开始总结，今天不在此作介绍。

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

Socket原理机制：

通信的两端都有Socket,网络通信其实就是Socket间的通信，数据在两个Socket间通过IO传输。

Java中的网络支持：针对网络通信的不同层次，Java提供了不同的API，其提供的网络功能有四大类：

InetAddress:用于标识网络上的硬件资源，主要是IP地址

URL：统一资源定位符，通过URL可以直接读取或写入网络上的数据。

Sockets:使用TCP协议实现的网络通信Socket相关的类

Datagram：使用UPD协议，将数据保存在用户数据中，通过网络进行通信。

1:InetAddress

标识网络上的硬件资源，没有构造方法(默认都没有)，标识互联网协议IP地址

package lesson1220Socket;

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

public class InetAddressDemo {

    public static void main(String[] args) throws UnknownHostException {
        InetAddress address = InetAddress.getLocalHost();
        
        //InetAddress ad = new InetAddress();   The constructor InetAddress() is not visible
        
        byte [] by = address.getAddress();   //实际上里面存的值是[100, 98, 60, 87]       
        System.out.println(by);        
        System.out.println(address.getHostAddress());
        System.out.println(address.getHostName());
        return;        
    }
}

运行结果：

[B@626287d3
100.98.60.87
CN00204505

2、URL类

统一资源定位符，标识Internet上某一资源的地址，

Java中的网络编程

　Java中的网路编程主要是Java的Socket编程，属于JavaEE中的高级的部分，以下内容是对java网路编程的一个小结，代码都是经过编译调试的

　　C/S程序应用：客户/服务器模式，如QQ客户端，客户端连到服务器上，一个C/S模式的应用必须有两套程序，一个是客户端的程序，一个是服务器程序。

　　B/S程序应用：浏览器/服务器模式，如当下的各种网站都是B/S模式，所有的程序代码都在服务器上，用户通过浏览器去访问。

C/S程序分为两种：

        基于TCP协议：Socket（套接字）, 可靠的编程： A->B 如打电话先建立连接

        基于UDP协议：不可靠，如短信功能。

如果编写一个TCP程序需要JAVA的两个包支持：

        java.net.*: 主要提供网络支持；

                |-ServerSocket类：服务器端程序

                |-Socket类：客户端程序

        java,io.*:传递信息流

3、TCP编程

TCP协议是面向连接的、可靠的、有序的、以字节流的方式发送数据。通过三次握手方式建立连接。形成传输数据的通道。在连接中进行大量数据的传输，效率会稍低。

Java中基于TCP协议实现网络通信的类：客户端是Socket, 服务器端是ServerSocket。

 看上面图，可以看出Socket通信步骤：创建ServerSocket和Socket，打开连接到Socket的输入输出流，按照协议对Socket进行读写操作，关闭输入输出流，关闭Socket。

3.1 服务器端：

a:创建ServerScoket,并绑定端口

b:调用accept()开始监听端口

c:建立连接后，通过输入流获取客户端发送的请求信息

d:通过输出流向客户端返回响应信息

e:关闭Socket等相关资源

3.2 客户端：

a:创建Socket,并指定需要连接的服务器的IP和端口

b:建立连接后，通过输出流向服务器端发送信息

c:通过输入流获取服务器返回的响应信息

d:关闭Socket等资源

例子如下：

package lesson1220Socket;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

import com.sun.org.apache.xalan.internal.xsltc.trax.OutputSettings;

//基于TCP/IP协议的Socket,用户实现登录服务器端
public class ServeSocketDemo {
    public static void main(String[] args) throws Exception {
        
        //1、创建一个ServerSocket服务端，指定绑定的端口，并监听端口
        ServerSocket ss = new ServerSocket(10086);   //1024-65535的某个值
        System.out.println("服务器端开始监听10086端口.....");
        //2、调用accept方法开始监听端口
        Socket socket = ss.accept();
        
        //3、获取输入流，并读取客户端信息
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);   //InputStreamReader
        BufferedReader br = new BufferedReader(isr);
        
        String info = null;
        while((info = br.readLine())!=null){
            System.out.println("我是服务器，客户端说："+info);            
        }
        socket.shutdownInput();
        
        //4、获取输出流，响应客户端请求
        OutputStream os = socket.getOutputStream();
        PrintWriter pw = new PrintWriter(os);
        pw.write("欢迎您");        
        pw.flush();
        System.out.println("给客户端回响应.....");
        
        //5、关闭资源
        pw.close();
        os.close();
        br.close();
        isr.close();
        is.close();
        socket.close();
        ss.close();
        
    }

}


package lesson1220Socket;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class ClientSocketDemo {

    public static void main(String[] args) throws UnknownHostException, IOException {
        //1、创建客户端Socket,指定服务器和端口
        Socket cs = new Socket("127.0.0.1", 10086);
        System.out.println("与服务端建立连接.....");
        
        //2、获取输出流，向服务器发送信息
        OutputStream os = cs.getOutputStream();//直接输出流
        PrintWriter pw = new PrintWriter(os);
        pw.write("用户名：admin,密码：123");
        pw.flush();
        cs.shutdownOutput();
        System.out.println("向服务端发送信息.....");
        
        //3、获取输入流，得到服务器响应信息
        InputStream is = cs.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(isr);
        String info;
        while((info = br.readLine())!=null){
            System.out.println("我是客户端，服务端响应信息："+info);            
        }
        
        //4、关闭资源
        br.close();
        isr.close();
        is.close();
        pw.close();
        os.close();
        cs.close();            

    }

}

上面先运行服务端：ServeSocketDemo，再启动客户端：ClientSocketDemo

运行结果如下：

ServeSocketDemo：

服务器端开始监听10086端口.....
我是服务器，客户端说：用户名：admin,密码：123
给客户端回响应.....
ClientSocketDemo：

与服务端建立连接.....
向服务端发送信息.....
我是客户端，服务端响应信息：欢迎您

4、UDP编程

前面介绍的Socket编程都是基于TCP/IP协议的，现在来看一下基于UDP协议编程。

UPD协议（用户数据报协议）是无连接的、不可靠的、无序的,速度快。进行数据传输时，首先将要传输的数据定义成数据报（Datagram），大小限制在64k，在数据报中指明数据索要达到的Socket（主机地址和端口号），然后再将数据报发送出去。UDP协议的主要作用就是完成网络数据流和数据包之间的转换-------在信息发送端，UDP协议将网络数据流封装到数据报，然后被数据报发送出去；在信息接收端，UDP协议将数据报转换成实际数据内容。

1>首先在UDP网络编程中没有服务器和客户端这种说法，两个Socket之间没有虚拟链路。只是接收和发送报文

2>这里面有两个重要的类：DatagramSocket和DatagramPacket.

DatagramSocket的两个构造函数：

public DatagramSocket()：构造数据报套接字并将其绑定到本地主机上任何可用的端口。

public DatagramSocket(int port)：创建数据报套接字并将其绑定到本地主机上的指定端口。

在我们下面的DEMO中，UDPServerTest类中先发送数据报，使用的是套接字的无参构造器，而UDPClientTest类中先接收数据报，必须监听某一个端口，所以使用的是套接字的有参构造器。

DatagramPacket的构造函数：

public DatagramPacket(byte buf[], int length)：用来接收长度为length的数据包

public DatagramPacket(byte buf[], int length, InetAddress address, int port)：用来将长度为length的包发送到指定主机上的指定端口号。

package lesson1220Socket;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

public class UDPServer2 {

    public static void main(String[] args) throws Exception {
        DatagramSocket ds = new DatagramSocket();
        String str = "hello world";
        //构造用于发送的数据包，指定主机和端口号
        DatagramPacket packet = new DatagramPacket(str.getBytes(),
                str.length(), InetAddress.getByName("localhost"), 5555);
        ds.send(packet);
        
        //读取从客户端发送过来的响应
        byte[] buffer = new byte[1024];
        DatagramPacket packet2 = new DatagramPacket(buffer,buffer.length);
        ds.receive(packet2);
        System.out.println("address: " + packet2.getAddress() + " port: "+ packet2.getPort());
        String str2 = new String(buffer,0,packet2.getLength());
        System.out.println(str2);
        ds.close();
    }

}

package lesson1220Socket;

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

public class UDPClient2 {

    public static void main(String[] args) throws Exception {
        DatagramSocket ds = new DatagramSocket(5555);
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
        ds.receive(packet);
        System.out.println("address: " + packet.getAddress() + " port: "+ packet.getPort());
        String str = new String(buffer, 0, packet.getLength());
        System.out.println(str);

        // 接收到数据包之后，客户端返回响应回去
        String str2 = "welcome";
        DatagramPacket packet2 = new DatagramPacket(str2.getBytes(), str2
                .length(), packet.getAddress(), packet.getPort());
        ds.send(packet2);
        ds.close();
    }

}

上面的例子，要先运行UDPClient2（接收端先启动） ，然后再运行UDPServer2 ，

运行结果如下：

UDPServer2：

address: /127.0.0.1 port: 5555
welcome

UDPClient2：

address: /127.0.0.1 port: 54071
hello world

1、上面的程序中，第一步是服务器端（暂且以这种叫法来区分这两个类）创建一个UDP套接字，没有指定端口，使用的是系统分配的端口。然后构建了一个数据包，包中指定      了目标机器的ip和端口号。

2、作为客户端，创建了一个UDP套接字，并且绑定了端口，如果想要接收到服务端发送过来的报文，绑定的端口必须和服务器端发送的包中指定的端口一致。

3、客户端打印了包中的内容之后，想要返回一些内容回去。这个时候，服务器端的ip和端口号可以从之前发送过来的数据包中获取。

     DatagramPacket packet2 = new DatagramPacket(str2.getBytes(), str2.length(), packet.getAddress(), packet.getPort());

4、在服务器接收数据包的时候，已经不需要再像客户端创建套接字一样去绑定端口了，因为目前监听的端口和客户端发送的包中指定的端口是一样的。

5、打印看下服务器端的ip和监听的端口号：（注意理解下这个地方端口号，不是5555）

serverIp =/127.0.0.1;serverPort=54071

6、其中DatagramSocket的receive(DatagramPacket p)方法在接收到数据包前一直阻塞。

看下面这个例子：各自交互三次：

package lesson1220Socket;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

public class UDPServer {

    public static void main(String[] args) throws Exception {
        //1:创建服务器端Socket，指定端口
        DatagramSocket ds = new DatagramSocket(8888);
        //2、创建数据报，用于接收客户端发送的信息
        byte [] data = new byte[1024];        
        DatagramPacket dp = new DatagramPacket(data, data.length);
        //3、接收客户端发送的数据
        System.out.println("开始接收数据1111！");
        ds.receive(dp);        
        
        //4、读取数据
        String info = new String(data, 0, dp.getLength());
        System.out.println("我是服务端，收到客户端的信息是： "+info);
        
        
        //5、像客户端响应数据
        //定义客户端的地址、端口号和数据
        InetAddress ia = dp.getAddress();
        int port = dp.getPort();
        System.out.println("dp ia: " + ia + " port: " + port);
        //组装发送数据报
        byte []data2 = "你好客户端！".getBytes();
        DatagramPacket dp2 = new DatagramPacket(data2, data2.length, ia, port);        
        //响应客户端
        System.out.println("开始发送数据2222！");
        ds.send(dp2);
        
        
        //6、接收客户端第二次发送的数据
        System.out.println("开始接受数据3333！");
        ds.receive(dp);
        System.out.println("dp ia: " + dp.getAddress() + " port: " + dp.getPort());
        
        //7、读取数据
        info = new String(data, 0, dp.getLength());
        System.out.println("我是服务端，收到第二次客户端的信息是： "+info);
        
        
        ds.close();
    }

}

package lesson1220Socket;

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

import sun.io.ByteToCharCp1006;

public class UDPClient {

    public static void main(String[] args) throws Exception {
        
        InetAddress ia = InetAddress.getLocalHost();
        
        //1:创建客户端端Socket，指定端口和地址
        DatagramSocket ds = new DatagramSocket();
        //2、创建数据报，用于向服务器端发送信息
        byte [] data = "服务端你好".getBytes();        
        DatagramPacket dp = new DatagramPacket(data, data.length, ia, 8888);        
        //3、向服务器端发送数据
        System.out.println("A开始发送数据1111！");
        ds.send(dp);
        
        
        //4、读取数据
        byte [] data2 = new byte[1024];        
        DatagramPacket dp2 = new DatagramPacket(data2, data2.length);
        System.out.println("A开始接收数据2222！");
        ds.receive(dp2);
        
        System.out.println("dp2 ia: " + dp2.getAddress() + " port: " + dp2.getPort());
        String info = new String(data2, 0, dp2.getLength());
        System.out.println("我是客户端，服务器回的信息是： "+info);
       
        //5、第二次发送数据
        DatagramPacket dp3 = new DatagramPacket(data, data.length, dp2.getAddress(), dp2.getPort());    
        System.out.println("A开始发送数据3333！");
        ds.send(dp3);
        
        ds.close();
        
    }

}

上面这个程序先运行UDPServer, 再运行UDPClient。

运行结果：

UDPServer：

开始接收数据1111！
我是服务端，收到客户端的信息是： 服务端你好
dp ia: /100.98.19.103 port: 56013
开始发送数据2222！
开始接受数据3333！
dp ia: /100.98.19.103 port: 56013
我是服务端，收到第二次客户端的信息是： 服务端你好

 UDPClient：

A开始发送数据1111！
A开始接收数据2222！
dp2 ia: /100.98.19.103 port: 8888
我是客户端，服务器回的信息是： 你好客户端！
A开始发送数据3333！

参考帖子：

https://www.cnblogs.com/dongguacai/p/5747603.html

https://www.cnblogs.com/dongguacai/p/5747397.html

 https://www.cnblogs.com/rocomp/p/4790340.html-------基础讲解

https://www.cnblogs.com/Qian123/tag/java%E5%9F%BA%E7%A1%80/default.html?page=3

https://www.cnblogs.com/yiwangzhibujian/p/7107785.html

https://blog.csdn.net/facekbook/article/details/55506347

其他基础：

https://blog.csdn.net/hguisu/article/category/1122753

https://www.cnblogs.com/dolphin0520/category/602384.html

关于TCP/IP中更多的例子请看另一篇关于Socket多线程编程！