Socket通信工具类
TCP客户端
public class TCPClientUtil {
public static final String TAG = "Control";
private Socket mSocket;
private final ExecutorService mExecutorService;
public TCPClientUtil(){
mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
}
public void startClient(final String address,final int port){
if (address == null){
return;
}
if (mSocket == null){
Runnable mRunnable = new Runnable() {
@Override
public void run() {
try {
Log.i(TAG,"TCP启动客户端成功");
mSocket = new Socket(address, port);
Log.i(TAG,"TCP客户端连接成功");
InputStream inputStream = mSocket.getInputStream();
byte[] buffer = new byte[1024];
int len = -1;
while ((len = inputStream.read(buffer))!=-1){
// 将读取到的数据复制到一个新的数组中
//String s = new String(buffer, 0, len);
byte[] data = Arrays.copyOfRange(buffer, 0, len);
mIMessageCallback.callback(data);
Log.i(TAG, "TCP收到服务器的数据-------:" + Arrays.toString(data));
}
mIServerDisConnect.callback();
Log.i(TAG,"TCP客户端断开连接");
} catch (Exception e) {
Log.e(TAG,"TCP 客户端无法连接服务器:"+e.getMessage());
} finally {
try {
if (mSocket != null){
mSocket.close();
}
}catch (IOException e){
e.printStackTrace();
}
mSocket = null;
}
}
};
mExecutorService.execute(mRunnable);
}
}
public void sendTcpMessage(final byte[] msg){
if (mSocket != null && mSocket.isConnected()){
Runnable mRunnable = new Runnable() {
@Override
public void run() {
try {
mSocket.getOutputStream().write(msg);
mSocket.getOutputStream().flush();
Log.i(TAG,"TCP客户端发送数据-------:"+ Arrays.toString(msg));
} catch (IOException e) {
e.printStackTrace();
}
}
};
mExecutorService.execute(mRunnable);
}
}
public boolean isConnect(){
if (mSocket != null){
return mSocket.isConnected();
}else {
return false;
}
}
public void closeConnect() throws IOException {
mSocket.close();
}
IServerDisConnect mIServerDisConnect;
public interface IServerDisConnect{
void callback();
}
public void setIServerDisConnect(IServerDisConnect serverDisConnect){
this.mIServerDisConnect = serverDisConnect;
}
IMessageCallback mIMessageCallback;
public interface IMessageCallback{
void callback(byte[] bytes);
}
public void setIMessageCallback(IMessageCallback messageCallback){
this.mIMessageCallback = messageCallback;
}
}
TCP服务端
public class TCPServerUtil {
public static final String TAG = "TCP";
private ServerSocket mServerSocket;
private ExecutorService mExecutorService;
private Socket mSocket;
public TCPServerUtil() {
mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
try {
Log.i("tcp", "启动服务端");
mServerSocket = new ServerSocket(8989);
Log.i("tcp", "服务端连接成功");
} catch (Exception e) {
Log.i("tcp", "启动服务端失败");
}
}
public void startSever() {
Runnable mRunnable = new Runnable() {
@Override
public void run() {
while (true) {
try {
mSocket = mServerSocket.accept();
Log.i(TAG, mSocket.getRemoteSocketAddress().toString() + "");
InputStream inputStream = mSocket.getInputStream();
byte[] buffer = new byte[1024];
int len = -1;
while ((len = inputStream.read(buffer)) != -1) {
byte[] data = Arrays.copyOfRange(buffer, 0, len);
//String data = new String(buffer, 0, len);
mIMessageCallback.callback(data);
Log.i(TAG, "收到客户端的数据-------------------:" + data);
}
Log.i(TAG, "客户端断开连接");
} catch (Exception EE) {
EE.printStackTrace();
Log.i(TAG, "服务端无法连接服务器" + EE.getMessage());
break;
} finally {
try {
if (mServerSocket != null) {
mServerSocket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
mServerSocket = null;
}
}
}
};
mExecutorService.execute(mRunnable);
}
public void sendTcpMessage(final byte[] msg) {
Runnable mRunnable = new Runnable() {
@Override
public void run() {
try {
mSocket.getOutputStream().write(msg);
mSocket.getOutputStream().flush();
} catch (IOException e) {
e.printStackTrace();
}
}
};
mExecutorService.execute(mRunnable);
}
public void des() {
try {
mServerSocket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public IMessageCallback mIMessageCallback;
public interface IMessageCallback {
void callback(byte[] data);
}
public void setIMessageCallback(IMessageCallback messageCallback) {
this.mIMessageCallback = messageCallback;
}
}
UDP客户端
ublic class UDPClientUtil {
public static final String TAG = "Control";
private DatagramSocket mDatagramSocket;
private ExecutorService mExecutorService;
private DatagramPacket sendPacket;
private DatagramPacket receivePacket;
private InetSocketAddress address;
public UDPClientUtil() {
mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
}
public void startClient() {
if (mDatagramSocket == null) {
Runnable mRunnable = new Runnable() {
@Override
public void run() {
try {
Log.i(TAG, "UDP启动客户端");
mDatagramSocket = new DatagramSocket(8989);//本机监听的端口
mDatagramSocket.setReuseAddress(true);
Log.i(TAG, "UDP客户端连接成功");
byte[] buffer = new byte[1024];
int len = -1;
while (true) {
receivePacket = new DatagramPacket(buffer, buffer.length);
mDatagramSocket.receive(receivePacket);
Log.i(TAG, receivePacket.getAddress().toString() + ":" + receivePacket.getPort());
byte[] data = Arrays.copyOfRange(receivePacket.getData(), receivePacket.getOffset(), receivePacket.getLength());
//String data = new String(receivePacket.getData(), 0, receivePacket.getData().length, "utf-8");//针对中文要采用utf-8
mIMessageCallback.callback(data);
Log.i(TAG, "收到UDP服务器的数据--------:" + Arrays.toString(data));
}
//Log.i(TAG, "客户端断开连接");
} catch (Exception e) {
Log.e(TAG,"UDP 客户端无法连接服务器:"+e.getMessage());
} finally {
try {
if (mDatagramSocket != null) {
mDatagramSocket.close();
}
} catch (Exception e) {
e.printStackTrace();
}
mDatagramSocket = null;
}
}
};
mExecutorService.execute(mRunnable);
}
}
/**
* @param msg 要发送的数据
* @param ip 目标IP地址
* @param port 目标端口号
*/
public void sendUdpMessage(final byte[] msg, final String ip, final int port) {
if (mDatagramSocket != null) {
Runnable mRunnable = new Runnable() {
@Override
public void run() {
try {
sendPacket = new DatagramPacket(msg, msg.length, InetAddress.getByName(ip), port);
mDatagramSocket.send(sendPacket);
Log.i(TAG,"UDP客户端发送数据-------:"+ Arrays.toString(msg)+"向服务器发送"+ip+":"+port);
} catch (IOException e) {
e.printStackTrace();
}
}
};
mExecutorService.execute(mRunnable);
}
}
public boolean isConnect(){
if (mDatagramSocket != null){
return mDatagramSocket.isConnected();
}else {
return false;
}
}
public void closeConnect(){
mDatagramSocket.close();
}
IMessageCallback mIMessageCallback;
public interface IMessageCallback {
void callback(byte[] data);
}
public void setIMessageCallback(IMessageCallback messageCallback) {
this.mIMessageCallback = messageCallback;
}
}
UDP服务端
public class UDPServerUtil {
public static final String TAG = "UDP";
private DatagramSocket mDatagramSocket;
private ExecutorService mExecutorService;
private DatagramPacket sendPacket;
private DatagramPacket receivePacket;
public UDPServerUtil() {
mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
try {
Log.i(TAG, "启动服务端");
mDatagramSocket = new DatagramSocket(8989);
Log.i(TAG, "服务端连接成功");
} catch (Exception e) {
Log.i(TAG, "启动服务端失败");
}
}
public void startClient() {
Runnable mRunnable = new Runnable() {
@Override
public void run() {
try {
byte[] buffer = new byte[1024];
int len = -1;
receivePacket = new DatagramPacket(buffer, buffer.length);
while (true) {
mDatagramSocket.receive(receivePacket);
byte[] data = Arrays.copyOfRange(receivePacket.getData(), receivePacket.getOffset(), receivePacket.getLength());
//String data = new String(receivePacket.getData(), 0, buffer.length, "utf-8");//针对中文要采用utf-8
mIMessageCallback.callback(data);
Log.i(TAG, "收到服务器的数据-------------------:" + data);
}
} catch (Exception EE) {
EE.printStackTrace();
Log.i(TAG, "客户端无法连接服务器" + EE.getMessage());
} finally {
try {
if (mDatagramSocket != null) {
mDatagramSocket.close();
}
} catch (Exception e) {
e.printStackTrace();
}
mDatagramSocket = null;
}
}
};
mExecutorService.execute(mRunnable);
}
public void sendTcpMessage(final byte[] msg, final String ip, final int port) {
if (mDatagramSocket != null) {
Runnable mRunnable = new Runnable() {
@Override
public void run() {
try {
sendPacket = new DatagramPacket(msg, msg.length, InetAddress.getByName(ip), port);
mDatagramSocket.send(sendPacket);
} catch (IOException e) {
e.printStackTrace();
}
}
};
mExecutorService.execute(mRunnable);
}
}
public void des() {
try {
mDatagramSocket.close();
} catch (Exception e) {
Log.i(TAG, e.toString());
}
}
public IMessageCallback mIMessageCallback;
public interface IMessageCallback {
void callback(byte[] data);
}
public void setIMessageCallback(IMessageCallback messageCallback) {
this.mIMessageCallback = messageCallback;
}
}
标签:Socket,void,通信,TAG,new,工具,mDatagramSocket,public,Log
From: https://www.cnblogs.com/liaomengjie/p/17876896.html