Java 返回对象-OnPostExecute

我尝试使用此函数返回对象数组：

  public static JSONEvent[] invokeFunction(String funName, String requestContent) {

        final String functionName = funName;
        final String requestPayload = requestContent;

        new AsyncTask<Void, Void, InvokeResult>() {
            @Override
            protected InvokeResult doInBackground(Void... params) {
                try {
                    final ByteBuffer payload =
                            ENCODER.encode(CharBuffer.wrap(requestPayload));

                    final InvokeRequest invokeRequest =
                            new InvokeRequest()
                                    .withFunctionName(functionName)
                                    .withInvocationType(InvocationType.RequestResponse)
                                    .withPayload(payload);

                    final InvokeResult invokeResult =
                            AWSMobileClient
                                    .defaultMobileClient()
                                    .getCloudFunctionClient()
                                    .invoke(invokeRequest);

                    return invokeResult;
                } catch (final Exception e) {
                    Log.e("LAMBDA", "AWS Lambda invocation failed : " + e.getMessage(), e);
                    final InvokeResult result = new InvokeResult();
                    result.setStatusCode(500);
                    result.setFunctionError(e.getMessage());
                    return result;
                }
            }

            @Override
            protected void onPostExecute(final InvokeResult invokeResult) {

                try {
                    final int statusCode = invokeResult.getStatusCode();
                    final String functionError = invokeResult.getFunctionError();
                    final String logResult = invokeResult.getLogResult();

                    if (statusCode != 200) {
                        //showError(invokeResult.getFunctionError());
                    } else {
                        final ByteBuffer resultPayloadBuffer = invokeResult.getPayload();

                        //resultPayloadBuffer.rewind();
//                        while (resultPayloadBuffer.hasRemaining())
//                            Log.e("BUFFER",resultPayloadBuffer.position() + " -> " + resultPayloadBuffer.get());

//                        User a = new User(23, 24);
//
//                        User b = new User(58, 59);
//                        User[] ab = new User[] {a, b};

                       // User [] events = new User[3];

                        ObjectMapper mapper = new ObjectMapper();





                        final String resultPayload = DECODER.decode(resultPayloadBuffer).toString();
                        Log.e("LAMBDA-SUCCESS", resultPayload);
                        try {
                           // String s2 = getJson2(ab);
                           // Log.e("S2", s2);
                            //User[] user2 = mapper.readValue(resultPayload, User[].class);
                            events = mapper.readValue(resultPayload, JSONEvent[].class);

//                            for (JSONEvent u : events)
//                                Log.e("USER",u.getLocationLat()+"");

                            Log.e("ARRAY",Arrays.toString(events));

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

                        //return resultPayload;
                        // mResultField.setText(resultPayload);
                    }

                    if (functionError != null) {
                        Log.e("LAMBDA", "AWS Lambda Function Error: " + functionError);
                    }

                    if (logResult != null) {
                        Log.d("LAMBDA", "AWS Lambda Log Result: " + logResult);
                    }
                }
                catch (final Exception e) {
                    Log.e("LAMBDA", "Unable to decode results. " + e.getMessage(), e);
                    //showError(e.getMessage());
                }
            }
        }.execute();

        return events;
    }

publicstaticjsonevent[]invokeFunction（stringfunname，stringrequestcontent）{
最后一个字符串functionName=funName；
最终字符串requestPayload=requestContent；
新建异步任务（）{
@凌驾
受保护的InvokeResult doInBackground（无效…参数）{
试一试{
最终ByteBuffer有效载荷=
encode（CharBuffer.wrap（requestPayload））；
最终调用请求调用请求=
新的InvokeRequest（）
.withFunctionName（函数名）
.withInvocationType（InvocationType.RequestResponse）
.有效载荷（有效载荷）；
最终调用结果调用结果=
不良客户
.defaultMobileClient（）
.getCloudFunctionClient（）
.调用（调用请求）；
返回invokeResult；
}捕获（最终异常e）{
Log.e（“LAMBDA”，“AWS LAMBDA调用失败：”+e.getMessage（），e）；
final InvokeResult result=new InvokeResult（）；
结果：设置状态代码（500）；
result.setFunctionError（例如getMessage（））；
返回结果；
}
}
@凌驾
受保护的void onPostExecute（最终InvokeResult InvokeResult）{
试一试{
final int statusCode=invokeResult.getStatusCode（）；
最后一个字符串functionError=invokeResult.getFunctionError（）；
最终字符串logResult=invokeResult.getLogResult（）；
如果（状态代码！=200）{
//淋浴错误（invokeResult.getFunctionError（））；
}否则{
final ByteBuffer resultPayloadBuffer=invokeResult.getPayload（）；
//resultPayloadBuffer.rewind（）；
//while（resultPayloadBuffer.hasRemaining（））
//Log.e（“BUFFER”，resultPayloadBuffer.position（）+”->“+resultPayloadBuffer.get（））；
//用户a=新用户（23,24）；
//
//用户b=新用户（58,59）；
//用户[]ab=新用户[]{a，b}；
//用户[]事件=新用户[3]；
ObjectMapper mapper=新的ObjectMapper（）；
最终字符串resultPayload=DECODER.decode（resultPayloadBuffer.toString（）；
Log.e（“LAMBDA-SUCCESS”，resultPayload）；
试一试{
//字符串s2=getJson2（ab）；
//Log.e（“S2”，S2）；
//User[]user2=mapper.readValue（resultPayload，User[].class）；
events=mapper.readValue（resultPayload，JSONEvent[].class）；
//对于（JSONEvent u:事件）
//Log.e（“USER”，u.getLocationLat（）+”）；
Log.e（“数组”，Arrays.toString（事件））；
}捕获（例外e）{
e、 printStackTrace（）；
}
//返回resultPayload；
//mResultField.setText（resultPayload）；
}
if（functionError！=null）{
Log.e（“LAMBDA”，“AWS LAMBDA函数错误：“+函数错误”）；
}
if（logResult！=null）{
Log.d（“LAMBDA”，“AWS LAMBDA日志结果：”+logResult）；
}
}
捕获（最终异常e）{
Log.e（“LAMBDA”，“无法解码结果”。+e.getMessage（），e）；
//淋浴错误（如getMessage（））；
}
}
}.execute（）；
返回事件；
}

---

问题是，我在Different activity中调用invokeFunction，它返回null，但在onPostExecute中，数组不是null。似乎它在调用OnPostExecute之前返回数组。如何解决这个问题？

问题在于方法invokeFunction在onPostExecute（异步）之前完成 您可以使用一个接口来交流异步任务和活动

接口（伪代码）：

您的asynFunction（pseucode）：

并在postExecute中调用侦听器的函数（伪代码）：

在活动中声明接口并使用侦听器调用方法（伪代码）：

最后，在活动中，实现返回的方法（伪代码）：

---

但是请记住，响应将是异步的，问题是方法invokeFunction在onPostExecute（异步）之前完成

 private void invokeFunction(String funName, String requestContent{
    YourTask task = new YourTask();
    task.execute(new String[]{funName, requestContent});
}

static class YourTask extends AsyncTask<String, Void, InvokeResult> { 

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

        String funName = params[0];
        String requestContent = params[1];

       // ... 
    }

    @Override
    protected void onPostExecute(final InvokeResult invokeResult) {

       ///  . .. 
        doWhatYouNeedWithTheResult(result);
    }
    };
}

您可以使用一个接口来交流异步任务和活动

接口（伪代码）：

您的asynFunction（pseucode）：

并在postExecute中调用侦听器的函数（伪代码）：

在活动中声明接口并使用侦听器调用方法（伪代码）：

最后，在活动中，实现返回的方法（伪代码）：

但是请记住，响应将是bw asynchonous

private void invokeFunction（字符串funName，字符串requestContent{
 private void invokeFunction(String funName, String requestContent{
    YourTask task = new YourTask();
    task.execute(new String[]{funName, requestContent});
}

static class YourTask extends AsyncTask<String, Void, InvokeResult> { 

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

        String funName = params[0];
        String requestContent = params[1];

       // ... 
    }

    @Override
    protected void onPostExecute(final InvokeResult invokeResult) {

       ///  . .. 
        doWhatYouNeedWithTheResult(result);
    }
    };
}

YourTask=新建YourTask（）；
execute（新字符串[]{funName，requestContent}）；
}
静态类YourTask扩展了AsyncTask{
@凌驾
受保护的InvokeResult doInBackground（字符串…参数）{
字符串funName=params[0]；
字符串requestContent=params[1]；
// ... 
}
@凌驾
受保护的void onPostExecute（最终InvokeResult InvokeResult）{
///  . .. 
道氏
protected void onPostExecute(final InvokeResult invokeResult) {
    ...

    listener.sendUsers(events);

    }

public class MyActivity implements AsyncCom {

    ...

    invokeFunction(funName, requestContent, this);

    ...

public void sendUsers(User [] events){
    // do wathever you want with users
}

 private void invokeFunction(String funName, String requestContent{
    YourTask task = new YourTask();
    task.execute(new String[]{funName, requestContent});
}

static class YourTask extends AsyncTask<String, Void, InvokeResult> { 

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

        String funName = params[0];
        String requestContent = params[1];

       // ... 
    }

    @Override
    protected void onPostExecute(final InvokeResult invokeResult) {

       ///  . .. 
        doWhatYouNeedWithTheResult(result);
    }
    };
}