利用java的Socket实现一个简单hello/hi聊天程序

SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
{
    unsigned long a[AUDITSC_ARGS];
    unsigned long a0, a1;
    int err;
    unsigned int len;

    if (call < 1 || call > SYS_SENDMMSG)
        return -EINVAL;
    call = array_index_nospec(call, SYS_SENDMMSG + 1);

    len = nargs[call];
    if (len > sizeof(a))
        return -EINVAL;

    /* copy_from_user should be SMP safe. */
    if (copy_from_user(a, args, len))
        return -EFAULT;

    err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
    if (err)
        return err;

    a0 = a[0];
    a1 = a[1];

    switch (call) {
    case SYS_SOCKET:
        err = __sys_socket(a0, a1, a[2]);
        break;
    case SYS_BIND:
        err = __sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
        break;
    case SYS_CONNECT:
        err = __sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
        break;
    case SYS_LISTEN:
        err = __sys_listen(a0, a1);
        break;
    case SYS_ACCEPT:
        err = __sys_accept4(a0, (struct sockaddr __user *)a1,
                    (int __user *)a[2], 0);
        break;
    ...
    ...
    default:
        err = -EINVAL;
        break;
    }
    return err;
}

SeverSocket();   //创建不绑定服务器的套接字
ServerSocket server = new ServerSocket(int port);  //指定端口号绑定
ServerSocket(int port,int backlog);   //指定的backlog创建服务器套接字并绑定到指定的本地端口号
ServerSocket(int port,int backlog,InetAddress bindAddr);  //使用指定的端口，监听backlog和要绑定的本地IP地址创建服务器

Socket client = server.accept();

DataInputStream dis = new DataInputStream(client.getInputStream());

DataOutputStream dos= new DataOutputStream(client.getOutputStream());

package chat1;
?
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
?
/*
 * 简易在线聊天程序服务端
 */
public class server {
    public static void main(String[]args) throws UnknownHostException,IOException{
        System.out.println("---server---");
        //指定端口 使用ServerSocket创建服务器
        ServerSocket server = new ServerSocket(666);
        //阻塞式等待连接
        Socket client = server.accept();
        System.out.println("一个客户端连接建立");
        //接收消息
        DataInputStream dis = new DataInputStream(client.getInputStream());
        String msg = dis.readUTF();
        System.out.println("client say:"+msg);
        //返回消息
        DataOutputStream dos= new DataOutputStream(client.getOutputStream());
        dos.writeUTF(msg);
        //释放资源
        dos.flush();
        dos.close();
        dis.close();
        client.close();
    }
}

package chat1;
?
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;
?
/*
 * 简易在线聊天程序客户端
 */
public class client {
    public static void main(String[]args) throws UnknownHostException, IOException{
        System.out.println("---client---");
        //连接建立，使用Socket创建客户端，这里要注意端口号要跟本地其它已经写过的网络程序相区分开
        Socket client =new Socket("localhost",666);
        //客户端发送消息
        BufferedReader console=new BufferedReader(new InputStreamReader(System.in));
        String msg = console.readLine();
        DataOutputStream dos= new DataOutputStream(client.getOutputStream());
        dos.writeUTF(msg);
        dos.flush();
        //接收消息
        DataInputStream dis = new DataInputStream(client.getInputStream());
        msg = dis.readUTF();
        System.out.println(msg);
        //释放资源
        dos.close();
        dis.close();
        client.close();
        }
}

package chat2;
?
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
?
/*
 * 简易在线聊天程序服务器端，实现多个客户消息发送
 */
public class Multiserver {
    public static void main(String[] args)throws IOException{
        System.out.println("----server---");
        //指定端口666，使用SeverSocekt创建服务器
        ServerSocket server =new ServerSocket(666);
        //阻塞式监听，等待连接
        while(true){
            Socket client=server.accept();
            System.out.println("一个客户端连接建立");
            new Thread(new Channel(client)).start();
        }
    }
    //为了多个响应多个客户，封装成多线程
    static class Channel implements Runnable{
        private Socket client;
        //输入输出流封装
        private DataInputStream dis;
        private DataOutputStream dos;
        private boolean isRuning;
        //构造器
        public Channel(Socket client) throws IOException{
            this.client=client;
            try {
                //输入流
                dis = new DataInputStream(client.getInputStream());
                //输出流
                dos = new DataOutputStream(client.getOutputStream());
                isRuning = true;
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                release();
            }
        }
        //接收数据
        private String receive() {
            String msg = "";
            try {
                msg = dis.readUTF();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return msg;
        }
        //发送数据
        private void send(String msg) {
            System.out.println(msg);
            try {
                dos.writeUTF(msg);
                dos.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
            
        }
        //释放资源
        private void release() throws IOException{
            this.isRuning=false;
            Util.close(dis,dos);
            client.close();
        }
        @Override
        public void run() {
            while(isRuning){
                String msg = receive();
                if(!msg.equals("")){
                    send(msg);
                }
            }
        }
    }
}

package chat2;
?
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;
?
/*
 * 简易在线聊天程序客户端，实现多个客户消息发送
 */
public class Multiclient {
    public static void main(String[]args) throws UnknownHostException, IOException{
        System.out.println("---client---");
        //连接建立，使用Socket创建客户端，这里要注意端口号要跟本地其它已经写过的网络程序相区分开
        Socket client =new Socket("localhost",666);
        //发送消息
        new Thread(new send(client)).start();
        //接收消息
        new Thread(new receive(client)).start();
        }
}

package chat2;
?
import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;
?
/*
 * 使用多线程封装接收端
 */
public class receive implements Runnable{
    private DataInputStream dis;
    private Socket client;
    private boolean isRuning = true;
    public receive(Socket client){
        this.client = client;
        try {
            dis = new DataInputStream(client.getInputStream());
        } catch (IOException e) {
            e.printStackTrace();
            this.release();
        }
    }
    @Override
    public void run() {
        while(isRuning){
            String msg = receive();
            if(!msg.equals("")){
                //System.out.println(msg);
            }
        }
    }
    //接收数据
    private String receive() {
        String msg = "";
        try {
            msg = dis.readUTF();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return msg;
    }
    //释放资源
    private void release(){
        this.isRuning = false;
        Util.close(dis);
        try {
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package chat2;
?
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
?
/*
 * 使用多线程封装发送端
 */
public class send implements Runnable{
    private BufferedReader console;
    private DataOutputStream dos;
    private Socket client;
    private boolean isRuning = true;
    //构造器
    public send(Socket client){
        this.client = client;
        console = new BufferedReader(new InputStreamReader(System.in));
        try {
            dos= new DataOutputStream(client.getOutputStream());
        } catch (IOException e) {
            e.printStackTrace();
            this.release();
        }
    }
    @Override
    public void run() {
        while(isRuning){
            String msg = getStrFromConsole();
            if(!msg.equals("")){
                send(msg);
            }
        }
        
    }
    //从控制台获取消息
    private String getStrFromConsole(){
        try {
            return console.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }
    //发送消息
    private void send(String msg){
        System.out.println(msg);
        try {
            dos.writeUTF(msg);
            dos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //释放资源
    private void release(){
        this.isRuning = false;
        Util.close(dos);
        try {
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package chat2;
?
import java.io.Closeable;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;
?
/*
 * 工具类
 */
public class Util {
    /*
     * 释放资源
     */
    public static void close(Closeable...targets){
        for(Closeable target:targets){
            try{
                if(null!=target)
                    target.close();
            }catch(Exception e){
                
            }
        }
    }
}