java中用socket通信怎么获取访问者的IP

新建一个ServerSocket对象然后用accept（）方法接受请求连接的Socket对象在调用获得的Socket对象的getInetAddress（）方法获取InetAddress对象在调用InetAddress对象的getHostAddress方法来获取IP地址。

程序清单 codes/ / /Client java

public class Client

{

public static void main（String[] args）

throws IOException

{

Socket socket = new Socket（ ）

//将Socket对应的输入流包装成BufferedReader

BufferedReader br = new BufferedReader（

new InputStreamReader（socket getInputStream（）））

//进行普通IO *** 作

String line = br readLine（）

System out println（ 来自服务器的数据 + line）

//关闭输入流 socket

br close（）

socket close（）

}

}

上面程序中粗体字代码是使用ServerSocket和Socket建立网络连接的代码 斜体字代码是通过Socket获取输入流 输出流进行通信的代码 通过程序不难看出 一旦使用ServerSocket Socket建立网络连接之后 程序通过网络通信与普通IO并没有太大的区别

先运行上面程序中的Server类 将看到服务器一直处于等待状态 因为服务器使用了死循环来接受来自客户端的请求 再运行Client类 将可看到程序输出 来自服务器的数据 您好 您收到了服务器的新年祝福！ 这表明客户端和服务器端通信成功

上面程序为了突出通过ServerSocket和Socket建立连接 并通过底层IO流进行通信的主题 程序没有进行异常处理 也没有使用finally块来关闭资源

实际应用中 程序可能不想让执行网络连接 读取服务器数据的进程一直阻塞 而是希望当网络连接 读取 *** 作超过合理时间之后 系统自动认为该 *** 作失败 这个合理时间就是超时时长 Socket对象提供了一个setSoTimeout（int timeout）来设置超时时长 如下的代码片段所示

Socket s = new Socket（ ）

//设置 秒之后即认为超时

s setSoTimeout（ ）

当我们为Socket对象指定了超时时长之后 如果在使用Socket进行读 写 *** 作完成之前已经超出了该时间限制 那么这些方法就会抛出SocketTimeoutException异常 程序可以对该异常进行捕捉 并进行适当处理 如下代码所示

try

{

//使用Scanner来读取网络输入流中的数据

Scanner scan = new Scanner（s getInputStream（））

//读取一行字符

String line = scan nextLine（）

…

}

//捕捉SocketTimeoutException异常

catch（SocketTimeoutException ex）

{

//对异常进行处理

…

}

假设程序需要为Socket连接服务器时指定超时时长 即经过指定时间后 如果该Socket还未连接到远程服务器 则系统认为该Socket连接超时 但Socket的所有构造器里都没有提供指定超时时长的参数 所以程序应该先创建一个无连接的Socket 再调用Socket的connect（）方法来连接远程服务器 而connect方法就可以接受一个超时时长参数 如下代码所示

//创建一个无连接的Socket

Socket s = new Socket（）

//让该Socket连接到远程服务器 如果经过 秒还没有连接到 则认为连接超时

s connconnect（new InetAddress（host port） ）

       返回目录 疯狂Java讲义

       编辑推荐

       Java程序性能优化 让你的Java程序更快 更稳定

       新手学Java 编程

       Java程序设计培训视频教程

lishixinzhi/Article/program/Java/hx/201311/27265

计算机网络相关的问题，如果想去了解，前提就是深刻理解网络4/7层模型。

记住并理解，上面每一层。切记，切记，切记。知道一些就可以开始主题，分两个部分TCP和Socket。

TCP是（Tranfer Control Protocol）的简称，在OSI参考模型第四层，也就是端口，到端口的的通信，它是一个可靠的双向连接，一旦建立连接就可以双向数据传输，双方都可以进行发送或接收 *** 作。

最常听说的就是三次握手。是的它说的就是TCP建立连接的过程。具体的步骤如下：

第一步：Server监听端口，状态为：Listen 

第二部：Client发送SNY包，请求连接，并将状态改为：SYN_SEND

第三部：Server发送ACK包，和SNY包，同意，并请求连接，状态改为：SYN_RCVD

第四部：Client发送ACK包，Server收到包后，连接建立。双方状态改为：ESTABLISHED

第一步：Client发起FIN包。状态变为：FNI_WAIT_1

第二步：Server发送ACK包。状态变为：CLOSE_WAIT，Client收包后状态变为：FNI_WAIT_2

第三步：Server发送FIN包，状态变为：LAST_ACK。Client收包后状态变为：TIME_WAIT

第四步：Client发送ACK包。双方状态变为：CLOSED 

需要注意的是，Client是在收到Server FIN包后两个最大报文时间（2MSL）后变为CLOSED状态的。双方都可以发起断开请求，上面是已先发起请求的是Client。

如何验证上面讲的这些呢？那就是抓包分析，其实日常的开发中也可以通过抓包来发现问题。在这里我简单贴个图看一下TCP的包，这个工具非常强大感兴趣的朋友可以去深入了解一下。

1可以在这个过滤，通过协议，通过IP，通过端口都可以。

2这个就是每个包，例子中的这个是个[SYN，ACK]包，就是建立TCP连接的第二次握手

3被抓取的包对应的网络层，从上到下分别是：物理层、数据链路层、网络层、传输层。

Socket其实就是TCP协议的实现。也就是说它就是TCP的API，当然其实Socket也支持别的协议如：UDP。既然是API那，上面说的其实就是它的原理。下面说一下它的使用。大概说一下。

1ServerSocket：是服务端来监听的类。监听方法accept()。

2客户端：创建Socket对象，设定IP和Port

3当有新的客户端连接时可以通过ServerSocket类获取Socket。而Socket就是我们的通讯渠道。

4发送和读取数据分别使用OutputStream和InputStream而这两个类是从Socket获取的。

其实Socket的基本使用就是这么简单，但是在其实项目中这样是无法满足需求的。实际上大多数场景都是需要一对多的提供服务。

使用多线程实现多客户端的通信

实现服务器与多个客户端进行通信， 可以接受多个客户端的请求并进行回复

应用多线程来实现服务器与多客户端之间的通信

1、服务器端创建ServerSocket，循环调用accept()等待客户端连接

2、客户端创建一个Socket并请求和服务器端连接

3、服务器端接受客户端请求，创建socket与该客户建立专线连接

4、建立连接的两个socket在一个单独的线程上对话

5、服务器端继续等待新的连接

1、客户端链接服务器

2、客户端发送用户名到服务器(比如发送"name:张三")

3、服务器根据前缀name: 验证用户，同时将当前socket与name存放在一个hashmap集合中，有了这个socket你害怕获取不到对应用户的ip

基于C#的socket编程的TCP异步实现

一、摘要

本篇博文阐述基于TCP通信协议的异步实现。

二、实验平台

Visual Studio 2010

三、异步通信实现原理及常用方法

31 建立连接　

在同步模式中，在服务器上使用Accept方法接入连接请求，而在客户端则使用Connect方法来连接服务器。相对地，在异步模式下，服务器可以使用BeginAccept方法和EndAccept方法来完成连接到客户端的任务，在客户端则通过BeginConnect方法和EndConnect方法来实现与服务器的连接。

BeginAccept在异步方式下传入的连接尝试，它允许其他动作而不必等待连接建立才继续执行后面程序。在调用BeginAccept之前，必须使用Listen方法来侦听是否有连接请求，BeginAccept的函数原型为：

BeginAccept(AsyncCallback AsyncCallback, Ojbect state)

参数：

AsyncCallBack：代表回调函数

state：表示状态信息，必须保证state中包含socket的句柄

使用BeginAccept的基本流程是：

(1)创建本地终节点，并新建套接字与本地终节点进行绑定；

(2)在端口上侦听是否有新的连接请求；

(3)请求开始接入新的连接，传入Socket的实例或者StateOjbect的实例。

参考代码：

复制代码

//定义IP地址

IPAddress local = IPAddressParse("1270,0,1");

IPEndPoint iep = new IPEndPoint(local,13000);

//创建服务器的socket对象

Socket server = new Socket(AddressFamilyInterNetwork,SocketTypeStream,ProtocolTypeTcp);

serverBind(iep);

serverListen(20);

serverBeginAccecpt(new AsyncCallback(Accept),server);

复制代码

当BeginAccept()方法调用结束后，一旦新的连接发生，将调用回调函数，而该回调函数必须包括用来结束接入连接 *** 作的EndAccept()方法。

该方法参数列表为 Socket EndAccept(IAsyncResult iar)

下面为回调函数的实例：

复制代码

void Accept(IAsyncResult iar)

{

//还原传入的原始套接字

Socket MyServer = (Socket)iarAsyncState;

//在原始套接字上调用EndAccept方法，返回新的套接字

Socket service = MyServerEndAccept(iar);

}

复制代码

至此，服务器端已经准备好了。客户端应通过BeginConnect方法和EndConnect来远程连接主机。在调用BeginConnect方法时必须注册相应的回调函数并且至少传递一个Socket的实例给state参数，以保证EndConnect方法中能使用原始的套接字。下面是一段是BeginConnect的调用：

Socket socket=new Socket(AddressFamilyInterNetwork,SocketTypeStream,ProtocolTypeTcp)

IPAddress ip=IPAddressParse("127001");

IPEndPoint iep=new IPEndPoint(ip,13000);

socketBeginConnect(iep, new AsyncCallback(Connect),socket);

EndConnect是一种阻塞方法，用于完成BeginConnect方法的异步连接诶远程主机的请求。在注册了回调函数后必须接收BeginConnect方法返回的IASynccReuslt作为参数。下面为代码演示：

复制代码

void Connect(IAsyncResult iar)

{

Socket client=(Socket)iarAsyncState;

try

{

clientEndConnect(iar);

}

catch (Exception e)

{

ConsoleWriteLine(eToString());

}

finally

{

}

}

复制代码

除了采用上述方法建立连接之后，也可以采用TcpListener类里面的方法进行连接建立。下面是服务器端对关于TcpListener类使用BeginAccetpTcpClient方法处理一个传入的连接尝试。以下是使用BeginAccetpTcpClient方法和EndAccetpTcpClient方法的代码：

复制代码

public static void DoBeginAccept(TcpListener listner)

{

//开始从客户端监听连接

ConsoleWriteLine("Waitting for a connection");

//接收连接

//开始准备接入新的连接，一旦有新连接尝试则调用回调函数DoAcceptTcpCliet

listnerBeginAcceptTcpClient(new AsyncCallback(DoAcceptTcpCliet), listner);

}

//处理客户端的连接

public static void DoAcceptTcpCliet(IAsyncResult iar)

{

//还原原始的TcpListner对象

TcpListener listener = (TcpListener)iarAsyncState;

//完成连接的动作，并返回新的TcpClient

TcpClient client = listenerEndAcceptTcpClient(iar);

ConsoleWriteLine("连接成功");

}

复制代码

代码的处理逻辑为：

(1)调用BeginAccetpTcpClient方法开开始连接新的连接，当连接视图发生时，回调函数被调用以完成连接 *** 作；

(2)上面DoAcceptTcpCliet方法通过AsyncState属性获得由BeginAcceptTcpClient传入的listner实例；

(3)在得到listener对象后，用它调用EndAcceptTcpClient方法，该方法返回新的包含客户端信息的TcpClient。

BeginConnect方法和EndConnect方法可用于客户端尝试建立与服务端的连接，这里和第一种方法并无区别。下面看实例：

复制代码

public void doBeginConnect(IAsyncResult iar)

{

Socket client=(Socket)iarAsyncState;

//开始与远程主机进行连接

clientBeginConnect(serverIP[0],13000,requestCallBack,client);

ConsoleWriteLine("开始与服务器进行连接");

}

private void requestCallBack(IAsyncResult iar)

{

try

{

//还原原始的TcpClient对象

TcpClient client=(TcpClient)iarAsyncState;

//

clientEndConnect(iar);

ConsoleWriteLine("与服务器{0}连接成功",clientClientRemoteEndPoint);

}

catch(Exception e)

{

ConsoleWriteLine(eToString());

}

finally

{

}

}

复制代码

以上是建立连接的两种方法。可根据需要选择使用。

32 发送与接受数据

在建立了套接字的连接后，就可以服务器端和客户端之间进行数据通信了。异步套接字用BeginSend和EndSend方法来负责数据的发送。注意在调用BeginSend方法前要确保双方都已经建立连接，否则会出异常。下面演示代码：

复制代码

private static void Send(Socket handler, String data)

{

// Convert the string data to byte data using ASCII encoding

byte[] byteData = EncodingASCIIGetBytes(data);

// Begin sending the data to the remote device

handlerBeginSend(byteData, 0, byteDataLength, 0, new AsyncCallback(SendCallback), handler);

}

private static void SendCallback(IAsyncResult ar)

{

try

{

// Retrieve the socket from the state object

Socket handler = (Socket)arAsyncState;

// Complete sending the data to the remote device

int bytesSent = handlerEndSend(ar);

ConsoleWriteLine("Sent {0} bytes to client", bytesSent);

handlerShutdown(SocketShutdownBoth);

handlerClose();

}

catch (Exception e)

{

ConsoleWriteLine(eToString());

}

}

复制代码

接收数据是通过BeginReceive和EndReceive方法：

复制代码

private static void Receive(Socket client)

{

try

{

// Create the state object

StateObject state = new StateObject();

stateworkSocket = client;

// Begin receiving the data from the remote device

clientBeginReceive(statebuffer, 0, StateObjectBufferSize, 0, new AsyncCallback(ReceiveCallback), state);

}

catch (Exception e)

{

ConsoleWriteLine(eToString());

}

}

private static void ReceiveCallback(IAsyncResult ar)

{

try

{

// Retrieve the state object and the client socket

// from the asynchronous state object

StateObject state = (StateObject)arAsyncState;

Socket client = stateworkSocket;

// Read data from the remote device

int bytesRead = clientEndReceive(ar);

if (bytesRead > 0)

{

// There might be more data, so store the data received so far

statesbAppend(EncodingASCIIGetString(statebuffer, 0, bytesRead));

// Get the rest of the data

clientBeginReceive(statebuffer, 0, StateObjectBufferSize, 0, new AsyncCallback(ReceiveCallback), state);

}

else

{

// All the data has arrived; put it in response

if (statesbLength > 1)

{

response = statesbToString();

}

// Signal that all bytes have been received

receiveDoneSet();

}

}

catch (Exception e)

{

ConsoleWriteLine(eToString());

}

}

复制代码

上述代码的处理逻辑为：

(1)首先处理连接的回调函数里得到的通讯套接字client，接着开始接收数据；

(2)当数据发送到缓冲区中，BeginReceive方法试图从buffer数组中读取长度为bufferlength的数据块，并返回接收到的数据量bytesRead。最后接收并打印数据。

除了上述方法外，还可以使用基于NetworkStream相关的异步发送和接收方法，下面是基于NetworkStream相关的异步发送和接收方法的使用介绍。

NetworkStream使用BeginRead和EndRead方法进行读 *** 作，使用BeginWreite和EndWrete方法进行写 *** 作，下面看实例：

复制代码

static void DataHandle(TcpClient client)

{

TcpClient tcpClient = client;

//使用TcpClient的GetStream方法获取网络流

NetworkStream ns = tcpClientGetStream();

//检查网络流是否可读

if(nsCanRead)

{

//定义缓冲区

byte[] read = new byte[1024];

nsBeginRead(read,0,readLength,new AsyncCallback(myReadCallBack),ns);

}

else

{

ConsoleWriteLine("无法从网络中读取流数据");

}

}

public static void myReadCallBack(IAsyncResult iar)

{

NetworkStream ns = (NetworkStream)iarAsyncState;

byte[] read = new byte[1024];

String data = "";

int recv;

recv = nsEndRead(iar);

data = StringConcat(data, EncodingASCIIGetString(read, 0, recv));

//接收到的消息长度可能大于缓冲区总大小，反复循环直到读完为止

while (nsDataAvailable)

{

nsBeginRead(read, 0, readLength, new AsyncCallback(myReadCallBack), ns);

}

//打印

ConsoleWriteLine("您收到的信息是" + data);

}

复制代码

33 程序阻塞与异步中的同步问题

Net里提供了EventWaitHandle类来表示一个线程的同步事件。EventWaitHandle即事件等待句柄，他允许线程通过 *** 作系统互发信号和等待彼此的信号来达到线程同步的目的。这个类有2个子类，分别为AutoRestEevnt(自动重置)和ManualRestEvent(手动重置)。下面是线程同步的几个方法：

(1)Rset方法：将事件状态设为非终止状态，导致线程阻塞。这里的线程阻塞是指允许其他需要等待的线程进行阻塞即让含WaitOne()方法的线程阻塞；

(2)Set方法：将事件状态设为终止状态，允许一个或多个等待线程继续。该方法发送一个信号给 *** 作系统，让处于等待的某个线程从阻塞状态转换为继续运行，即WaitOne方法的线程不在阻塞；

(3)WaitOne方法：阻塞当前线程，直到当前的等待句柄收到信号。此方法将一直使本线程处于阻塞状态直到收到信号为止，即当其他非阻塞进程调用set方法时可以继续执行。

复制代码

public static void StartListening()

{

// Data buffer for incoming data

byte[] bytes = new Byte[1024];

// Establish the local endpoint for the socket

// The DNS name of the computer

// running the listener is "hostcontosocom"

//IPHostEntry ipHostInfo = DnsResolve(DnsGetHostName());

//IPAddress ipAddress = ipHostInfoAddressList[0];

IPAddress ipAddress = IPAddressParse("127001");

IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);

// Create a TCP/IP socket

Socket listener = new Socket(AddressFamilyInterNetwork,SocketTypeStream, ProtocolTypeTcp);

// Bind the socket to the local

//endpoint and listen for incoming connections

try

{

listenerBind(localEndPoint);

listenerListen(100);

while (true)

{

// Set the event to nonsignaled state

allDoneReset();

// Start an asynchronous socket to listen for connections

ConsoleWriteLine("Waiting for a connection");

listenerBeginAccept(new AsyncCallback(AcceptCallback),listener);

// Wait until a connection is made before continuing

allDoneWaitOne();

}

}

catch (Exception e)

{

ConsoleWriteLine(eToString());

}

ConsoleWriteLine("\nPress ENTER to continue");

ConsoleRead();

}

复制代码

上述代码的逻辑为：

(1)试用了ManualRestEvent对象创建一个等待句柄，在调用BeginAccept方法前使用Rest方法允许其他线程阻塞；

(2)为了防止在连接完成之前对套接字进行读写 *** 作，务必要在BeginAccept方法后调用WaitOne来让线程进入阻塞状态。

当有连接接入后系统会自动调用会调用回调函数，所以当代码执行到回调函数时说明连接已经成功，并在函数的第一句就调用Set方法让处于等待的线程可以继续执行

一般socket链接有以下两种方式：长（常）链接和短链接。

长链接：当数据发送完成后socket链接不断开。一直保留到异常或者是程序退出为止 ，这种方式的好处是不用每次去发起连接断开，在速度上可以比短连接要快一些，但是相 对来说对服务器的资源压力也要大些。长链接用的范围很广，比如游戏系统，qq等等，长 （常）链接一般还需要定时向服务器ping数据，以保证socket链接畅通。当ping不通服务 器时，需要重新开启链接。

短链接：当一次数据发送完毕后，主动断开链接，每次发送数据都要一次链接、断开 *** 作，这种方式的好处是：对服务器的资源占用相对来说比较小，但是由于每次都要重新 链接，速度开销上也比较大，这种方式对于那种不需要经常与服务器交互的情况下比较适 用。

上面两种方法在用户量非常大的情况下都存在着很大的不足，因此，考虑可以用 一种折衷的办法，那就是使用socket的连接池。

程序一开始初始化创建若干数量的长链接。给他们设置一个标识位，这个标识位表示 该链接是否空闲的状态。当需要发送数据的时候，系统给它分配一个当前空闲的链接。同 时，将得到的链接设置为“忙”，当数据发送完毕后，把链接标识位设置为 “闲”，让系统可以分配给下个用户，这样使得两种方式的优点都充分的发挥 出来了。用户数量足够多的时候，只需要动态增加链接池的数量即可。

下面我们用具体的程序来讲解下：

首先声明一个socket类：

public class XieGouSocket

{

public Socket m_socket; //Socket对象

public bool m_isFree; //判断是否空闲

public int m_index; //在链接缓存池中的索引值

}

下面的函数是创建socket链接池，这里为了使代码更加清晰，特地把异常处理部分 全部取掉了。

public XieGouSocket[] m_socket; //先定义个缓冲池

public void CreateSocketPool()

{

string ip= “127001”;

string port= 2003;

IPAddress serverIp=IPAddressParse(ip);

int serverPort=ConvertToInt32(port);

IPEndPoint iep=new IPEndPoint(serverIp,serverPort);

m_socket = new XieGouSocket[200];

for(int i =0; i {

m_socket[i] = new XieGouSocket();

m_socket[i]m_index = i ;

m_socket[i]m_isFree = true;

m_socket[i]m_socket =new Socket (AddressFamilyInterNetwork,SocketTypeStream,ProtocolTypeTcp);

m_socket[i]m_socketSetSocketOption (SocketOptionLevelSocket,SocketOptionNameSendTimeout,1000);

m_socket[i]m_socketConnect(iep);

}

}

下面的函数是获取当前空闲的socket链接：

因为是多线程，所以需要加一个原子 *** 作，定义一个原子变量，以防止多个线程 之间抢占资源问题的发生。

private static Mutex m_mutex=new Mutex();

public static XieGouSocket GetFreeConnection()

{

m_mutexWaitOne(); //先阻塞

for(int i =0; i {

if(m_socket[i]m_isFree) //如果找到一个空闲的

{

m_socket[i]m_isFree = false;

m_mutexReleaseMutex();//释放资源

return m_socket[i];

}

}

//如果没有空闲的链接，要么等待，要么程序再动态创建一个链接。

m_mutexReleaseMutex();//释放资源

return null;

}

当数据发送完毕后，程序必须将m_isFree 设置为 False。否则只使用不释放，程序很 快就溢出了。

以上就是关于java中用socket通信怎么获取访问者的IP全部的内容，包括:java中用socket通信怎么获取访问者的IP、疯狂Java讲义：使用Socket进行通信[2]、TCP及Socket等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！