Cómo enviar datos a un servidor Node.js desde una aplicación de Android

Suponga que desea enviar una var llamada “nombre” (una variable JAVA) desde su aplicación de Android a su servidor Node.

Primero cree una ruta en el servidor de nodo para manejar la solicitud ( solicitud POST más específicamente). Tenga en cuenta que estoy usando express para escribir menos código aquí.

Supongamos que desea realizar una solicitud a través de la URL http://mynodeapp.xyz/route1/

Así que defina esta ruta como:

var express = require (‘express’);
aplicación var = express ();

app.post (‘/ route1’, function (req, res) {
var post = req.body;
console.log (“Variable recibida:” + post.name);
res.send (“Enviando algún mensaje);
});

La publicación variable tendrá todas las variables que le pasaron desde su actividad de Android. Si desea enviar algún mensaje de respuesta desde el servidor, puede usar res.send ().

Ahora, para enviar el “nombre” var desde la Actividad de Android, puede usar la Clase AsyncTask integrada de Android. Esta clase auxiliar le permite realizar operaciones en segundo plano.

Dentro de su actividad, defina una clase de fondo que amplíe la clase AsyncTask y realice la tarea requerida de enviar los datos al servidor de nodo.

Algo como

clase BackgroundWorker extiende AsyncTask {
Public BackgroundWorker (Contexto ctx) {
contexto = ctx;
}
@Anular
String protegido doInBackground (String … params) {
Nombre de cadena = params [0];
String myurl = “http://mynodeapp.xyz/route1/”;
tratar{
URL url = nueva URL (myurl);
HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection (); httpURLConnection.setRequestMethod (“POST”);
httpURLConnection.setDoOutput (verdadero);
httpURLConnection.setDoInput (verdadero);
OutputStream outputStream = httpURLConnection.getOutputStream ();
BufferedWriter bufferedWriter = nuevo BufferedWriter (nuevo OutputStreamWriter (outputStream, “UTF-8”));
Cadena post_data = URLEncoder.encode (“nombre”, “UTF-8”);
bufferedWriter.write (post_data);
bufferedWriter.flush ();
bufferedWriter.close ();
outputStream.close ();
InputStream inputStream = httpURLConnection.getInputStream ();
BufferedReader bufferedReader = nuevo BufferedReader (nuevo InputStreamReader (inputStream, “iso-8859-1”));
Cadena resultado = “”;
Línea de cadena = “”;
while ((line = bufferedReader.readLine ())! = null)
resultado + = línea;
bufferedReader.close ();
inputStream.close ();
httpURLConnection.disconnect ();
resultado de retorno;
} catch (MalformedURLException e) {
e.printStackTrace ();
} catch (IOException e) {
e.printStackTrace ();
}
}
@Anular
nulo protegido en PreExecute () {
}
@Anular
vacío protegido en PostExecute () {
}
@Anular
nulo protegido en ProgressUpdate (nulo … valores) {
super.onProgressUpdate (valores);
}
}
BackgroundWorker backgroundWorker = new BackgroundWorker (esto);
backgroundWorker.execute (nombre);

Puede mostrar algunas barras de progreso o cuadros de diálogo en onPreExecute () o onPostExecute (). También deberá importar las clases adecuadas en esta actividad de Android.

Espero que te muestre la forma de enviar datos a algún servidor desde Android.

Busca en Google donde te quedaste y

¡Sigue codificando!

La forma más popular en que los clientes se comunican con los servidores es usando el protocolo HTTP. Y dado que desea enviar datos a un servidor, lo que necesita es una solicitud HTTP POST.

Hay dos formas de hacer esto, ya sea usando la clase HttpURLConnection o usando la biblioteca HTTP para Android llamada Volley. Estaré usando la última aquí.

Primero, si está ejecutando Express: configure el enrutamiento para manejar las solicitudes de publicación que su servidor recibirá:

var express = require (‘express’);
aplicación var = express ();

const bodyParser = require (‘body-parser’);
servidor var = app.listen (3000);

app.use (bodyParser.json ());
app.use (bodyParser.urlencoded ({extended: true}));

app.post (‘/ postdata’, (req, res) => {
datos var = req.body.data; // tu información
// hacer algo con esos datos (escribir en una base de datos, por ejemplo)
res.status (200) .json ({
mensaje: “Datos recibidos con éxito”
});
});

A continuación, debe escribir una solicitud POST de Volley en una actividad que envíe datos en formato JSON, porque esa es la forma ideal de comunicación con un servidor de nodo RESTful. En Android Studio se hace así:

clase pública MainActivity extiende AppCompatActivity {
Button RequestButton; // botón que al hacer clic envía la solicitud
TextView DisplayText; // un campo de texto para mostrar la respuesta a la solicitud
TextView DataField; // un campo de texto donde se ingresan los datos a enviar

@Anular
vacío protegido onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);

RequestButton = (Botón) findViewById (R.id.RequestButton);
DataField = (TextView) findViewById (R.id.DataField);
DisplayText = (TextView) findViewById (R.id.DisplayText);

cola final de RequestQueue = Volley.newRequestQueue (esto);
final String url = ” http: // serverdomainorip / postdata & quot ;; // su URL

queue.start ();
RequestButton.setOnClickListener (nueva View.OnClickListener () {
@Anular
public void onClick (Ver v) {
HashMap params = new HashMap ();
params.put (“datos”, DataField.getText (). toString ()); // los datos ingresados ​​como el cuerpo.

JsonObjectRequest jsObjRequest = nuevo
JsonObjectRequest (Request.Method.POST,
url
nuevo JSONObject (params),
nuevo Response.Listener () {
@Anular
public void onResponse (respuesta JSONObject) {
tratar {
DisplayText.setText (response.getString (“mensaje”));
} catch (JSONException e) {
e.printStackTrace ();
}
}
}, nueva Response.ErrorListener () {
@Anular
public void onErrorResponse (error VolleyError) {
DisplayText.setText (“¡Eso no funcionó!”);
}
});
queue.add (jsObjRequest);
}
});
}
}

Esencialmente, el código anterior toma los datos ingresados ​​en un campo de texto y los envía como el cuerpo de una solicitud POST a su servidor de nodo al hacer clic en un botón en la página. Una vez que se recibe la respuesta, establece esa respuesta como el texto de otro campo de texto en la página para que la vea. Aquí, los datos se envían como JSON envolviéndolos en un objeto JSON y la respuesta recibida también está en formato JSON.