tcp,udp实现的聊天

 

 

socket：网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口。

socket通信模型：

socket实现tcp编程:

服务器端：

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * classname TcpServer
 * author Layne_Luo
 * date 2018/8/3 14:25
 * Description:服务器端
 */
public class TcpServer{

    public static void main(String[] args){
        try{
            //创建一个服务器端ServerSocket，指定端口
            ServerSocket serverSocket = new ServerSocket(20000);
            Socket socket = null;
            //记录客户端的数量
            int count=0;
            while(true){
                socket = serverSocket.accept();
                ServerThread st=new ServerThread(socket);   //创建线程类，每个客户端连接都会创建一个socket进行通信
                new Thread(st).start();
                count++;
                System.out.println("当前客户端的数量"+count);
                InetAddress address=socket.getInetAddress();
                System.out.println("当前客户端的IP地址："+address.getHostAddress());

            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

客户端： 

import java.io.*;
import java.net.Socket;

/**
 * classname ClientA
 * author Layne_Luo
 * date 2018/8/3 14:25
 * Description:
 */
public class Client {
    public static void main(String[] args) {
        try {
            //创建socket，并指定端口
            Socket socket=new Socket("localhost",20000);
            //创建输出流
            OutputStream os=socket.getOutputStream();
            PrintWriter pw=new PrintWriter(os);
            pw.write("你好服务器，我是客户端XX");
            pw.flush();
            socket.shutdownOutput();//关闭输出流
            //获取输入流
            InputStream is=socket.getInputStream();
            BufferedReader br=new BufferedReader(new InputStreamReader(is));//添加缓冲
            String info=null;
            while((info=br.readLine())!=null){
                System.out.println("服务器端:"+info);
            }


            //4.关闭其他相关资源
            br.close();
            is.close();
            pw.close();
            os.close();
            socket.close();



        } catch (IOException e) {


        }
    }
}

/**
 * classname ServerThread
 * author Layne_Luo
 * date 2018/8/3 15:59
 * Description:
 */
public class ServerThread implements Runnable{

    Socket socket=null;


    public ServerThread(Socket socket){
        //初始化Socket
        this.socket=socket;
    }

    @Override
    public void run() {
        InputStream is = null;//字节输入流
        InputStreamReader isr=null;
        BufferedReader br=null;
        OutputStream os=null;
        PrintWriter pw=null;
        try {
            is = socket.getInputStream();
            //获取输入流,读取客户端的信息
            isr = new InputStreamReader(is);
            br = new BufferedReader(isr);
            String info = null;
            while ((info = br.readLine()) != null) {
                System.out.println("客户端:" + info);
            }
            socket.shutdownInput();//关闭输入流
            //4.获取输出流
            os = socket.getOutputStream();
            pw = new PrintWriter(os);
            pw.write("we are family");
            pw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5.关闭相关的资源,finally是一定会被执行的
            try {
                if(pw!=null)
                    pw.close();
                if(os!=null)
                    os.close();
                if(br!=null)
                    br.close();
                if(isr!=null)
                    isr.close();
                if(is!=null)
                    is.close();
                if(socket!=null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

socket实现udp编程

服务器端：

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

/**
 * classname TcpServer
 * author Layne_Luo
 * date 2018/8/3 14:47
 * Description:服务器端
 */
public class UdpServer {
    public static void main(String[] args) {
        try {
            /**
             * 接收客户端信息
             */
            //创建服务器端DatagramSocket，并且指定端口
            DatagramSocket socket=new DatagramSocket(20000);
            //创建数据报，用于接收客户端发送的数据
            byte[] data=new byte[1024];
            DatagramPacket packet=new DatagramPacket(data,data.length);//接受信息的数组以及接收的长度
            //接收客户端发送的数据
            socket.receive(packet);
            //数据转化
            String info=new String(data,0,packet.getLength());
            System.out.println("客户端："+info);
            /**
             * 向客户端响应数据
             */
            //定义客户端的地址，端口号和数据
            InetAddress adress=packet.getAddress();
            int port=packet.getPort();
            byte []data2="we are family".getBytes();
            //创建数据报，包含响应的数据信息，
            DatagramPacket packet2=new DatagramPacket(data2,data2.length,adress,port);
            //响应客户端
            socket.send(packet2);
            //关闭相应的资源信息
            socket.close();

        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端：

import java.io.IOException;
import java.net.*;

/**
 * classname Client
 * author Layne_Luo
 * date 2018/8/3 14:47
 * Description:
 */
public class Client {
    public static void main(String[] args) {
        try {
            /**
             * 向服务器端发送数据
             */
            //定义服务器的地址、端口号以及相应要发送的数据
            InetAddress address=InetAddress.getByName("localhost");
            int port=20000;
            byte data[]="你好服务器，我是客户端XX".getBytes();
            //创建数据报，包含发送的相关数据，服务器地址端口以及信息
            DatagramPacket packet=new DatagramPacket(data,data.length,address,port);
            //创建datagramSocket来实现数据的发送
            DatagramSocket socket=new DatagramSocket();
            //使用datagramsocket向服务器端发送数据报
            socket.send(packet);
            /**
             * 接收服务端响应的数据
             */
            //创建数据报，用来接收服务器端响应的数据，数据保存在字节数组里
            byte [] data2=new byte[1024];
            DatagramPacket packet2=new DatagramPacket(data2,data2.length);
            //接收服务器端响应的数据
            socket.receive(packet2);
            //读取服务器端相应的数据信息
            String reply=new String(data2,0,packet2.getLength());
            System.out.println("服务器端："+reply);
            //关闭资源
            socket.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}