socket

最新推荐文章于 2019-09-12 17:57:13 发布
转载 最新推荐文章于 2019-09-12 17:57:13 发布 · 562 阅读 · 0

 今天终于有时间来实践一下Java socket的使用方法了，需要注意几个问题：

(1)、使用socket.getInputStream 读取数据时，该方法是阻塞方法，即如果管道流中没有数据时，使用inputStream.read(byte)是会一直阻塞，所以如果想要使用inputStream.read(new byte[]) > 0 来结束

循环是行不通的；

（2）、由于我的目的是不停的交互数据，所以不能IO流关闭，也不能把socket会话关闭，否则数据交换就会停止。

贴代码做记录：

1、服务端代码：

001package com.server;
002 
003import java.io.IOException;
004import java.io.InputStream;
005import java.io.OutputStream;
006import java.net.ServerSocket;
007import java.net.Socket;
008 
009import com.base.Constant;
010 
011public class ServerMain {
012    /**
013     * @param args
014     */
015    public static void main(String[] args) {
016        ServerSocket serverSocket = null;
017        System.out.println("ServerSocket Begin........");
018        int num = 0;
019        try {
020                serverSocket = new ServerSocket(Constant.PORT);
021                //使用循环方式一直等待客户端的连接
022                while(true){
023                    num ++;
024                    Socket accept = serverSocket.accept();
025                    //启动一个新的线程，接管与当前客户端的交互会话
026                    new Thread(new ServerThread(accept),"Client "+num).start();
027                }
028        } catch (IOException e) {
029            e.printStackTrace();
030        }
031        finally{
032            try {
033                serverSocket.close();
034                System.out.println("---->  serverSocket closed.");
035            } catch (IOException e) {
036                e.printStackTrace();
037            }
038        }
039    }
040}
041/**
042 * @author JCC
043 * 服务器处理客户端会话的线程
044 */
045class ServerThread implements Runnable {
046     
047    Socket socket = null;
048    public ServerThread(Socket socket){
049        System.out.println("Create a new ServerThread...");
050        this.socket = socket;
051    }
052 
053    @Override
054    public void run() {
055        InputStream in = null;
056        OutputStream out = null;
057        try {
058            in = socket.getInputStream();
059            out  = socket.getOutputStream();
060            //使用循环的方式，不停的与客户端交互会话
061            while(true){
062                try {
063                    Thread.sleep(1000);
064                } catch (InterruptedException e) {
065                    e.printStackTrace();
066                }
067                //处理客户端发来的数据
068                doRead(in);
069                System.out.println("send Message to client.");
070                //发送数据回客户端
071                doWrite(out);
072            }
073             
074        } catch (IOException e) {
075            e.printStackTrace();
076        }
077        finally{
078            try {
079                in.close();
080                out.close();
081            } catch (IOException e) {
082                // TODO Auto-generated catch block
083                e.printStackTrace();
084            }
085        }
086    }
087     
088    /**
089     * 读取数据
090     * @param in
091     * @return
092     */
093    public boolean doRead(InputStream in){
094        //引用关系，不要在此处关闭流
095        try {
096            byte[] bytes = new byte[in.available()];
097            in.read(bytes);
098            System.out.println("line:"+new String(bytes).trim());
099        } catch (IOException e) {
100            e.printStackTrace();
101        }
102         
103        return true;
104    }
105     
106    /**
107     * 写入数据
108     * @param out
109     * @return
110     */
111    public boolean doWrite(OutputStream out){
112        //引用关系，不要在此处关闭流
113        try {
114            out.write("welcome you client.".getBytes());
115            out.flush();       
116        } catch (IOException e) {
117            // TODO Auto-generated catch block
118            e.printStackTrace();
119        }
120        return true;
121    }
122}

 

2、客户端代码：

001package com.client;
002 
003import java.io.IOException;
004import java.io.InputStream;
005import java.io.OutputStream;
006import java.net.Socket;
007import java.net.UnknownHostException;
008 
009import com.base.Constant;
010 
011class ClientMain {
012    /**
013     * @param args
014     */
015    public static void main(String[] args) {
016        Socket socket = null;
017        System.out.println("ClientSocket Begin........");
018        try {
019            for(int i = 0;i<5;i++){
020                socket = new Socket(Constant.SERVER_IP,Constant.PORT);
021                new Thread(new ClientThread(socket,i),"ClientThread "+i).start();
022            }
023             
024        } catch (UnknownHostException e) {
025            e.printStackTrace();
026        } catch (IOException e) {
027            e.printStackTrace();
028        }
029    }
030     
031     
032}
033 
034/**
035 * 客户端线程
036 * @author JCC
037 *
038 */
039class ClientThread implements Runnable{
040    Socket socket = null;
041    int id = 0;
042    public ClientThread(Socket socket,int id){
043        this.socket = socket;
044        this.id = id;
045    }
046    @Override
047    public void run() {
048        OutputStream out = null;
049        InputStream in = null;
050        System.out.println("Begin to Chat to server...");
051        try {
052            out = socket.getOutputStream();
053            in = socket.getInputStream();
054            //循环发送与服务端不停的交互数据
055            while(true){
056                try {
057                    Thread.sleep(1000);
058                } catch (InterruptedException e) {
059                    e.printStackTrace();
060                }
061                doWrite(out);
062                System.out.println("begin read message from server.");
063                doRead(in);
064            }
065             
066        } catch (IOException e) {
067            e.printStackTrace();
068        }
069        finally{
070            try {
071                in.close();
072                out.close();
073            } catch (IOException e) {
074                e.printStackTrace();
075            }
076        }
077    }
078     
079    /**
080     * 读取服务端数据
081     * @param in
082     * @return
083     */
084    public static boolean doRead(InputStream in){
085        //引用关系，不要在此处关闭流
086        byte[] bytes = new byte[1024];
087        try {
088            in.read(bytes);
089            System.out.println("line:"+new String(bytes).trim());
090        } catch (IOException e) {
091            e.printStackTrace();
092        }
093         
094        return true;
095    }
096     
097    /**
098     * 发送数据到服务端
099     * @param out
100     * @return
101     */
102    public boolean doWrite(OutputStream out){
103        //引用关系，不要在此处关闭流
104        String line = "Hello server, I am client = "+id +"\n";
105        line = line +"I want you to do something for me";
106        try {
107            out.write(line.getBytes());
108            out.flush();       
109        } catch (IOException e) {
110            e.printStackTrace();
111        }
112        return true;
113    }
114}

 

3、常量类：

1package com.base;
2 
3public interface Constant {
4 
5    public static final  String SERVER_IP = "192.168.1.44";
6    public static final int PORT = 4567;
7}

 

执行结果：

（1）服务端结果：

01ServerSocket Begin........
02Create a new ServerThread...
03Create a new ServerThread...
04Create a new ServerThread...
05Create a new ServerThread...
06Create a new ServerThread...
07line:
08send Message to client.
09line:
10send Message to client.
11line:
12send Message to client.
13line:Hello server, I am client = 3
14I want you to do something for me
15send Message to client.
16line:Hello server, I am client = 4
17I want you to do something for me
18send Message to client.
19line:Hello server, I am client = 0
20I want you to do something for me
21send Message to client.
22line:Hello server, I am client = 1
23I want you to do something for me
24send Message to client.
25line:Hello server, I am client = 2
26I want you to do something for me
27send Message to client.
28line:
29send Message to client.
30line:
31send Message to client.
32line:Hello server, I am client = 0
33I want you to do something for me
34send Message to client.
35line:Hello server, I am client = 1
36I want you to do something for me
37send Message to client.
38line:Hello server, I am client = 2
39I want you to do something for me
40send Message to client.
41line:Hello server, I am client = 3
42I want you to do something for me
43send Message to client.
44line:Hello server, I am client = 4
45I want you to do something for me
46send Message to client.
47line:Hello server, I am client = 0
48I want you to do something for me
49send Message to client.

（2）客户端结果：

01ClientSocket Begin........
02Begin to Chat to server...
03Begin to Chat to server...
04Begin to Chat to server...
05Begin to Chat to server...
06Begin to Chat to server...
07begin read message from server.
08line:welcome you client.
09begin read message from server.
10line:welcome you client.
11begin read message from server.
12line:welcome you client.
13begin read message from server.
14line:welcome you client.
15begin read message from server.
16line:welcome you client.
17begin read message from server.
18line:welcome you client.
19begin read message from server.
20line:welcome you client.
21begin read message from server.
22line:welcome you client.
23begin read message from server.
24line:welcome you client.
25begin read message from server.
26line:welcome you client.
27begin read message from server.
28line:welcome you client.
29begin read message from server.
30line:welcome you client.
31begin read message from server.
Socket通信原理
aolizhi4552的博客
07-29 845
对TCP/IP、UDP、Socket编程这些词你不会很陌生吧？随着网络技术的发展，这些词充斥着我们的耳朵。那么我想问：1.什么是TCP/IP、UDP？2.Socket在哪里呢？3.Socket是什么呢？4.你会使用它们吗？什么是TCP/IP、UDP？ TCP/IP（Transmission Co...
记一次Socket通信InputStream中数据读取不完整踩坑
weixin_43861609的博客
04-13 3580
记一次Socket通信InputStream中数据读取不完整踩坑 问题代码： String message="ceshibaowen"; Socket socket=new Socket(socketIP,socketPort); socket.setSoTimeout(120000); DataInputStream in=new DataInputStream(socket.getInputStream()); OutputStream out=socket.getOutputStream(); out
Java Socket正确读取数据姿势
Kelly
09-12 2万+
前言 平时日常开发用得最多是Http通讯，接口调试也比较简单的，也有比较强大的框架支持（OkHttp）。 个人平时用到socket通讯的地方是Android与外设通讯，Android与ssl服务通讯，这种都是基于TCP/IP通讯，而且服务端和设备端协议都是不能修改的，只能按照相关报文格式进行通信。 但使用socket通讯问题不少，一般有两个难点： socket通讯层要自己写及IO流不正确使用，遇......
Java socket ， 服务端与客户端多线程交互
amornio
05-24 250
Socket服务端，用一个池对象来保存SocketServer接收到的socket链接。 实现过程中注意 接收客户端连接,只要客户端进行了连接,就会触发accept();从而建立连接。如下： socket=serverSocket.accept(); 此时需要new Handler(socket)一个对象，并将其放入线程池中。如下： executorService.exe...
C#高性能大容量SOCKET并发完成端口例子（有C#客户端）完整实例源码
06-08
例子主要包括SocketAsyncEventArgs通讯封装、服务端实现日志查看、SCOKET列表、上传、下载、远程文件流、吞吐量协议，用于测试SocketAsyncEventArgs的性能和压力，最大连接数支持65535个长连接，最高命令交互速度...
SocketTool4下载 socket安装包下载windows sockettool v4
03-27
socket工具，socketTool v4版本
Socket测试工具 设置服务端，发送socket报文
07-24
Socket测试工具 设置服务端，发送socket报文 Socket测试工具 设置服务端，发送socket报文 Socket测试工具 设置服务端，发送socket报文
Socket调试助手，该助手可用于调试socket通信，包含socket客户端，socket服务器，udp客户端，udp服务器
10-28
Socket调试助手，该助手可用于调试socket通信，包含socket客户端，socket服务器，udp客户端，udp服务器
SocketTool，网络调试助手
最新发布
07-09
SocketTool，网络调试助手
Socket编程--客户端InputStream数据读取
csyyj的专栏
12-04 1万+
问题描述：用java编写一个客户端程序连接指定的IP和端口，一直收不到目标地址返回数据。 运行下面的代码收不到返回数据：（这段代码应该写在一个线程里）                     BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
socket.getInputStream().read方法的疑问
12-30 861
背景：之前三星5.0手机会出现网络断开的现象，其他手机没有问题。之前疑问如下，可以不关注。 http://bbs.youkuaiyun.com/topics/391070063 现在，调查出socket.getInputStream.read(buffer[])的时候，返回-1，然后socket连接就不可用了。所以出现问题。 客户端连接服务器代码（和服务器端连接一直存在）： socket.c
常见的socket出错总结
qq_22613757的博客
09-10 3129
转载：https://blog.youkuaiyun.com/epeaktop/article/details/48714435 常见错误                      ECONNREFUSED(111):   没有这个端口             EAGAIN(11):                      buff已满             EPIPE(32):        ...
java socket服务器 ，socket.getInputStream()读取时阻塞
yunyexiangfeng的博客
03-13 1万+
贴代码：public static void main(String[] args){ MessageDeal deal = new MessageDeal(); deal.init(); } public void init(){ try { ServerSocket serverSocket = new Se...
Socket 的方法 getOutputStream() 和 getInputStream()
热门推荐
u011951979的博客
09-03 2万+
一个非常简单的客户端程序：import java.io.*; import java.net.*;public class DailyAdviceClient { public void go() { try { Socket s = new Socket("127.0.0.1", 5000); InputStreamReade
Java Socket编程基础
"Java+Socket 教程，深入解析Java中的Socket编程技术" 在Java编程中，Socket是一种网络通信机制，允许两台计算机之间进行数据交换。本教程由developerWorks提供，旨在帮助开发者掌握Java中Socket的基础知识和实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值