Download - Java Php Mysql
JAVA – PHP – MYSQL: I INTRODUCCIÓN
Muy Buenos Días a todos, debido a mi proyecto final de carrera, he tenido que
interactuar con distintas tecnologías, así pues, tuve que “apañármelas” para poder
hacer una aplicación en JAVA que pudiese comunicarse con una base de datos
dinámicamente. Tras estar indagando por internet decidí realizar esta parte de mi
proyecto haciendo interactuar JAVA con una base de datos por medio de PHP. Así
pues conseguí crear una aplicación JAVA que pudiera transmitir información a un
archivo PHP y que este a su vez insertará la información en la base de datos, así
como mostrar en pantalla los datos que hemos introducido en la base de datos. Y
como a mí me gusta compartir mi conocimiento con todo aquel que quiera
aprenderlo he decidido crear una serie de tutoriales que abarquen este tema.
Esta serie de tutoriales se va a componer de 6 tutoriales:
1. JAVA – PHP – MySQL: I Introducción
2. JAVA – PHP – MySQL: II Creación de una base de datos en MySQL
3. JAVA – PHP – MySQL: III Crear una conexión con la base de datos en PHP
4. JAVA – PHP – MySQL: IV Consultas Básicas e inserción de datos en PHP
5. JAVA – PHP – MySQL: V Insertar datos en MySQL desde JAVA con PHP
6. JAVA – PHP – MySQL: VI Obtener datos de MySQL en JAVA con PHP
Los objetivos que nos proponemos con esta serie de tutoriales son los siguientes:
MySQL
Aprender a crear una base de datos en MySQL.
PHP
Aprender a insertar datos en nuestra base de datos.
Aprender a mostrar datos de nuestra base de datos.
Consolidar los conocimientos aprendidos en la serie de tutoriales JSON.
Mostrar los datos introducidos en la base de datos en pantalla.
JAVA
Crear JSON a partir de los datos introducidos por el usuario.
Enviar JSON vía GET en JAVA.
Enviar JSON vía POST en JAVA.
Obtener un JSON generado en PHP.
En un principio el título del tutorial parece un poco confuso. Así pues vamos a
proponer un ejemplo de lo que pretendemos hacer y como lo vamos a hacer.
Supongamos que tenemos una base de datos con una tabla llamada“usuarios”.
Esta tabla va a tener los siguientes campos:
id_usernombreapellidosemail
Se pretende que con esta serie de tutoriales se aprenda a mostrar los datos de la
base de datos en PHP vía web, que se puedan almacenar los datos mediante una
sencilla aplicación JAVA o que se puedan obtener los datos desde unPHP en
java.
El esquema que vamos a seguir para realizar esta serie de tutoriales es el
siguiente:
De aquí podemos concluir varias cosas:
El acceso a la base de datos sólo va a ser accesible vía PHP no en java, es
decir, MySQL sólo va a trabajar con PHP.
PHP se encargará de enviar los datos a la base de datos. También se va a
encargar de proporcionar los datos a JAVA, así como mostrarlos en una web
JAVA se encargará de enviar datos a PHP vía GET o vía POST. También se
encargará de leer directamente el código HTML y obtener datos de él.
Quizás algunos piensen que no tiene sentido insertar los datos vía PHP que quizás
sea más fácil y sencillo crear una conexión desde java a la base de datos y enviar
los datos a ella como sugiere el siguiente esquema:
Pero desde mi punto de vista el esquema mostrado en primer lugar tiene varias
ventajas respecto al esquema mostrado en el segundo lugar.
Seguridad: si introduces los datos del servidor donde tienes alojada la base de
datos en una clase java, cualquier usuario con una experiencia mínima en
programación podrá obtener los datos de tu sever, mientras que si lo haces con
PHP los datos de tu server son invisibles al usuario, el usuario no podrá obtener
(Teóricamente) los datos de tu server.
Interacción Web: el primer esquema propone un escenario donde los datos de tu
aplicación en java interactúen directamente con el usuario vía web. Por poner un
ejemplo, podrías crear un juego en JAVA que almacene en una base de datos los
records de los usuarios, y mostrarlos en una página web.
Creación de una API: con el primer esquema es posible crear tu propia API para
tu aplicación.
Y esto es todo, si estáis interesados en seguir esta serie de tutoriales, por favor
dejar un comentario indicando que cambiarías, que te gustaría aprender sobre este
tema, o cualquier duda que tengas sobre esta serie de tutoriales. Así pues en el
primer tutorial vamos a aprender cómo crear una base de datos fácilmente
desde PHPmyAdmin.
¡Un saludo @alex_esquiva!
JAVA – PHP – MYSQL: II CREACIÓN DE UNA BASE DE DATOS EN MYSQL
¡Hola a todos!, En este nuevo tutorial de la serie de tutoriales JAVA – PHP –
MySQL vamos a aprender a crear una base de datos en MySQL con ayuda del
gestor web PHPMyAdmin, antes de empezar, vamos a repasar el índice de esta
serie de tutoriales así como los objetivos que nos proponemos.
1. JAVA – PHP – MySQL: I Introducción
2. JAVA – PHP – MySQL: II Creación de una base de datos en MySQL
3. JAVA – PHP – MySQL: III Crear una conexión con la base de datos en PHP
4. JAVA – PHP – MySQL: IV Consultas Básicas e inserción de datos en PHP
5. JAVA – PHP – MySQL: V Insertar datos en MySQL desde JAVA con PHP
6. JAVA – PHP – MySQL: VI Obtener datos de MySQL en JAVA con PHP
Los objetivos que nos proponemos con esta serie de tutoriales son los siguientes:
MySQL
Aprender a crear una base de datos en MySQL.
PHP
Aprender a insertar datos en nuestra base de datos.
Aprender a mostrar datos de nuestra base de datos.
Consolidar los conocimientos aprendidos en la serie de tutoriales JSON.
Mostrar los datos introducidos en la base de datos en pantalla.
JAVA
Crear JSON a partir de los datos introducidos por el usuario.
Enviar JSON vía GET en JAVA.
Enviar JSON vía POST en JAVA.
Obtener un JSON generado en PHP.
Para seguir con el ejemplo del primer tutorial, vamos a crear una base de datos
llamada GeekyTheoryBD en esta base de datos vamos a incluir una tabla
llamada usuarios como esta:
id_usernombreapellidosemail
Para crear la base de datos usaremos PHPMyAdmin el cual consiste en una
interfaz web para la gestión de bases de datos. Para poder
usar PHPMyAdmin vamos a descargar EasyPHP, este contenedor de programas
contiene todas las herramientas necesarias para desarrollar una página web en
un servidor l0cal. Puedes descargar y saber más sobreEasyPHP en el tutorial que
le dedicamos en Geeky Theory.
Una vez que tenemos instalado EasyPHP lo ejecutamos y escribimos en nuestro
navegador la siguiente ruta: http://localhost/home/index.php Lo siguiente será
pulsar sobre el botón “open” en “modules”, nos aparecerá algo como esto:
Para crear una base de datos debemos pulsar sobre el botón de “Nueva“:
Escribimos el Nombre de la base de datos y le damos a crear:
Podemos ver que ahora nos aparece una nueva base de datos en nuestro
directorio de PHPMyAdmin:
Pulsamos sobre nuestra base de datos y nos aparecerá un formulario para crear
una tabla en nuestra base de datos. Siguiendo el ejemplo de nuestro tutorial
vamos a añadir a nuestra base de datos una tabla llamada “usuarios” que va a
tener 4 columnas:
El siguiente paso será añadir las columnas en la base de datos, en nuestro
ejemplo, vamos a crear un campo llamado “id_user” el cual será de tipo entero
de longitud 11 y autoincrementable. Seguidamente crearemos tres campos
llamados nombre, apellidos y email consecutivamente con longitudes
adecuadas, el tipo de estos tres campos será “VARCHAR“. Se nos tiene que
quedar algo como esto:
Guardamos y ya tenemos creada la tabla “usuarios” necesaria para seguir con la
serie de tutoriales de JAVA – PHP – MYSQL.
Y esto es todo por hoy, en este tutorial hemos aprendido a crear una base de
datos mediante el gestor PHPMyAdminde una forma sencilla. En el siguiente
tutorial aprenderemos a crear una conexión en PHP con MySQL.
Espero que os haya gustado y no olvidéis de compartir el tutorial en vuestras
redes sociales.
¡Saludos! @alex_esquiva
JAVA – PHP – MYSQL: III CREAR UNA CONEXIÓN CON LA BASE DE DATOS EN PHP
!Buenos Días!, en este breve tutorial vamos a realizar una conexión en PHP con la
base de datos que realizamos en elúltimo tutorial. Antes de seguir vamos a ver un
índice de esta serie de tutoriales y lo que pretendemos conseguir.
1. JAVA – PHP – MySQL: I Introducción
2. JAVA – PHP – MySQL: II Creación de una base de datos en MySQL
3. JAVA – PHP – MySQL: III Crear una conexión con la base de datos en PHP
4. JAVA – PHP – MySQL: IV Consultas Básicas e inserción de datos en PHP
5. JAVA – PHP – MySQL: V Insertar datos en MySQL desde JAVA con PHP
6. JAVA – PHP – MySQL: VI Obtener datos de MySQL en JAVA con PHP
Los objetivos que nos proponemos con esta serie de tutoriales son los siguientes:
MySQL
Aprender a crear una base de datos en MySQL.
PHP
Aprender a insertar datos en nuestra base de datos.
Aprender a mostrar datos de nuestra base de datos.
Consolidar los conocimientos aprendidos en la serie de tutoriales JSON.
Mostrar los datos introducidos en la base de datos en pantalla.
JAVA
Crear JSON a partir de los datos introducidos por el usuario.
Enviar JSON vía GET en JAVA.
Enviar JSON vía POST en JAVA.
Obtener un JSON generado en PHP.
Sin más vamos a escribir en PHP un script que nos permita conectarnos a nuestra
base de datos alojada en nuestroservidor local. Para esto, vamos a disponer de
dos funciones creadas por nosotros mismo. La función conectarBD() y la
función desconectarBD().
123456789101112131415
/***Función que crea y devuelve un objeto de conexión a la base de datos y chequea el estado de la misma. */function conectarBD(){ $server = "localhost"; $usuario = "root"; $pass = ""; $BD = "GeekyTheoryBD"; //variable que guarda la conexión de la base de datos $conexion = mysqli_connect($server, $usuario, $pass, $BD); //Comprobamos si la conexión ha tenido exito if($conexion){ echo 'La conexion de la base de datos se ha hecho satisfactoriamente<br>';
161718192021222324252627282930313233
}else{ echo 'Ha sucedido un error inexperado en la conexion de la base de datos<br>'; } //devolvemos el objeto de conexión para usarlo en las consultas return $conexion; } /*Desconectar la conexion a la base de datos*/function desconectarBD($conexion){ //Cierra la conexión y guarda el estado de la operación en una variable $close = mysqli_close($conexion); //Comprobamos si se ha cerrado la conexión correctamente if($close){ echo 'La desconexion de la base de datos se ha hecho satisfactoriamente<br>'; }else{ echo 'Ha sucedido un error inexperado en la desconexion de la base de datos<br>'; } //devuelve el estado del cierre de conexión return $close; }
De este código destacar que en el caso de que nuestra base de datos no este en
un servidor local debemos de introducir los credenciales de la base de datos que
tengamos, así como el usuario y la contraseña del usuario que tenga permisos
sobre esa base de datos en la función conectarBD().
Y esto es todo por hoy, en el próximo tutorial vamos a aprender a crear consultas
básicas sobre la base de datos que estamos usando como ejemplo. Recordar de
compartir este tutorial en vuestras redes sociales y no olvidar que si os apetece
compartir vuestros conocimientos en Geeky Theory podéis hacerlo siguiendo los
pasos que se indican en el siguiente enlace.
!Un saludo! @alex_esquiva
JAVA – PHP – MYSQL: IV CONSULTAS E INSERCIÓN DE DATOS EN MYSQL CON PHP
!Hola a todos!, En este cuarto tutorial sobre JAVA – PHP – MYSQL vamos a
repasar sentencias básicas de SQL para insertar o consultar datos de una base de
datos. Una vez hayamos repasado las sentencias más usadas vamos a aplicar
estos conocimientos con la base de datos ejemplo de esta serie de tutoriales
(GeekyTheoryBD) que creamos en el segundo tutorial de la serie JAVA – PHP –
MYSQL.
Antes de empezar vamos a ver el índice de esta serie de tutoriales así como lo que
pretendemos aprender.
1. JAVA – PHP – MySQL: I Introducción
2. JAVA – PHP – MySQL: II Creación de una base de datos en MySQL
3. JAVA – PHP – MySQL: III Crear una conexión con la base de datos en PHP
4. JAVA – PHP – MySQL: IV Consultas Básicas e inserción de datos en PHP
5. JAVA – PHP – MySQL: V Insertar datos en MySQL desde JAVA con PHP
6. JAVA – PHP – MySQL: VI Obtener datos de MySQL en JAVA con PHP
Los objetivos que nos proponemos con esta serie de tutoriales son los siguientes:
MySQL
Aprender a crear una base de datos en MySQL.
PHP
Aprender a insertar datos en nuestra base de datos.
Aprender a mostrar datos de nuestra base de datos.
Consolidar los conocimientos aprendidos en la serie de tutoriales JSON.
Mostrar los datos introducidos en la base de datos en pantalla.
JAVA
Crear JSON a partir de los datos introducidos por el usuario.
Enviar JSON vía GET en JAVA.
Enviar JSON vía POST en JAVA.
Obtener un JSON generado en PHP.
Para quien no lo sepa el lenguaje estándar para comunicarse con una base de
datos es un lenguaje sencillo y “casi”universal llamado SQL. Este lenguaje
dispone de una sencilla sintaxis para comunicarse con la base de datos que
tengamos disponible.
Algunas de las sentencias básicas que vamos a usar en esta serie de tutoriales
son las siguientes:
Obtener todos los datos de la tabla “tabla”.
1 SELECT * FROM tabla;
Obtener todos los datos de las columnas llamadas “columna1″ y “columna2″
pertenecientes a la tabla “tabla”.
1 SELECT columna1,columna2 FROM tabla;
Obtener todos los datos de la tabla cuando columna 1 es igual al parametro que
queramos.
1 SELECT * FROM tabla WHERE columna1='lo que queramos';
Obtener todos los datos de la tabla cuando columna 1 es igual al parametro que
queramos y columna 2 es igual a lo que queramos.
1SELECT * FROM tabla WHERE columna1='lo que queramos' and columna2='lo que queramos2';
Obtener todos los datos de la tabla cuando columna 1 es igual al parametro que
queramos o columna 2 es igual a lo que queramos.
1SELECT * FROM tabla WHERE columna1='lo que queramos' or columna2='lo que queramos2';
Obtener los datos de una tabla ordenados en orden ascendente por un campo
dado.
1 SELECT * FROM tabla ORDER BY columna1 ASC;
Obtener los datos de una tabla ordenados en orden descendente por un campo
dado.
1 SELECT * FROM tabla ORDER BY columna1 DESC;
Insertar una nueva fila en una tabla.
1 INSERT INTO tabla (columna1,columna2,columna3) values (123,'geekytheory',5469);
Modificar una nueva fila en una tabla.
1 UPDATE tabla SET columna1="lo que quiera cambiar" WHERE columna1 ="condición/ID";
Para más información sobre sentencias SQL visitar el siguiente
enlace: w3school
A tener en cuenta los siguientes puntos:
Los campos cuyo tipo de datos es de tipo VARCHAR van siempre entre
comillas cuando hacemos un WHERE mientras que los datos tipo INT no.
Tener cuidado con la codificación de la base de datos, ya que algunas veces
hay problemas cuando queremos introducir datos de tipo VARCHAR con tildes.
Una consulta, inserción o modificación de algún dato de nuestra base de datos es
ejecutada en tres puntos:
Conexión de la base de datos
Ejecución (y obtención de datos) enviando una “query” (sentencia) SQL
Desconexión de la base de datos.
Usando como referencia el guion anterior y la base de datos (GeekyTheoryBD)
que estamos usando en esta serie de tutoriales JAVA – PHP – MySQL vamos
crear una clase que gestione la tabla “usuarios“.
Las funciones que incluiremos en la clase “Usuarios” para gestionar la tabla
“usuarios” son las siguientes:
conectarBD
desconectarBD
getArraySQL
createUser
getAllInfo
getNombre
getApellidos
getEmail
El siguiente código comentado y explicado muestra la implementación de la clase
“usuarios“:
12345678910111213141516171819202122232425262728293031323334353637383940414243
<?phpclass Usuarios{ public $id_user = 0 ; //Función que crea y devuelve un objeto de conexión a la base de datos y chequea el estado de la misma. function conectarBD(){ $server = "localhost"; $usuario = "root"; $pass = ""; $BD = "GeekyTheoryBD"; //variable que guarda la conexión de la base de datos $conexion = mysqli_connect($server, $usuario, $pass, $BD); //Comprobamos si la conexión ha tenido exito if(!$conexion){ echo 'Ha sucedido un error inexperado en la conexion de la base de datos<br>'; } //devolvemos el objeto de conexión para usarlo en las consultas return $conexion; } /*Desconectar la conexion a la base de datos*/ function desconectarBD($conexion){ //Cierra la conexión y guarda el estado de la operación en una variable $close = mysqli_close($conexion); //Comprobamos si se ha cerrado la conexión correctamente if(!$close){ echo 'Ha sucedido un error inexperado en la desconexion de la base de datos<br>'; } //devuelve el estado del cierre de conexión return $close; } //Devuelve un array multidimensional con el resultado de la consulta function getArraySQL($sql){ //Creamos la conexión $conexion = $this->conectarBD();
44454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192
//generamos la consulta if(!$result = mysqli_query($conexion, $sql)) die(); $rawdata = array(); //guardamos en un array multidimensional todos los datos de la consulta $i=0; while($row = mysqli_fetch_array($result)) { //guardamos en rawdata todos los vectores/filas que nos devuelve la consulta $rawdata[$i] = $row; $i++; } //Cerramos la base de datos $this->desconectarBD($conexion); //devolvemos rawdata return $rawdata; } //inserta en la base de datos un nuevo registro en la tabla usuarios function createUser($nombre,$apellidos,$email){ //creamos la conexión $conexion = $this->conectarBD(); //Escribimos la sentencia sql necesaria respetando los tipos de datos $sql = "insert into usuarios (nombre,apellidos,email) values ('".$nombre."','".$apellidos."','".$email."')"; //hacemos la consulta y la comprobamos $consulta = mysqli_query($conexion,$sql); if(!$consulta){ echo "No se ha podido insertar una nueva Medalla en la base de datos<br><br>".mysqli_error($conexion); } //Desconectamos la base de datos $this->desconectarBD($conexion); //devolvemos el resultado de la consulta (true o false) return $consulta; } //obtiene toda la informacion de la base de datos function getAllInfo(){ //Creamos la consulta $sql = "SELECT * FROM usuarios;"; //obtenemos el array con toda la información return $this->getArraySQL($sql); } //obtiene el nombre del usuario cuyo ID user es el que se le asigna al objeto de la clase function getNombre(){
93949596979899100101102103104105106107108109110111112113114115116117118119120
//Creamos la consulta $sql = "SELECT nombre FROM usuarios WHERE id_user = ".$this->id_user.";"; //obtenemos el array $data = $this->getArraySQL($sql); //obtenemos el primer elemento, ya que así no tenemos que extraerlo posteriormente return $data[0][0]; } //obtiene los apellidos del usuario cuyo ID user es el que se le asigna al objeto de la clase function getApellidos(){ //Creamos la consulta $sql = "SELECT apellidos FROM usuarios WHERE id_user = ".$this->id_user.";"; //obtenemos el array $data = $this->getArraySQL($sql); //obtenemos el primer elemento, ya que así no tenemos que extraerlo posteriormente return $data[0][0]; } //obtiene el mail del usuario cuyo ID user es el que se le asigna al objeto de la clase function getEmail(){ //Creamos la consulta $sql = "SELECT email FROM usuarios WHERE id_user = ".$this->id_user.";"; //obtenemos el array $data = $this->getArraySQL($sql); //obtenemos el primer elemento, ya que así no tenemos que extraerlo posteriormente return $data[0][0]; }} //Para hacer un ejemplo de funcionamiento vamos a realizar los siguientes pasos:////1º Vamos a crear un objeto de la clase Usuarios//2º Vamos a crear un nuevo usuario en la base de datos//3º Vamos a obtener su Nombre, Apellido y email del usuario que acabamos de insertar en la base de datos //--Creamos un objeto de la clase Usuarios$userObject = new Usuarios();//Insertamos un nuevo usuario en la base de datos$userObject->createUser("Alejandro","Esquiva","[email protected]");
121122123124125126127
//Obtenemos los datos del usuario que acabamos de mostrar, como es el primer//elemento de la base de datos vamos a suponer que tiene como ID el número 1//En caso de que no fuese así deberiamos crearnos una función para obtener //el último id, esta función la dejo como ejercicio para aquellos que quiera practicar$userObject->id_user=1;//Obtenemos el nombre y lo mostramos por pantallaecho $userObject->getNombre()."<br>";//Obtenemos los apellidos y lo mostramos por pantallaecho $userObject->getApellidos()."<br>";//Obtenemos el nombre y lo mostramos por pantallaecho $userObject->getEmail()."<br>";?>
Podemos observar en el código que hemos usado funciones ya usadas en otros
tutoriales como por ejemplo las funciones conectarBD/desconectarBD del tutorial
anterior.
Si ejecutamos el código anterior usando nuestro servidor local o hosting privado
veremos que hemos insertado correctamente un usuario en la tabla “usuarios” de
la base de datos.
A su vez vemos que una vez que hemos insertado el usuario en la base de datos,
podemos obtener sus datos haciendo consultas a ella:
Y esto es todo en este tutorial, si queremos realizar consultas personalizadas se
pueden usar el esquema que he ido siguiendo en este tutorial.
En el siguiente tutorial de JAVA – PHP – MySQL vamos a ver como insertar datos
en la tabla “usuarios” a través una aplicación en JAVA con ayuda de PHP.
No olvides de compartir este tutorial en vuestras redes sociales!
Saludos!
JAVA – PHP – MYSQL: V INSERTAR DATOS EN MYSQL DESDE JAVA CON PHP
Buenas días a todos!, en este quinto tutorial de JAVA – PHP -MySQL vamos a ver
como podemos comunicarnos insertar datos a una base de datos MySQL desde
JAVA con PHP, en un principio el esquema que vamos a seguir es una
arquitectura cliente-servidor, podéis ver un esquema en el siguiente gráfico:
Esquema JAVA – PHP – MySQL
Antes de empezar, vamos a repasar el índice de esta serie de tutoriales así como
los objetivos que nos proponemos.
1. JAVA – PHP – MySQL: I Introducción
2. JAVA – PHP – MySQL: II Creación de una base de datos en MySQL
3. JAVA – PHP – MySQL: III Crear una conexión con la base de datos en PHP
4. JAVA – PHP – MySQL: IV Consultas Básicas e inserción de datos en PHP
5. JAVA – PHP – MySQL: V Insertar datos en MySQL desde JAVA con PHP
6. JAVA – PHP – MySQL: VI Obtener datos de MySQL en JAVA con PHP
Los objetivos que nos proponemos con esta serie de tutoriales son los siguientes:
MySQL
Aprender a crear una base de datos en MySQL.
PHP
Aprender a insertar datos en nuestra base de datos.
Aprender a mostrar datos de nuestra base de datos.
Consolidar los conocimientos aprendidos en la serie de tutoriales JSON.
Mostrar los datos introducidos en la base de datos en pantalla.
JAVA
Crear JSON a partir de los datos introducidos por el usuario.
Enviar JSON vía GET en JAVA.
Enviar JSON vía POST en JAVA.
Obtener un JSON generado en PHP.
Una vez que hemos repasado lo que pretendemos hacer vamos a comenzar este
quinto tutorial de JAVA – PHP – MySQL. Para continuar un poco con la línea de
los tutoriales vamos a suponer que hemos realizado los anteriores tutoriales
satisfactoriamente. Hemos creado una base de datos donde almacenaremos los
datos de usuario (Tutorial II). Seguidamente hemos creado una clase en PHP para
administrar esta tabla en la base de datos (Tutorial IV).
Este tutorial consta de dos partes, la parte del cliente (Java) donde se generará un
JSON (Ver serie de Tutoriales JSON) y se enviará por POST a la parte del
servidor (PHP), el cual consistirá en un archivo PHP que espera una llegada de
datos por POST, procesará el contenido del JSON y lo almacenará en la base de
datos.
SERVIDOR
Teniendo en cuenta que en el tutorial anterior creamos una clase
llamada usuariosClass.php con las siguientes funciones:
conectarBD
desconectarBD
getArraySQL
createUser
getAllInfo
getNombre
getApellidos
getEmail
Vamos a crear dos archivos en PHP que este a la escucha de datos, los archivos
en cuestión seránlistenPost.php y listenGet.php. El primero de ellos escuchará
llamadas mediante método POST, mediante que el segundo escuchará las
llamadas mediante el método GET.
A continuación se mostrará el código de ambos archivos comentados.
LISTENPOST.PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<meta charset="utf-8">
<?php
/**
*Autor: Alejandro Esquiva Rodríguez (@alex_esquiva)
*Desarrollado para Geeky Theory
*
*Este archivo estará a la escucha de llamadas procedentes del cliente JAVA
*/
//--Incluimos el archivo en usuarioClass.php
require_once("usuarioClass.php");
//Comprobamos si hemos recibido alguna llamada por GET
if(isset($_POST["json"])){
$json = $_POST["json"];
$json = urldecode($json);
$json = str_replace("\\", "",$json);
$jsonencode = json_decode($json);
18
19
20
21
22
//--Creamos un objeto de la clase usuarioClass
$userObject = new Usuarios();
//Insertamos un nuevo usuario en la base de datos
$userObject->createUser($jsonencode[0]->nombre,$jsonencode[0]->apellidos,$jsonencode[0]->email);
}
LISTENGET.PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<meta charset="utf-8">
<?php
/**
*Autor: Alejandro Esquiva Rodríguez (@alex_esquiva)
*Desarrollado para Geeky Theory
*
*Este archivo estará a la escucha de llamadas procedentes del cliente JAVA
*/
//--Incluimos el archivo en usuarioClass.php
require_once("usuarioClass.php");
//Comprobamos si hemos recibido alguna llamada por GET
if(isset($_GET["json"])){
$json = $_GET["json"];
$json = urldecode($json);
15
16
17
18
19
20
21
22
$json = str_replace("\\", "",$json);
$jsonencode = json_decode($json);
//--Creamos un objeto de la clase usuarioClass
$userObject = new Usuarios();
//Insertamos un nuevo usuario en la base de datos
$userObject->createUser($jsonencode[0]->nombre,$jsonencode[0]->apellidos,$jsonencode[0]->email);
}
En ambos casos comprobamos que hemos recibido un parámetro
llamado json con el contenido del JSON en texto plan, una vez que hemos
recibido el JSON lo tenemos que decodificar y eliminar la barra “\”.
Decodificamos el JSON e insertamos un nuevo usuario en la base de datos.
CLIENTE
Una vez que hemos creado nuestro servidor en PHP para la escucha de datos,
vamos a crear un nuevo programa en JAVA que envíe los datos a nuestro
servidor. En mi caso el servidor será local por lo que las llamadas deberán
enviarse a localhost.
Vamos a usar Netbeans como IDE JAVA. En primer lugar creamos una nueva
aplicación Java llamada JavaPHPMySQL cuyo main contenga lo siguiente:
1 /*
* To change this license header, choose License Headers in
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package javaphpmysql;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import static java.lang.System.in;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import org.json.simple.JSONObject;
import org.json.simple.JSONValue;
/**
*
* @author IdeaPad Z500
*/
public class JavaPHPMySQL {
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
/**
* @param args the command line arguments
*/
private static final String USER_AGENT = "Mozilla/5.0";
private static final String SERVER_PATH = "http://localhost/";
static String nombre = "Alejandro";
static String apellidos = "Esquiva Rodríguez";
static String email = "[email protected]";
public static void main(String[] args) {
//Tenemos dos funciones, una para enviar por GET y otra para enviar por POST
sendPost();
//sendGet();
}
public static void sendPost(){
//Creamos un objeto JSON
JSONObject jsonObj = new JSONObject();
//Añadimos el nombre, apellidos y email del usuario
jsonObj.put("nombre",nombre);
jsonObj.put("apellidos", apellidos);
jsonObj.put("email", email);
//Creamos una lista para almacenar el JSON
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
List l = new LinkedList();
l.addAll(Arrays.asList(jsonObj));
//Generamos el String JSON
String jsonString = JSONValue.toJSONString(l);
System.out.println("JSON GENERADO:");
System.out.println(jsonString);
System.out.println("");
try {
//Codificar el json a URL
jsonString = URLEncoder.encode(jsonString, "UTF-8");
//Generar la URL
String url = SERVER_PATH+"listenPost.php";
//Creamos un nuevo objeto URL con la url donde queremos enviar el JSON
URL obj = new URL(url);
//Creamos un objeto de conexión
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
//Añadimos la cabecera
con.setRequestMethod("POST");
con.setRequestProperty("User-Agent", USER_AGENT);
con.setRequestProperty("Accept-Language", "en-US,en;q=0.5");
//Creamos los parametros para enviar
String urlParameters = "json="+jsonString;
// Enviamos los datos por POST
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
con.setDoOutput(true);
DataOutputStream wr = new DataOutputStream(con.getOutputStream());
wr.writeBytes(urlParameters);
wr.flush();
wr.close();
//Capturamos la respuesta del servidor
int responseCode = con.getResponseCode();
System.out.println("\nSending 'POST' request to URL : " + url);
System.out.println("Post parameters : " + urlParameters);
System.out.println("Response Code : " + responseCode);
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
//Mostramos la respuesta del servidor por consola
System.out.println(response);
//cerramos la conexión
in.close();
} catch (Exception e) {
e.printStackTrace();
}
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
}
public static void sendGet(){
//Creamos un objeto JSON
JSONObject jsonObj = new JSONObject();
//Añadimos el nombre, apellidos y email del usuario
jsonObj.put("nombre",nombre);
jsonObj.put("apellidos", apellidos);
jsonObj.put("email", email);
//Creamos una lista para almacenar el JSON
List l = new LinkedList();
l.addAll(Arrays.asList(jsonObj));
//Generamos el String JSON
String jsonString = JSONValue.toJSONString(l);
System.out.println("JSON GENERADO:");
System.out.println(jsonString);
System.out.println("");
try{
//Codificar el json a URL
jsonString = URLEncoder.encode(jsonString, "UTF-8");
//Generar la URL
String url = SERVER_PATH+"listenGet.php?json="+jsonString;
URL obj = new URL(url);
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
// optional default is GET
con.setRequestMethod("GET");
//add request header
con.setRequestProperty("User-Agent", USER_AGENT);
int responseCode = con.getResponseCode();
System.out.println("\nSending 'GET' request to URL : " + url);
System.out.println("Response Code : " + responseCode);
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
//print result
System.out.println(response.toString());
}catch (Exception e) {
e.printStackTrace();
}
}
}
Antes de comenzar a explicar el código por encima hay que indicar que para que
este ejemplo funciones es necesario importar la librería json-simple-1.1.1.jar en
nuestro proyecto. Esta librería nos permitirá gestionar objetos JSON.
Observamos que la clase principal del cliente consta de dos métodos para enviar
los datos encapsulados en un JSON, el método sendPost() y sendGet(). Es obvio
que el metodo sendPost enviará un JSON encapsulado a nuestro servidor
mediante POST y el método sendGet lo enviará mediante método GET.
Podemos observar que ambos métodos son similares. en un principio generamos
en texto plano un JSON con los datos del usuario que queramos, en el ejemplo he
puesto mis propios datos. Una vez que tenemos el JSON en texto plano lo
enviamos con ayuda de los objetos URL url y HttpURLConnection con. Así
mismo obtenemos la respuesta del servidor y la mostramos por pantalla.
Por último, hay que tener en cuenta los siguientes puntos a la hora de realizar este
tutorial:
Hay que indicar la url del servidor donde queremos enviar los datos en la
constante SERVER_PATH.
Este tutorial se ha basado en el envio de JSON, pero no es extrictamente
necesario encapsular los datos en un JSON, podemos enviar los datos en texto
plano si queremos, enviar los datos en JSON nos va a ahorrar trabajo a la hora de
que enviemos una gran cantidad de datos a almacenar.
El envío de datos por GET tiene la desventaja de la cantidad de caracteres que
podemos enviar por este método, si enviamos muchos datos a la vez
encapsulados en un JSON nos podría dar error de longitud.
JAVA – PHP – MYSQL: VI OBTENER DATOS DE MYSQL EN JAVA CON PHP
Buenas a todos, en este último tutorial de la serie JAVA – PHP – MySQL vamos a
hacer justo lo contrario que hicimos en el antiguo tutorial. Vamos a tener dos
aplicaciones, la primera de ellas será la aplicación del servidor (PHP) que ofrecerá
información en un JSON, la segunda aplicación será la aplicación de escritorio
(JAVA) que leerá el JSON que ha generado la aplicación del servidor y gestionará
el JSON para mostrarlo en pantalla.
Así pues, antes de empezar me gustaría mostrar el índice y los objetivos de esta
serie de tutoriales JAVA – PHP – MySQL:
1. JAVA – PHP – MySQL: I Introducción
2. JAVA – PHP – MySQL: II Creación de una base de datos en MySQL
3. JAVA – PHP – MySQL: III Crear una conexión con la base de datos en PHP
4. JAVA – PHP – MySQL: IV Consultas Básicas e inserción de datos en PHP
5. JAVA – PHP – MySQL: V Insertar datos en MySQL desde JAVA con PHP
6. JAVA – PHP – MySQL: VI Obtener datos de MySQL en JAVA con PHP
Los objetivos que nos proponemos con esta serie de tutoriales son los siguientes:
MySQL
Aprender a crear una base de datos en MySQL.
PHP
Aprender a insertar datos en nuestra base de datos.
Aprender a mostrar datos de nuestra base de datos.
Consolidar los conocimientos aprendidos en la serie de tutoriales JSON.
Mostrar los datos introducidos en la base de datos en pantalla.
JAVA
Crear JSON a partir de los datos introducidos por el usuario.
Enviar JSON vía GET en JAVA.
Enviar JSON vía POST en JAVA.
Obtener un JSON generado en PHP.
Una vez que hemos visto los objetivos de esta serie de tutoriales vamos a
proceder a empezar con este último tutorial de la serie JAVA – PHP – MySQL.
Me gustaría empezar explicando el contexto de este tutorial. En los tutoriales
anteriores creamos una tabla en nuestra base de datos con el siguiente aspecto:
Nuestro objetivo será extraer los usuarios de la base de datos y encapsular los
datos en un JSON que mostraremos con ayuda de PHP.
CREACIÓN DE UN ARCHIVO PHP QUE MUESTRE UN JSON
Para poder realizar esta parte vamos a basarnos en un tutorial realizado por mi
en Geeky Theory de la serie de tutoriales sobre JSON:
JSON II – Creación de un JSON a partir de una consulta en MySQL
También vamos a tener en cuenta que en el tutorial IV creamos una clase
llamada usuariosClass.php con las siguientes funciones:
conectarBD
desconectarBD
getArraySQL
createUser
getAllInfo
getNombre
getApellidos
getEmail
Así pues crearemos un archivo PHP llamado getUsuariosJSON.php que
muestra un JSON con la información de los usuarios:
1
2
3
4
5
<?php
/**
*Autor: Alejandro Esquiva Rodríguez (@alex_esquiva)
*Desarrollado para Geeky Theory
*
6
7
8
9
10
11
12
13
14
15
16
*Este archivo mostrará un JSON para que la aplicación JAVA lo lea
*/
//--Incluimos el archivo en usuarioClass.php
require_once("usuarioClass.php");
//--Creamos una instancia de la calse usuarios
$userObject = new Usuarios();
//--Obtenemos un array multidimensional con todos los usuarios registrados
$users = $userObject->getAllInfo();
//Codificamos el array multidimensional y lo mostramos en pantalla
echo json_encode($users);
?>
Observamos en el código anterior que hemos incluido la clase creada en el tutorial
IV usuarioClass.php seguidamente hemos obtenido un array multidimensional
con toda la información de todos lo usuarios. Por último hemos codificado y
mostrado esa información en JSON.
El resultado de este script es el siguiente:
Esto es lo que vamos a leer y mostrar en nuestra aplicación JAVA.
LEER JSON GENERADO EN PHP DEDE JAVA
La última parte es un poco más complicada, para hacer esta parte vamos a
continuar el proyecto que creamos en el tutorial anterior. Recordad que para que la
gestión de JSON funcione en JAVA debemos incluir la librería json-simple-
1.1.1.jar.
Así pues vamos a crear una nueva clase en JAVA llamada GestionarJSON que
tenga dos métodos, el primer método llamado getJSON obtendra en un String el
JSON que hemos servido en la parte del servidor. El segundo método
llamado showJSON, recibirá como parámetro un JSON el cual se gestionará y se
extraerá la información mostrando esta en la consola.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package javaphpmysql;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import static javaphpmysql.JavaPHPMySQL.sendPost;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.JSONValue;
public class GestionarJSON {
private static final String USER_AGENT = "Mozilla/5.0";
private static final String SERVER_PATH = "http://localhost/";
public static void main(String[] args) {
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//Obtenemos el JSON
String json = getJSON();
//Lo mostramos
showJSON(json);
}
private static String getJSON(){
StringBuffer response = null;
try {
//Generar la URL
String url = SERVER_PATH+"getUsuariosJSON.php";
//Creamos un nuevo objeto URL con la url donde pedir el JSON
URL obj = new URL(url);
//Creamos un objeto de conexión
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
//Añadimos la cabecera
con.setRequestMethod("POST");
con.setRequestProperty("User-Agent", USER_AGENT);
con.setRequestProperty("Accept-Language", "en-US,en;q=0.5");
// Enviamos la petición por POST
con.setDoOutput(true);
//Capturamos la respuesta del servidor
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
int responseCode = con.getResponseCode();
System.out.println("\nSending 'POST' request to URL : " + url);
System.out.println("Response Code : " + responseCode);
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
//Mostramos la respuesta del servidor por consola
System.out.println("Respuesta del servidor: "+response);
System.out.println();
//cerramos la conexión
in.close();
} catch (Exception e) {
e.printStackTrace();
}
return response.toString();
}
private static void showJSON(String json){
System.out.println("INFORMACIÓN OBTENIDA DE LA BASE DE DATOS:");
72
73
74
75
76
77
78
79
80
81
82
83
84
85
//Crear un Objeto JSON a partir del string JSON
Object jsonObject =JSONValue.parse(json.toString());
//Convertir el objeto JSON en un array
JSONArray array=(JSONArray)jsonObject;
//Iterar el array y extraer la información
for(int i=0;i<array.size();i++){
JSONObject row =(JSONObject)array.get(i);
String nombre = row.get("nombre").toString();
String apellidos = row.get("apellidos").toString();
String email = row.get("email").toString();
//Mostrar la información en pantalla
System.out.println("Nombre: " + nombre + "|| Apellidos: " + apellidos + "|| Email: " + email);
}
}
}
Observamos que el código esta comentado, explicando todos los pasos que
estamos realizando. Si ejecutamos esta aplicación java observamos que hemos
obtenido todos los datos tal como se muestra en la siguiente captura:
Y esto es todo, para terminar me gustaría dejar unos enlaces de interés de
tutoriales que podrían mejorar las funcionalidad de esta serie de tutoriales.
Serie de tutoriales sobre JSON.
Serie de tutoriales sobre PHP
Serie de tutoriales sobre JAVA
Tutorial sobre graficación de datos