socket同步java

① 如何干净的实现Android/java Socket 长连接通信

Java Socket通信有很多的时候需要我们不断的学习。方面效率虽然不及C与C++但它以灵活语言优势，为大家广为使用。 本文就对在使用java做通信方面程序时候应改注意问题做以说明。1.长连接、短链接只是针对客户端而言，服务器无所谓长、短；2.无论同步或者异步通信，发送之后务必要又响应回复，确认收到，负责进行一定范围内重发，例如重发三次；3.长连接服务器与客户端之间务必需要心跳探测，由客户端主动发起；4.短连接服务器通用代码：
package com.biesan.sms.gate.unioncom.communication;
import com.biesan.commons.Constants;
import com.biesan.commons.util.CodeUtil;
import com.biesan.sms.gate.unioncom.data.*;
import com.biesan.sms.gate.unioncom.util.GateInfo;
import java.net.*;
import java.io.*;
import java.util.*;
import org.apache.log4j.*;
import spApi.*;
public class UnioncomDeliver extends Thread {
// stop flag
private boolean unInterrupt = true;
private boolean unErr = true;
//private boolean closeSocketFlag = false;
// server socket
private ServerSocket serverSo = null;
// current socket
private Socket so = null
private OutputStream output = null;
private InputStream input = null;
// gate command
private SGIP_Command tmpCmd = null;
private SGIP_Command cmd = null;
private Bind bind = null;
private BindResp bindResp = null;
//private Unbind unBind = null;
private UnbindResp unBindResp = null;
private boolean unAcceptErrorFlag = true;
Logger unioncomLog = Logger.getLogger(Unioncom
Deliver.class.getName());
public UnioncomDeliver() {
}
public void run() {
unioncomLog.info("Start...");
while (unInterrupt) {
this.initServer();
this.startServices();
while (this.unAcceptErrorFlag) {
try {
//接受连接请求
unioncomLog.info("before accept connection!.......
FreeMemroy :" + Runtime.getRuntime().freeMemory());
this.acceptConnection();
unioncomLog.info("after accept connection!.......
FreeMemroy :" + Runtime.getRuntime().freeMemory());
while (unErr) {
cmd = new Command();
unioncomLog.info("before read command from stream
........... FreeMemroy: " + Runtime.getRuntime().
freeMemory());
tmpCmd = cmd.read(input);
unioncomLog.info("after read command from stream " +
getCommandString(cmd.getCommandID()) + " FreeMemroy: " +
Runtime.getRuntime().freeMemory());
if (tmpCmd == null) {
unErr = false;
break;
}
switch (cmd.getCommandID()) {
// biad ready communication
case SGIP_Command.ID_SGIP_BIND: {
this.dealBind();
break;
}// exit bind
case SGIP_Command.ID_SGIP_UNBIND: {
this.dealUnBind();
unioncomLog.info("after unbind connection!.......
FreeMemroy :" + Runtime.getRuntime().freeMemory());
break;
}// deliver
....
default : //错误的命令字
break;
}// switch
}// while(unErr)
} catch (Exception e) {
unioncomLog.error("Unioncom Recv Service Error"
+ e.getMessage());
} finally {
if (this.so != null) {
this.closeSocket();
}
this.unErr = true;
}
}// while (this.unAcceptErrorFlag)
try {
this.closeServerSocket();
sleep(200);// sleep
} catch (InterruptedException ie) {
}
}// while(unInterrupt)
}
private String getCommandString(int cmd){
switch (cmd) {
// biad ready communication
case SGIP_Command.ID_SGIP_BIND: {
return " BIND COMMAND ";
}// exit bind
case SGIP_Command.ID_SGIP_UNBIND: {
return " UNBIND COMMAND ";
}// deliver
case ...
default:
return " UNKNOWN COMMAND";
}
}
private void dealBind() {
try {
bind = new Bind(tmpCmd);
if (bind.readbody() != 0) {
unioncomLog.warn("Read Bind error");
this.unErr = false;
}
bindResp = new BindResp(tmpCmd.getMsgHead());
bindResp.SetResult(0);
bindResp.write(output);
unioncomLog.debug("Bind success!");
} catch (Exception e) {
unioncomLog.error("Dela Union Recv Bind Error!" +
e.getMessage());
this.unErr = false;
}
}
private void dealUnBind() {
try {
//unBind = (Unbind) tmpCmd;
unBindResp = new UnbindResp(tmpCmd.getMsgHead());
unBindResp.write(output);
unioncomLog.debug("UnBind success!");
} catch (Exception e) {
unioncomLog.warn("Unbind error!" + e.getMessage());
}
this.unErr = false;
}
private void startServices() {
boolean unStartServices = true;
while (unStartServices) {
try {
serverSo = new ServerSocket(ugInfo.getLocalServerPort(), 5,
InetAddress.getByName(ugInfo.getLocalIpAdd()));
//serverSo.setSoTimeout(60000);
unStartServices = false;
unioncomLog.info("Create union recv socket Ok!");
} catch (IOException e) {
unioncomLog.warn("Create union recv socket error!"
+ e.getMessage());
unStartServices = true;
UnioncomSubmit.thrSlp(3000);
}
}
}
private void acceptConnection() {
// Accept 失败
try {
so = serverSo.accept();
so.setSoTimeout(10000);
} catch (Exception e) {
unioncomLog.warn("Accept Error!" + e.getMessage());
this.closeServerSocket();
this.unAcceptErrorFlag = false;
this.unErr=false;
}
// Accept成功
try {
input = so.getInputStream();
output = so.getOutputStream();
} catch (IOException e) {
unioncomLog.warn("Get I/O stream Error!" + e.getMessage());
this.closeService();
this.unAcceptErrorFlag = false;
this.unErr=false;
}
}
private void closeSocket() {
try {
so.close();
unioncomLog.info("Socket Close Success!!!");
} catch (Exception e) {
unioncomLog.error("Socket Close Failure!!!" + e.getMessage());
}
}
private void closeServerSocket() {
try {
serverSo.close();
unioncomLog.info("ServerSocket Close Success!!!");
} catch (Exception e) {
unioncomLog
.error("ServerSocket Close Failure!!!" + e.getMessage());
}
}
private void closeService() {
this.closeSocket();
this.closeServerSocket();
}
private void initServer() {
this.bind = null;
this.bindResp = null;
//this.unBind = null;
this.unBindResp = null;
this.tmpCmd = null;
this.cmd = null;
this.serverSo = null;
this.so = null;
this.output = null;
this.input = null;
this.unErr = true;
//this.closeSocketFlag = false;
unioncomLog.info("Memory***==="
+ java.lang.Runtime.getRuntime().freeMemory());
}
public synchronized void requireStop() {
this.unInterrupt = false;
unioncomLog.info("Requre interrupt!!!");
}
public String convertMsgContentCoding
(int msgCoding, byte[] msgContent) {
String deliverContent = null;
try {
if (msgContent != null) {
if (msgCoding == 8) { // 处理ucs32编码
deliverContent = new String(msgContent,
"UnicodeBigUnmarked");
} else if (msgCoding == 0) { // 处理ASCII编码
deliverContent = new String(msgContent, "ASCII");
} else if (msgCoding == 4) { // 处理binary编码
deliverContent = new String(msgContent);
} else if (msgCoding == 15) { // 处理GBK编码
deliverContent = new String(msgContent, "GBK");
// 处理DELIVER数据包的短信息ID
} else {
unioncomLog.error("编码格式错误!");
return "";
}
} else
return "";
return deliverContent;
} catch (UnsupportedEncodingException ex) {
unioncomLog.error("deal content error!" +
ex.getMessage());
return "";
}
}
}

② java中的socket是什么意思

所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
以J2SDK-1.3为例，Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。
重要的Socket API：
java.net.Socket继承于java.lang.Object，有八个构造器，其方法并不多，下面介绍使用最频繁的三个方法，其它方法大家可以见JDK-1.3文档。
. Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。
. getInputStream方法获得网络连接输入，同时返回一个InputStream对象实例。
. getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。
注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。
2ServerSocket类例子编辑

package com.lanber.socket;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo {
/**
* 注意：Socket的发送与接收是需要同步进行的，即客户端发送一条信息，服务器必需先接收这条信息，
* 而后才可以向客户端发送信息，否则将会有运行时出错。
* @param args
*/
public static void main(String[] args) {
ServerSocket ss = null;
try {
ss = new ServerSocket(8888);
//服务器接收到客户端的数据后，创建与此客户端对话的Socket
Socket socket = ss.accept();
//用于向客户端发送数据的输出流
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
//用于接收客户端发来的数据的输入流
DataInputStream dis = new DataInputStream(socket.getInputStream());
System.out.println("服务器接收到客户端的连接请求：" + dis.readUTF());
//服务器向客户端发送连接成功确认信息
dos.writeUTF("接受连接请求，连接成功!");
//不需要继续使用此连接时，关闭连接
socket.close();
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

3客户端的例子编辑
package com.lanber.socket;
importjava.io.DataInputStream;
import java.io.DataOutputStream;
importjava.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class ClientDemo {
/**
* @param args
*/
public static void main(String[] args) {
Socket socket = null;
try {
socket = new Socket("localhost",8888);
//获取输出流，用于客户端向服务器端发送数据
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
//获取输入流，用于接收服务器端发送来的数据
DataInputStream dis = new DataInputStream(socket.getInputStream());
//客户端向服务器端发送数据
dos.writeUTF("我是客户端，请求连接!");
//打印出从服务器端接收到的数据
System.out.println(dis.readUTF());
//不需要继续使用此连接时，记得关闭哦
socket.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

③ java如何实现基于TCP协议的socket传输

服务端监听：ServerSocket server=new ServerSocket(port);//port：绑定的端口号
Socket client=server.accept();//监听端口，一旦逗返神取得连接则获世陵得客户端的socket连接对象client

客户端： Socket s=new Socket(ip,port);//要连接的服务器的ip以及端口号

如果正常连接上之后，socket的对象可以获得InputStream和OutputStreame，然后就可以进行通信了

完成通信山亏之后，执行socket对象的close（）方法关闭连接，完成一次完整的socket连接

④ 关于用文本来实现Socket通信（java），求高手

这是服务辩罩器端：
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.net.Socket;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import javax.swing.JFrame;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.JScrollPane;

public class J_ChatClient extends JFrame
{
private ObjectInputStream m_input; // 输入流
private ObjectOutputStream m_output; //知橡 输出流
private JTextField m_enter; // 输入区域
private JTextArea m_display; // 显示区域

public J_ChatClient( ) // 在图形界面中携猛闹添加组件
{
super("聊天程序客户端");
Container c = getContentPane( );
m_enter = new JTextField( );
m_enter.setEnabled( false );
m_enter.addActionListener(new ActionListener( )
{
public void actionPerformed( ActionEvent event )
{ // 向服务器端发送数据
try
{
String s = event.getActionCommand( );
m_output.writeObject( s );
m_output.flush( );
mb_displayAppend( "客户端: " + s );
m_enter.setText( "" ); // 清除输入区域的原有内容
}
catch (Exception e)
{
System.err.println("发生异常:" + e);
e.printStackTrace( );
} // try-catch结构结束
} // 方法actionPerformed结束
} // 实现接口ActionListener的内部类结束
); // addActionListener方法调用结束
c.add( m_enter, BorderLayout.NORTH );
m_display = new JTextArea( );
c.add( new JScrollPane( m_display ), BorderLayout.CENTER );
} // J_ChatClient构造方法结束

public void mb_displayAppend( String s )
{
m_display.append( s + "\n" );
m_display.setCaretPosition( m_display.getText( ).length( ) );
m_enter.requestFocusInWindow( ); // 转移输入焦点到输入区域
} // 方法mb_displayAppend结束

public boolean mb_isEndSession( String m )
{
if (m.equalsIgnoreCase("q"))
return(true);
if (m.equalsIgnoreCase("quit"))
return(true);
if (m.equalsIgnoreCase("exit"))
return(true);
if (m.equalsIgnoreCase("end"))
return(true);
if (m.equalsIgnoreCase("结束"))
return(true);
return(false);
} // 方法mb_isEndSession结束

public void mb_run( String host, int port)
{
try
{
mb_displayAppend("尝试连接");
Socket s = new Socket(host, port);
String m; // 来自服务器端的消息
m_output = new ObjectOutputStream( s.getOutputStream( ) );
m_input = new ObjectInputStream( s.getInputStream( ) );
m_enter.setEnabled( true );
do
{
m = (String) m_input.readObject( );
mb_displayAppend("服务器端: " + m);
} while(!mb_isEndSession( m ));// do-while循环结束
m_output.writeObject("q"); // 通知服务端退出程序
m_output.flush( );
m_output.close( );
m_input.close( );
s.close( );
System.exit( 0 );
}
catch (Exception e)
{
System.err.println("发生异常:" + e);
e.printStackTrace( );
mb_displayAppend("发生异常");
} // try-catch结构结束
} // 方法mb_run结束

public static void main(String args[ ])
{
J_ChatClient app = new J_ChatClient( );
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
app.setSize(350, 150);
app.setVisible(true);
if ( args.length == 0 )
app.mb_run("localhost", 5000);
else app.mb_run(args[0], 5000);
} // 方法main结束
} // 类J_ChatClient结束
这是客户端：
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.net.ServerSocket;
import java.net.Socket;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import javax.swing.JFrame;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.JScrollPane;

public class J_ChatServer extends JFrame
{
private ObjectInputStream m_input; // 输入流
private ObjectOutputStream m_output; // 输出流
private JTextField m_enter; // 输入区域
private JTextArea m_display; // 显示区域
private int m_clientNumber = 0; // 连接的客户数

public J_ChatServer( ) // 在图形界面中添加组件
{
super("聊天程序服务器端");
Container c = getContentPane( );
m_enter = new JTextField( );
m_enter.setEnabled( false );
m_enter.addActionListener(new ActionListener( )
{
public void actionPerformed( ActionEvent event )
{ // 向客户端发送数据
try
{
String s = event.getActionCommand( );
m_output.writeObject( s );
m_output.flush( );
mb_displayAppend( "服务器端: " + s );
m_enter.setText( "" ); // 清除输入区域的原有内容
}
catch (Exception e)
{
System.err.println("发生异常:" + e);
e.printStackTrace( );
} // try-catch结构结束
} // 方法actionPerformed结束
} // 实现接口ActionListener的内部类结束
); // addActionListener方法调用结束
c.add( m_enter, BorderLayout.NORTH );
m_display = new JTextArea( );
c.add( new JScrollPane( m_display ), BorderLayout.CENTER );
} // J_ChatServer构造方法结束

public void mb_displayAppend( String s )
{
m_display.append( s + "\n" ); //将给定文本追加到文档结尾
//设置 TextComponent 的文本插入符的位置。注意，插入符可跟踪更改，所以如果组件的基础文本被更改，
//则此位置可能会移动。如果文档为 null，则不执行任何操作。位置必须在 0 和组件的文本长度之间，否则将抛出异常
m_display.setCaretPosition( m_display.getText( ).length( ) );
m_enter.requestFocusInWindow( ); // 转移输入焦点到输入区域
} // 方法mb_displayAppend结束

public boolean mb_isEndSession( String m )
{
if (m.equalsIgnoreCase("q"))
return(true);
if (m.equalsIgnoreCase("quit"))
return(true);
if (m.equalsIgnoreCase("exit"))
return(true);
if (m.equalsIgnoreCase("end"))
return(true);
if (m.equalsIgnoreCase("结束"))
return(true);
return(false);
} // 方法mb_isEndSession结束

public void mb_run( )
{
try
{
ServerSocket server = new ServerSocket(5000);
String m; // 来自客户端的消息
while (true)
{
m_clientNumber++;
mb_displayAppend("等待连接[" + m_clientNumber + "]" + " ");
Socket s = server.accept( );
mb_displayAppend("接收到客户端连接[" + m_clientNumber + "]" + " ");
m_output = new ObjectOutputStream( s.getOutputStream( ) );
m_input = new ObjectInputStream( s.getInputStream( ) );
m_output.writeObject("连接成功");
m_output.flush( );
m_enter.setEnabled( true );
do
{
m = (String) m_input.readObject( );
mb_displayAppend("客户端: " + m);
} while(!mb_isEndSession( m ));// do-while循环结束
m_output.writeObject("q"); // 通知客户端退出程序
m_output.flush( );
m_enter.setEnabled( false );
m_output.close( );
m_input.close( );
s.close( );
mb_displayAppend("连接[" + m_clientNumber + "]结束" + " ");
} // while循环结束
}
catch (Exception e)
{
System.err.println("发生异常:" + e);
e.printStackTrace( );
mb_displayAppend("连接[" + m_clientNumber +"]发生异常" + " ");
} // try-catch结构结束
} // 方法mb_run结束

public static void main(String args[ ])
{
J_ChatServer app = new J_ChatServer( );

app.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE);
app.setSize(350, 150);
app.setVisible(true);
app.mb_run( );
} // 方法main结束
} // 类J_ChatServer结束
楼主看看就应该懂了，我注释的很详细的，这个是我以前学Socket编程的时候，写的一个例子

⑤ JAVA TCP Socket端口的数据同步问题。

。。。 你方法错了。 建议你先看看 ftp 的协议。 我简单的说下 ftp 协议。
ftp 在客户端连接上之后 ，客户端 执行get 命令 服务端返回服务端口号，客户端收到端口号 并根据端口号创喊胡租建连接， 连接建立成功后 服务端 直接读取本地文件 通过数据流的方式边读边将数据 输出到 tcp 流，然后客户端就是边读数据流边写入到本地。服务端将文件读取完成之后 就close 数据流，客户端就可以 捕获到一个数据流关闭的异常，
再说 你的 问题。 socket is closed 就是 说tcp 已做薯经关闭了。 你还说 你使用了 shutdownoutput。。。。 这不是说 socket 停止的么？ 停止了 还没关闭？ 已经被你的代码关闭郑兆了。！

⑥ 200分求JAVA 用socket进行文件的同步

客户端，Client.java:

public class Client {
public static void main(String[] args) throws IOException {
Socket socket = null;
String host = "127.0.0.1";

socket = new Socket(host, 4444);

File file = new File("M:\\test.xml");
// Get the size of the file
long length = file.length();
byte[] bytes = new byte[16 * 1024];
InputStream in = new FileInputStream(file);
OutputStream out = socket.getOutputStream();

int count;
while ((count = in.read(bytes)) > 0) {
out.write(bytes, 0, count);
}

out.close();
in.close();
socket.close();
}
}

服务端，Server.java:
public class Server {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = null;

try {
serverSocket = new ServerSocket(4444);
} catch (IOException ex) {
System.out.println("Can't setup server on this port number. ");
}

Socket socket = null;
InputStream in = null;
OutputStream out = null;

try {
socket = serverSocket.accept();
} catch (IOException ex) {
System.out.println("Can't accept client connection. ");
}

try {
in = socket.getInputStream();
} catch (IOException ex) {
System.out.println("Can't get socket input stream. ");
}

try {
out = new FileOutputStream("M:\\test2.xml");
} catch (FileNotFoundException ex) {
System.out.println("File not found. ");
}

byte[] bytes = new byte[16*1024];

int count;
while ((count = in.read(bytes)) > 0) {
out.write(bytes, 0, count);
}

out.close();
in.close();
socket.close();
serverSocket.close();
}
}

⑦ iOS socket怎么和java通讯

SOCKET敲得例子，非常简雀锋单，TCP协议：
客户端代码：
import java.net.*;
import java.io.*;
public class SocketClient{
public static void main(String args[]){
try{
//客户端连接服务器
Socket socket1 = new Socket("127.0.0.1",1989);
InputStream is = socket1.getInputStream();
DataInputStream dis = new DataInputStream(is);
//客户端接受服务首岁脊器端的信息
System.out.println(dis.readUTF());
dis.close();
socket1.close();
}
catch(IOException e){
System.out.println("IO异常");
}
}
}
服务器代码：
import java.net.*;
import java.io.*;
public class SocketServer{
public static void main(String args[]){
try{
ServerSocket ss = new ServerSocket(1989);
Socket socket1 = ss.accept();
OutputStream os = socket1.getOutputStream();
DataOutputStream dos = new DataOutputStream(os);
//服务器端发给客者渗户端的信息
dos.writeUTF("anyway,i need u！"+socket1.getInetAddress()+"port:"+socket1.getPort());
dos.close();
socket1.close();
}
catch(IOException e){
System.out.println("IO错误!");
}
}
}

⑧ JAVA客户端与服务端Socket通信问题

你就发了一句话,怎么能接受两遍呢

改成这样 String lin=null;

if((lin=dis.readUTF())!=null){

备谈System.out.println(lin);

旦滚绝模姿}

这样试试

⑨ Java 多线程 用socket通信

ServerSocket
server=new
ServerSocket(port);
/*..以下是监御首听旦拆祥.*/
try{
while(true){
Socket
socket=server.accept(0;
Thread
handleThread=new
Thread(new
HandleRun(socket)).start();
//直接把跟客户端连接的socket放到一个线程中处理。
//模搏之后，自己定义一个实现Runnable的HandleRun类即可（用于处理c-s之间的通信）
}
}catch（Exception
ex){}
看不懂的话，就追问。再不会的话，可以花点时间帮你写个小小的Demo

⑩ JAVA Socket收发不同步

知隐桐芦道为什么延迟了吗？

因为TCP的Nagle算法使得发送的内容先被缓冲起来轮培，做了灶带传输优化而导致的微小的延迟。
看看Java帮助文档的Socket部分：

setTcpNoDelay
public void setTcpNoDelay(boolean on)
throws SocketException

启用/禁用 TCP_NODELAY（启用/禁用 Nagle 算法）。

参数：
on - 为 true 表示启用 TCP_NODELAY；为 false
表示禁用。
抛出：
SocketException -
如果底层协议出现错误，例如 TCP 错误。
从以下版本开始：
JDK1.1
另请参见：
getTcpNoDelay()