Android中构建数据业务应用

Android中构建数据业务应用

    构建Android中的数据业务应用,Android提供了几种网络访问方式: 移动IP网络(GPRS,基于移动网络的数据应用层 ),WiFi,蓝牙。这里讨论的是基于第一种方式的网络应用。Android主要提供了java.net和org.apache.httpclient两个包来处理相关的网络应用,另外还有android.net这个包,它只是对org.apache.httpclient进行了简单的封装,所以重点介绍apache包的应用,当然也会对java.net作简单介绍。

    

    1:检查网络连接状态

     Android提供各种后台Service以便我们可以获得系统共用对象的实例,ConectivityManager是用来检查网络连接的类,下面代码是它通用使用方法:

     ConnectivityManager  mConnMgr = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);

   

    2:Android中简单的Http访问

    首先通过一个简单的例子使用标准的Java.net API 通过Http Get方法来从指定URL获得一个简单的Html流。Http Get请求只需要把查询参数放入请求的URL中,

    private String getHttpResponse(String location) {

           String result = null;

            URL url = null;

     try {

         url = new URL(location); //构造一个URL对象

        } catch (MalformedURLException e) {

        Log.e(Constants.LOGTAG, “ERROR”, e);

       }

        if (url != null) {

           try {

            HttpURLConnection urlConn = (HttpURLConnection) url.openConnection(); //使用HttpURLConnection打开连接

            BufferedReader in = new BufferedReader(new InputStreamReader(urlConn.getInputStream()));//为输出创建BufferedReader

            String inputLine;

            int lineCount = 0; // limit the lines for the example

           while ((lineCount < 10) && ((inputLine = in.readLine()) != null)) { //读Response中的数据

                    lineCount++;

                    result += “\n” + inputLine; #6

           }

           in.close();

          urlConn.disconnect();

         } catch (IOException e) {

          Log.e(Constants.LOGTAG, “ERROR”, e);

          }

     } else {

          Log.e(Constants.LOGTAG, ” url NULL”);

          }

         return result;

      }

     通过上面可以看到,通过Http访问数据在Anroid是很容易的,但是在实际应用中,通常都是复杂频繁的网络请求访问而不是如例子中简单的获取数据,如果这样的话,例子中的做法就会变得很笨重,为了对Java.net中的类可以被更好的使用,apache提供了HttpClient,它对Java.net中的类做了封装和更好的抽象,用来支持设计更复杂的Http应用,而且能在独立的线程上处理这些请求。

    3:使用HttpClient

     这个例子展示了怎样把网络访问请求运行的独立的线程之中,它使用了Apache的ResponseHandler和Android Handler。

    private final Handler handler = new Handler() {     //创建一个Android Handler

         @Override

          public void handleMessage(final Message msg) {

            progressDialog.dismiss();

            String bundleResult = msg.getData().getString(“RESPONSE”);//在Handler内部来处理刷新UI

            ApacheHTTPSimple.this.output.setText(bundleResult);

         }

};

private void performRequest() {

      final ResponseHandler<String> responseHandler = new ResponseHandler<String>() { //使用ResponseHandler来创建一个异步的Http调用

                  public String handleResponse(HttpResponse response) {//实现OnResponse的回调函数

                        StatusLine status = response.getStatusLine();

                        HttpEntity entity = response.getEntity();//获得Response的Entity

                        String result = null;

                        try {

                           result = StringUtils.inputStreamToString(entity.getContent());

                           Message message = new Message();

                           Bundle bundle = new Bundle();

                           bundle.putString(“RESPONSE”, result);

                           message.setData(bundle);

                           handler.sendMessage(message); //向UI handler发送消息,把Http请求的数据传递给UI进程

                         } catch (IOException e) {}

                        return result;

                      }

                  };

      this.progressDialog = ProgressDialog.show(this, “working . . .”, “performing HTTP request”);

      new Thread() {//使用一个独立线程进行Http请求

            @Override

            public void run() {

                   try {

                       DefaultHttpClient client = new DefaultHttpClient();

                       HttpGet httpMethod = new HttpGet(ApacheHTTPSimple.this.urlChooser.getSelectedItem().toString());//根据URL创建一个HttpGet对象

                       client.execute(httpMethod, responseHandler); //通过HttpClient运行HttpGet

                      } catch (ClientProtocolException e) {

                      Log.e(Constants.LOGTAG, ” ” + ApacheHTTPSimple.CLASSTAG, e);

                     } catch (IOException e) {

                          Log.e(Constants.LOGTAG, ” ” + ApacheHTTPSimple.CLASSTAG, e);

                     }

              }

         }.start();

}

以下是结构示意图

Android中构建数据业务应用

    现在我们已经了解了HttpClient的使用和基本的访问方法, 为了避免重复的创建代码,基于一个稳定的Http访问模型,下面通过分析WebKit的Http访问架构,来展现一个可以兼容Http Get ,Post,多任务而且容易管理结构模型。

    4: WebKit中Http访问架构解析

    下面是模型结构图:

    
Android中构建数据业务应用

把Http Request行为抽象到一个单例中,通过HttpClient进行Get或者Post访问。

ContractedBlock.gif
ExpandedBlockStart.gif
Code

public class NetworkManager {

    
private static NetworkManager sInstance = null;
    
private Context mContext = null;
    
private DefaultHttpClient mHttpClient = null;

    protected String mCookie=null;
   
    
private NetworkManager(Context context) {

        mContext 
= context;
        mHttpClient 
= new DefaultHttpClient();
    }
   
    
public static synchronized NetworkManager getInstance(Context context) {

        
if (null == sInstance) {

            sInstance 
= new NetworkManager(context);
        }   
        
return sInstance;
    }

    public boolean requestURL(String method, String url, Map<String, String> headers,
            
byte[] body, AbstractHttpHandler handler) {

        
//Check URL       
        if (!URLUtil.isValidUrl(url)) {

            Log.e(TAG, 
Invalid URL: + url);
            handler.error(
1Invalid URL: + url);
            
return false;
        }
       
        Log.d(TAG, 
requestURL: + url);
       
       
        
//Http Request
        HttpUriRequest request = null;
       
        
if (HttpGet.METHOD_NAME.equalsIgnoreCase(method)) {

            
//HttpGet
            request = new HttpGet(url);
        } 
else {

            
//HttpPost
            if (null != body && body.length > 0) {

                Log.d(TAG, 
Request Entity: + body.toString());
                
//post.setEntity(new InputStreamEntity(new ByteArrayInputStream(body), body.length));
                post.setEntity(new ByteArrayEntity(body));               
            }
            request 
= post;
        }
       
        
//Http Headers
        addHeaders(request, headers);   
       
        
//Cookie
        request.addHeader(cookiethis.mCookie);
       
        handler.setNetworkManager(
this);
        
//Cache it
        handler.setCachedRequestParam(method, url, headers, body);
       
        
//Connection Timeout
        HttpParams hp = mHttpClient.getParams();
        
if(null != hp) {

            ConnManagerParams.setTimeout(hp, 
5000);
        }
       
        
//Execute Request
        try {

            HttpResponse response 
= mHttpClient.execute(request);
       
            
//Handle Response
            handler.handleResponse(response);
        } 
catch(Exception e) {

            e.printStackTrace();   
        }
       
        
return true;
    }

    public void setCookie(String cookies){

        
this.mCookie=cookies;
    }
}

每个Task负责开启一个访问线程,与UI线程的交互都由Task来完成

ContractedBlock.gif
ExpandedBlockStart.gif
Code

public abstract class AbstractTask implements Runnable {

    
private final static String TAG = AbstractTask;
   
    
public final static int TASK_FINISHED = 1000;
   
    
protected Context mContext = null;
    
protected Handler mCallback = null;
    
private boolean mIsCanceled = false;
    
private int mTaskType=0;
   
    
public final static int ERROR_NO_ERROR = 0;
    
public final static int ERROR_FAILED = 1;
    
public final static int ERROR_RESPONSE_XML = 1000;
    
public final static int ERROR_RESQUEST_XML = 1001;
   
    
public final static int RESPONSE_STATUS_SUCCESS = 0;
   
    
protected int mErrorCode = ERROR_NO_ERROR;
    
protected String mErrorMsg = “”;
   
    
public AbstractTask(Context context, Handler callback) {

        mContext 
= context;
        mCallback 
= callback;
    }
   
    
protected synchronized void finishedCallback() {

        
if (null != mCallback && !isCanceled()) {

            Log.d(TAG, 
finishedCallback);
            Message msg 
= mCallback.obtainMessage(TASK_FINISHED, this);
            mCallback.sendMessage(msg);
            mCallback 
= null;
        }
    }
   
    
public synchronized void cancel() {

        mIsCanceled 
= true;
    }
   
    
public synchronized boolean isCanceled() {

        
return mIsCanceled;
    }
   
    
protected void setError(int code, String msg) {

        mErrorCode 
= code;
        mErrorMsg 
= msg;
    }
   
    
public int getErrorCode() {

        
return mErrorCode;
    }
   
    
public String getErrorMsg() {

        
return mErrorMsg;
    }
   
    
public String formatErrMsg() {

        
return “” + mErrorMsg + ( + mErrorCode + );
    }
   
    
public Handler getCallbackHandler() {

        
return mCallback;
    }
    
public int getTaskType()
    {

        
return mTaskType;
    }
    
public void setTaskType(int type){

        mTaskType
=type;
    }
   
    
public void run() {

    }

}

//类似于ResponseHandler

ContractedBlock.gif
ExpandedBlockStart.gif
Code

public abstract class AbstractTask implements Runnable {

    
private final static String TAG = AbstractTask;
   
    
public final static int TASK_FINISHED = 1000;
   
    
protected Context mContext = null;
    
protected Handler mCallback = null;
    
private boolean mIsCanceled = false;
    
private int mTaskType=0;
   
    
public final static int ERROR_NO_ERROR = 0;
    
public final static int ERROR_FAILED = 1;
    
public final static int ERROR_RESPONSE_XML = 1000;
    
public final static int ERROR_RESQUEST_XML = 1001;
   
    
public final static int RESPONSE_STATUS_SUCCESS = 0;
   
    
protected int mErrorCode = ERROR_NO_ERROR;
    
protected String mErrorMsg = “”;
   
    
public AbstractTask(Context context, Handler callback) {

        mContext 
= context;
        mCallback 
= callback;
    }
   
    
protected synchronized void finishedCallback() {

        
if (null != mCallback && !isCanceled()) {

            Log.d(TAG, 
finishedCallback);
            Message msg 
= mCallback.obtainMessage(TASK_FINISHED, this);
            mCallback.sendMessage(msg);
            mCallback 
= null;
        }
    }
   
    
public synchronized void cancel() {

        mIsCanceled 
= true;
    }
   
    
public synchronized boolean isCanceled() {

        
return mIsCanceled;
    }
   
    
protected void setError(int code, String msg) {

        mErrorCode 
= code;
        mErrorMsg 
= msg;
    }
   
    
public int getErrorCode() {

        
return mErrorCode;
    }
   
    
public String getErrorMsg() {

        
return mErrorMsg;
    }
   
    
public String formatErrMsg() {

        
return “” + mErrorMsg + ( + mErrorCode + );
    }
   
    
public Handler getCallbackHandler() {

        
return mCallback;
    }
    
public int getTaskType()
    {

        
return mTaskType;
    }
    
public void setTaskType(int type){

        mTaskType
=type;
    }
   
    
public void run() {

    }

}

//Demo Task,继承AbstractTask

ContractedBlock.gif
ExpandedBlockStart.gif
Code

public abstract class AbstractTask implements Runnable {

    
private final static String TAG = AbstractTask;
   
    
public final static int TASK_FINISHED = 1000;
   
    
protected Context mContext = null;
    
protected Handler mCallback = null;
    
private boolean mIsCanceled = false;
    
private int mTaskType=0;
   
    
public final static int ERROR_NO_ERROR = 0;
    
public final static int ERROR_FAILED = 1;
    
public final static int ERROR_RESPONSE_XML = 1000;
    
public final static int ERROR_RESQUEST_XML = 1001;
   
    
public final static int RESPONSE_STATUS_SUCCESS = 0;
   
    
protected int mErrorCode = ERROR_NO_ERROR;
    
protected String mErrorMsg = “”;
   
    
public AbstractTask(Context context, Handler callback) {

        mContext 
= context;
        mCallback 
= callback;
    }
   
    
protected synchronized void finishedCallback() {

        
if (null != mCallback && !isCanceled()) {

            Log.d(TAG, 
finishedCallback);
            Message msg 
= mCallback.obtainMessage(TASK_FINISHED, this);
            mCallback.sendMessage(msg);
            mCallback 
= null;
        }
    }
   
    
public synchronized void cancel() {

        mIsCanceled 
= true;
    }
   
    
public synchronized boolean isCanceled() {

        
return mIsCanceled;
    }
   
    
protected void setError(int code, String msg) {

        mErrorCode 
= code;
        mErrorMsg 
= msg;
    }
   
    
public int getErrorCode() {

        
return mErrorCode;
    }
   
    
public String getErrorMsg() {

        
return mErrorMsg;
    }
   
    
public String formatErrMsg() {

        
return “” + mErrorMsg + ( + mErrorCode + );
    }
   
    
public Handler getCallbackHandler() {

        
return mCallback;
    }
    
public int getTaskType()
    {

        
return mTaskType;
    }
    
public void setTaskType(int type){

        mTaskType
=type;
    }
   
    
public void run() {

    }

}

//TaskManager负责创建Task,管理Task

ContractedBlock.gif
ExpandedBlockStart.gif
Code

public abstract class AbstractTask implements Runnable {

    
private final static String TAG = AbstractTask;
   
    
public final static int TASK_FINISHED = 1000;
   
    
protected Context mContext = null;
    
protected Handler mCallback = null;
    
private boolean mIsCanceled = false;
    
private int mTaskType=0;
   
    
public final static int ERROR_NO_ERROR = 0;
    
public final static int ERROR_FAILED = 1;
    
public final static int ERROR_RESPONSE_XML = 1000;
    
public final static int ERROR_RESQUEST_XML = 1001;
   
    
public final static int RESPONSE_STATUS_SUCCESS = 0;
   
    
protected int mErrorCode = ERROR_NO_ERROR;
    
protected String mErrorMsg = “”;
   
    
public AbstractTask(Context context, Handler callback) {

        mContext 
= context;
        mCallback 
= callback;
    }
   
    
protected synchronized void finishedCallback() {

        
if (null != mCallback && !isCanceled()) {

            Log.d(TAG, 
finishedCallback);
            Message msg 
= mCallback.obtainMessage(TASK_FINISHED, this);
            mCallback.sendMessage(msg);
            mCallback 
= null;
        }
    }
   
    
public synchronized void cancel() {

        mIsCanceled 
= true;
    }
   
    
public synchronized boolean isCanceled() {

        
return mIsCanceled;
    }
   
    
protected void setError(int code, String msg) {

        mErrorCode 
= code;
        mErrorMsg 
= msg;
    }
   
    
public int getErrorCode() {

        
return mErrorCode;
    }
   
    
public String getErrorMsg() {

        
return mErrorMsg;
    }
   
    
public String formatErrMsg() {

        
return “” + mErrorMsg + ( + mErrorCode + );
    }
   
    
public Handler getCallbackHandler() {

        
return mCallback;
    }
    
public int getTaskType()
    {

        
return mTaskType;
    }
    
public void setTaskType(int type){

        mTaskType
=type;
    }
   
    
public void run() {

    }

}

//在UI主线程里,启动一个请求Task,

        Task mTask = new DemoTask(mContext, mHandler);

        TaskManager.getInstance().startTask(mTask);

下面是负责在Task与UI主进程交互的Handler

    private final Handler mHandler = new Handler() {     //创建一个Android Handler

         @Override

          public void handleMessage(final Message msg) {

           switch(msg.what) {

                case AbstractTask.TASK_FINISHED:

                  DemoTask task = (DemoTask) msg.obj;//在Handler内部来处理刷新UI

            

         }

};

转载于:https://www.cnblogs.com/abob/archive/2009/06/16/1504389.html

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/110899.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • 默认网关 计算机网络_计算机网络默认网关

    默认网关 计算机网络_计算机网络默认网关什么是网关?  大家都知道,从一个房间走到另一个房间,必然要经过一扇门。同样,从一个网络向另一个网络发送信息,也必须经过一道“关口”,这道关口就是网关。顾名思义,网关(Gateway)就是一个网络连接到另一个网络的“关口”。按照不同的分类标准,网关也有很多种。TCP/IP协议里的网关是最常用的,在这里我们所讲的“网关”均指TCP/IP协议下的网关。  网关实质上是一个网络通向其他网络的IP地址…

    2022年10月27日
  • serdes接口速率_通用串行接口

    serdes接口速率_通用串行接口在以往的IC之间的源同步当中,发送的信号包括数据流信号,以及随着数据流信号同步的时钟信号,时钟信号在低速传输的情况下:1G以下传输,外部的扰动以及时钟抖动不会太影响数据流的恢复,但是如果时钟信号突破了1G甚至更高的情况下,外界环境中比如EMI的各种影响会引起时钟发生抖动,在高速采样恢复的过程中,这就没办法使用该时钟信号恢复数据,这里就用到了高速Serdes串行接口的恢复办法,将数据和时钟都通过高速线上传输,然后接受端通过PLL从数据流中恢复时钟,即使在传输的线上有轻微抖动,但是时钟和数据同时…

    2022年10月31日
  • 深度学习 | Word2vec原理及应用

    深度学习 | Word2vec原理及应用聊聊Word2vec1前言2什么是Word2vec?2.1定义2.1.1分词的原理介绍2.1.2文本向量化的方式2.2数学原理2.2.1CBOW(ContinuousBag-of-Words)原理2.2.2Skip-Gram原理2.2.3为什么要有Word2vec而不是用原来的?2.2.4Word2vec基础:霍夫曼树2.2.5HierarchicalSoftmax2….

  • java二维数组坐标_Java 二维数组

    java二维数组坐标_Java 二维数组二维数组的定义二维数组本质上是以数组作为数组元素的数组,即“数组的数组”。因为数组只能保存一行数据。在生活中,比如坐标等等,我们需要用二维数组来表示。通过行号和列好来定位数据。定义:类型数组[][]  类型[][]数组名例如:floata[3][4];  //定义a为3行4列的数组二维数组的声明和初始化二维数组的声明、初始化和引用与一维数组相似。当使用new来创建二维数组时,不必指定每一维的…

  • java数组去重方法是,java数组去重的两种方法

    java数组去重方法是,java数组去重的两种方法我们对于数组元素的使用,有时候在创建数组的初期,并没有考虑过元素的重复问题。当我们想要不重复元素的数组时,就要再进行一步去重的工作。数组的去重有两种方法可以实现,一个是循环比较,另一个是hashSet的集合方法。下面我们就这两种Java数组去重的方法带来详解。1、循环比较循环对比每个元素的值是否一致,这个就不过多去介绍,主要是第2种方法2、利用hashSet去重hashSet是一个没有重复元素的集…

  • vue 生成二维码 打印_代码生成二维码

    vue 生成二维码 打印_代码生成二维码npminstallqrcodejs2–save<template><div><divid=”qrCode”ref=”qrCodeDiv”></div></div></template><script>importQRCodefrom’qrcodejs2′;exportdefault{name:”qrCode”,data(){.

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号