当前位置: 首页 > 编程笔记 >

Android通过Socket与服务器之间进行通信的示例

云焱
2023-03-14
本文向大家介绍Android通过Socket与服务器之间进行通信的示例,包括了Android通过Socket与服务器之间进行通信的示例的使用技巧和注意事项,需要的朋友参考一下

一、首先进行Server的编写:

public class SocketServer {
 private static Socket mSocket;

 public static void main(String[] argc) {
  try {
   //1.创建一个服务器端Socket,即ServerSocket,指定绑定的端口,并监听此端口
   ServerSocket serverSocket = new ServerSocket(12345);
   InetAddress address = InetAddress.getLocalHost();
   String ip = address.getHostAddress();

   //2.调用accept()等待客户端连接
   System.out.println("~~~服务端已就绪,等待客户端接入~,服务端ip地址: " + ip);
   mSocket = serverSocket.accept();

   //3.连接后获取输入流,读取客户端信息
   InputStream is = null;
   InputStreamReader isr = null;
   BufferedReader br = null;
   OutputStream os = null;
   is = mSocket.getInputStream();
   isr = new InputStreamReader(is, "UTF-8");
   br = new BufferedReader(isr);
   String info = null;
   while ((info = br.readLine()) != null) {
    System.out.println("客户端发送过来的信息" + info);
    if (info.equals(BackService.HEART_BEAT_STRING)) {
     sendmsg("ok");

    } else {
     sendmsg("服务器发送过来的信息" + info);

    }
   }

   mSocket.shutdownInput();
   mSocket.close();

  } catch (IOException e) {
   e.printStackTrace();
  }

}


 //为连接上服务端的每个客户端发送信息
 public static void sendmsg(String msg) {
  PrintWriter pout = null;
  try {
   pout = new PrintWriter(new BufferedWriter(
    new OutputStreamWriter(mSocket.getOutputStream(), "UTF-8")), true);
   pout.println(msg);
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

二、对客户端的编写,主要用用AIDL进行Server和Client

AIDL 的编写主要为以下三部分:

1、创建 AIDL

1)、创建要操作的实体类,实现 Parcelable 接口,以便序列化/反序列化
2)、新建 aidl 文件夹,在其中创建接口 aidl 文件以及实体类的映射 aidl 文件
3)、Make project ,生成 Binder 的 Java 文件

2、服务端

1)、创建 Service,在其中创建上面生成的 Binder 对象实例,实现接口定义的方法
2)、在 onBind() 中返回

3、客户端

1)、实现 ServiceConnection 接口,在其中拿到 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的编写,命名为BackService

public class BackService extends Service {
 private static final String TAG = "danxx";
 public static final String HEART_BEAT_STRING = "HeartBeat";//心跳包内容
 /**
  * 心跳频率
  */
 private static final long HEART_BEAT_RATE = 3 * 1000;
 /**
  * 服务器ip地址
  */
 public static final String HOST = "172.16.50.115";
 /**
  * 服务器端口号
  */
 public static final int PORT = 12345;
 /**
  * 服务器消息回复广播
  */
 public static final String MESSAGE_ACTION = "message_ACTION";
 /**
  * 服务器心跳回复广播
  */
 public static final String HEART_BEAT_ACTION = "heart_beat_ACTION";
 /**
  * 读线程
  */
 private ReadThread mReadThread;

 private LocalBroadcastManager mLocalBroadcastManager;
 /***/
 private WeakReference<Socket> mSocket;

 // For heart Beat
 private Handler mHandler = new Handler();
 /**
  * 心跳任务,不断重复调用自己
  */
 private Runnable heartBeatRunnable = new Runnable() {

  @Override
  public void run() {
   if (System.currentTimeMillis() - sendTime >= HEART_BEAT_RATE) {
    boolean isSuccess = sendMsg(HEART_BEAT_STRING);//就发送一个\r\n过去 如果发送失败,就重新初始化一个socket
    if (!isSuccess) {
     mHandler.removeCallbacks(heartBeatRunnable);
     mReadThread.release();
     releaseLastSocket(mSocket);
     new InitSocketThread().start();
    }
   }
   mHandler.postDelayed(this, HEART_BEAT_RATE);
  }
 };

 private long sendTime = 0L;
 /**
  * aidl通讯回调
  */
 private IBackService.Stub iBackService = new IBackService.Stub() {

  /**
   * 收到内容发送消息
   * @param message 需要发送到服务器的消息
   * @return
   * @throws RemoteException
   */
  @Override
  public boolean sendMessage(String message) throws RemoteException {
   return sendMsg(message);
  }
 };

 @Override
 public IBinder onBind(Intent arg0) {
  return iBackService;
 }

 @Override
 public void onCreate() {
  super.onCreate();
  new InitSocketThread().start();
  mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);
 }

 public boolean sendMsg(final String msg) {
  if (null == mSocket || null == mSocket.get()) {
   return false;
  }
  final Socket soc = mSocket.get();
  if (!soc.isClosed() && !soc.isOutputShutdown()) {
   new Thread(new Runnable() {
    @Override
    public void run() {
     try {
      OutputStream os = soc.getOutputStream();
      String message = msg + "\r\n";
      os.write(message.getBytes());
      os.flush();
     } catch (IOException e) {
      e.printStackTrace();
     }
    }
   }).start();
   sendTime = System.currentTimeMillis();//每次发送成数据,就改一下最后成功发送的时间,节省心跳间隔时间
  } else {
   return false;
  }
  return true;
 }

 private void initSocket() {//初始化Socket
  try {
   //1.创建客户端Socket,指定服务器地址和端口
   Socket so = new Socket(HOST, PORT);
   mSocket = new WeakReference<Socket>(so);
   mReadThread = new ReadThread(so);
   mReadThread.start();
   mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);//初始化成功后,就准备发送心跳包
  } catch (UnknownHostException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }

 /**
  * 心跳机制判断出socket已经断开后,就销毁连接方便重新创建连接
  *
  * @param mSocket
  */
 private void releaseLastSocket(WeakReference<Socket> mSocket) {
  try {
   if (null != mSocket) {
    Socket sk = mSocket.get();
    if (!sk.isClosed()) {
     sk.close();
    }
    sk = null;
    mSocket = null;
   }
  } catch (IOException e) {
   e.printStackTrace();
  }
 }

 class InitSocketThread extends Thread {
  @Override
  public void run() {
   super.run();
   initSocket();
  }
 }

 // Thread to read content from Socket
 class ReadThread extends Thread {
  private WeakReference<Socket> mWeakSocket;
  private boolean isStart = true;

  public ReadThread(Socket socket) {
   mWeakSocket = new WeakReference<Socket>(socket);
  }

  public void release() {
   isStart = false;
   releaseLastSocket(mWeakSocket);
  }

  @Override
  public void run() {
   super.run();
   Socket socket = mWeakSocket.get();
   if (null != socket) {
    try {
     InputStream is = socket.getInputStream();
     byte[] buffer = new byte[1024 * 4];
     int length = 0;
     while (!socket.isClosed() && !socket.isInputShutdown() && isStart && ((length = is.read(buffer)) != -1)) {
      if (length > 0) {
       String message = new String(Arrays.copyOf(buffer, length)).trim();
       Log.e(TAG, message);
       //收到服务器过来的消息,就通过Broadcast发送出去
       if (message.equals("ok")) {//处理心跳回复
        Intent intent = new Intent(HEART_BEAT_ACTION);
        mLocalBroadcastManager.sendBroadcast(intent);

       } else {
        //其他消息回复
        Intent intent = new Intent(MESSAGE_ACTION);
        intent.putExtra("message", message);
        mLocalBroadcastManager.sendBroadcast(intent);
       }
      }
     }
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
  }
 }

 @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 = new ServiceConnection() {

  @Override
  public void onServiceDisconnected(ComponentName name) {
   iBackService = null;

  }

  @Override
  public void onServiceConnected(ComponentName name, IBinder service) {
   iBackService = IBackService.Stub.asInterface(service);
  }
 };

 class MessageBackReciver extends BroadcastReceiver {
  private WeakReference<TextView> textView;

  public MessageBackReciver(TextView tv) {
   textView = new WeakReference<TextView>(tv);
  }

  @Override
  public void onReceive(Context context, Intent intent) {
   String action = intent.getAction();
   TextView tv = textView.get();
   if (action.equals(BackService.HEART_BEAT_ACTION)) {
    if (null != tv) {
     Log.i("danxx", "Get a heart heat");
     tv.setText("Get a heart heat");
    }
   } else {
    Log.i("danxx", "Get a heart heat");
    String message = intent.getStringExtra("message");
    tv.setText("服务器消息:" + message);
   }
  }
 }

 private MessageBackReciver mReciver;

 private IntentFilter mIntentFilter;

 private LocalBroadcastManager mLocalBroadcastManager;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);

  mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);

  mResultText = (TextView) findViewById(R.id.resule_text);
  mEditText = (EditText) findViewById(R.id.content_edit);
  findViewById(R.id.send).setOnClickListener(this);
  findViewById(R.id.send1).setOnClickListener(this);
  mReciver = new MessageBackReciver(mResultText);

  mServiceIntent = new Intent(this, BackService.class);

  mIntentFilter = new IntentFilter();
  mIntentFilter.addAction(BackService.HEART_BEAT_ACTION);
  mIntentFilter.addAction(BackService.MESSAGE_ACTION);

 }

 @Override
 protected void onStart() {
  super.onStart();
  mLocalBroadcastManager.registerReceiver(mReciver, mIntentFilter);
  bindService(mServiceIntent, conn, BIND_AUTO_CREATE);
 }

 @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 = mEditText.getText().toString();
    try {
     boolean isSend = 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() {
     @Override
     public void run() {
      try {
       acceptServer();
      } catch (IOException e) {
       e.printStackTrace();
      }
     }
    }).start();
    break;

   default:
    break;
  }
 }


 private void acceptServer() throws IOException {
  //1.创建客户端Socket,指定服务器地址和端口
  Socket socket = new Socket("172.16.50.115", 12345);
  //2.获取输出流,向服务器端发送信息
  OutputStream os = socket.getOutputStream();
  PrintWriter printWriter = new PrintWriter(os); //将输出流包装为打印流

  //获取客户端的IP地址
  InetAddress address = InetAddress.getLocalHost();
  String ip = address.getHostAddress();
  printWriter.write("客户端:~" + ip + "~ 接入服务器!!");
  printWriter.flush();
  socket.shutdownInput();
  socket.close();
 }
}

源码地址

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持小牛知识库。

 类似资料:
  • 问题内容: 我知道这并不是一件容易的事,但是很遗憾,自昨天以来我一直被困在这里并与之抗争。我遵循了Android互助身份验证教程,将密钥库放置在资源中并尝试通过SSL连接到我的服务器,但是得到以下异常 java.lang.RuntimeException:org.spongycastle.jcajce.provider.asymmetric.x509.CertificateFactory $ Ex

  • 本文向大家介绍python服务器与android客户端socket通信实例,包括了python服务器与android客户端socket通信实例的使用技巧和注意事项,需要的朋友参考一下 本文实例讲述了python服务器与android客户端socket通信的方法。分享给大家供大家参考。具体实现方法如下: 首先,服务器端使用python完成,下面为python代码: 下面是Android代码: 安卓代

  • 我正在开发一个应用程序,需要在Windows/Linux/Mac计算机上建立一个服务器,该服务器需要通过现有的WiFi网络与Android/iOS设备通信。 我现在只是在研究阶段,虽然我可以找到在PC-Android、PC-iOS、iOS等之间交流的答案,但我找不到一个可以做到这一切的答案。 当然,这两个平台的移动应用程序是不同的,但是服务器应用程序最好是相同的,并且应该是跨平台的。我还应该提到服

  • 问题内容: 我的项目结构如下 我试图像这样从模块(即默认模块)导入, 但事实证明。但是我可以在内部实现相同的功能。请注意,我正在同时运行和文件。 问题答案: 部署后,GAE服务/模块不会在其模块目录(文件所在的目录)之外共享 任何内容。 因此,在dir(存在的地方)上方看不到任何东西,因此看不到。但是可以,因为模型位于其目录(存在)中。 如果需要,可以在内部进行符号链接,请参阅在App Engin

  • Web主要围绕HTTP的请求/响应范例构建。客户端加载网页,然后在用户点击下一页之前没有任何操作。大约在2005年,AJAX开始让网络感觉更有活力。仍然,所有HTTP通信都由客户端引导,这需要用户交互或定期轮询以从服务器加载新数据。 使服务器能够在知道新数据可用的瞬间将数据发送到客户端的技术已存在很长时间了。它们的名称如“Push”或“Comet”。 将套接字引入Web Websocket规范定义

  • 本文向大家介绍PHP的Socket通信之UDP通信实例,包括了PHP的Socket通信之UDP通信实例的使用技巧和注意事项,需要的朋友参考一下 本文实例讲述了PHP的Socket通信之UDP通信方法。分享给大家供大家参考。具体如下: 1.创建一简单的UDP服务器 2.简单的客户端 希望本文所述对大家的php程序设计有所帮助。