java与android通信
① 怎样实现android和javaweb数据交互
要想运行网页上的js脚本,webview必须设置支持Javas cript。
Java代码
1mWebview.getSettings().setJavas criptEnabled(true);
然后是设置webview要加载的网页:
web的网页:webView.loadUrl("http://www.google.com");
本地的网页:webView.loadUrl("file:///android_asset/XX.html"); //本地的存放在:assets文件夹中
webview做完基本的初始化后我们还要要给它,加进一个回调的代理类Javas criptInterface,并给它一个调用的名称:ncp
Java代码
1mWebView.addJavas criptInterface(new Javas criptInterface(),"ncp");
Javas criptInterface可以是一个普通的Java类,类实现的方法,均可被js回调:
Java代码
final class Javas criptInterface {
public int callOnJs() {
return 1000;
}
public void callOnJs2(String mode) {
//TODO
}
}
Java要调用js的方法,只需知道js的方法名称即可:
Java代码
1mWebView.loadUrl("javas cript:onSaveCallback()");
js 这边就更简单:
Js代码
window.onload = function(){
document.getElementById('btn_1').addEventListener('click', onBtnClick, false);
var _int_value = window.ncp.callOnJs();
alert("get int from java:" + _int_value );
}
function onBtnClick() {
window.ncp.callOnJs2("click");
}
Java和js交互有以下一些特点:
1.Java 调用 js 里面的函数,速度并不令人满意,大概一次一两百毫秒吧,如果要做交互性很强的事情,这种速度会让人疯掉的。而反过来就不一样了, js 去调 java 的方法,速度很快,基本上 40-50 毫秒一次。所以尽量用 js 调用 java 方法,而不是 java 去调用 js 函数。
2.Java 调用 js 的函数,没有返回值,而 Js 调用 java 方法,可以有返回值。返回值可以是基本类型、字符串,也可以是对象。如果是字符串,有个很讨厌的问题,第 3 点我会讲的。如果是对象,这个对象会被转换为 js 的对象,直接可以访问里面的方法。但是我不推荐 java 返回给 js 的是对象,除非是必须。因为 js 收到 java 返回的对象,会产生一些交换对象,而如果这些对象的数量增加到了 500 或 600 以上,程序就会出问题。所以尽量返回基本数据类型或者字符串。
3.Js 调用 Java 的方法,返回值如果是字符串,你会发现这个字符串是 native 的,不能对它进行一些修改操作,比如想对它 substr ,取不到。怎么解决呢?转成 locale 的。使用 toLocaleString() 函数就可以了。不过这个函数的速度并不快,转化的字符串如果很多,将会很耗费时间。
② android客户端如何与后台java服务器交互
php做前端,java做后端淘宝是个例子服务器端前后分开是为了两方面，虽然淘宝最开始并不想这样做。。。先说下历史，淘宝是最开始php全部，后来发现开销太大，代码效率不行，就直接把数据存储啊，用户通知啊就交给java实际上大部分网站都乐意采用这种前端php后端java或者c++这种形式，我是phpc++这种。优点，核心动作效率肯定高，c++java这种代码效率奇高。比php脚本好很多。前端php，语法简单，维护简单，部署简单，而且容易找到维护人员。总之就是开发快，维护成本低。大致了解了吗？你说的h5+java实际上就是把java提到前台，不是不可以，维护和开发成本太高了啊。前端开发要经常搞，但是java做前台要调试、编译部署还要重编译。麻烦，人工开销也大。不划算如果是.net技术就更高成本了。光服务器软件一块就要多少了。所以微软的框架用的不多。国内外都不多，用.met的成本开发维护都麻烦。要气硬件条件还苛刻。
③ java服务器推送消息给android
几种常见的解决方案实现原理
1）轮询(Pull)方式：客户端定时向服务器发送询问消息，一旦服务器有变化则立即同步消息。
2）SMS(Push)方式：通过拦截SMS消息并且解析消息内容来了解服务器的命令，但这种方式一般用户在经济上很难承受。
3）持久连接(Push)方式：客户端和服务器之间建立长久连接，这样就可以实现消息的及时行和实时性。
3、消息推送解决方案概述
A、C2DM云端推送方案
在Android手机平台上，Google提供了C2DM（Cloudto Device Messaging）服务。Android
Cloud to Device Messaging (C2DM)是一个用来帮助开发者从服务器向Android应用程序发送数据的服务。该服务提供了一个简单的、轻量级的机制，允许服务器可以通知移动应用程序直接与服务器进行通信，以便于从服务器获取应用程序更新和用户数据。
该方案存在的主要问题是C2DM需要依赖于Google官方提供的C2DM服务器，由于国内的网络环境，这个服务经常不可用。
B、MQTT协议实现Android推送
采用MQTT协议实现Android推送功能也是一种解决方案。MQTT是一个轻量级的消息发布/订阅协议，它是实现基于手机客户端的消息推送服务器的理想解决方案。
wmqtt.jar
是IBM提供的MQTT协议的实现。我们可以从这里（https://github.com/toku/AndroidPushNotificationsDemo）下载该项目的实例代码，并且可以找到一个采用PHP书写的服务器端实现（https://github.com/toku/PhpMQTTClient）。
C、RSMB实现推送功能
Really Small Message Broker (RSMB)
，是一个简单的MQTT代理，同样由IBM提供，其查看地址是：http://www.alphaworks.ibm.com/tech/rsmb。缺省打开1883端口，应用程序当中，它负责接收来自服务器的消息并将其转发给指定的移动设备。SAM是一个针对MQTT写的PHP库。我们可以从这个http://pecl.php.net/package/sam/download/0.2.0地址下载它.
D、XMPP协议实现Android推送
Google官方的C2DM服务器底层也是采用XMPP协议进行的封装。XMPP(可扩展通讯和表示协议)是基于可扩展标记语言（XML）的协议，它用于即时消息（IM）以及在线探测。这个协议可能最终允许因特网用户向因特网上的其他任何人发送即时消息。
androidpn是一个基于XMPP协议的java开源Android push notification实现。它包含了完整的客户端和服务器端。但也存在一些不足之处：
1）
比如时间过长时，就再也收不到推送的信息了。
2）性能上也不够稳定。
3）如果将消息从服务器上推送出去，就不再管理了，不管消息是否成功到达客户端手机上。
如果我们要使用androidpn，则还需要做大量的工作，需要理解XMPP协议、理解Androidpn的实现机制，需要调试内部存在的BUG。
④ JAVA服务端android客户端如何通信
一、HTTP请求(APACHE的HttpClient实现)
服务器端，就是普通的servlet、Strutus2就可以
移动端
protected static String get(String url, List<NameValuePair> params) {
String resultMsg;
// 设置http请求配置
HttpParams parms = new BasicHttpParams();
parms.setParameter("charset", HTTP.UTF_8);
// 配置连接超时
HttpConnectionParams.setConnectionTimeout(parms, 10 * 1000);
// 设置请求超时
HttpConnectionParams.setSoTimeout(parms, 15 * 1000);
// 实例化HttpClient
HttpClient httpclient = new DefaultHttpClient(parms);
// 实例化HttpGet
HttpGet httpget = new HttpGet(url);
// 设置请求头
httpget.addHeader("Content-Type", "application/json");
httpget.addHeader("charset", HTTP.UTF_8);
try {
if (params.size() > 0)
url = url + "?" + URLEncodedUtils.format(params, HTTP.UTF_8);
HttpResponse resp = httpclient.execute(httpget);
int statusCode = resp.getStatusLine().getStatusCode();
if (statusCode == HttpStatus.SC_OK) {
StringBuffer result = getResponse(resp);
resultMsg = result.toString();
} else {
resultMsg = "连接异常";
}
} catch (Exception e) {
resultMsg = "连接异常";
} finally {
// 关闭get
httpget.abort();
// 关闭连接 ,释放资源
httpclient.getConnectionManager().shutdown();
}
return resultMsg;
}
protected static String post(String uri, Object params) {
String resultMsg;
// 设置http请求配置
HttpParams hp = new BasicHttpParams();
hp.setParameter("charset", HTTP.UTF_8);
// 配置连接超时
HttpConnectionParams.setConnectionTimeout(hp, 10 * 1000);
HttpConnectionParams.setSoTimeout(hp, 15 * 1000);
// 实例化HttpClient
HttpClient httpclient = new DefaultHttpClient(hp);
// 实例化HttpPost请求
HttpPost httppost = new HttpPost(uri);
// 设置头信息
httppost.addHeader("Content-Type", "application/json");
httppost.addHeader("charset", HTTP.UTF_8);
try {
// 将参数进行json化
ObjectMapper mapper = new ObjectMapper();
String jsonStr = mapper.writeValueAsString(params);
Log.i(TAG, "URI=" + uri + ",BEAN=" + jsonStr);
// 定义消息实体
StringEntity se = new StringEntity(jsonStr, HTTP.UTF_8);
httppost.setEntity(se);
// 通信
HttpResponse resp = httpclient.execute(httppost);
int statusCode = resp.getStatusLine().getStatusCode();
Log.i(TAG, "StatusCode=" + statusCode);
if (statusCode == HttpStatus.SC_OK) {
StringBuffer result = getResponse(resp);
resultMsg = result.toString();
} else {
resultMsg = "连接异常";
}
} catch (Exception e) {
e.printStackTrace();
resultMsg = "连接异常";
} finally {
// 关闭get
httppost.abort();
// 关闭连接 ,释放资源
httpclient.getConnectionManager().shutdown();
}
Log.i(TAG, resultMsg);
return resultMsg;
}
二、SOCKET连接
服务器端：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class service_java_test {
public static void main(String[] args) throws IOException {
ServerSocket server = new ServerSocket(10000); //绑定的端口号
Socket socket = server.accept(); //连接不成功以至于下一行的"连接成功"
//在调试区显示不出来
System.out.println("连接成功");
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream());
while (true) {
String msg = in.readLine();
System.out.println(msg);
out.println("Server received " + msg); //向接收方发送已接受到了的语句
out.flush();
if (msg.equals("bye")) { //若接收到"bye"则break
break;
}
}
socket.close();
}
}
安卓客户端：
package com.example.t4_android;
import java.net.Socket;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
public class MainActivity extends Activity {
private TextView myTextView;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
myTextView = (TextView) findViewById(R.id.textView1);
Thread t = new Thread(new Runnable(){
public void run(){
try {
Socket sk = new Socket("192.168.253.1", 10000);//绑定套接字，这一行一直执行不成功
//以至于下一行在安卓页面的TextView上
//不显示“已连接”的字样
//"192.168.253.1"是我利用DOS命令查找
//的本机IP
myTextView.setText("已连接");
} catch (Exception e) {
e.printStackTrace();
}
}
});
t.start();
}
}
⑤ 如何干净的实现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 "";
}
}
}