JAVA PHP MYSQL: I INTRODUCCIN

Muy Buenos Das a todos, debido a mi proyecto final de carrera, he tenido que
interactuar con distintas tecnologas, as pues, tuve que aparmelas para poder
hacer una aplicacin en JAVA que pudiese comunicarse con una base de datos
dinmicamente. 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 aplicacin JAVA que pudiera transmitir informacin a un
archivo PHP y que este a su vez insertar la informacin 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 Introduccin
2. JAVA PHP MySQL: II Creacin de una base de datos en MySQL
3. JAVA PHP MySQL: III Crear una conexin con la base de datos en PHP
4. JAVA PHP MySQL: IV Consultas Bsicas e insercin 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 va GET en JAVA.
Enviar JSON va POST en JAVA.
Obtener un JSON generado en PHP.


En un principio el ttulo 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 llamadausuarios.
Esta tabla va a tener los siguientes campos:
id_user nombre apellidos email

Se pretende que con esta serie de tutoriales se aprenda a mostrar los datos de la
base de datos en PHP va web, que se puedan almacenar los datos mediante una
sencilla aplicacin 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 slo va a ser accesible va PHP no en java, es
decir, MySQL slo va a trabajar con PHP.
PHP se encargar de enviar los datos a la base de datos. Tambin se va a
encargar de proporcionar los datos a JAVA, as como mostrarlos en una web
JAVA se encargar de enviar datos a PHP va GET o va POST. Tambin se
encargar de leer directamente el cdigo HTML y obtener datos de l.
Quizs algunos piensen que no tiene sentido insertar los datos va PHP que quizs
sea ms fcil y sencillo crear una conexin 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 mnima en
programacin 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
(Tericamente) los datos de tu server.
Interaccin Web: el primer esquema propone un escenario donde los datos de tu
aplicacin en java interacten directamente con el usuario va web. Por poner un
ejemplo, podras crear un juego en JAVA que almacene en una base de datos los
records de los usuarios, y mostrarlos en una pgina web.
Creacin de una API: con el primer esquema es posible crear tu propia API para
tu aplicacin.

Y esto es todo, si estis interesados en seguir esta serie de tutoriales, por favor
dejar un comentario indicando que cambiaras, que te gustara aprender sobre este
tema, o cualquier duda que tengas sobre esta serie de tutoriales. As pues en el
primer tutorial vamos a aprender cmo crear una base de datos fcilmente
desde PHPmyAdmin.
Un saludo @alex_esquiva!

JAVA PHP MYSQL: II CREACIN 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 Introduccin
2. JAVA PHP MySQL: II Creacin de una base de datos en MySQL
3. JAVA PHP MySQL: III Crear una conexin con la base de datos en PHP
4. JAVA PHP MySQL: IV Consultas Bsicas e insercin 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 va GET en JAVA.
Enviar JSON va 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_user nombre apellidos email
Para crear la base de datos usaremos PHPMyAdmin el cual consiste en una
interfaz web para la gestin de bases de datos. Para poder
usar PHPMyAdmin vamos a descargar EasyPHP, este contenedor de programas
contiene todas las herramientas necesarias para desarrollar una pgina web en
un servidor l0cal. Puedes descargar y saber ms 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 botn open en modules, nos aparecer algo como esto:
Para crear una base de datos debemos pulsar sobre el botn 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 aadir a nuestra base de datos una tabla llamada usuarios que va a
tener 4 columnas:

El siguiente paso ser aadir 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 conexin en PHP con MySQL.
Espero que os haya gustado y no olvidis de compartir el tutorial en vuestras
redes sociales.
Saludos! @alex_esquiva

JAVA PHP MYSQL: III CREAR UNA CONEXIN
CON LA BASE DE DATOS EN PHP

!Buenos Das!, en este breve tutorial vamos a realizar una conexin en PHP con la
base de datos que realizamos en elltimo tutorial. Antes de seguir vamos a ver un
ndice de esta serie de tutoriales y lo que pretendemos conseguir.
1. JAVA PHP MySQL: I Introduccin
2. JAVA PHP MySQL: II Creacin de una base de datos en MySQL
3. JAVA PHP MySQL: III Crear una conexin con la base de datos en PHP
4. JAVA PHP MySQL: IV Consultas Bsicas e insercin 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 va GET en JAVA.
Enviar JSON va POST en JAVA.
Obtener un JSON generado en PHP.
Sin ms 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 funcin conectarBD() y la
funcin desconectarBD().

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
*Funcin que crea y devuelve un objeto de conexin 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 conexin de la base de datos
$conexion = mysqli_connect($server, $usuario, $pass, $BD);
//Comprobamos si la conexin ha tenido exito
if($conexion){
echo 'La conexion de la base de datos se ha hecho satisfactoriamente<br>';
}else{
echo 'Ha sucedido un error inexperado en la conexion de la base de
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
datos<br>';
}
//devolvemos el objeto de conexin para usarlo en las consultas
return $conexion;
}

/*Desconectar la conexion a la base de datos*/
function desconectarBD($conexion){
//Cierra la conexin y guarda el estado de la operacin en una variable
$close = mysqli_close($conexion);
//Comprobamos si se ha cerrado la conexin 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 conexin
return $close;
}
De este cdigo 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 contrasea del usuario que tenga permisos
sobre esa base de datos en la funcin conectarBD().
Y esto es todo por hoy, en el prximo tutorial vamos a aprender a crear consultas
bsicas 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 podis hacerlo siguiendo los
pasos que se indican en el siguiente enlace.
!Un saludo! @alex_esquiva





JAVA PHP MYSQL: IV CONSULTAS E INSERCIN
DE DATOS EN MYSQL CON PHP

!Hola a todos!, En este cuarto tutorial sobre JAVA PHP MYSQL vamos a
repasar sentencias bsicas de SQL para insertar o consultar datos de una base de
datos. Una vez hayamos repasado las sentencias ms 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 Introduccin
2. JAVA PHP MySQL: II Creacin de una base de datos en MySQL
3. JAVA PHP MySQL: III Crear una conexin con la base de datos en PHP
4. JAVA PHP MySQL: IV Consultas Bsicas e insercin 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 va GET en JAVA.
Enviar JSON va POST en JAVA.
Obtener un JSON generado en PHP.

Para quien no lo sepa el lenguaje estndar para comunicarse con una base de
datos es un lenguaje sencillo y casiuniversal llamado SQL. Este lenguaje
dispone de una sencilla sintaxis para comunicarse con la base de datos que
tengamos disponible.
Algunas de las sentencias bsicas 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.

1 SELECT * 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.

1 SELECT * 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 ="condicin/ID";

Para ms informacin 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 codificacin de la base de datos, ya que algunas veces
hay problemas cuando queremos introducir datos de tipo VARCHAR con tildes.

Una consulta, insercin o modificacin de algn dato de nuestra base de datos es
ejecutada en tres puntos:
Conexin de la base de datos
Ejecucin (y obtencin de datos) enviando una query (sentencia) SQL
Desconexin 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 cdigo comentado y explicado muestra la implementacin de la clase
usuarios:

1
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
<?php
class Usuarios{

public $id_user = 0 ;
//Funcin que crea y devuelve un objeto de conexin 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 conexin de la base de datos
$conexion = mysqli_connect($server, $usuario, $pass, $BD);
//Comprobamos si la conexin ha tenido exito
if(!$conexion){
echo 'Ha sucedido un error inexperado en la conexion de la base de
datos<br>';
}
//devolvemos el objeto de conexin para usarlo en las consultas
return $conexion;
}
/*Desconectar la conexion a la base de datos*/
function desconectarBD($conexion){
//Cierra la conexin y guarda el estado de la operacin en una variable
$close = mysqli_close($conexion);
//Comprobamos si se ha cerrado la conexin correctamente
if(!$close){
echo 'Ha sucedido un error inexperado en la desconexion de la base de
datos<br>';
}
//devuelve el estado del cierre de conexin
return $close;
}

//Devuelve un array multidimensional con el resultado de la consulta
function getArraySQL($sql){
//Creamos la conexin
$conexion = $this->conectarBD();
//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++;
51
52
53
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
}
//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 conexin
$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 informacin
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(){
//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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
$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","alejandro@geekytheory.com");
//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 nmero 1
//En caso de que no fuese as deberiamos crearnos una funcin para obtener
//el ltimo id, esta funcin la dejo como ejercicio para aquellos que quiera practicar
$userObject->id_user=1;
//Obtenemos el nombre y lo mostramos por pantalla
echo $userObject->getNombre()."<br>";
//Obtenemos los apellidos y lo mostramos por pantalla
echo $userObject->getApellidos()."<br>";
//Obtenemos el nombre y lo mostramos por pantalla
echo $userObject->getEmail()."<br>";
?>
Podemos observar en el cdigo que hemos usado funciones ya usadas en otros
tutoriales como por ejemplo las funciones conectarBD/desconectarBD del tutorial
anterior.
Si ejecutamos el cdigo 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 travs una aplicacin 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 das 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, podis ver un esquema en el siguiente grfico:

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 Introduccin
2. JAVA PHP MySQL: II Creacin de una base de datos en MySQL
3. JAVA PHP MySQL: III Crear una conexin con la base de datos en PHP
4. JAVA PHP MySQL: IV Consultas Bsicas e insercin 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 va GET en JAVA.
Enviar JSON va 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 lnea 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 cuestin sernlistenPost.php y listenGet.php. El primero de ellos escuchar
llamadas mediante mtodo POST, mediante que el segundo escuchar las
llamadas mediante el mtodo GET.
A continuacin se mostrar el cdigo de ambos archivos comentados.
LISTENPOST.PHP


1
2
3
<meta charset="utf-8">
<?php
/**
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
*Autor: Alejandro Esquiva Rodrguez (@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);

//--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 <meta charset="utf-8">
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
/**
*Autor: Alejandro Esquiva Rodrguez (@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);
$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 parmetro
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 enve los datos a nuestro
servidor. En mi caso el servidor ser local por lo que las llamadas debern
enviarse a localhost.
Vamos a usar Netbeans como IDE JAVA. En primer lugar creamos una nueva
aplicacin Java llamada J avaPHPMySQL cuyo main contenga lo siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*
* To change this license header, choose License Headers in 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;
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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 {

/**
* @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 Rodrguez";
static String email = "alejandro@geekytheory.com";

public static void main(String[] args) {
//Tenemos dos funciones, una para enviar por GET y otra para enviar por
POST

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
sendPost();
//sendGet();

}

public static void sendPost(){
//Creamos un objeto JSON
JSONObject jsonObj = new JSONObject();
//Aadimos 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+"listenPost.php";
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
//Creamos un nuevo objeto URL con la url donde queremos enviar el JSON
URL obj = new URL(url);
//Creamos un objeto de conexin
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
//Aadimos 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
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();
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
//Mostramos la respuesta del servidor por consola
System.out.println(response);
//cerramos la conexin
in.close();
} catch (Exception e) {
e.printStackTrace();
}
}

public static void sendGet(){
//Creamos un objeto JSON
JSONObject jsonObj = new JSONObject();
//Aadimos 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:");
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
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();

// 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();

145
146
147
148
149
150
151
152
153
154
155
156
157
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 cdigo por encima hay que indicar que para que
este ejemplo funciones es necesario importar la librera json-simple-1.1.1.jar en
nuestro proyecto. Esta librera nos permitir gestionar objetos JSON.
Observamos que la clase principal del cliente consta de dos mtodos para enviar
los datos encapsulados en un JSON, el mtodo sendPost() y sendGet(). Es obvio
que el metodo sendPost enviar un JSON encapsulado a nuestro servidor
mediante POST y el mtodo sendGet lo enviar mediante mtodo GET.
Podemos observar que ambos mtodos 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 envo de datos por GET tiene la desventaja de la cantidad de caracteres que
podemos enviar por este mtodo, si enviamos muchos datos a la vez
encapsulados en un JSON nos podra 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 aplicacin del servidor (PHP) que ofrecer
informacin en un JSON, la segunda aplicacin ser la aplicacin de escritorio
(JAVA) que leer el JSON que ha generado la aplicacin del servidor y gestionar
el JSON para mostrarlo en pantalla.
As pues, antes de empezar me gustara mostrar el ndice y los objetivos de esta
serie de tutoriales JAVA PHP MySQL:
1. JAVA PHP MySQL: I Introduccin
2. JAVA PHP MySQL: II Creacin de una base de datos en MySQL
3. JAVA PHP MySQL: III Crear una conexin con la base de datos en PHP
4. JAVA PHP MySQL: IV Consultas Bsicas e insercin 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 va GET en JAVA.
Enviar JSON va 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 gustara 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.
CREACIN 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 Creacin de un JSON a partir de una consulta en MySQL
Tambin 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 getUsuariosJ SON.php que
muestra un JSON con la informacin de los usuarios:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
/**
*Autor: Alejandro Esquiva Rodrguez (@alex_esquiva)
*Desarrollado para Geeky Theory
*
*Este archivo mostrar un JSON para que la aplicacin 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 cdigo anterior que hemos incluido la clase creada en el tutorial
IV usuarioClass.php seguidamente hemos obtenido un array multidimensional
con toda la informacin de todos lo usuarios. Por ltimo hemos codificado y
mostrado esa informacin en JSON.
El resultado de este script es el siguiente:

Esto es lo que vamos a leer y mostrar en nuestra aplicacin JAVA.
LEER JSON GENERADO EN PHP DEDE JAVA
La ltima parte es un poco ms complicada, para hacer esta parte vamos a
continuar el proyecto que creamos en el tutorial anterior. Recordad que para que la
gestin de JSON funcione en JAVA debemos incluir la librera json-simple-
1.1.1.jar.
As pues vamos a crear una nueva clase en JAVA llamada GestionarJ SON que
tenga dos mtodos, el primer mtodo llamado getJ SON obtendra en un String el
JSON que hemos servido en la parte del servidor. El segundo mtodo
llamado showJ SON, recibir como parmetro un JSON el cual se gestionar y se
extraer la informacin mostrando esta en la consola.

1
2
3
4
5
6
7
package javaphpmysql;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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) {
//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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
URL obj = new URL(url);
//Creamos un objeto de conexin
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
//Aadimos la cabecera
con.setRequestMethod("POST");
con.setRequestProperty("User-Agent", USER_AGENT);
con.setRequestProperty("Accept-Language", "en-US,en;q=0.5");
// Enviamos la peticin por POST
con.setDoOutput(true);
//Capturamos la respuesta del servidor
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 conexin
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
in.close();
} catch (Exception e) {
e.printStackTrace();
}

return response.toString();
}

private static void showJSON(String json){
System.out.println("INFORMACIN OBTENIDA DE LA BASE DE
DATOS:");
//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 informacin
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 informacin en pantalla
System.out.println("Nombre: " + nombre + "|| Apellidos: " + apellidos + "||
Email: " + email);
}
}
}
Observamos que el cdigo esta comentado, explicando todos los pasos que
estamos realizando. Si ejecutamos esta aplicacin java observamos que hemos
obtenido todos los datos tal como se muestra en la siguiente captura:

Y esto es todo, para terminar me gustara dejar unos enlaces de inters de
tutoriales que podran 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 graficacin de datos