Java Architecture for XML Binding (JAXB)

JAXB te permite almacenar y recuperar datos en memoria en cualquier formato XML, sin la necesidad de implementar un conjunto específico de rutinas de carga y guardado de XML para la estructura de clases del programa.

Vamos a utilizar las interfaces Marshaller y Unmarshaller, responsables de dirigir el proceso de serialización de los contenidos de un objeto de alguna clase de Java a datos XML y viceversa.

Marshalling
La interface Marshaller es la interfaz que define los métodos utilizados para realizar el binding de nuestras clases desde objetos a XML. De esta forma:
1 – Definimos una clase Persona.

@XmlRootElement(name = "Persona")
public class Persona{

    @XmlElement()
    private String nombre;
    @XmlElement()
    private String apellido;
 
    public Persona()
    {
    }
 
    public Persona(String nombre, String apellido)
    {
        this.nombre= nombre;
        this.apellido= apellido;
    }
    …
}

2 – creamos el objeto que pretendemos convertir a xml:

Persona person = new Persona("Manuel", "Perez");

3 – Una vez creado el objeto Marshaller solo resta invocarlo pasándole el objeto a serializar y el flujo donde almacenará el resultado:

JAXBContext context = JAXBContext.newInstance(Person.class);
Marshaller marshaller = context.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
     
FileWriter file = new FileWriter("/temp/Persona.xml");
marshaller.marshal(person, file);

4 –El fichero creado tendrá esta estructura:

< ?xml version="1.0" encoding="UTF-8" standalone="yes"?>
< Persona>
    < nombre>Manuel< /nombre>
    < apellido>Perez< /apellido>
< /Persona>

Unmarshalling
La interface Unarshaller es la interfaz que define los métodos utilizados para realizar el binding de nuestras clases desde XML a objetos. Pasamos directamente al ejemplo:

JAXBContext jc = JAXBContext.newInstance (Persona.class);
Unmarshaller u = jc.createUnmarshaller ();
File f = new File ("/temp/DB.xml");
Persona personadelxml= (Persona)u.unmarshal(f);

Fuente: http://es.wikipedia.org/wiki/JAXB
Documentación

Usar Apache CXF para montar servicios en java

En primer lugar comentar unos conceptos básicos… tenemos dos tipos de servicios web: SOAP y REST.
– SOAP consiste en el intercambio de mensajes envueltos en un XML. El cliente envía un mensaje XML en formato SOAP, dicho mensaje es recibido por el servidor, que desencapsula dicho mensaje en el formato correspondiente (SOAP es multilenguaje, acepta varios lenguajes, entre ellos Java), que recibe los datos, procesa una respuesta y la devuelve.
En Java existe la implementación JAX WS.

– Rest es una implementación posterior. No sólo utiliza un tipo de mensaje HTTP para el intercambio de mensajes, si no que permite más mensajes. Con Rest puedes tener un cliente que envíe mensajes HTTP de tipo GET, PUT, POST y DELETE. Cada mensaje enviará los datos correspondientes asociados hacia el servidor, que, recibirá la petición, la entenderá, y delegará en el método correspondiente. GET sirve para recuperar un dato desde el cliente al servidor, PUT para insertar un dato, POST para enviar información para modificar y DELETE para eliminar información del servidor.
En Java existe la implementación JAX RS.

Una forma muy sencilla de montar nuestros servicios en java es utilizar Apache CXF que se adapta tanto a Jax WS como a Jax RS. Además, se integra muy bien con Spring.
En la documentación hay numerosos ejemplos: Documentación oficial

A continuación un par de ejemplos muy sencillos:

package es.com.disastercode;

import javax.jws.WebService;

@WebService
public interface EjemploService{
    String getTipoCoche(String matricula);
}

Archivo de implementación JAX WS. Para exponer un servicio y publicarlo en un contendor de aplicaciones que soporte JAX-WS. Automáticamente el contenedor se encargará de generar el contrato (WSDL).

package es.com.disastercode;

import javax.jws.WebService;

@WebService(endpointInterface = "es.com.disastercode.EjemploService")
public class EjemploServiceWSImpl implements EjemploService {

    public String getTipoCoche(String matricula) {
        return "Seat Ibiza";
    }
}

Archivo de implementación JAX-RS. Permite realizar lo mismo que antes pero exponiendolo como recursos REST.

package es.com.disastercode;

import javax.jws.WebService;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;

@WebService(endpointInterface = "es.com.disastercode.EjemploService")
@Produces("application/json")
public class EjemploServiceRSImpl implements EjemploService {
       
    @GET
    @Path("/{matricula}")
    public String getTipoCoche(@PathParam("matricula")String matricula) {
        return "Seat Ibiza";
    }
}

Ahora sólo nos faltaría configurar los servicios en Spring. Para ello:
1/ añadir al web.xml:

        < context-param>
                < param-name>contextConfigLocation< /param-name>
                < param-value>WEB-INF/appCtx.xml< /param-value>
        < /context-param>

        < listener>
                < listener-class>
                        org.springframework.web.context.ContextLoaderListener
                < /listener-class>
        < /listener>

        < servlet>
                < servlet-name>CXFServlet
                < servlet-class>
                        org.apache.cxf.transport.servlet.CXFServlet
                < /servlet-class>
                < load-on-startup>1
        < /servlet>

        < servlet-mapping>
                CXFServlet
                /*
        < /servlet-mapping>

2/ añadir la configuración de JAX WS a spring.

< beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
		http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

	< import resource="classpath:META-INF/cxf/cxf.xml" />
	< import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
        < import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />

	< bean id="ejemploServiceController"
		class="es.com.disastercode.EjemploServiceWSImpl">
	< /bean>

	< jaxws:endpoint id="ejemploService" implementor="#ejemploServiceController"
		address="/ws/exps">
        < jaxws:dataBinding>
        	
            < /bean>
        < /jaxws:dataBinding>
    < /jaxws:endpoint>     
< /beans>

3/ añadir la configuración de JAX RS a spring.

< beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:jaxrs="http://cxf.apache.org/jaxrs"
      xsi:schemaLocation="
         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
         http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd">

	< import resource="classpath:META-INF/cxf/cxf.xml" />
	< import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
        < import resource="classpath*:META-INF/cxf/cxf-extension-*.xml" />
    

	< bean id="ejemploServiceRestController"
		class="es.com.disastercode.EjemploServiceRSImpl">
	< /bean>


    < jaxrs:server id="ejemploServiceRest" address="/rest">
        < jaxrs:serviceBeans>
            < ref bean="ejemploServiceRestController" />
        < /jaxrs:serviceBeans>
        
         
		< jaxrs:providers>
		 < ref bean="jsonProvider"/>
		< /jaxrs:providers>
		 
		< jaxrs:features>
 		< /jaxrs:features>
 		
    < /jaxrs:server>

    < bean id="jsonProvider" class="org.codehaus.jackson.jaxrs.JacksonJsonProvider"/>
< /beans>

Cómo acceder al ResourceBundle en un action Struts

A continuación se muestra un ejemplo en el cual se accede al ResourceBundle en un action de struts.

public static String getLocalizedMessage(HttpServletRequest request, 
                                                       String messageKey) {
    //Obtenermos el MessageResources de la request.
    MessageResources messageResources = (MessageResources) 
                                request.getAttribute(Globals.MESSAGES_KEY);

    String localizedMessage = null;
    if(messageResources != null) {
        //buscamos la key deseada en la request.
        localizedMessage = messageResources.getMessage(
                                           request.getLocale(), messageKey);
    }
    if(localizedMessage == null) {
        localizedMessage = "";
    }
    return localizedMessage;
}


//Ejemplo de uso 
//(suponemos que en el properties tenemos la key: key.welcome=bienvenido)
getLocalizedMessage(request, "key.welcome");

Como usar la API de Twiter (parte 2)

A continuación, se muestra un ejemplo de como usar la API de Twiter con PHP.

En primer lugar comentar que se va a utilizar la librería TwitterAPIExchange. Esta librería contiene las funciones necesarias para conectar la API con los credenciales del usuario y realizar de una manera sencilla las operaciones deseadas.

Variable settings con los tokens a usar:

    $settings = array(
        'oauth_access_token' => "",
        'oauth_access_token_secret' => "",
        'consumer_key' => "",
        'consumer_secret' => ""
    );

Ejemplo 1: Listar los ids de los amigos que tiene el usuario robertopf81

//DOC: https://dev.twitter.com/docs/api/1.1/get/friends/ids
function listIdsFriends($usuario, $settings){
        ini_set('display_errors', 1);
        require_once('TwitterAPIExchange.php');
        $url = 'https://api.twitter.com/1.1/friends/ids.json';

        $getfield = '?cursor=-1&screen_name='.$usuario.'&count=5000';        
        $requestMethod = 'GET';
        $twitter = new TwitterAPIExchange($settings);
        $json =  $twitter->setGetfield($getfield)->buildOauth($url, $requestMethod)->performRequest();
        return $json;
}


//ahora la utilizariamos así:
	$friends = listIdsFriends("robertopf81", $settings);
	$jsonFriends = json_decode($friends);
	$num_friends = count($jsonFriends->ids);
	for($i=0; $i<$num_friends; $i++){
		$user = $jsonFriends->ids[$i];
		echo "Friend ". ($i+1) . ": " . $user . "
";
	}

Ejemplo 2: Seguir a un nuevo amigo llamado usuarioaseguir.

//DOC: https://dev.twitter.com/docs/api/1.1/post/friendships/create
function follow($usuario, $settings){
        ini_set('display_errors', 1);
        require_once('TwitterAPIExchange.php');
        $url = 'https://api.twitter.com/1.1/friendships/create.json';

        $requestMethod = 'POST';
        $postfields = array( 'screen_name' => $usuario,'follow' => "true" );

        $twitter = new TwitterAPIExchange($settings);
        return $twitter->buildOauth($url, $requestMethod)->setPostfields($postfields)->performRequest();
}


//ahora la utilizariamos así:
	$respuesta = follow("usuarioaseguir", $settings);
	echo $respuesta;
	$json = json_decode($respuesta);
	echo '';
	echo "Usuario: ".$json->name." (@".$json->screen_name.")";
	echo "
";
	echo "ID USER: ".$json->id_str;
	echo "
";
	echo "Fecha Envio: ".$json->created_at;

Se han dejado en github estos ejemplos y alguno más: ver aquí.

Como usar la API de Twiter (parte 1)

Si tienes una cuenta de twiter y quieres realizarte una aplicación personalizada que utilice toda la información que hay en twiter (número de seguidores, amigos, tweets, etc), la gente de Twiter nos facilita una serie de llamadas rest que podemos utilizar para interactuar con ellos. Más información aquí.

En primer lugar decir que a día de hoy la versión de la API de twitter es la 1.1 (la 1.0 ya está deprecada). Esta versión 1.1 requiere usar autentificación OAUTH, de otra forma no podremos poner a funcionar la aplicación.

Por lo tanto para poder utilizar la api se deben seguir estos pasos:
1/ Crear una cuenta de desarrollador: esto se hace en https://dev.twitter.com/

2/ Una vez creada la cuenta de desarrollador ya podrás crear una nueva aplicación en la zona de «Mis Aplicaciones«.

3/ Tras crear la aplicación lo siguiente es crear los Tokens de acceso. (API keys y Access Tokens)

4/ Llegados a este punto ya podriamos utilizar la api. Existen ya un gran número de librerias que nos facilitaran el uso del api twiter para no tener que implementarlo de cero. Además, hay librerías para casi cualquier lenguaje posible. (Ver aquí)

Codemotion ES: Feliz 15 aniversario, SQL Injection

Charla impartida por Chema Alonso en el Codemotion del 2013. Habla sobre el SQL Injection.

Plugin xml Sitemaps para WordPress

En primer lugar está bien definir en que consiste un sitemap o mapa de un sitio web. Se puede ver en la wikipedia.

Si tienes una página realizada con wordpress debes saber que tienes unos cuantos plugins que te generan el sitemap. Entre ellos me gustaría destacar el Google XML Sitemaps que se puede descargar de aquí.

Permite configurar a través de WordPress el sitemap de tu web, accediendo para ello al menú de “Ajustes” del panel de administración del WordPress. Una vez configurado el plugin se encargará de actualizar automáticamente tu sitemap y notificar esta actualización a los robots de los principales buscadores (Google, Yahoo, Bing y Ask) que así sabrán que deben volver a visitarte porque hay novedades.

Videotutoriales para aprender a programar IOS

A continuación se muestran unos videos bastante interesantes para iniciación de programación en iOS 7.

Capítulo 1:

Capítulo 2:

Capítulo 3:

Capítulo 4:

Capítulo 5:

Concatenar múltiples filas de una columna en una sentencia SQL para Oracle

Ejemplo:

Tenemos 1 tabla llamada ciudades, con los campos: id, nombreCiudad y nombrePais. Y queremos sacar un listado de todos los paises con sus ciudades concatenadas separadas por una coma. Para ello bastaria con ejecutar esta sentencia:

Select nombrePais, rtrim(xmlagg(xmlelement(ciudades, nombreCiudad ||’,’)).extract(‘//text()’), ‘,’)
from ciudades group by nombrePais;

Funciones utilizadas
rtrim – Se usa para quitar la la última coma de la cadena formada.
xmlagg – Retorna una colección de nodos en formato XMLFormat object, con todas las ciudades de cada pais (ya que hemos agrupado por pais en el group by).
xmlelement – Se utiliza para generar el formato que van a tener los nodos. El primer campo el es identificador del tag que se le asigna dentro del xml y el segundo campo el contenido de ese tag.
extract – En este caso se usa para extraer del docuemtno xml generado el texto.

Nota: Si en lugar de campos separados por comas se deseara separar las ciudades con saltos de línea se podría hacer lo siguiente:

Select nombrePais, rtrim(xmlagg(xmlelement(ciudades, nombreCiudad || CHR(13) || CHR(10))).extract(‘//text()’), CHR(13) || CHR(10))
from ciudades group by nombrePais;

Libreria de funciones JSTL

La libreria functions de JSTL (TAGLIB) nos facilita trabajar con Strings y Arrays en el lenguaje EL de JSP. Consta de las siguientes funciones:

fn:contains()
fn:containsIgnoreCase()
fn:endsWith()
fn:escapeXml()
fn:indexOf()
fn:join()
fn:length()
fn:replace()
fn:split()
fn:startsWith()
fn:substring()
fn:substringAfter()
fn:substringBefore()
fn:toLowerCase()
fn:toUpperCase()
fn:trim()

Para poder utilizarla es necesario incluir la siguiente cabecera:

< %@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>

Tutorial
JavaDoc
Página con ejemplos de uso