web应用添加socket接口

1.涉及到的类

2.MyClientRefreshTask

import java.util.ArrayList;
import java.util.List;

public class MyClientRefreshTask extends java.util.TimerTask {

	@Override
	public void run() {
		refreshClient();

	}

	private static void refreshClient() {
		List<SocketClientBean> dels = new ArrayList<SocketClientBean>();
		for (int i = 0; i < MyServer.clientlist.size(); i++) {
			if (MyServer.clientlist.get(i).getSocket().isClosed()) {
				System.out.println("it is the del client!");
				dels.add(MyServer.clientlist.get(i));
			}
		}
//		System.out.println("clientlist num:" + MyServer.clientlist.size());
//		System.out.println("dels num:" + dels.size());
		MyServer.clientlist.removeAll(dels);
//		System.out.println("clientlist left num:" + MyServer.clientlist.size());
	}

}

3.MyServer

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Timer;

import javax.annotation.Resource;

import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;

import com.rainier.ve.service.common.FileUploadService;
import com.rainier.ve.service.u3d.ScoreRuleService;

import cn.org.rapid_framework.util.holder.ApplicationContextHolder;
public class MyServer {
	public static List<SocketClientBean> clientlist = new ArrayList<SocketClientBean>();
	private static Timer timer = new Timer();
	public static void rerfresh() {
		timer.schedule(new MyClientRefreshTask(), 1000 * 0, 1000 * 15);
	}

	public static void destroyedTimer() {
		if (timer != null) {
			timer.cancel();
		}
	}

	public static void invoke(final Socket client) throws IOException {
		new Thread(new Runnable() {
			public void run() {
				String errcmd = "{\"cmd\":-1}";
				String nocmd = "{\"cmd\":0}";

				BufferedReader in = null;
				PrintWriter out = null;
				try {
					in = new BufferedReader(new InputStreamReader(client.getInputStream()));
					out = new PrintWriter(client.getOutputStream());
					Integer count = 0;
//					while (true) {
						String cmdmsg = in.readLine();
						count++;
//						System.out.println(count);
//						System.out.println("Server received " + cmdmsg);
//						Gson gs=new Gson();
//						JSONObject jsmsg = JSONObject.fromObject(cmdmsg);
//						System.out.println("JSONObject success");
//						String cmd = jsmsg.getString("cmd");
//						switch (cmd) {
//						case "1":
//							com.progress.cmd1.process(client, jsmsg);
//							break;
//						case "2":
//							com.progress.cmd2.process(client, jsmsg);
//							break;
//						default:
//							out.println(nocmd);
//							out.flush();
//						}
						System.out.println("msg:"+cmdmsg);
//						if ("bye".equals(cmdmsg)) {
//							break;
//						}
						String toClientStr="返回的数据";
						out.println(toClientStr);
						out.flush();
//					}
//				} catch (JSONException ex) {
//					System.out.println("JSONObject err");
//					out.println(errcmd);
//					out.flush();
				} catch (Exception ex) {
					ex.printStackTrace();
				} finally {
					try {
						in.close();
					} catch (Exception e) {
					}
					try {
						out.close();
					} catch (Exception e) {
					}
					try {
						client.close();
					} catch (Exception e) {
					}
				}
			}
		}).start();
	}
}

4.ServerSocketListener

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class ServerSocketListener implements ServletContextListener {

	private SocketThread socketThread;

    public void contextDestroyed(ServletContextEvent e)
    {
        if (socketThread != null && socketThread.isInterrupted())
        {
            socketThread.closeServerSocket();
            socketThread.interrupt();
        }
    }

    public void contextInitialized(ServletContextEvent e)
    {
        ServletContext servletContext = e.getServletContext();
        System.out.println("Server contextInitialized over");
        if (socketThread == null)
        {
            socketThread = new SocketThread(null, servletContext);
            socketThread.start(); 
        }
    }


}

5.SocketClientBean

import java.net.Socket;

public class SocketClientBean {
	private Socket socket;

	public Socket getSocket() {
		return socket;
	}

	public void setSocket(Socket socket) {
		this.socket = socket;
	}
	
}

6.SocketThread

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

import javax.servlet.ServletContext;

public class SocketThread extends Thread {
	Integer count = 0;
    private ServletContext servletContext;
    private ServerSocket serverSocket;

    public SocketThread(ServerSocket serverSocket, ServletContext servletContext)
    {
        this.servletContext = servletContext;
        // 从web.xml中context-param节点获取socket端口
        String port = this.servletContext.getInitParameter("socketPort");
        if (serverSocket == null)
        {
            try
            {
                this.serverSocket = new ServerSocket(Integer.parseInt(port));
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }
    public void run()
    {
        try
        {
            Integer count = 0;
            while (!this.isInterrupted())
            {
                MyServer.rerfresh();
                
                Socket socket = serverSocket.accept();
                count++;
//                System.out.println("Server SocketThread start:"+count);
                if (socket != null)
                {
                    SocketClientBean client = new SocketClientBean();
                    client.setSocket(socket);
                    MyServer.clientlist.add(client);
//
                    System.out.println("new commer:"+socket.getRemoteSocketAddress().toString());
                    MyServer.invoke(socket);
                }
            }
        }
        catch (Exception ex)
        {
            System.out.println("SocketThread err:"+ex.getMessage());
        }
    }
    
    public void closeServerSocket()
    {
        try
        {
            if (serverSocket != null && !serverSocket.isClosed())
            {
                serverSocket.close();
                MyServer.destroyedTimer();
            }

        }
        catch (Exception ex)
        {
            System.out.println("SocketThread err:"+ex.getMessage());
        }
    }

}

7.ClientTest

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class ClientTest {
	 public static void main(String[] args) {
		 try {
              // 1、创建客户端Socket，指定服务器地址和端口
              Socket socket=new Socket("127.0.0.1",9090);
              System.out.println("客户端启动成功");
              // 2、获取输出流，向服务器端发送信息
              // 向本机的9090端口发出客户请求
              BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
              // 由系统标准输入设备构造BufferedReader对象
              PrintWriter write = new PrintWriter(socket.getOutputStream());
              // 由Socket对象得到输出流，并构造PrintWriter对象
              //3、获取输入流，并读取服务器端的响应信息 
              BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
              // 由Socket对象得到输入流，并构造相应的BufferedReader对象
              String readline=
            		 "传到服务器的字符串";
              write.println(readline);
              write.flush();
//              readline = br.readLine(); // 从系统标准输入读入一字符串
//              write.println("123");
//              while (!readline.equals("end")) {
//                  // 若从标准输入读入的字符串为 "end"则停止循环
//                  write.println(readline);
//                  // 将从系统标准输入读入的字符串输出到Server
//                  write.flush();
//                  // 刷新输出流，使Server马上收到该字符串
//                  System.out.println("Client:" + readline);
//                  // 在系统标准输出上打印读入的字符串
//                  System.out.println("Server:" + in.readLine());
//                  // 从Server读入一字符串，并打印到标准输出上
//                  readline = br.readLine(); // 从系统标准输入读入一字符串
//              } // 继续循环
              //4、关闭资源 
              write.close(); // 关闭Socket输出流
              in.close(); // 关闭Socket输入流
              socket.close(); // 关闭Socket
          } catch (Exception e) {
              System.out.println("can not listen to:" + e);// 出错，打印出错信息
          }
	    }
}

阿里云幸运券欢迎领取

web应用添加socket接口

猜你喜欢