java4-网络编程

字节流传输

服务器

import java.io.InputStream;
import java.lang.Thread;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class test {
    public static void main(String[] args) throws Exception {
//        System.out.println(InetAddress.getLocalHost().getHostAddress());   //获取本机的ip地址
        ServerSocket serverSocket = new ServerSocket(35038);  //创建socket套接字并指定端口
        System.out.println("服务端开始进行监听");
        Socket sk1 = serverSocket.accept(); //使用serversocket进行监听，如果监听到就指定到sk1
        System.out.println("有连接上");
        InputStream inputStream=sk1.getInputStream();
        while (true){
            byte[] data=new byte[1024];
            inputStream.read(data);    //一直在这接收，并且只接收1024一次
            System.out.println(new String(data,"utf8"));
        }
    }
}

客户端

import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

public class client {
    public static void main(String[] args) {
        try {
            Scanner scanner=new Scanner(System.in);
            Socket sk1=new Socket("127.0.0.1",35038);   //写连接服务器的ip和端口号
            OutputStream outputStream=sk1.getOutputStream();
            while (true){
                String neirong=scanner.nextLine();
                byte[] data= neirong.getBytes("utf-8");
                if (data.length>1024){
                    System.out.println("输入的数据太长了");
                }
                else{
                    outputStream.write(data);
                }
            }
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
}

字符流

服务器

import java.io.DataInputStream;
import java.io.InputStream;
import java.lang.Thread;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class test {
    public static void main(String[] args) throws Exception {
//        System.out.println(InetAddress.getLocalHost().getHostAddress());   //获取本机的ip地址
        ServerSocket serverSocket = new ServerSocket(35038);  //创建socket套接字并指定端口
        System.out.println("服务端开始进行监听");
        Socket sk1 = serverSocket.accept(); //使用serversocket进行监听，如果监听到就指定到sk1
        System.out.println("有连接上");
        InputStream inputStream=sk1.getInputStream();
        DataInputStream dataInputStream=new DataInputStream(inputStream);  //将字节流变成字符流
        while (true){
            System.out.println(dataInputStream.readUTF());   //输出
        }
    }
}

客户端

import java.io.DataOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

public class client {
    public static void main(String[] args) {
        try {
            Scanner scanner=new Scanner(System.in);
            Socket sk1=new Socket("127.0.0.1",35038);   //写连接服务器的ip和端口号
            OutputStream outputStream=sk1.getOutputStream();
            DataOutputStream dataOutputStream=new DataOutputStream(outputStream); //将字节流包装成字符流
            while (true){
                String neirong=scanner.nextLine();

                dataOutputStream.writeUTF(neirong);

            }
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
}

 双线程同时收发

服务器

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.lang.Thread;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class server {
    public static void main(String[] args) throws Exception {
        /*-----初始化socket服务得到sk1-----*/
        ServerSocket serverSocket = new ServerSocket(35038);  //创建socket套接字并指定端口
        System.out.println("服务端开始进行监听");
        Socket sk1 = serverSocket.accept(); //使用serversocket进行监听，如果监听到就指定到sk1
        /*-----线程1发送线程设置启动-----*/
        Server_send server_send=new Server_send(sk1);
        server_send.start();
        /*-----主线程接收线程主体部分-----*/
        InputStream inputStream=sk1.getInputStream();
        DataInputStream dataInputStream=new DataInputStream(inputStream);  //将字节流变成字符流
        while (true){
            System.out.println(dataInputStream.readUTF());   //输出
        }
    }
}

class Server_send extends Thread{
    private Socket send_server;   //sk1传到这
    public Server_send(){
    }
    public Server_send(Socket socket){
        this.send_server=socket;
    }
    public void run(){
        try{
            /*-----线程1发送线程主体部分-----*/
            Scanner scanner=new Scanner(System.in);
            System.out.println("服务端开始进行监听-send");
            DataOutputStream dataOutputStream=new DataOutputStream(send_server.getOutputStream());
            while (true){
                    System.out.println("请输入想要发送的内容");
                    String neirong=scanner.nextLine();
                    dataOutputStream.writeUTF(neirong);
            }
        }catch (Exception e){}
    }
}

客户端

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

public class client {
    public static void main(String[] args) {
        try {
            /*-----初始化socket得到sk1-----*/
            Scanner scanner=new Scanner(System.in);
            Socket sk1=new Socket("127.0.0.1",35038);   //写连接服务器的ip和端口号
            /*-----线程1接收线程设置启动-----*/
            Client_recv client_recv=new Client_recv(sk1);
            client_recv.start();
            /*-----主线程发送线程主体部分-----*/
            OutputStream outputStream=sk1.getOutputStream();
            DataOutputStream dataOutputStream=new DataOutputStream(outputStream); //将字节流包装成字符流
            while (true){
                System.out.println("请输入想传输的内容");
                String neirong=scanner.nextLine();
                dataOutputStream.writeUTF(neirong);
            }
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
}
class Client_recv extends Thread{
    private Socket recv_server;
    public Client_recv(){
    }
    public Client_recv(Socket socket){
        this.recv_server=socket;
    }
    public void run(){
        try{
            /*-----线程1接收线程主体部分-----*/
            DataInputStream dataInputStream=new DataInputStream(recv_server.getInputStream());
            while (true){
                String data=dataInputStream.readUTF();
                System.out.println(data);
            }
        }catch (Exception e){}
    }
}

 检测连接人员离线。多客户端发给服务端信息

服务端

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.lang.Thread;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
 *  zqh设计，一开始先是初始化Socket_obj对象，它里面定义了专门存放(传心跳包对象的数组,消息收发的数组,用户名的数组)，第二步是开启循环监听，如果有socket对象
 *  连接建立成功，就首先判断有没有达到连接上限，到达上限就拒绝连接，否则将(传心跳包Socket,消息收发的Socket,用户名)存放到各自的数组里
 *  放完之后开启发送心跳包的线程和接收消息的线程。发送心跳包的线程里当前socket连接不断向用户端发消息，如果发不通，就说明用户离线，就把该用户从
 *  socket对象的数组里面抹掉         博客园https://www.cnblogs.com/zqh962903415/
 **/
//socket存放对象
class Socket_obj {
    private static int link_num=2;  //socket列表的长度
    private static List socketlist =new ArrayList();  //socket列表
    private static List namelist =new ArrayList();
    private static List messagelist =new ArrayList();
    int get_num(){
        return link_num;   //获取长度值
    }
    List get_socklist(){
        return socketlist;   //获取soket列表
    }
    List get_namelist(){
        return namelist;   //获取soket列表
    }
    List get_messagelist(){
        return messagelist;   //获取soket列表
    }
    void set_sl(List list){
        socketlist=list;    //修改socket列表
    }
    void set_nl(List list){
        namelist=list;    //修改socket列表
    }
    void set_ml(List list){
        messagelist=list;
    }
    @Override
    public String toString() {
        return super.toString();
    }
}
/*---------检测在线状态sk--------------*/
class Check_online extends Thread {
    private Socket sk;   //！！！！sk不能是静态的，每个用户的sk都不同
    private Socket msk;  //！！！！msk不能是静态的，每个用户的msk都不同
    private static Socket_obj socket_obj;   //socket存放对象大家引用的应该是相同的
    private String username;  //username非静态，每个用户都不同
    Check_online(Socket sk,Socket msk,Socket_obj socket_obj,String username) {
        this.sk = sk;
        this.msk=msk;
        this.username=username;
        Check_online.socket_obj=socket_obj;
    }
    public void run() {
        try {
            while (true) {                        //!!!!!!直接服务端发心跳包给客户端行了，如果拿着对象的sk发，发不出去就直接在异常那里消掉它
                DataOutputStream dataOutputStream=new DataOutputStream(sk.getOutputStream());
                dataOutputStream.writeUTF("2");   //每1s向客户端发送2（心跳）
                Thread.sleep(1000);
                }
        } catch (Exception e) {
            System.out.println("有人离线");   //连接不通就到这
            try{sk.close();msk.close();}catch (Exception f){}  //心跳和消息的socket都给他断开
            synchronized (socket_obj) {     //同步锁socket——obj对象，一个线程修改完这个另一个线程才能改这个
                List new_sl = socket_obj.get_socklist();   //获取当前的心跳包socket数组
                new_sl.remove(sk);    //删掉当前离线的
                socket_obj.set_sl(new_sl);    //更新
                List new_nl = socket_obj.get_namelist();
                new_nl.remove(username);
                socket_obj.set_nl(new_nl);
                List new_ml = socket_obj.get_messagelist();
                new_ml.remove(msk);
                socket_obj.set_ml(new_ml);
            }
        }
    }
}
/*---------消息接收口msk----------------*/
class Sev_m_rec extends Thread{
    private Socket socket;
    Sev_m_rec(Socket socket){
        this.socket=socket;
    }
    public void run(){
        try {
            while (true){
            DataInputStream dataInputStream=new DataInputStream(socket.getInputStream());
            System.out.println(dataInputStream.readUTF());
            }
        }catch (Exception e){}
    }
}
/*------------主程序——————————————————————*/
public class Server {
    public static void main(String[] args) throws Exception {
        /*-----初始化socket对象-----*/
        Socket_obj socket_obj = new Socket_obj();  //实例化socket列表对象
        int link_num = socket_obj.get_num();   //获取列表的长度
        /*-----------------------*/
        ServerSocket serverSocket = new ServerSocket(35038);  //创建socket套接字并指定端口
        /*---------并发socket监听---------*/
        while (true) {
                Socket sk = serverSocket.accept(); //使用serversocket进行监听，如果监听到就指定到sk
                Socket msk = serverSocket.accept();
//            System.out.println("服务端开始进行监听");
            if (socket_obj.get_socklist().size()>link_num-1) {                  //超过link_num就不让连接
                Thread.sleep(1000);
                sk.close();
                msk.close();
                continue;
            }else {
                DataInputStream dataInputStream = new DataInputStream(sk.getInputStream());
                String username = dataInputStream.readUTF(); //接收客户端发来的用户名消息
                /*------socketlist里面的是心跳包操作，判断是否在线的socket*/
                synchronized (socket_obj) {          //同步socket_obj,一个线程修改完之后另一个线程才能对它进行修改
                    List sl_new = socket_obj.get_socklist();    //获取当前的心跳包socket数组
                    sl_new.add(sk);                            //增加当前连接进来的
                    socket_obj.set_sl(sl_new);                 //更新
                    /*-----namelist里面放的是用户名*/
                    List ml_new = socket_obj.get_messagelist();
                    ml_new.add(msk);
                    socket_obj.set_ml(ml_new);
                    /*------messagelist里面放的是消息传输的socket----*/
                    List nl_new = socket_obj.get_namelist();
                    nl_new.add(username);
                    socket_obj.set_nl(nl_new);
                }
                    System.out.println(socket_obj.get_socklist().toString());
                    Check_online check_online = new Check_online(sk, msk, socket_obj, username);  //开检测在线状态线程
                    check_online.start();
                    Sev_m_rec sev_m_rec = new Sev_m_rec(msk);      //开信息接收线程
                    sev_m_rec.start();
                    }
                }
            }
        }

客户端

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;
import java.util.Scanner;
//class Mes_rec extends Thread{
//    private Socket socket;
//    Mes_rec(Socket socket){
//        this.socket=socket;
//    }
//    public void run(){
//        try {
//            DataInputStream dataInputStream=new DataInputStream(socket.getInputStream());
//            while(true){
//                System.out.println(dataInputStream.readUTF());
//            }
//        }catch (Exception e){}
//    }
//}
class Mes_send extends Thread{
    private Socket socket;
    private String username;
    Mes_send(Socket socket,String username){
        this.socket=socket;  this.username=username;
    }
    Scanner scanner=new Scanner(System.in);
    public void run(){
        try {
            DataOutputStream dataOutputStream=new DataOutputStream(socket.getOutputStream());
            while(true){
                System.out.println("请输入想要发送的内容:");
                String neirong=username+"说到："+scanner.nextLine();
                dataOutputStream.writeUTF(neirong);
            }
        }catch (Exception e){}
    }
}
class Client1 {

    public static void main(String[] args) {
        try {
            System.out.println("请输入用户名");
            Scanner scanner=new Scanner(System.in);
            String username= scanner.nextLine();
            /*-----初始化socket得到sk1-----*/
            Socket sk1=new Socket("127.0.0.1",35038);   //sk1心跳包socket
            Socket msk=new Socket("127.0.0.1",35038);   //msk消息收发socket
            /*------接收服务器发过来的状态------*/
            DataOutputStream dataOutputStream=new DataOutputStream(sk1.getOutputStream());
            dataOutputStream.writeUTF(username);
            Thread.sleep(1000);
//            Mes_rec mes_rec=new Mes_rec(msk);
//            mes_rec.start();
            Mes_send mes_send=new Mes_send(msk,username);
            mes_send.start();
            while(true){
                dataOutputStream.writeUTF("1");
                Thread.sleep(1000);
            }
            /*----------------------------*/
        }
        catch(Exception e){
            System.out.println("未连接到服务器,请重新启动");
        }
    }
}

 /--------------------****服务端的程序使用jdk，千万不要使用jre，不然会令人崩溃----------------------------/

posted @ 2021-03-05 21:15  克莱比-Kirby  阅读(87)  评论(0)    收藏  举报