1.socket 服务器搭建

实例化socket服务器，循环获取请求

  1. package com.orange.util;
  2.  
  3. import java.io.IOException;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  6. import java.util.Timer;
  7. import java.util.TimerTask;
  8. import java.util.concurrent.Executors;
  9. import java.util.concurrent.ScheduledExecutorService;
  10. import java.util.concurrent.TimeUnit;
  11.  
  12. /**
  13.  * socket服务器
  14.  *
  15.  * @author Chengjq
  16.  *
  17.  */
  18. public class SocketServer {
  19.  
  20.     public static int count = 0;
  21.  
  22.     public static void main(String[] args) {
  23.         // TODO 自动生成的方法存根
  24.         int port = 4404;
  25.         // 首先直接创建serversocket
  26.         ServerSocket serverSocket = null;
  27.         Socket socket = null;
  28.         try {
  29.             serverSocket = new ServerSocket(port);
  30.             System.out.println("启动socketServer成功,等待客户端的连接");
  31.             while (true) {
  32.                 socket = serverSocket.accept();
  33.                 System.out.println("有新的客户端请求连接");
  34.                 SocketThread st = new SocketThread(socket);
  35.                 st.start();
  36.                 ChatManager.getChatManager().add(st);
  37.                 //启动定时任务，如果10s内没有进程
  38.                 /*Runnable runnable = new Runnable() {
  39.                     int clientNum = 0;
  40.                     public void run() {
  41.                         // task to run goes here
  42.                         clientNum = ChatManager.getChatManager().vector.size();
  43.                         System.out.println("剩余客户端数量:"+clientNum);
  44.                         if(clientNum ==0 ){
  45.                             System.out.println("连接超时，或者无客户端连接，关闭serverSocket");
  46.                             //关闭socket
  47.                             //.....
  48.                         }
  49.                     }
  50.                 };
  51.                 ScheduledExecutorService service = Executors
  52.                         .newSingleThreadScheduledExecutor();
  53.                 // 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间
  54.                 service.scheduleAtFixedRate(runnable, 2, 10, TimeUnit.SECONDS);  */
  55.             }
  56.         } catch (IOException e) {
  57.             // TODO Auto-generated catch block
  58.             e.printStackTrace();
  59.         } finally {
  60.             System.out.println("serverSocket已超时");
  61.             try {
  62.                 socket.close();
  63.                 serverSocket.close();
  64.             } catch (IOException e) {
  65.                 // TODO Auto-generated catch block
  66.                 e.printStackTrace();
  67.             }
  68.  
  69.         }
  70.     }
  71.  
  72. }

SocketThread类实现多线程通信

  1. package com.orange.util;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9.  
  10. /**
  11.  * SocketThread实现多线程通信
  12.  *
  13.  * @author Administrator
  14.  *
  15.  */
  16. public class SocketThread extends Thread {
  17.  
  18. 	ServerSocket serverSocket = null;
  19.  
  20. 	Socket socket = null;
  21.  
  22. 	public SocketThread(ServerSocket serverSocket,Socket socket) {
  23. 		super();
  24. 		this.serverSocket = serverSocket;
  25. 		this.socket = socket;
  26. 	}
  27.  
  28. 	public SocketThread(Socket socket) {
  29. 		super();
  30. 		this.socket = socket;
  31. 	}
  32.  
  33. 	public void out(String out) {
  34.         try {
  35.             socket.getOutputStream().write(out.getBytes("utf-8"));
  36.         } catch (IOException e) {
  37.             e.printStackTrace();
  38.         }
  39.     }
  40.  
  41. 	public void publish(String out){
  42. 		ChatManager.getChatManager().publish(this, out);
  43. 	}
  44.  
  45. 	@Override
  46. 	public void run() {
  47. 		// TODO Auto-generated method stub
  48. 		BufferedReader socketIn = null;
  49. 		PrintWriter socketOut = null;
  50. 		String inMess = null;
  51. 		try {
  52. 			socketIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  53. 			socketOut = new PrintWriter(socket.getOutputStream());
  54. 			while (true) {
  55. 				inMess = socketIn.readLine();
  56. 				publish(inMess);
  57. 				if("bye".equals(inMess)){
  58. 					ChatManager.getChatManager().remove(this);
  59. 				}
  60. 			}
  61. 		} catch (IOException e) {
  62. 			// TODO Auto-generated catch block
  63. 			e.printStackTrace();
  64. 		} finally {
  65. 			try {
  66. 				System.out.println("已结束当前会话");
  67. 				socketOut.close();
  68. 				socketIn.close();
  69. 				socket.close();
  70. 			} catch (IOException e) {
  71. 				// TODO Auto-generated catch block
  72. 				e.printStackTrace();
  73. 			}
  74. 		}
  75.  
  76. 	}
  77.  
  78. }

　　单例Chatmanage，对所有客户端线程管控处理

  1. package com.orange.util;
  2.  
  3. import java.util.Vector;
  4.  
  5. public class ChatManager {
  6.     // 实现单例化
  7.     private ChatManager() {
  8.     };
  9.  
  10.     private static final ChatManager cm = new ChatManager();
  11.  
  12.     public static ChatManager getChatManager() {// 返回值为ChatManager
  13.         return cm;
  14.     }
  15.  
  16.     // 单例化完成
  17.     Vector<SocketThread> vector = new Vector<SocketThread>();
  18.  
  19.     public void add(SocketThread st) {// 为当前集合添加SocketThread对象
  20.         vector.add(st);
  21.     }
  22.  
  23.     public void remove(SocketThread st) {// 当前客户端关闭连接
  24.         vector.remove(st);
  25.     }
  26.  
  27.     public void removeall() {// 关闭所有连接
  28.         for (int i = 0; i < vector.size(); i++) {// 遍历所有的线程
  29.             SocketThread csChatSocket = vector.get(i);
  30.             if(csChatSocket!=null){
  31.                 vector.remove(csChatSocket);
  32.             }
  33.  
  34.         }
  35.     }
  36.  
  37.     // 某一个线程向其他的客户端发送信息
  38.     public void publish(SocketThread st, String out) {
  39.         for (int i = 0; i < vector.size(); i++) {// 遍历所有的线程
  40.             SocketThread csChatSocket = vector.get(i);
  41.             if (csChatSocket != st)// 判断不是当前线程就发送此消息
  42.                 csChatSocket.out(out + "\n");
  43.         }
  44.     }
  45.  
  46.     // 向当前线程发信息
  47.     public void publish_present(SocketThread st, String out) {
  48.         st.out(out + "\n");
  49.     }
  50. }

至此，服务器搭建完成

2.客户端（创建两个客户端）

客户端1（监听指定服务器，通过控制台输入消息进行服务器与客户端以及客户端之间的通信，）

  1. package com.orange;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  8. import java.net.UnknownHostException;
  9.  
  10. /**
  11.  * 客户端1
  12.  * @author Chengjq
  13.  *
  14.  */
  15. public class SocketClient1 {
  16.  
  17. 	@SuppressWarnings("static-access")
  18. 	public static void main(String[] args) {
  19. 		try {
  20. 			//初始化客户端
  21. 			Socket socket = new Socket("127.0.0.1", 4404);
  22. 			BufferedReader readline = new BufferedReader(new InputStreamReader(System.in));
  23. 			//获取输出打印流
  24. 			PrintWriter socketOut = new PrintWriter(socket.getOutputStream());
  25. 			String outTemp = null;
  26. 			System.out.println("开始准备向服务器端发起请求---\n自己:");
  27. 			// 已启动连接socket服务器，准备实时接收来自其他客户端的消息
  28. 			GetMess getMess = new GetMess(socket);
  29. 			getMess.start();
  30. 			// 通过控制台发送消息给其他客户端，以“bye”为结束语
  31. 			while ((outTemp = readline.readLine()) != null) {
  32. 				//发送信息
  33. 				socketOut.println(outTemp);
  34. 				socketOut.flush();
  35. 				if("bye".equals(outTemp)){
  36. 					break;
  37. 				}
  38. 			}
  39. 			getMess.currentThread().interrupt();
  40. 			//依次关闭各种流
  41. 			readline.close();
  42. 			socketOut.close();
  43. 			socket.close();
  44. 		} catch (UnknownHostException e) {
  45. 			// TODO Auto-generated catch block
  46. 			e.printStackTrace();
  47. 		} catch (IOException e) {
  48. 			// TODO Auto-generated catch block
  49. 			e.printStackTrace();
  50. 		}
  51.  
  52. 	}
  53. }

　　客户端2

  1. package com.orange;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  8. import java.net.UnknownHostException;
  9.  
  10. public class SocketClient2 {
  11.     @SuppressWarnings("static-access")
  12.     public static void main(String[] args) {
  13.  
  14.         try {
  15.             //初始化客户端
  16.             Socket socket = new Socket("127.0.0.1", 4404);
  17.             BufferedReader readline = new BufferedReader(new InputStreamReader(System.in));
  18.             //获取输出打印流
  19.             PrintWriter socketOut = new PrintWriter(socket.getOutputStream());
  20.             String outTemp = null;
  21.             System.out.println("开始准备向服务器端发起请求---\n自己:");
  22.             // 已启动连接socket服务器，准备实时接收来自其他客户端的消息
  23.             GetMess getMess = new GetMess(socket);
  24.             getMess.start();
  25.             // 通过控制台发送消息给其他客户端，以“bye”为结束语
  26.             while ((outTemp = readline.readLine()) != null) {
  27.                 //发送信息
  28.                 socketOut.println(outTemp);
  29.                 socketOut.flush();
  30.                 if("bye".equals(outTemp)){
  31.                     break;
  32.                 }
  33.             }
  34.             getMess.currentThread().interrupt();
  35.             //依次关闭各种流
  36.             readline.close();
  37.             socketOut.close();
  38.             socket.close();
  39.         } catch (UnknownHostException e) {
  40.             // TODO Auto-generated catch block
  41.             e.printStackTrace();
  42.         } catch (IOException e) {
  43.             // TODO Auto-generated catch block
  44.             e.printStackTrace();
  45.         }
  46.  
  47.     }
  48. }

GetMess（多线程处理获取其他客户端的消息并且展示）

  1. package com.orange;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.net.Socket;
  8.  
  9. public class GetMess extends Thread {
  10.  
  11.     Socket socket = null;
  12.  
  13.     public GetMess(Socket socket) {
  14.         super();
  15.         this.socket = socket;
  16.     }
  17.  
  18.     @Override
  19.     public void run() {
  20.         // TODO Auto-generated method stub
  21.         BufferedReader socketIn = null;
  22.         try {
  23.             InputStream is = socket.getInputStream();
  24.             InputStreamReader isr = new InputStreamReader(is);
  25.             socketIn = new BufferedReader(isr);
  26.             String inTemp = null;
  27.             while(true){
  28.                 inTemp = socketIn.readLine();
  29.                 if(inTemp != null && !"bye".equals(inTemp) ){
  30.                     System.out.println("好友:\n"+inTemp);
  31.                 }else{
  32.                     System.out.println("好友:\n已下线，关闭当前回话");
  33.                     break;
  34.                 }
  35.             }
  36.         } catch (IOException e) {
  37.             // TODO Auto-generated catch block
  38.             e.printStackTrace();
  39.         }finally {
  40.             try {
  41.                 Thread.currentThread().interrupt();
  42.                 socketIn.close();
  43.             } catch (IOException e) {
  44.                 // TODO Auto-generated catch block
  45.                 e.printStackTrace();
  46.             }
  47.  
  48.         }
  49.  
  50.     }
  51.  
  52. }

ok，简单的sockte服务与客户端完成了

先启动server

在分别启动client

输入结束bye,关闭当前会话

简单的socket编程的更多相关文章

  1. linux网络编程1 最简单的socket编程

    下面是socket编程的服务器端 先看一个图,1 #include<stdio.h> #include<stdlib.h> #include<string.h> # ...

  2. python 简单的Socket编程

    python 编写server的步骤: 1第一步是创建socket对象.调用socket构造函数.如: socket = socket.socket(family, type ) family参数代表 ...

  3. Java 简单的 socket 编程入门实战

    这个是给女朋友写的:) 首先需要知道我们每个电脑都可以成为server(服务器) 和 client(客户端) 我们需要使用java来实现客户端与服务器的数据传输 先帖上代码 注意这里两张代码处于两个j ...

  4. Linux Socket编程

    “一切皆Socket!” 话虽些许夸张,但是事实也是,现在的网络编程几乎都是用的socket. ——有感于实际编程和开源项目研究. 我们深谙信息交流的价值,那网络中进程之间如何通信,如我们每天打开浏览 ...

  5. Linux Socket编程（不限Linux）【转】

    转自:http://www.cnblogs.com/skynet/archive/2010/12/12/1903949.html “一切皆Socket!” 话虽些许夸张,但是事实也是,现在的网络编程几 ...

  6. SOCKet 编程 简介

    “一切皆Socket!” 话虽些许夸张,但是事实也是,现在的网络编程几乎都是用的socket. ——有感于实际编程和开源项目研究. 我们深谙信息交流的价值,那网络中进程之间如何通信,如我们每天打开浏览 ...

  7. Linux Socket编程（不限Linux）

    "一切皆Socket!" 话虽些许夸张,但是事实也是,现在的网络编程几乎都是用的socket. --有感于实际编程和开源项目研究. 我们深谙信息交流的价值,那网络中进程之间如何通信 ...

  8. socket编程（Linux）

    “一切皆Socket!” 话虽些许夸张,但是事实也是,现在的网络编程几乎都是用的socket. ——有感于实际编程和开源项目研究. 我们深谙信息交流的价值,那网络中进程之间如何通信,如我们每天打开浏览 ...

  9. socket编程：客户端与服务器间的连接以及各函数的用法

    在认真的看UNP之前,一直被socket编程说的云里雾里,今天我要让大家从整天上认识socket编程,让我们知道socket编程的整个流程和各个函数的用法.这样:我们在写一些简单的socket编程时就 ...

随机推荐

  1. Alpha版本检测报告

    1.Alpha版本测试报告 发布一篇随笔,作为项目的测试报告,内容包括: (1)测试计划 测试人员 工作安排 覃一霸 编写测试报告 张江波 执行测试.截图测试结果 测试功能 功能 描述 效果 结果 登 ...

  2. HTML5 Canvas ( 填充图形的绘制 ) closePath, fillStyle, fill

    <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title> ...

  3. 数学公式 AS3应用

    普通做法: var pA:Point=new Point(100,100); var pB:Point=new Point(300,200); var dx:Number=pA.x-pB.x; var ...

  4. 基于HttpClient的HttpUtils(后台访问URL)

    最近做在线支付时遇到需要以后台方式访问URL并获取其返回的数据的问题,在网络上g了一把,发现在常用的还是Apache的HttpClient.因为以经常要用到的原故,因此我对其进行了一些简单的封装,在此 ...

  5. clientdataset 用法

    http://www.360doc.com/content/10/0709/01/2071424_37769962.shtml

  6. Maven的配置以及IDEA导入本地Maven

    1.首先看你的电脑jdk的环境变量是否配成功 2.Maven的下载地址:http://maven.apache.org/download.cgi 3.下载完成后解压到你要安装的目录,我的是直接放在D: ...

  7. liblas 1.8.1编译安装

    liblas https://github.com/libLAS/libLAS/issues/102 https://liblas.org/start.html 源码 https://github.c ...

  8. nginx-----惹不起的端口修改

    1,查看端口是否被占用 打开CMD,输入输入netstat -aon | findstr :80 出现: TCP    0.0.0.0:80             0.0.0.0:0        ...

  9. Away3D 学习笔记(一): 加载3DS格式的模型文件

    加载外部的3DS文件分为两种: 1: 模型与贴图独立于程序的,也就是从外部的文件夹中读取 private function load3DSFile():Loader3D { loader = new ...

  10. oozie错误：javax.servlet.jsp.el.ELException: variable [***] cannot be resolved

    完整错误: javax.servlet.jsp.el.ELException: variable [compute] cannot be resolved at org.apache.oozie.ut ...