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 ...