java网络编程

网络通信三要素
IP
端口号
协议(UDP&TCP)

UDP协议与TCP协议各自特点
UDP
1.不需要建立连接；
2.有数据大小限制，每个数据包的大小在限制在64k；
3.无连接，是不可靠协议；
4.速度快。
TCP
1.在连接中进行大数据量传输（数据无限制）；
2.通过三次握手完成连接；
3.是可靠协议；

Socket
通过IP地址和端口号可以 创建一个Socket对象，也就是说Socket由IP和端口组成
网络通信其实就是Socket之间的通信,比如Socket对象1和Socket对象2 两个对象之间的通信
Socket通信中数据底层是通过IO流来传输的

InetAddress
概述：
IP信息的包装类
本机ip 127.0.0.1
ping 192.168.1.xxx
常用方法：
获取本地主机：getLocalHost
获取任意主机：getByName（String ip）
主机名：getHostName
主机Ip地址：getHostAddress

DatagramPacket
概述：
数据包对象，两个Socket之间是通过发送和解析DatagramPacket来交互的

构造方法：

DatagramPacket(byte[] buf, int length)
构造 DatagramPacket，用来接收长度为 length 的数据包。DatagramPacket(byte[] buf, int length, InetAddress address, int port)
构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。

成员方法：
InetAddress getAddress()
返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。

byte[] getData()
返回数据缓冲区。
intgetLength()
返回将要发送或接收到的数据的长度。
intgetPort()
SocketAddressgetSocketAddress()
获取要将此包发送到的或发出此数据报的远程主机的 SocketAddress（通常为 IP 地址 + 端口号）。

UDP代码

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

public class UDPUtil {
       /**
        * 接收功能
        *
        * @param port
        *            端口
        * @return DatagramPacket
        */
       public static DatagramPacket receive(int port) {
              DatagramSocket ds = null; // socket对象
              DatagramPacket packet = null;// 数据包对象
              byte[] bys = new byte[1024];

              try {
                     packet = new DatagramPacket(bys, bys.length);
                     ds = new DatagramSocket(port);
                     ds.receive(packet);
              } catch (SocketException e) {
                     e.printStackTrace();
              } catch (IOException e) {
                     e.printStackTrace();
              } finally {
                     ds.close();
              }

              return packet;

       }


       /**
        * 发送功能
        *
        * @param msg
        *            发送的消息内容
        * @param ip
        *            接收IP(对方IP)，null代表本机
        * @param port
        *            端口号
        */
       public static void send(String msg, String ip, int port) {
              DatagramSocket ds = null; // socket对象
              InetAddress address = null; // ip地址对象
              DatagramPacket packet = null;// 数据包对象
              byte[] bys;
              try {

                     if (ip == null) {
                            address = InetAddress.getLocalHost();
                     } else {
                            address = InetAddress.getByName(ip);
                     }

                     if (msg == null) {
                            bys = "".getBytes();
                     } else {
                            bys = msg.getBytes();
                     }

                     packet = new DatagramPacket(bys, bys.length, address, port);
                     ds = new DatagramSocket();
                     ds.send(packet);
              } catch (UnknownHostException e) {
                     e.printStackTrace();
              } catch (SocketException e) {
                     e.printStackTrace();
              } catch (IOException e) {
                     e.printStackTrace();
              } finally {
                     if (ds != null) {
                            ds.close();
                     }
              }
       }
}

TCP代码
TCP 三次握手：
客户端 给服务器发送数据第一次
服务器给客户端响应数据第二次
客户端再次给服务端发送数据第三次

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

public class TCPUtil {
         public static ServerSocket createServer(int port) throws IOException {
                   return new ServerSocket(port);
         }

         public interface Process {

                   /**
                    * 客户端或者服务端具体的业务逻辑
                    * @param socket
                    * @throws Exception
                    */
                   public void process(Socket socket) throws Exception;

         }

         /**
          * 客户端处理数据业务逻辑
          * @param ip 服务器IP
          * @param port 服务器上的某个应用程序的端口
          * @param p 处理数据的业务逻辑
          * @throws Exception
          */
         public static void clientProcess(String ip, int port, Process p)throws Exception {
                   Socket socket = new Socket(ip, port);
                   p.process(socket);
                   socket.close();
         }

         /**
          * 服务器端处理数据业务逻辑
          * @param server
          * @param p
          * @throws Exception
          */
         public static void serviceProcess(ServerSocket server, Process p) throws Exception {

                   Socket socket = server.accept();
                   p.process(socket);
         }

}

客户端实现

import java.io.InputStream;
importjava.io.OutputStream;
importjava.net.Socket;
importutil.TCPUtil;
importutil.TCPUtil.Process;
public classTCPClient {
       public static voidmain(String[] args) throws Exception {
              TCPUtil.clientProcess("127.0.0.1", 12306, new Process() {
                     @Override
                     public void process(Socket socket) throws Exception {
                            OutputStream os = socket.getOutputStream();
                            os.write("hello , service".getBytes());

                            InputStream is = socket.getInputStream();
                            byte bys[] = new byte[1024];
                            int len = is.read(bys);
                            System.out.println(newString(bys, 0, len));
                            os.write("ok".getBytes());
                     }
              });
       }
}

服务端实现

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

import util.TCPUtil.Process;
importutil.TCPUtil;
public classTCPServer {
       public static voidmain(String[] args) throws Exception {
              ServerSocket server = TCPUtil.createServer(12306);

              while (true) {
                     TCPUtil.serviceProcess(server, new Process() {

                            @Override
                            public void process(Socket socket) throws Exception {
                                   InputStream is = socket.getInputStream();
                                   byte bys[] = new byte[1024];
                                   int len = is.read(bys);
                                   System.out.println(newString(bys,0,len));

                                   OutputStream os = socket.getOutputStream();
                                   os.write("en , ni ye hao client".getBytes());

                                   is = socket.getInputStream();
                                   len = is.read(bys);
                                   System.out.println(newString(bys,0,len));
                            }
                     });
              }
       }
}