Java Android：实时获取数据，而不是使用异步任务

我对Android编程比较陌生，但我确实来自Java背景，为企业应用程序构建后端。现在，我正在从事一个Android项目，在这个项目中，我想从服务器检索一个java.util.List的餐馆

目前，为了完成这些任务，我正在使用一个带有新Runnable的简单线程，因为该线程立即位于线程池中，然后我可以简单地加入该线程，并等待它收到服务器的回复，然后将其发送回。这很方便，工作也很好

但是，有两件事我不能用线程来做，在客户端检查Internet连接和显示进度条。据我所知，这两件事都可以通过异步任务来实现

但这里是关键点，我不希望AsyncTask在不久的将来执行，然后返回结果，因为使用我当前的线程模型，我可以简单地加入线程并放松

现在，我的问题是，在AsyncTask中是否同样可能，我不是说在1000毫秒后使用get方法。我的意思是真正地等待它。我如何做到这一点？有了这个，我想知道我如何检查互联网，如果成功，那么只提出一个请求

下面是我在项目中使用的异步方法之一，接下来是我在项目中使用的简单线程模型

 private class LoginUserViaRest extends AsyncTask<Void, Void, String> {

        @Override
        protected String doInBackground(Void... params) {

            final EditText userEmail = (EditText) findViewById(R.id.usernameText);
            final EditText userPassword = (EditText) findViewById(R.id.PasswordField);

            rest.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
            StaticRestTemplate.jsessionid = rest.execute(StaticRestTemplate.baseURL+"j_spring_security_check", HttpMethod.POST,
                    new RequestCallback() {
                        @Override
                        public void doWithRequest(ClientHttpRequest request) throws IOException {
                            request.getBody().write(("j_username=" + userEmail.getText().toString() + "&j_password=" + userPassword.getText().toString()).getBytes());
                        }
                    }, new ResponseExtractor<String>() {
                        @Override
                        public String extractData(ClientHttpResponse response) throws IOException {
                            List<String> cookies = response.getHeaders().get("Cookie");
                            if (cookies == null) {
                                cookies = response.getHeaders().get("Set-Cookie");
                            }
                            String cookie = cookies.get(cookies.size() - 1);
                            int start = cookie.indexOf('=');
                            int end = cookie.indexOf(';');

                            return cookie.substring(start + 1, end);
                        }
                    });
            return null;
        }

        @Override
        protected void onPostExecute(String aVoid) {
            super.onPostExecute(aVoid);
        }
    }

私有类LoginUserSet扩展异步任务{
@凌驾
受保护字符串doInBackground（无效…参数）{
最终EditText userEmail=（EditText）findViewById（R.id.usernameText）；
最终的EditText用户密码=（EditText）findViewById（R.id.PasswordField）；
添加（新的MappingJackson2HttpMessageConverter（））；
StaticRestTemplate.jsessionid=rest.execute（StaticRestTemplate.baseURL+“j_spring_security_check”，HttpMethod.POST，
新的RequestCallback（）{
@凌驾
public void doWithRequest（ClientHttpRequest请求）引发IOException{
request.getBody（）.write（（（“j_username=“+userEmail.getText（）.toString（）+”&j_password=“+userPassword.getText（）.toString（））.getBytes（））；
}
}，新的响应抽取器（）{
@凌驾
公共字符串提取数据（ClientHttpResponse响应）引发IOException{
List cookies=response.getHeaders（）.get（“Cookie”）；
如果（cookies==null）{
cookies=response.getHeaders（）.get（“设置Cookie”）；
}
字符串cookie=cookies.get（cookies.size（）-1）；
int start=cookie.indexOf（'='）；
int end=cookie.indexOf（“；”）；
返回cookie.substring（开始+1，结束）；
}
});
返回null；
}
@凌驾
受保护的void onPostExecute（字符串避免）{
super.onPostExecute（避免）；
}
}

要检索图像的线程：

 @Override
    public List<RestImage> getImagesForMenuCard(final int menuCardId) {
        final RestTemplate restTemplate = StaticRestTemplate.getRest();

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                HttpHeaders requestHeaders = new HttpHeaders();
                requestHeaders.add("Cookie", "JSESSIONID=" + StaticRestTemplate.jsessionid);
                requestHeaders.setAccept(Collections.singletonList(new MediaType("application", "json")));
                HttpEntity<?> requestEntity = new HttpEntity<Object>(requestHeaders);
                restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
                menuCardImageEntity = restTemplate.exchange(menucardImageList + menuCardId, HttpMethod.GET, requestEntity, RestImage[].class);
            }
        });
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        RestImage[] restImages = menuCardImageEntity.getBody();
        List<RestImage> restImageList = new ArrayList<>();
        Collections.addAll(restImageList, restImages);
        return restImageList;
    }

@覆盖
公共列表GetImagesFormNuCard（最终整数菜单）{
final RestTemplate RestTemplate=StaticRestTemplate.getRest（）；
Thread Thread=新线程（new Runnable（）{
@凌驾
公开募捐{
HttpHeaders requestHeaders=新的HttpHeaders（）；
添加（“Cookie”、“JSSessionId=“+StaticRestTemplate.jsSessionId”）；
setAccept（Collections.singletonList（新媒体类型（“应用程序”、“json”））；
HttpEntity requestEntity=新的HttpEntity（requestHeaders）；
restemplate.getMessageConverters（）.add（新映射Jackson2HttpMessageConverter（））；
menuCardImageEntity=restTemplate.exchange（menucardImageList+menuCardId，HttpMethod.GET，requestEntity，RestImage[].class）；
}
});
thread.start（）；
试一试{
thread.join（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
RestImage[]restImages=menuCardImageEntity.getBody（）；
List restImageList=新的ArrayList（）；
Collections.addAll（restImageList，restImages）；
返回图像列表；
}

我发现线程模型很容易，因为我更了解它。我真的不理解创建一个类来发出网络请求的要求。 我对AsyncTask的理解是否被打破了，或者这是应该的方式

为大量的文字道歉，我想我会简明扼要地解释我的情况。非常感谢

如果调用join（），则您的线程正在等待另一个线程死亡。因为调用连接的线程是主线程或UI线程，这意味着您正在阻塞UI，这是您应该避免的。现在-我真的讨厌AsyncTask，但它是Android执行（可能）长时间运行任务的标准方式。您可以看看IntentService（但您必须管理服务和UI之间的通信），也可以看看RxJava和RxAndroid（这是我最喜欢的框架）

关于检查连接，您需要类，这当然需要一个上下文。

如果调用join（），您的线程正在等待另一个线程死亡。因为调用连接的线程是主线程或UI线程，这意味着您正在阻塞UI，这是您应该避免的。现在-我真的讨厌AsyncTask，但它是Android执行（可能）长时间运行任务的标准方式。您可以查看IntentService（但您必须管理服务和UI之间的通信），或者您可以查看RxJava和RxAndroid（这是我最喜欢的框架）

    public class BackgroundOperationWorker implements Runnable{

       private Thread thread;
       private IOperationListener listener;
       Handler handler;

       public BackgroundOperationWorker(Handler mainThreadHandler,IOperationListener listener) 
       {
            this.handler = mainThreadHandler;
            this.listener = listener;
       }

        public void doIt(){
        thread = new Thread(this);
        thread.start();
        }

        @Override
        public void run(){
        /**
         do what you have to do in the thread
        **/

        if(success){
           handler.post(new Runnable(){
           listener.operationSuccess();
           });
          }else{
           handler.post(new Runnable(){
           listener.operationFailed();
           });
          }
        }
}

public class MyClass implements IOperationListener{

public BackgroundOperationWorker worker;

public MyClass(Context context){

this.worker = new BackgroundOperationWorker(new Handler(context.getMainLooper()),this/*as an instance of IOperationListener*/);

this.worker.doIt();
}

@Override
public void onOperationSuccess(){
//notify the user that the operation is successful
}

@Override
public void onOperationFailed(){
//notify the user that the operation has failed
}

}