java socket发送数据包给 c socket成功,然后c socket发送包回来给java socket,可是偏偏收不到。而且我使用防火墙来查看本机截获的数据包,确定看到c socket发送过来的包。
所以说明,c socket方面的程序是没有问题的。问题应该处在 java socket上,可是我这个java socket客户端 也和java socket写的服务端连接通讯过啊,收发都很正常啊。难道java 连接其他的socket有特殊设置的地方么?
以下是我java 程序中收包的代码:
socket = new Socket("127.0.0.1",8080);
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String msg = in.readLine();//程序到此就停止不运行了
System.out.println(msg);
47 个解决方案
#1
String msg = in.readLine();//程序到此就停止不运行了
表示你的socket没有接收到数据。
你的socket没有抛出异常吗?
表示你的socket没有接收到数据。
你的socket没有抛出异常吗?
#2
没有任何异常,所以我就纳闷啊
#3
用C端多发几次,或者多发些内容,看看java端能不能受到
#4
这个东西,让我来看看
#5
sc = (SocketConnection) Connector.open("socket://localhost:"+PORT);
si.setText("Connected to server");
dis = sc.openDataInputStream();
dos = sc.openDataOutputStream();
这样试试
si.setText("Connected to server");
dis = sc.openDataInputStream();
dos = sc.openDataOutputStream();
这样试试
#6
1. Server program source
// Server.java
import java.net.*;
import java.io.*;
public class Server
{
ServerSocket server;
DataOutputStream output;
Socket socket;
public Server (){
try{
// create a server on port 5000
server=new ServerSocket(5000);
// display interactive informaion
System.out.println("Server created.");
System.out.println("waiting for client to connect on...");
// waiting for client to connect on...
socket = server.accept();
// client connected
System.out.println("client connected.\nShutdown!");
output = new DataOutputStream(socket.getOutputStream());
output.writeUTF("Welcome to Server.Bye!");
output.close();
server.close();
}
catch(SocketException e){
System.out.println(e.toString());
e.printStackTrace();
System.exit(1);
}
catch(IOException e){
System.out.println(e.toString());
e.printStackTrace();
System.exit(1);
}
}
public static void main(String args[]){
Server game=new Server();
}
}
2. Application Client program source
// Client.java
import java.io.*;
import java.net.*;
public class Client {
public static void main(String args[]) {
try{
if (args.length != 1){
System.out.println("USAGE: java Client servername");
return;
}
String connectto= args[0];
Socket connection;
// connect to server
if(connectto.equals("localhost")){
connection=new Socket(InetAddress.getLocalHost(),5000);
}
else{
connection=new Socket(InetAddress.getByName(connectto),5000);
}
DataInputStream input=new DataInputStream(connection.getInputStream());
// read information from server
String info;
info = input.readUTF();
System.out.println(info);
connection.close();
}
catch(SecurityException e){
System.out.println("SecurityException when connecting Server!");
}
catch(IOException e){
System.out.println("IOException when connecting Server!");
}
}
}
// Server.java
import java.net.*;
import java.io.*;
public class Server
{
ServerSocket server;
DataOutputStream output;
Socket socket;
public Server (){
try{
// create a server on port 5000
server=new ServerSocket(5000);
// display interactive informaion
System.out.println("Server created.");
System.out.println("waiting for client to connect on...");
// waiting for client to connect on...
socket = server.accept();
// client connected
System.out.println("client connected.\nShutdown!");
output = new DataOutputStream(socket.getOutputStream());
output.writeUTF("Welcome to Server.Bye!");
output.close();
server.close();
}
catch(SocketException e){
System.out.println(e.toString());
e.printStackTrace();
System.exit(1);
}
catch(IOException e){
System.out.println(e.toString());
e.printStackTrace();
System.exit(1);
}
}
public static void main(String args[]){
Server game=new Server();
}
}
2. Application Client program source
// Client.java
import java.io.*;
import java.net.*;
public class Client {
public static void main(String args[]) {
try{
if (args.length != 1){
System.out.println("USAGE: java Client servername");
return;
}
String connectto= args[0];
Socket connection;
// connect to server
if(connectto.equals("localhost")){
connection=new Socket(InetAddress.getLocalHost(),5000);
}
else{
connection=new Socket(InetAddress.getByName(connectto),5000);
}
DataInputStream input=new DataInputStream(connection.getInputStream());
// read information from server
String info;
info = input.readUTF();
System.out.println(info);
connection.close();
}
catch(SecurityException e){
System.out.println("SecurityException when connecting Server!");
}
catch(IOException e){
System.out.println("IOException when connecting Server!");
}
}
}
#7
in.readLine();
你c socket发送了\n吗?
直接read(byte[] array)试试。
你c socket发送了\n吗?
直接read(byte[] array)试试。
#8
那极有可能是数据问题了,readLine()以'\n'结束,你做个循环,我原来是发'\0'给C,C就以为socket结束了,估计同理。
#9
哦,有兄弟回答了,按 ilovevc(ilovevc)说的试试吧
#10
按 ilovevc(ilovevc)说得方法,我这样子写了代码
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
#11
结果和对方发送过来的东西不一样啊,是需要进行什么转换么?
#12
String msg = in.readLine();//程序到此就停止不运行了
需要一个换行符才能结束,所以问题可能是你的 C socket 发送的数据中没有换行符.
所以这句就一直阻塞住,不能继续运行.
需要一个换行符才能结束,所以问题可能是你的 C socket 发送的数据中没有换行符.
所以这句就一直阻塞住,不能继续运行.
#13
按 ilovevc(ilovevc)说得方法,我这样子写了代码
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
结果和对方发送过来的东西不一样啊,是需要进行什么转换么?
是你两个程序使用的编码不一样, 你只要统一到一个字符编码就可以了, 比如 GBK
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
结果和对方发送过来的东西不一样啊,是需要进行什么转换么?
是你两个程序使用的编码不一样, 你只要统一到一个字符编码就可以了, 比如 GBK
#14
前面这个问题我已经解决,就是
再使用
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
读取c socket发送的数据时发现不对:
java socket收到的是:[C@192d342
而c socket发送的是:007408020101000000000000000000000000000032c847140856032e78537976368cea91e8
请问这是怎么回事?
再使用
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
读取c socket发送的数据时发现不对:
java socket收到的是:[C@192d342
而c socket发送的是:007408020101000000000000000000000000000032c847140856032e78537976368cea91e8
请问这是怎么回事?
#15
如何统一呢?
#16
你java打印出来的好像是地址。试试
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+ new String(cbuf));
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+ new String(cbuf));
#17
上面错了。你C那边显示的是二进制数据,不是string。
java不太熟悉,大概要搞个什么转换的函数将char显示成16进制格式。
java不太熟悉,大概要搞个什么转换的函数将char显示成16进制格式。
#18
我可以确定c socket发送过来的数据不是16进制,是一串10进制数字加英文字符
因为我在防火墙的包分析里面看到了这些数据
就是java socket显示不了
我使用如下办法也没有
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
String b=cbuf.toString();
String a=URLEncoder.encode(b,"UTF-8");
System.out.println("读取到的输入字符是:"+a);
因为我在防火墙的包分析里面看到了这些数据
就是java socket显示不了
我使用如下办法也没有
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
String b=cbuf.toString();
String a=URLEncoder.encode(b,"UTF-8");
System.out.println("读取到的输入字符是:"+a);
#19
暑假时做过类似的东西,要通过socket让两个程序通信,要先知道字节顺序
目前的字节顺序有两类:BIG_ENGIAN和LITTLE_ENDIAN
c端是用的是LITTLE_ENDIAN,而java使用的是LITTLE_ENDIAN,
所以你可以在c端做一个转换,或者java端做一个转换
目前的字节顺序有两类:BIG_ENGIAN和LITTLE_ENDIAN
c端是用的是LITTLE_ENDIAN,而java使用的是LITTLE_ENDIAN,
所以你可以在c端做一个转换,或者java端做一个转换
#20
是这样作么?
bytebuf.order(ByteOrder.LITTLE_ENDIAN); //按照LITTLE_ENDIAN字节序收发数据
具体如何转换呢?
能给你一个具体可用的例子么?
bytebuf.order(ByteOrder.LITTLE_ENDIAN); //按照LITTLE_ENDIAN字节序收发数据
具体如何转换呢?
能给你一个具体可用的例子么?
#21
应该是传递的数据格式和你接收的不一致
#22
最简单的办法就是在C那边的send字符串末尾加上'\n'
反正我使用这个没有问题。
反正我使用这个没有问题。
#23
我现在写成这种形式:
ByteBuffer bytebuf = ByteBuffer.allocate(2048); // 创建一个指定大小的缓冲区
bytebuf.order(ByteOrder.BIG_ENDIAN); //按照LITTLE_ENDIAN字节序收发数据BIG_ENDIAN
InetSocketAddress isa = new InetSocketAddress("192.168.0.2",7910);
SocketChannel sc = SocketChannel.open(); // 建立一个socket通道
Charset charset = Charset.forName("GBK"); // ???为对等方的编码名,java必须支持。
CharsetDecoder decoder = charset.newDecoder();
CharsetEncoder encoder = charset.newEncoder();
sc.connect( isa); // 建立一个socket连接
//System.out.println("收到的数据:"+bytebuf.toString());
sc.read(bytebuf); // 程序到此又走不下去了,一直等待,直到socket自动关闭
CharBuffer charbuf = decoder.decode(bytebuf);
System.out.println("收到的数据:"+charbuf);
ByteBuffer bytebuf = ByteBuffer.allocate(2048); // 创建一个指定大小的缓冲区
bytebuf.order(ByteOrder.BIG_ENDIAN); //按照LITTLE_ENDIAN字节序收发数据BIG_ENDIAN
InetSocketAddress isa = new InetSocketAddress("192.168.0.2",7910);
SocketChannel sc = SocketChannel.open(); // 建立一个socket通道
Charset charset = Charset.forName("GBK"); // ???为对等方的编码名,java必须支持。
CharsetDecoder decoder = charset.newDecoder();
CharsetEncoder encoder = charset.newEncoder();
sc.connect( isa); // 建立一个socket连接
//System.out.println("收到的数据:"+bytebuf.toString());
sc.read(bytebuf); // 程序到此又走不下去了,一直等待,直到socket自动关闭
CharBuffer charbuf = decoder.decode(bytebuf);
System.out.println("收到的数据:"+charbuf);
#24
tcp协议传输数据是以16进制的byte来传送的
所以
byte[] message = new byte[100];
in.read(message);
String trueMsg = new String(message,"GBK");
System.out.println(trueMsg);
如果以上传送的是中文编码的数据
那应该能打印出正常的文字了
To:qasdew(笑天狂客)
SocketChannel类虽然支持无阻塞模式,但默认还是处于阻塞模式,需要手动改为无阻塞模式
//设置工作模式为无阻塞模式
sc.configureBlocking(false);
所以
byte[] message = new byte[100];
in.read(message);
String trueMsg = new String(message,"GBK");
System.out.println(trueMsg);
如果以上传送的是中文编码的数据
那应该能打印出正常的文字了
To:qasdew(笑天狂客)
SocketChannel类虽然支持无阻塞模式,但默认还是处于阻塞模式,需要手动改为无阻塞模式
//设置工作模式为无阻塞模式
sc.configureBlocking(false);
#25
细想了一下,由于:“sc.read(bytebuf); // 程序到此又走不下去了,一直等待,直到socket自动关闭”。我们一般采用阻塞方式,那么可以肯定socket没有接收到数据。
请看一下是不是防火墙的缘故?
请看一下是不是防火墙的缘故?
#26
另外,C的char对应java的byte,其实我建议如果两端不是一种语言,java这端最好使用byte[]接收数据。前两天我才作了java与c之间的通信,不同的是服务器端是java,客户端是c。
http://community.csdn.net/Expert/topic/3680/3680350.xml?temp=.5349237
http://community.csdn.net/Expert/topic/3680/3680350.xml?temp=.5349237
#27
确定不是防火墙的原因.我认为是socket没有收到数据的缘故。
可能是c socket发送来的数据包中第一个字符为/n
可能是c socket发送来的数据包中第一个字符为/n
#28
有个软件叫sniffer
可以查看发送的封包内容
可以查看发送的封包内容
#29
比如:我要在c这边把int转换为big-endian放入流中
注:小端序就是内存的低地址存放的是数据的高字节,
可以这么做
static bool int2str(int n, char *buf)
{
buf[0] = char((n & 0xff000000) >> 24 buf[1] = char((n & 0x00ff0000) >> 16);
buf[2] = char((n & 0x0000ff00) >> 8);
buf[3] = char((n & 0x000000ff));
return true;
}
同样你要是想在java端转(把big-endian转为little-endian)
private void insertIntToByteArray(byte[] data,int i,int offset){
data[offset]==(byte)(i>>0);
data[offset+1]=(byte)(i>>8)
data[offset+2]=(byte)(i>>16)
data[offset+3]=(byte)(i>>24)
}
这样!
}
注:小端序就是内存的低地址存放的是数据的高字节,
可以这么做
static bool int2str(int n, char *buf)
{
buf[0] = char((n & 0xff000000) >> 24 buf[1] = char((n & 0x00ff0000) >> 16);
buf[2] = char((n & 0x0000ff00) >> 8);
buf[3] = char((n & 0x000000ff));
return true;
}
同样你要是想在java端转(把big-endian转为little-endian)
private void insertIntToByteArray(byte[] data,int i,int offset){
data[offset]==(byte)(i>>0);
data[offset+1]=(byte)(i>>8)
data[offset+2]=(byte)(i>>16)
data[offset+3]=(byte)(i>>24)
}
这样!
}
#30
我晕
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
Java 里数组是这样打印处理的吗?
自己使用循环打印吧!
另外,你可以先发送 byte 型数据试试,不要一来就使用 String ,把问题复杂化.
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
Java 里数组是这样打印处理的吗?
自己使用循环打印吧!
另外,你可以先发送 byte 型数据试试,不要一来就使用 String ,把问题复杂化.
#31
关注...
#32
while(true)
{
str=socket.readLine();
if (str!=null)
break;
}
我们一般是用这段代码来收信息的,你的程序从理论上来讲是没有问题的,关键是你在readLine()是时候是不是能够保证Server己经发过来信息了?计算机比你要快多了,这个时候你收的时候信息肯定没有到,而且你的Client又只收一遍就不管了,也就是说你的Client只接收Server第一次发过来的信息,以后的都不接收,所以你的Client就收不到信息了。
{
str=socket.readLine();
if (str!=null)
break;
}
我们一般是用这段代码来收信息的,你的程序从理论上来讲是没有问题的,关键是你在readLine()是时候是不是能够保证Server己经发过来信息了?计算机比你要快多了,这个时候你收的时候信息肯定没有到,而且你的Client又只收一遍就不管了,也就是说你的Client只接收Server第一次发过来的信息,以后的都不接收,所以你的Client就收不到信息了。
#33
另外java socket和c socket应该 有一个是Server 呀?楼主不会两个都是Client吧!
#34
我想知道你做的怎么样了!?
#35
能把你的代码发份给我么?我也遇到同样问题了
#36
你的C可能没有加“\n” 所以S停了,在C端上加上,就可了
#37
TO abcdhy(程旭):
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
这样打印是完全可以的,如果将char[] 转换为string,不能使用cbuf.tostring()这样的方法,否则将会得到乱码,必须使用string.valueof(cbuf),才会得到正确的字符串
使用String msg = in.readLine()来收包出现程序停止的问题的确是因为c socket发送过来的字符中似乎第一就是/n,所以程序就停止等待直到socket超时,如果采用int int_rec= in.read(cbuf);来读取的话就可以全部收取.
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
这样打印是完全可以的,如果将char[] 转换为string,不能使用cbuf.tostring()这样的方法,否则将会得到乱码,必须使用string.valueof(cbuf),才会得到正确的字符串
使用String msg = in.readLine()来收包出现程序停止的问题的确是因为c socket发送过来的字符中似乎第一就是/n,所以程序就停止等待直到socket超时,如果采用int int_rec= in.read(cbuf);来读取的话就可以全部收取.
#38
特别感谢 wjsfr(令狐葱) 的关注和支持.
通过这几天的研究发现,不管与任何socket通信,第一要清楚对方socket是基于字符还是比特传输的.如果基于字符传输,在java socket这一端就必须使用char[]来接受数据包,当然如果基于比特就使用byte[].
所以 wwalpha(尘埃) 说的tcp基于比特传输的说法也不完全对了.
正确的写法如下:
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
String b=String.valueOf(cbuf);
System.out.println("读取到的输入字符是:"+b);
如上书写代码,不但可以读取数据包,而且可以正确显示数据包的内容.
通过这个帖子大家给出了很多建议,我很感动,对于我这样的新手很有帮助,没想到关于socket编程还有很多东西可以研究,我都不舍得结这个贴,想和大家更加深入的讨论.
通过这几天的研究发现,不管与任何socket通信,第一要清楚对方socket是基于字符还是比特传输的.如果基于字符传输,在java socket这一端就必须使用char[]来接受数据包,当然如果基于比特就使用byte[].
所以 wwalpha(尘埃) 说的tcp基于比特传输的说法也不完全对了.
正确的写法如下:
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
String b=String.valueOf(cbuf);
System.out.println("读取到的输入字符是:"+b);
如上书写代码,不但可以读取数据包,而且可以正确显示数据包的内容.
通过这个帖子大家给出了很多建议,我很感动,对于我这样的新手很有帮助,没想到关于socket编程还有很多东西可以研究,我都不舍得结这个贴,想和大家更加深入的讨论.
#39
又出现了一个问题:
packet2="8277CDC61FCCCE51D5043DB06BB3268F";
char[] send_buf2=new char[32];
send_buf2=packet2.toCharArray();
out.println(send_buf2);//数据包发送完毕
out.flush();
这样发包过去,为什么对方总接收到在我包的末尾有回车?
packet2="8277CDC61FCCCE51D5043DB06BB3268F";
char[] send_buf2=new char[32];
send_buf2=packet2.toCharArray();
out.println(send_buf2);//数据包发送完毕
out.flush();
这样发包过去,为什么对方总接收到在我包的末尾有回车?
#40
收藏
#41
out.println(send_buf2);//数据包发送完毕
what about out.print(send_buf2)?
what about out.print(send_buf2)?
#42
呵呵.
println当然有换行了
println当然有换行了
#43
我也需要“java的socket客户端使用阻塞方式与一个c写的socket服务器通讯”,哪位有这方面的源代码可以共享?
#44
ding
#45
String msg = in.readLine();//程序到此就停止不运行了
当然停了,你是readline呀,发送的数据要有换行,你这编才接受的!
用InputStream的read吧!
当然停了,你是readline呀,发送的数据要有换行,你这编才接受的!
用InputStream的read吧!
#46
顺便请大家看看这个贴子, 关于POI的,谢谢.
http://community.csdn.net/Expert/topic/3706/3706109.xml?temp=.6670801
http://community.csdn.net/Expert/topic/3706/3706109.xml?temp=.6670801
#47
不用这么麻烦,只要在java传输中处理bytes[]就可以了。
Jclient.java:
public class Jclient {
public static void main(String[] args) {
Socket JavaSocket = null;
DataOutputStream os = null;
DataInputStream is =null;
try {
JavaSocket= new Socket("210.72.13.72",9734);
os = new DataOutputStream(JavaSocket.getOutputStream());
is = new DataInputStream(JavaSocket.getInputStream());
} catch (UnknownHostException e) {
System.err.println("Don't know about host");
} catch (IOException e) {
System.err.println("Couldn't get I/O for the connection to");
}
if (JavaSocket != null && os != null && is != null)
{
try {
String jcStr="this is Java 客户端 send string";
byte[] jcBytes =jcStr.getBytes();
os.write(jcBytes);//使用byte[]发送数据包
os.flush();
byte[] cbuf=new byte[8096];
is.read(cbuf);
String responseLine=new String(cbuf);
System.out.println("读取到的String是:"+responseLine);
os.close();
is.close();
JavaSocket.close();
} catch (UnknownHostException e) {
System.err.println("Trying to connect to unknown host: " + e);
} catch (IOException e) {
System.err.println("IOException: " + e);
}
}
}
}
Jclient.java:
public class Jclient {
public static void main(String[] args) {
Socket JavaSocket = null;
DataOutputStream os = null;
DataInputStream is =null;
try {
JavaSocket= new Socket("210.72.13.72",9734);
os = new DataOutputStream(JavaSocket.getOutputStream());
is = new DataInputStream(JavaSocket.getInputStream());
} catch (UnknownHostException e) {
System.err.println("Don't know about host");
} catch (IOException e) {
System.err.println("Couldn't get I/O for the connection to");
}
if (JavaSocket != null && os != null && is != null)
{
try {
String jcStr="this is Java 客户端 send string";
byte[] jcBytes =jcStr.getBytes();
os.write(jcBytes);//使用byte[]发送数据包
os.flush();
byte[] cbuf=new byte[8096];
is.read(cbuf);
String responseLine=new String(cbuf);
System.out.println("读取到的String是:"+responseLine);
os.close();
is.close();
JavaSocket.close();
} catch (UnknownHostException e) {
System.err.println("Trying to connect to unknown host: " + e);
} catch (IOException e) {
System.err.println("IOException: " + e);
}
}
}
}
#1
String msg = in.readLine();//程序到此就停止不运行了
表示你的socket没有接收到数据。
你的socket没有抛出异常吗?
表示你的socket没有接收到数据。
你的socket没有抛出异常吗?
#2
没有任何异常,所以我就纳闷啊
#3
用C端多发几次,或者多发些内容,看看java端能不能受到
#4
这个东西,让我来看看
#5
sc = (SocketConnection) Connector.open("socket://localhost:"+PORT);
si.setText("Connected to server");
dis = sc.openDataInputStream();
dos = sc.openDataOutputStream();
这样试试
si.setText("Connected to server");
dis = sc.openDataInputStream();
dos = sc.openDataOutputStream();
这样试试
#6
1. Server program source
// Server.java
import java.net.*;
import java.io.*;
public class Server
{
ServerSocket server;
DataOutputStream output;
Socket socket;
public Server (){
try{
// create a server on port 5000
server=new ServerSocket(5000);
// display interactive informaion
System.out.println("Server created.");
System.out.println("waiting for client to connect on...");
// waiting for client to connect on...
socket = server.accept();
// client connected
System.out.println("client connected.\nShutdown!");
output = new DataOutputStream(socket.getOutputStream());
output.writeUTF("Welcome to Server.Bye!");
output.close();
server.close();
}
catch(SocketException e){
System.out.println(e.toString());
e.printStackTrace();
System.exit(1);
}
catch(IOException e){
System.out.println(e.toString());
e.printStackTrace();
System.exit(1);
}
}
public static void main(String args[]){
Server game=new Server();
}
}
2. Application Client program source
// Client.java
import java.io.*;
import java.net.*;
public class Client {
public static void main(String args[]) {
try{
if (args.length != 1){
System.out.println("USAGE: java Client servername");
return;
}
String connectto= args[0];
Socket connection;
// connect to server
if(connectto.equals("localhost")){
connection=new Socket(InetAddress.getLocalHost(),5000);
}
else{
connection=new Socket(InetAddress.getByName(connectto),5000);
}
DataInputStream input=new DataInputStream(connection.getInputStream());
// read information from server
String info;
info = input.readUTF();
System.out.println(info);
connection.close();
}
catch(SecurityException e){
System.out.println("SecurityException when connecting Server!");
}
catch(IOException e){
System.out.println("IOException when connecting Server!");
}
}
}
// Server.java
import java.net.*;
import java.io.*;
public class Server
{
ServerSocket server;
DataOutputStream output;
Socket socket;
public Server (){
try{
// create a server on port 5000
server=new ServerSocket(5000);
// display interactive informaion
System.out.println("Server created.");
System.out.println("waiting for client to connect on...");
// waiting for client to connect on...
socket = server.accept();
// client connected
System.out.println("client connected.\nShutdown!");
output = new DataOutputStream(socket.getOutputStream());
output.writeUTF("Welcome to Server.Bye!");
output.close();
server.close();
}
catch(SocketException e){
System.out.println(e.toString());
e.printStackTrace();
System.exit(1);
}
catch(IOException e){
System.out.println(e.toString());
e.printStackTrace();
System.exit(1);
}
}
public static void main(String args[]){
Server game=new Server();
}
}
2. Application Client program source
// Client.java
import java.io.*;
import java.net.*;
public class Client {
public static void main(String args[]) {
try{
if (args.length != 1){
System.out.println("USAGE: java Client servername");
return;
}
String connectto= args[0];
Socket connection;
// connect to server
if(connectto.equals("localhost")){
connection=new Socket(InetAddress.getLocalHost(),5000);
}
else{
connection=new Socket(InetAddress.getByName(connectto),5000);
}
DataInputStream input=new DataInputStream(connection.getInputStream());
// read information from server
String info;
info = input.readUTF();
System.out.println(info);
connection.close();
}
catch(SecurityException e){
System.out.println("SecurityException when connecting Server!");
}
catch(IOException e){
System.out.println("IOException when connecting Server!");
}
}
}
#7
in.readLine();
你c socket发送了\n吗?
直接read(byte[] array)试试。
你c socket发送了\n吗?
直接read(byte[] array)试试。
#8
那极有可能是数据问题了,readLine()以'\n'结束,你做个循环,我原来是发'\0'给C,C就以为socket结束了,估计同理。
#9
哦,有兄弟回答了,按 ilovevc(ilovevc)说的试试吧
#10
按 ilovevc(ilovevc)说得方法,我这样子写了代码
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
#11
结果和对方发送过来的东西不一样啊,是需要进行什么转换么?
#12
String msg = in.readLine();//程序到此就停止不运行了
需要一个换行符才能结束,所以问题可能是你的 C socket 发送的数据中没有换行符.
所以这句就一直阻塞住,不能继续运行.
需要一个换行符才能结束,所以问题可能是你的 C socket 发送的数据中没有换行符.
所以这句就一直阻塞住,不能继续运行.
#13
按 ilovevc(ilovevc)说得方法,我这样子写了代码
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
结果和对方发送过来的东西不一样啊,是需要进行什么转换么?
是你两个程序使用的编码不一样, 你只要统一到一个字符编码就可以了, 比如 GBK
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
结果和对方发送过来的东西不一样啊,是需要进行什么转换么?
是你两个程序使用的编码不一样, 你只要统一到一个字符编码就可以了, 比如 GBK
#14
前面这个问题我已经解决,就是
再使用
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
读取c socket发送的数据时发现不对:
java socket收到的是:[C@192d342
而c socket发送的是:007408020101000000000000000000000000000032c847140856032e78537976368cea91e8
请问这是怎么回事?
再使用
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
读取c socket发送的数据时发现不对:
java socket收到的是:[C@192d342
而c socket发送的是:007408020101000000000000000000000000000032c847140856032e78537976368cea91e8
请问这是怎么回事?
#15
如何统一呢?
#16
你java打印出来的好像是地址。试试
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+ new String(cbuf));
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+ new String(cbuf));
#17
上面错了。你C那边显示的是二进制数据,不是string。
java不太熟悉,大概要搞个什么转换的函数将char显示成16进制格式。
java不太熟悉,大概要搞个什么转换的函数将char显示成16进制格式。
#18
我可以确定c socket发送过来的数据不是16进制,是一串10进制数字加英文字符
因为我在防火墙的包分析里面看到了这些数据
就是java socket显示不了
我使用如下办法也没有
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
String b=cbuf.toString();
String a=URLEncoder.encode(b,"UTF-8");
System.out.println("读取到的输入字符是:"+a);
因为我在防火墙的包分析里面看到了这些数据
就是java socket显示不了
我使用如下办法也没有
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
String b=cbuf.toString();
String a=URLEncoder.encode(b,"UTF-8");
System.out.println("读取到的输入字符是:"+a);
#19
暑假时做过类似的东西,要通过socket让两个程序通信,要先知道字节顺序
目前的字节顺序有两类:BIG_ENGIAN和LITTLE_ENDIAN
c端是用的是LITTLE_ENDIAN,而java使用的是LITTLE_ENDIAN,
所以你可以在c端做一个转换,或者java端做一个转换
目前的字节顺序有两类:BIG_ENGIAN和LITTLE_ENDIAN
c端是用的是LITTLE_ENDIAN,而java使用的是LITTLE_ENDIAN,
所以你可以在c端做一个转换,或者java端做一个转换
#20
是这样作么?
bytebuf.order(ByteOrder.LITTLE_ENDIAN); //按照LITTLE_ENDIAN字节序收发数据
具体如何转换呢?
能给你一个具体可用的例子么?
bytebuf.order(ByteOrder.LITTLE_ENDIAN); //按照LITTLE_ENDIAN字节序收发数据
具体如何转换呢?
能给你一个具体可用的例子么?
#21
应该是传递的数据格式和你接收的不一致
#22
最简单的办法就是在C那边的send字符串末尾加上'\n'
反正我使用这个没有问题。
反正我使用这个没有问题。
#23
我现在写成这种形式:
ByteBuffer bytebuf = ByteBuffer.allocate(2048); // 创建一个指定大小的缓冲区
bytebuf.order(ByteOrder.BIG_ENDIAN); //按照LITTLE_ENDIAN字节序收发数据BIG_ENDIAN
InetSocketAddress isa = new InetSocketAddress("192.168.0.2",7910);
SocketChannel sc = SocketChannel.open(); // 建立一个socket通道
Charset charset = Charset.forName("GBK"); // ???为对等方的编码名,java必须支持。
CharsetDecoder decoder = charset.newDecoder();
CharsetEncoder encoder = charset.newEncoder();
sc.connect( isa); // 建立一个socket连接
//System.out.println("收到的数据:"+bytebuf.toString());
sc.read(bytebuf); // 程序到此又走不下去了,一直等待,直到socket自动关闭
CharBuffer charbuf = decoder.decode(bytebuf);
System.out.println("收到的数据:"+charbuf);
ByteBuffer bytebuf = ByteBuffer.allocate(2048); // 创建一个指定大小的缓冲区
bytebuf.order(ByteOrder.BIG_ENDIAN); //按照LITTLE_ENDIAN字节序收发数据BIG_ENDIAN
InetSocketAddress isa = new InetSocketAddress("192.168.0.2",7910);
SocketChannel sc = SocketChannel.open(); // 建立一个socket通道
Charset charset = Charset.forName("GBK"); // ???为对等方的编码名,java必须支持。
CharsetDecoder decoder = charset.newDecoder();
CharsetEncoder encoder = charset.newEncoder();
sc.connect( isa); // 建立一个socket连接
//System.out.println("收到的数据:"+bytebuf.toString());
sc.read(bytebuf); // 程序到此又走不下去了,一直等待,直到socket自动关闭
CharBuffer charbuf = decoder.decode(bytebuf);
System.out.println("收到的数据:"+charbuf);
#24
tcp协议传输数据是以16进制的byte来传送的
所以
byte[] message = new byte[100];
in.read(message);
String trueMsg = new String(message,"GBK");
System.out.println(trueMsg);
如果以上传送的是中文编码的数据
那应该能打印出正常的文字了
To:qasdew(笑天狂客)
SocketChannel类虽然支持无阻塞模式,但默认还是处于阻塞模式,需要手动改为无阻塞模式
//设置工作模式为无阻塞模式
sc.configureBlocking(false);
所以
byte[] message = new byte[100];
in.read(message);
String trueMsg = new String(message,"GBK");
System.out.println(trueMsg);
如果以上传送的是中文编码的数据
那应该能打印出正常的文字了
To:qasdew(笑天狂客)
SocketChannel类虽然支持无阻塞模式,但默认还是处于阻塞模式,需要手动改为无阻塞模式
//设置工作模式为无阻塞模式
sc.configureBlocking(false);
#25
细想了一下,由于:“sc.read(bytebuf); // 程序到此又走不下去了,一直等待,直到socket自动关闭”。我们一般采用阻塞方式,那么可以肯定socket没有接收到数据。
请看一下是不是防火墙的缘故?
请看一下是不是防火墙的缘故?
#26
另外,C的char对应java的byte,其实我建议如果两端不是一种语言,java这端最好使用byte[]接收数据。前两天我才作了java与c之间的通信,不同的是服务器端是java,客户端是c。
http://community.csdn.net/Expert/topic/3680/3680350.xml?temp=.5349237
http://community.csdn.net/Expert/topic/3680/3680350.xml?temp=.5349237
#27
确定不是防火墙的原因.我认为是socket没有收到数据的缘故。
可能是c socket发送来的数据包中第一个字符为/n
可能是c socket发送来的数据包中第一个字符为/n
#28
有个软件叫sniffer
可以查看发送的封包内容
可以查看发送的封包内容
#29
比如:我要在c这边把int转换为big-endian放入流中
注:小端序就是内存的低地址存放的是数据的高字节,
可以这么做
static bool int2str(int n, char *buf)
{
buf[0] = char((n & 0xff000000) >> 24 buf[1] = char((n & 0x00ff0000) >> 16);
buf[2] = char((n & 0x0000ff00) >> 8);
buf[3] = char((n & 0x000000ff));
return true;
}
同样你要是想在java端转(把big-endian转为little-endian)
private void insertIntToByteArray(byte[] data,int i,int offset){
data[offset]==(byte)(i>>0);
data[offset+1]=(byte)(i>>8)
data[offset+2]=(byte)(i>>16)
data[offset+3]=(byte)(i>>24)
}
这样!
}
注:小端序就是内存的低地址存放的是数据的高字节,
可以这么做
static bool int2str(int n, char *buf)
{
buf[0] = char((n & 0xff000000) >> 24 buf[1] = char((n & 0x00ff0000) >> 16);
buf[2] = char((n & 0x0000ff00) >> 8);
buf[3] = char((n & 0x000000ff));
return true;
}
同样你要是想在java端转(把big-endian转为little-endian)
private void insertIntToByteArray(byte[] data,int i,int offset){
data[offset]==(byte)(i>>0);
data[offset+1]=(byte)(i>>8)
data[offset+2]=(byte)(i>>16)
data[offset+3]=(byte)(i>>24)
}
这样!
}
#30
我晕
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
Java 里数组是这样打印处理的吗?
自己使用循环打印吧!
另外,你可以先发送 byte 型数据试试,不要一来就使用 String ,把问题复杂化.
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
Java 里数组是这样打印处理的吗?
自己使用循环打印吧!
另外,你可以先发送 byte 型数据试试,不要一来就使用 String ,把问题复杂化.
#31
关注...
#32
while(true)
{
str=socket.readLine();
if (str!=null)
break;
}
我们一般是用这段代码来收信息的,你的程序从理论上来讲是没有问题的,关键是你在readLine()是时候是不是能够保证Server己经发过来信息了?计算机比你要快多了,这个时候你收的时候信息肯定没有到,而且你的Client又只收一遍就不管了,也就是说你的Client只接收Server第一次发过来的信息,以后的都不接收,所以你的Client就收不到信息了。
{
str=socket.readLine();
if (str!=null)
break;
}
我们一般是用这段代码来收信息的,你的程序从理论上来讲是没有问题的,关键是你在readLine()是时候是不是能够保证Server己经发过来信息了?计算机比你要快多了,这个时候你收的时候信息肯定没有到,而且你的Client又只收一遍就不管了,也就是说你的Client只接收Server第一次发过来的信息,以后的都不接收,所以你的Client就收不到信息了。
#33
另外java socket和c socket应该 有一个是Server 呀?楼主不会两个都是Client吧!
#34
我想知道你做的怎么样了!?
#35
能把你的代码发份给我么?我也遇到同样问题了
#36
你的C可能没有加“\n” 所以S停了,在C端上加上,就可了
#37
TO abcdhy(程旭):
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
这样打印是完全可以的,如果将char[] 转换为string,不能使用cbuf.tostring()这样的方法,否则将会得到乱码,必须使用string.valueof(cbuf),才会得到正确的字符串
使用String msg = in.readLine()来收包出现程序停止的问题的确是因为c socket发送过来的字符中似乎第一就是/n,所以程序就停止等待直到socket超时,如果采用int int_rec= in.read(cbuf);来读取的话就可以全部收取.
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
System.out.println("读取到的输入字符是:"+cbuf);
这样打印是完全可以的,如果将char[] 转换为string,不能使用cbuf.tostring()这样的方法,否则将会得到乱码,必须使用string.valueof(cbuf),才会得到正确的字符串
使用String msg = in.readLine()来收包出现程序停止的问题的确是因为c socket发送过来的字符中似乎第一就是/n,所以程序就停止等待直到socket超时,如果采用int int_rec= in.read(cbuf);来读取的话就可以全部收取.
#38
特别感谢 wjsfr(令狐葱) 的关注和支持.
通过这几天的研究发现,不管与任何socket通信,第一要清楚对方socket是基于字符还是比特传输的.如果基于字符传输,在java socket这一端就必须使用char[]来接受数据包,当然如果基于比特就使用byte[].
所以 wwalpha(尘埃) 说的tcp基于比特传输的说法也不完全对了.
正确的写法如下:
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
String b=String.valueOf(cbuf);
System.out.println("读取到的输入字符是:"+b);
如上书写代码,不但可以读取数据包,而且可以正确显示数据包的内容.
通过这个帖子大家给出了很多建议,我很感动,对于我这样的新手很有帮助,没想到关于socket编程还有很多东西可以研究,我都不舍得结这个贴,想和大家更加深入的讨论.
通过这几天的研究发现,不管与任何socket通信,第一要清楚对方socket是基于字符还是比特传输的.如果基于字符传输,在java socket这一端就必须使用char[]来接受数据包,当然如果基于比特就使用byte[].
所以 wwalpha(尘埃) 说的tcp基于比特传输的说法也不完全对了.
正确的写法如下:
char[] cbuf=new char[74];
int int_rec= in.read(cbuf);
String b=String.valueOf(cbuf);
System.out.println("读取到的输入字符是:"+b);
如上书写代码,不但可以读取数据包,而且可以正确显示数据包的内容.
通过这个帖子大家给出了很多建议,我很感动,对于我这样的新手很有帮助,没想到关于socket编程还有很多东西可以研究,我都不舍得结这个贴,想和大家更加深入的讨论.
#39
又出现了一个问题:
packet2="8277CDC61FCCCE51D5043DB06BB3268F";
char[] send_buf2=new char[32];
send_buf2=packet2.toCharArray();
out.println(send_buf2);//数据包发送完毕
out.flush();
这样发包过去,为什么对方总接收到在我包的末尾有回车?
packet2="8277CDC61FCCCE51D5043DB06BB3268F";
char[] send_buf2=new char[32];
send_buf2=packet2.toCharArray();
out.println(send_buf2);//数据包发送完毕
out.flush();
这样发包过去,为什么对方总接收到在我包的末尾有回车?
#40
收藏
#41
out.println(send_buf2);//数据包发送完毕
what about out.print(send_buf2)?
what about out.print(send_buf2)?
#42
呵呵.
println当然有换行了
println当然有换行了
#43
我也需要“java的socket客户端使用阻塞方式与一个c写的socket服务器通讯”,哪位有这方面的源代码可以共享?
#44
ding
#45
String msg = in.readLine();//程序到此就停止不运行了
当然停了,你是readline呀,发送的数据要有换行,你这编才接受的!
用InputStream的read吧!
当然停了,你是readline呀,发送的数据要有换行,你这编才接受的!
用InputStream的read吧!
#46
顺便请大家看看这个贴子, 关于POI的,谢谢.
http://community.csdn.net/Expert/topic/3706/3706109.xml?temp=.6670801
http://community.csdn.net/Expert/topic/3706/3706109.xml?temp=.6670801
#47
不用这么麻烦,只要在java传输中处理bytes[]就可以了。
Jclient.java:
public class Jclient {
public static void main(String[] args) {
Socket JavaSocket = null;
DataOutputStream os = null;
DataInputStream is =null;
try {
JavaSocket= new Socket("210.72.13.72",9734);
os = new DataOutputStream(JavaSocket.getOutputStream());
is = new DataInputStream(JavaSocket.getInputStream());
} catch (UnknownHostException e) {
System.err.println("Don't know about host");
} catch (IOException e) {
System.err.println("Couldn't get I/O for the connection to");
}
if (JavaSocket != null && os != null && is != null)
{
try {
String jcStr="this is Java 客户端 send string";
byte[] jcBytes =jcStr.getBytes();
os.write(jcBytes);//使用byte[]发送数据包
os.flush();
byte[] cbuf=new byte[8096];
is.read(cbuf);
String responseLine=new String(cbuf);
System.out.println("读取到的String是:"+responseLine);
os.close();
is.close();
JavaSocket.close();
} catch (UnknownHostException e) {
System.err.println("Trying to connect to unknown host: " + e);
} catch (IOException e) {
System.err.println("IOException: " + e);
}
}
}
}
Jclient.java:
public class Jclient {
public static void main(String[] args) {
Socket JavaSocket = null;
DataOutputStream os = null;
DataInputStream is =null;
try {
JavaSocket= new Socket("210.72.13.72",9734);
os = new DataOutputStream(JavaSocket.getOutputStream());
is = new DataInputStream(JavaSocket.getInputStream());
} catch (UnknownHostException e) {
System.err.println("Don't know about host");
} catch (IOException e) {
System.err.println("Couldn't get I/O for the connection to");
}
if (JavaSocket != null && os != null && is != null)
{
try {
String jcStr="this is Java 客户端 send string";
byte[] jcBytes =jcStr.getBytes();
os.write(jcBytes);//使用byte[]发送数据包
os.flush();
byte[] cbuf=new byte[8096];
is.read(cbuf);
String responseLine=new String(cbuf);
System.out.println("读取到的String是:"+responseLine);
os.close();
is.close();
JavaSocket.close();
} catch (UnknownHostException e) {
System.err.println("Trying to connect to unknown host: " + e);
} catch (IOException e) {
System.err.println("IOException: " + e);
}
}
}
}