一、首先进行Server的编写&＃xff1a;
public class SocketServer {
private static Socket mSocket;
public static void main(String[] argc) {
try {
//1.创建一个服务器端Socket&＃xff0c;即ServerSocket&＃xff0c;指定绑定的端口&＃xff0c;并监听此端口
ServerSocket serverSocket &＃61; new ServerSocket(12345);
InetAddress address &＃61; InetAddress.getLocalHost();
String ip &＃61; address.getHostAddress();
//2.调用accept()等待客户端连接
System.out.println("~~~服务端已就绪&＃xff0c;等待客户端接入~&＃xff0c;服务端ip地址: " &＃43; ip);
mSocket &＃61; serverSocket.accept();
//3.连接后获取输入流&＃xff0c;读取客户端信息
InputStream is &＃61; null;
InputStreamReader isr &＃61; null;
BufferedReader br &＃61; null;
OutputStream os &＃61; null;
is &＃61; mSocket.getInputStream();
isr &＃61; new InputStreamReader(is, "UTF-8");
br &＃61; new BufferedReader(isr);
String info &＃61; null;
while ((info &＃61; br.readLine()) !&＃61; null) {
System.out.println("客户端发送过来的信息" &＃43; info);
if (info.equals(BackService.HEART_BEAT_STRING)) {
sendmsg("ok");
} else {
sendmsg("服务器发送过来的信息" &＃43; info);
}
}
mSocket.shutdownInput();
mSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//为连接上服务端的每个客户端发送信息
public static void sendmsg(String msg) {
PrintWriter pout &＃61; null;
try {
pout &＃61; new PrintWriter(new BufferedWriter(
new OutputStreamWriter(mSocket.getOutputStream(), "UTF-8")), true);
pout.println(msg);
} catch (IOException e) {
e.printStackTrace();
}
}
}
二、对客户端的编写&＃xff0c;主要用用AIDL进行Server和Client
AIDL 的编写主要为以下三部分&＃xff1a;
1、创建 AIDL
1)、创建要操作的实体类&＃xff0c;实现 Parcelable 接口&＃xff0c;以便序列化/反序列化
2)、新建 aidl 文件夹&＃xff0c;在其中创建接口 aidl 文件以及实体类的映射 aidl 文件
3)、Make project &＃xff0c;生成 Binder 的 Java 文件
2、服务端
1)、创建 Service&＃xff0c;在其中创建上面生成的 Binder 对象实例&＃xff0c;实现接口定义的方法
2)、在 onBind() 中返回
3、客户端
1)、实现 ServiceConnection 接口&＃xff0c;在其中拿到 AIDL 类
2)、bindService()
3)、调用 AIDL 类中定义好的操作请求
IBackService.aidl 文件
package com.example.dell.aidlservice;
// Declare any non-default types here with import statements
interface IBackService {
/**
* Demonstrates some basic types that you can use as parameters
* and return values in AIDL.
*/
boolean sendMessage(String message);
}
Service的编写&＃xff0c;命名为BackService
public class BackService extends Service {
private static final String TAG &＃61; "danxx";
public static final String HEART_BEAT_STRING &＃61; "HeartBeat";//心跳包内容
/**
* 心跳频率
*/
private static final long HEART_BEAT_RATE &＃61; 3 * 1000;
/**
* 服务器ip地址
*/
public static final String HOST &＃61; "172.16.50.115";
/**
* 服务器端口号
*/
public static final int PORT &＃61; 12345;
/**
* 服务器消息回复广播
*/
public static final String MESSAGE_ACTION &＃61; "message_ACTION";
/**
* 服务器心跳回复广播
*/
public static final String HEART_BEAT_ACTION &＃61; "heart_beat_ACTION";
/**
* 读线程
*/
private ReadThread mReadThread;
private LocalBroadcastManager mLocalBroadcastManager;
/***/
private WeakReference mSocket;
// For heart Beat
private Handler mHandler &＃61; new Handler();
/**
* 心跳任务&＃xff0c;不断重复调用自己
*/
private Runnable heartBeatRunnable &＃61; new Runnable() {
&＃64;Override
public void run() {
if (System.currentTimeMillis() - sendTime >&＃61; HEART_BEAT_RATE) {
boolean isSuccess &＃61; sendMsg(HEART_BEAT_STRING);//就发送一个\r\n过去 如果发送失败&＃xff0c;就重新初始化一个socket
if (!isSuccess) {
mHandler.removeCallbacks(heartBeatRunnable);
mReadThread.release();
releaseLastSocket(mSocket);
new InitSocketThread().start();
}
}
mHandler.postDelayed(this, HEART_BEAT_RATE);
}
};
private long sendTime &＃61; 0L;
/**
* aidl通讯回调
*/
private IBackService.Stub iBackService &＃61; new IBackService.Stub() {
/**
* 收到内容发送消息
* &＃64;param message 需要发送到服务器的消息
* &＃64;return
* &＃64;throws RemoteException
*/
&＃64;Override
public boolean sendMessage(String message) throws RemoteException {
return sendMsg(message);
}
};
&＃64;Override
public IBinder onBind(Intent arg0) {
return iBackService;
}
&＃64;Override
public void onCreate() {
super.onCreate();
new InitSocketThread().start();
mLocalBroadcastManager &＃61; LocalBroadcastManager.getInstance(this);
}
public boolean sendMsg(final String msg) {
if (null &＃61;&＃61; mSocket || null &＃61;&＃61; mSocket.get()) {
return false;
}
final Socket soc &＃61; mSocket.get();
if (!soc.isClosed() && !soc.isOutputShutdown()) {
new Thread(new Runnable() {
&＃64;Override
public void run() {
try {
OutputStream os &＃61; soc.getOutputStream();
String message &＃61; msg &＃43; "\r\n";
os.write(message.getBytes());
os.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
sendTime &＃61; System.currentTimeMillis();//每次发送成数据&＃xff0c;就改一下最后成功发送的时间&＃xff0c;节省心跳间隔时间
} else {
return false;
}
return true;
}
private void initSocket() {//初始化Socket
try {
//1.创建客户端Socket&＃xff0c;指定服务器地址和端口
Socket so &＃61; new Socket(HOST, PORT);
mSocket &＃61; new WeakReference(so);
mReadThread &＃61; new ReadThread(so);
mReadThread.start();
mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);//初始化成功后&＃xff0c;就准备发送心跳包
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 心跳机制判断出socket已经断开后&＃xff0c;就销毁连接方便重新创建连接
*
* &＃64;param mSocket
*/
private void releaseLastSocket(WeakReference mSocket) {
try {
if (null !&＃61; mSocket) {
Socket sk &＃61; mSocket.get();
if (!sk.isClosed()) {
sk.close();
}
sk &＃61; null;
mSocket &＃61; null;
}
} catch (IOException e) {
e.printStackTrace();
}
}
class InitSocketThread extends Thread {
&＃64;Override
public void run() {
super.run();
initSocket();
}
}
// Thread to read content from Socket
class ReadThread extends Thread {
private WeakReference mWeakSocket;
private boolean isStart &＃61; true;
public ReadThread(Socket socket) {
mWeakSocket &＃61; new WeakReference(socket);
}
public void release() {
isStart &＃61; false;
releaseLastSocket(mWeakSocket);
}
&＃64;Override
public void run() {
super.run();
Socket socket &＃61; mWeakSocket.get();
if (null !&＃61; socket) {
try {
InputStream is &＃61; socket.getInputStream();
byte[] buffer &＃61; new byte[1024 * 4];
int length &＃61; 0;
while (!socket.isClosed() && !socket.isInputShutdown() && isStart && ((length &＃61; is.read(buffer)) !&＃61; -1)) {
if (length > 0) {
String message &＃61; new String(Arrays.copyOf(buffer, length)).trim();
Log.e(TAG, message);
//收到服务器过来的消息&＃xff0c;就通过Broadcast发送出去
if (message.equals("ok")) {//处理心跳回复
Intent intent &＃61; new Intent(HEART_BEAT_ACTION);
mLocalBroadcastManager.sendBroadcast(intent);
} else {
//其他消息回复
Intent intent &＃61; new Intent(MESSAGE_ACTION);
intent.putExtra("message", message);
mLocalBroadcastManager.sendBroadcast(intent);
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
&＃64;Override
public void onDestroy() {
super.onDestroy();
mHandler.removeCallbacks(heartBeatRunnable);
mReadThread.release();
releaseLastSocket(mSocket);
}
}
MainActivity
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
private TextView mResultText;
private EditText mEditText;
private Intent mServiceIntent;
private IBackService iBackService;
private ServiceConnection conn &＃61; new ServiceConnection() {
&＃64;Override
public void onServiceDisconnected(ComponentName name) {
iBackService &＃61; null;
}
&＃64;Override
public void onServiceConnected(ComponentName name, IBinder service) {
iBackService &＃61; IBackService.Stub.asInterface(service);
}
};
class MessageBackReciver extends BroadcastReceiver {
private WeakReference textView;
public MessageBackReciver(TextView tv) {
textView &＃61; new WeakReference(tv);
}
&＃64;Override
public void onReceive(Context context, Intent intent) {
String action &＃61; intent.getAction();
TextView tv &＃61; textView.get();
if (action.equals(BackService.HEART_BEAT_ACTION)) {
if (null !&＃61; tv) {
Log.i("danxx", "Get a heart heat");
tv.setText("Get a heart heat");
}
} else {
Log.i("danxx", "Get a heart heat");
String message &＃61; intent.getStringExtra("message");
tv.setText("服务器消息:" &＃43; message);
}
}
}
private MessageBackReciver mReciver;
private IntentFilter mIntentFilter;
private LocalBroadcastManager mLocalBroadcastManager;
&＃64;Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mLocalBroadcastManager &＃61; LocalBroadcastManager.getInstance(this);
mResultText &＃61; (TextView) findViewById(R.id.resule_text);
mEditText &＃61; (EditText) findViewById(R.id.content_edit);
findViewById(R.id.send).setOnClickListener(this);
findViewById(R.id.send1).setOnClickListener(this);
mReciver &＃61; new MessageBackReciver(mResultText);
mServiceIntent &＃61; new Intent(this, BackService.class);
mIntentFilter &＃61; new IntentFilter();
mIntentFilter.addAction(BackService.HEART_BEAT_ACTION);
mIntentFilter.addAction(BackService.MESSAGE_ACTION);
}
&＃64;Override
protected void onStart() {
super.onStart();
mLocalBroadcastManager.registerReceiver(mReciver, mIntentFilter);
bindService(mServiceIntent, conn, BIND_AUTO_CREATE);
}
&＃64;Override
protected void onStop() {
super.onStop();
unbindService(conn);
mLocalBroadcastManager.unregisterReceiver(mReciver);
}
public void onClick(View view) {
switch (view.getId()) {
case R.id.send:
String content &＃61; mEditText.getText().toString();
try {
boolean isSend &＃61; iBackService.sendMessage(content);//Send Content by socket
Toast.makeText(this, isSend ? "success" : "fail", Toast.LENGTH_SHORT).show();
mEditText.setText("");
} catch (RemoteException e) {
e.printStackTrace();
}
break;
case R.id.send1:
new Thread(new Runnable() {
&＃64;Override
public void run() {
try {
acceptServer();
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
break;
default:
break;
}
}
private void acceptServer() throws IOException {
//1.创建客户端Socket&＃xff0c;指定服务器地址和端口
Socket socket &＃61; new Socket("172.16.50.115", 12345);
//2.获取输出流&＃xff0c;向服务器端发送信息
OutputStream os &＃61; socket.getOutputStream();
PrintWriter printWriter &＃61; new PrintWriter(os); //将输出流包装为打印流
//获取客户端的IP地址
InetAddress address &＃61; InetAddress.getLocalHost();
String ip &＃61; address.getHostAddress();
printWriter.write("客户端&＃xff1a;~" &＃43; ip &＃43; "~ 接入服务器&＃xff01;&＃xff01;");
printWriter.flush();
socket.shutdownInput();
socket.close();
}
}
以上就是本文的全部内容&＃xff0c;希望对大家的学习有所帮助&＃xff0c;也希望大家多多支持脚本之家。
京公网安备 11010802041100号