Ich möchte den folgenden JSON-Text senden
{"Email":"aaa@tbbb.com","Password":"123456"}zu einem Webdienst und lesen Sie die Antwort. Ich kann JSON lesen. Das Problem ist, dass das obige JSON-Objekt in einem Variablennamen gesendet werden muss jason.
Wie kann ich das von Android aus machen? Was sind die Schritte wie das Erstellen eines Anforderungsobjekts, das Festlegen von Inhaltsheadern usw.
Antworten:
Android hat keinen speziellen Code zum Senden und Empfangen von HTTP. Sie können Standard-Java-Code verwenden. Ich würde empfehlen, den Apache HTTP-Client zu verwenden, der mit Android geliefert wird. Hier ist ein Codeausschnitt, mit dem ich einen HTTP-POST gesendet habe.
Ich verstehe nicht, was das Senden des Objekts in einer Variablen namens "jason" mit irgendetwas zu tun hat. Wenn Sie nicht sicher sind, was genau der Server will, sollten Sie ein Testprogramm schreiben, um verschiedene Zeichenfolgen an den Server zu senden, bis Sie wissen, in welchem Format er sein muss.
int TIMEOUT_MILLISEC = 10000; // = 10 seconds
String postMessage="{}"; //HERE_YOUR_POST_STRING.
HttpParams httpParams = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(httpParams, TIMEOUT_MILLISEC);
HttpConnectionParams.setSoTimeout(httpParams, TIMEOUT_MILLISEC);
HttpClient client = new DefaultHttpClient(httpParams);
HttpPost request = new HttpPost(serverUrl);
request.setEntity(new ByteArrayEntity(
postMessage.toString().getBytes("UTF8")));
HttpResponse response = client.execute(request);
postMessageist nicht definiert
Das Senden eines JSON-Objekts von Android aus ist einfach, wenn Sie den Apache HTTP-Client verwenden. Hier ist ein Codebeispiel, wie es geht. Sie sollten einen neuen Thread für Netzwerkaktivitäten erstellen, um den UI-Thread nicht zu blockieren.
protected void sendJson(final String email, final String pwd) {
Thread t = new Thread() {
public void run() {
Looper.prepare(); //For Preparing Message Pool for the child Thread
HttpClient client = new DefaultHttpClient();
HttpConnectionParams.setConnectionTimeout(client.getParams(), 10000); //Timeout Limit
HttpResponse response;
JSONObject json = new JSONObject();
try {
HttpPost post = new HttpPost(URL);
json.put("email", email);
json.put("password", pwd);
StringEntity se = new StringEntity( json.toString());
se.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
post.setEntity(se);
response = client.execute(post);
/*Checking response */
if(response!=null){
InputStream in = response.getEntity().getContent(); //Get the data in the entity
}
} catch(Exception e) {
e.printStackTrace();
createDialog("Error", "Cannot Estabilish Connection");
}
Looper.loop(); //Loop in the message queue
}
};
t.start();
}
Sie können auch Google Gson verwenden , um JSON zu senden und abzurufen.
public void postData(String url,JSONObject obj) {
// Create a new HttpClient and Post Header
HttpParams myParams = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(myParams, 10000);
HttpConnectionParams.setSoTimeout(myParams, 10000);
HttpClient httpclient = new DefaultHttpClient(myParams );
String json=obj.toString();
try {
HttpPost httppost = new HttpPost(url.toString());
httppost.setHeader("Content-type", "application/json");
StringEntity se = new StringEntity(obj.toString());
se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
httppost.setEntity(se);
HttpResponse response = httpclient.execute(httppost);
String temp = EntityUtils.toString(response.getEntity());
Log.i("tag", temp);
} catch (ClientProtocolException e) {
} catch (IOException e) {
}
}
HttpPostwird von Android Api Level 22 veraltet. Also, HttpUrlConnectionfür weitere Zwecke verwenden .
public static String makeRequest(String uri, String json) {
HttpURLConnection urlConnection;
String url;
String data = json;
String result = null;
try {
//Connect
urlConnection = (HttpURLConnection) ((new URL(uri).openConnection()));
urlConnection.setDoOutput(true);
urlConnection.setRequestProperty("Content-Type", "application/json");
urlConnection.setRequestProperty("Accept", "application/json");
urlConnection.setRequestMethod("POST");
urlConnection.connect();
//Write
OutputStream outputStream = urlConnection.getOutputStream();
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream, "UTF-8"));
writer.write(data);
writer.close();
outputStream.close();
//Read
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(urlConnection.getInputStream(), "UTF-8"));
String line = null;
StringBuilder sb = new StringBuilder();
while ((line = bufferedReader.readLine()) != null) {
sb.append(line);
}
bufferedReader.close();
result = sb.toString();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return result;
}Es gibt eine überraschend schöne Bibliothek für Android HTTP unter dem folgenden Link:
http://loopj.com/android-async-http/
Einfache Anfragen sind sehr einfach:
AsyncHttpClient client = new AsyncHttpClient();
client.get("http://www.google.com", new AsyncHttpResponseHandler() {
@Override
public void onSuccess(String response) {
System.out.println(response);
}
});So senden Sie JSON (Gutschrift an "voidberg" unter https://github.com/loopj/android-async-http/issues/125 ):
// params is a JSONObject
StringEntity se = null;
try {
se = new StringEntity(params.toString());
} catch (UnsupportedEncodingException e) {
// handle exceptions properly!
}
se.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
client.post(null, "www.example.com/objects", se, "application/json", responseHandler);Es ist alles asynchron, funktioniert gut mit Android und kann sicher von Ihrem UI-Thread aus aufgerufen werden. Der responseHandler wird auf demselben Thread ausgeführt, aus dem Sie ihn erstellt haben (normalerweise Ihrem UI-Thread). Es hat sogar einen eingebauten resonseHandler für JSON, aber ich bevorzuge die Verwendung von Google Gson.
Jetzt, da das HttpClientveraltet ist, besteht der aktuelle Arbeitscode HttpUrlConnectiondarin, die Verbindung zu erstellen und die Verbindung zu schreiben und daraus zu lesen. Aber ich habe es vorgezogen, den Volley zu benutzen . Diese Bibliothek ist von Android AOSP. Ich fand es sehr einfach zu bedienen JsonObjectRequestoderJsonArrayRequest
Nichts könnte einfacher sein als dies. Verwenden Sie OkHttpLibrary
Erstellen Sie Ihren JSON
JSONObject requestObject = new JSONObject();
requestObject.put("Email", email);
requestObject.put("Password", password);und senden Sie es so.
OkHttpClient client = new OkHttpClient();
RequestBody body = RequestBody.create(JSON, json);
Request request = new Request.Builder()
.addHeader("Content-Type","application/json")
.url(url)
.post(requestObject.toString())
.build();
okhttp3.Response response = client.newCall(request).execute();public class getUserProfile extends AsyncTask<Void, String, JSONArray> {
JSONArray array;
@Override
protected JSONArray doInBackground(Void... params) {
try {
commonurl cu = new commonurl();
String u = cu.geturl("tempshowusermain.php");
URL url =new URL(u);
// URL url = new URL("http://192.168.225.35/jabber/tempshowusermain.php");
HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
httpURLConnection.setRequestMethod("POST");
httpURLConnection.setRequestProperty("Content-Type", "application/json");
httpURLConnection.setRequestProperty("Accept", "application/json");
httpURLConnection.setDoOutput(true);
httpURLConnection.setRequestProperty("Connection", "Keep-Alive");
httpURLConnection.setDoInput(true);
httpURLConnection.connect();
JSONObject jsonObject=new JSONObject();
jsonObject.put("lid",lid);
DataOutputStream outputStream = new DataOutputStream(httpURLConnection.getOutputStream());
outputStream.write(jsonObject.toString().getBytes("UTF-8"));
int code = httpURLConnection.getResponseCode();
if (code == 200) {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(httpURLConnection.getInputStream()));
StringBuffer stringBuffer = new StringBuffer();
String line;
while ((line = bufferedReader.readLine()) != null) {
stringBuffer.append(line);
}
object = new JSONObject(stringBuffer.toString());
// array = new JSONArray(stringBuffer.toString());
array = object.getJSONArray("response");
}
} catch (Exception e) {
e.printStackTrace();
}
return array;
}
@Override
protected void onPreExecute() {
super.onPreExecute();
}
@Override
protected void onPostExecute(JSONArray array) {
super.onPostExecute(array);
try {
for (int x = 0; x < array.length(); x++) {
object = array.getJSONObject(x);
ComonUserView commUserView=new ComonUserView();// commonclass.setId(Integer.parseInt(jsonObject2.getString("pid").toString()));
//pidArray.add(jsonObject2.getString("pid").toString());
commUserView.setLid(object.get("lid").toString());
commUserView.setUname(object.get("uname").toString());
commUserView.setAboutme(object.get("aboutme").toString());
commUserView.setHeight(object.get("height").toString());
commUserView.setAge(object.get("age").toString());
commUserView.setWeight(object.get("weight").toString());
commUserView.setBodytype(object.get("bodytype").toString());
commUserView.setRelationshipstatus(object.get("relationshipstatus").toString());
commUserView.setImagepath(object.get("imagepath").toString());
commUserView.setDistance(object.get("distance").toString());
commUserView.setLookingfor(object.get("lookingfor").toString());
commUserView.setStatus(object.get("status").toString());
cm.add(commUserView);
}
custuserprof = new customadapterformainprofile(getActivity(),cm,Tab3.this);
gridusername.setAdapter(custuserprof);
// listusername.setAdapter(custuserprof);
} catch (Exception e) {
e.printStackTrace();
}
}