java网络编程之Socket编程详解编程语言

 　　public static void main(String[] args) throws UnknownHostException { 
        InetAdressDemo.getLocalHost(); 
        System.out.println("---------------------------"); 
        getHostByName("Lenovo-Autumn"); 
    } 
 
    /** 
     * 获取主机ip和主机名 
     * @throws UnknownHostException 
     */ 
    public static void getLocalHost() throws UnknownHostException { 
        //根据InetAddress获取主机名和主机ip 
        InetAddress localHost = InetAddress.getLocalHost(); 
        System.out.println(localHost);   //打印:Lenovo-Autumn/192.168.56.1 
 
        //根据getLocalHost()返回的值获取ip和主机名 
        String hostName = localHost.getHostName(); 
        String hostAddress = localHost.getHostAddress(); 
        System.out.println(hostName); //打印 Lenovo-Autumn 
        System.out.println(hostAddress); //打印 192.168.56.1 
 
        //根据切割获取主机名和ip 
        String[] str = localHost.toString().split("/"); 
        System.out.println(str[0]); //打印 Lenovo-Autumn 
        System.out.println(str[1]); //打印 192.168.56.1 
    } 
 
    /** 
     * 根据主机名称获取ip地址 
     * @param otherName  主机名(可以是局域网中的机器名或者是域名或者是ip) 
     * @throws UnknownHostException 
     */ 
    public static void getHostByName(String otherName) throws UnknownHostException { 
        InetAddress otherHost = InetAddress.getByName(otherName); 
        String hostName = otherHost.getHostName(); 
        String hostAddress = otherHost.getHostAddress(); 
        System.out.println(hostName); //打印 Lenovo-Autumn 
        System.out.println(hostAddress); //打印 192.168.56.1 
        System.out.println(otherHost);   //打印:Lenovo-Autumn/192.168.56.1 
    }

/** 
 * 实现udp发送端 
 *  用java.net.DatagramPackage封装数据 
 *  用java.net.DatagramSocket发送数据 
 * 
 * 实现步骤 
 *  1.用DatagramPackage对象,封装数据,接受的地址和端口 
 *  2.创建DatagramSocket 
 *  3.调用DatagramSocket对象send方法,发送数据 
 *  4.关闭资源 
 * 
 *  DatagramPackage构造函数 
 *    DatagramPacket(byte[] buf, int length, InetAddress address, int port) 
 *  DatagramSocket构造函数 
 *    DatagramSocket() 
 *    方法:send(DatagramPacket d) 
 *  Created by Autumn on 2018/2/5. 
 */ 
public class UdpSend { 
    public static void main(String[] args) throws Exception { 
        Scanner scanner = new Scanner(System.in); 
        //获取地址 
        InetAddress inet = InetAddress.getByName("127.0.0.1"); 
        //创建DatagramSocket,负责接受和发送数据 
        DatagramSocket ds = new DatagramSocket(); 
        while(true){ 
            String msg = scanner.nextLine(); 
            //创建数据包对象对象 
            byte[] data = msg.getBytes(); 
            //封装数据,接受的地址和端口 
            DatagramPacket dp = new DatagramPacket(data,data.length,inet,6000); 
 
            //发送数据包 
            ds.send(dp); 
            if(msg.equals("exit")){ 
                break; 
            } 
        } 
        //关闭 
        ds.close(); 
    } 
} 
 
 
/** 
 *  实现udp接收端 
 *  用java.net.DatagramPackage 接受数据 
 *  用java.net.DatagramSocket 接受数据包 
 * 
 *  步骤 
 *  1.创建DatagramSocket对象,绑定端口号(要和发送端端口一致) 
 *  2.创建字节数组用来接受数据 
 *  3.创建数据对象包DatagramPackage 
 *  4.创建DatagramSocket 
 *    receive(DatagramPackage dp)接受数据,将数据封装如dp中 
 *  5.拆包 
 *    发送端的ip地址(DatagramPackage.get) 
 *    接受到的字节数组 
 *    发送的端口号 
 *  6.关闭资源 
 * Created by Autumn on 2018/2/5. 
 */ 
public class UdpReceive { 
    public static void main(String[] args) throws IOException { 
        //创建数据包传输的对象,并绑定端口号 
        DatagramSocket ds = new DatagramSocket(6000); 
        //创建字节数组 
        byte[] data = new byte[1024]; 
        while(true){ 
            //创建数据包对象,传递字节数组 
            DatagramPacket dp = new DatagramPacket(data,data.length); 
            //调用ds对象的receive接受数据包,receive()有线程阻塞效果会一直等待接受数据 
            ds.receive(dp); 
 
            //获取数据包大小 
            int len = dp.getLength(); 
            //获取发送端的ip地址 
            InetAddress sendAddress = dp.getAddress(); 
            String sendHostAddress = sendAddress.getHostAddress(); 
            //System.out.println(sendHostAddress); 
            //获取发送端端口号 
            int port = dp.getPort(); 
            //System.out.println(port); 
 
            //System.out.println(new String(data));   //直接打印1024个字节的字符串,有很多空格 
            System.out.println(sendHostAddress+":"+port+"    "+new String(data,0,len));   //这样打印没有多余的空格 
 
            if(new String(data,0,len).equals("exit")){ 
                break; 
            } 
        } 
        //关闭 
        ds.close(); 
    } 
}

/** 
 * 实现TCP服务器程序 
 * 表示服务器程序的类java.net.ServerSocket 
 * 构造方法: 
 *      ServerSocket(int port);   传递端口号 
 * 
 * Important:必须获得客户端的套接字(Socket) 
 *     方法:Socket accept() 
 *     服务器可以获取到客户端的套接字 
 * Created by Autumn on 2018/2/5. 
 */ 
public class TCPServer { 
    public static void main(String[] args) throws IOException { 
        ServerSocket serverSocket = new ServerSocket(8888); 
        //调用服务器套接字对象accept()获取客户端套接字,具有线程等待效果 
        Socket socket = serverSocket.accept();    //这里会阻塞等待连接接入    cmd中telnet 127.0.0.1 8888即可连接 
        //根据获得的客户端的socket获取输入流 
        InputStream inputStream = socket.getInputStream(); 
        //根据输入流将数据读入到data中 
        byte[] data = new byte[1024]; 
        int len = inputStream.read(data);   //这里会阻塞,等待数据   cmd中ctrl+]进入到telnet操作模式send value发送数据 
        System.out.println(new String(data,0,len)); 
        socket.close(); 
        serverSocket.close(); 
    } 
} 
 
 
/** 
 * 实现TCP客户端,连接到服务器 
 * 和服务器实现数据交换 
 * 实现TCP客户端程序的类 java.net.Socket 
 * 
 * 构造方法: 
 *      Socket(String host, int port)传递服务器IP和端口号 
 *      注意:构造方法只要运行,就会和服务器进行连接,连接时报,抛出异常 
 * 
 *      OutputStream    getOutputStream()  返回套接字的输出流 
 *          作用:将数据输出,输出到服务器 
 *      InputStream    getInputStream()  返回套接字的输入流 
 *          作用:从服务器端读取数据 
 * 
 *      客户端服务器数据交换,必须使用套接字对象Socket中的获取的IO刘,自己new的流不行 
 * 
 * Created by Autumn on 2018/2/5. 
 */ 
public class TCPClient { 
    public static void main(String[] args) throws IOException { 
        //创建Socket对象,连接服务器 
        Socket socket = new Socket("127.0.0.1",8888); 
        //通过客户端的套接字对象Socket方法,获取字节输出流,将数据写向服务器 
        OutputStream out = socket.getOutputStream(); 
        out.write("这是一条来客户端的数据".getBytes()); 
        socket.close(); 
    } 
}

import java.io.IOException; 
import java.io.InputStream; 
import java.net.ServerSocket; 
import java.net.Socket; 
 
public class TCPServer { 
    /*同步阻塞*/ 
    public static void main(String[] args) throws IOException { 
        ServerSocket serverSocket = new ServerSocket(8888); 
        System.out.println("服务端启动成功..."); 
        while(true){ 
            /*一次只能处理一个连接,在一个连接没关闭前无法接收第二个连接,在这里开一个框发送数无问题,开放两个框时会出现第二个无反应*/ 
            Socket socket = serverSocket.accept();   //这里会阻塞等待连接接入    cmd中telnet 127.0.0.1 8888即代表连接 
            System.out.println("新客户端连接成功...."); 
            InputStream inputStream = socket.getInputStream(); 
            while(true) { 
                byte[] data = new byte[1024]; 
                System.out.println("正在等待数据..."); 
                int len = inputStream.read(data);    //这里会阻塞,等待数据，如果直接关闭cmd窗口会因为关闭socket通道导致len返回-1   cmd中ctrl+]进入到telnet操作模式send value发送数据 
                if (len != -1){ 
                    System.out.println(new String(data, 0,len, "GBK"));   //用GBK是因为CMD窗口命令发送的数据是GBK编码 
                }else{ 
                    break; 
                } 
            } 
        } 
        //socket.close(); 
        //serverSocket.close(); 
        //System.out.println("服务器端关闭...."); 
    } 
}

import java.io.IOException; 
import java.io.InputStream; 
import java.io.UnsupportedEncodingException; 
import java.net.ServerSocket; 
import java.net.Socket; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
 
public class TCPServer { 
    /*异步阻塞*/ 
    public static void main(String[] args) throws IOException { 
        ExecutorService threadPool = Executors.newCachedThreadPool();   //线程池 
        ServerSocket serverSocket = new ServerSocket(8888); 
        System.out.println("服务端启动成功..."); 
        while(true){ 
            /*一次只能处理一个连接,在一个连接没关闭前无法接收第二个连接,在这里开一个框发送数无问题,开放两个框时会出现第二个无反应*/ 
            System.out.println("等待客户端连接..."); 
            final Socket socket = serverSocket.accept();   //这里会阻塞等待连接接入    cmd中telnet 127.0.0.1 8888即代表连接 
            threadPool.execute(new Runnable() {   //启动一个线程 
                public void run() { 
                    try { 
                        System.out.println("新客户端连接成功...."); 
                        InputStream inputStream = socket.getInputStream(); 
                        while(true) { 
                            byte[] data = new byte[1024]; 
                            System.out.println("正在等待数据..."); 
                            int len = inputStream.read(data);    //这里会阻塞,等待数据，如果直接关闭cmd窗口会因为关闭socket通道导致len返回-1   cmd中ctrl+]进入到telnet操作模式send value发送数据 
                            if (len != -1){ 
                                    System.out.println(Thread.currentThread()+new String(data, 0,len, "GBK"));   //用GBK是因为CMD窗口命令发送的数据是GBK编码 
                            }else{ 
                                System.out.println("break循环"); 
                                break; 
                            } 
                        } 
                        System.out.println("一次Socket连接关闭"); 
                    } catch (UnsupportedEncodingException e) { 
                        e.printStackTrace(); 
                    } catch (IOException e) { 
                        e.printStackTrace(); 
                    } 
                } 
            }); 
 
        } 
        //socket.close(); 
        //serverSocket.close(); 
        //System.out.println("服务器端关闭...."); 
    } 
}