Cómo publicar un archivo crossdomain.xml en Mule 2.2.1 Standalone

En ésta publicación explico el procedimiento para publicar un archivo crossdomain.xml en Mule2.2.1.

El archivo crossdomain.xml es requerido por las aplicaciones Flex/Flash para poder consumir servicios web que se encuentran en diferentes dominios.

En el archivo de configuración de la aplicación de Mule, se tiene que incluir lo siguiente:

<jetty:connector name="jetty" useContinuations="false" />

<!-- ... -->
<service name="crossdomain">
    <inbound>
  <jetty:inbound-endpoint address="http://127.0.0.1:80/crossdomain.xml"
                                        connector-ref="jetty"
                                        synchronous="true" method="GET">
   <not-filter>
    <wildcard-filter pattern="/favicon.ico"/>
            </not-filter> 
            <response-transformers>
    <message-properties-transformer>
     <add-message-property key="Content-Type" value="application/xml"/>
                </message-properties-transformer>
            </response-transformers>
        </jetty:inbound-endpoint>
    </inbound>
    <component>
        <singleton-object class="org.mule.component.simple.StaticComponent">
   <property key="dataFile" value="flex/crossdomain.xml"/>
  </singleton-object>
 </component>
</service>

Nótese que para ésta configuración el archivo crossdomain.xml tendrá que ser colocado en el directorio %MULE_HOME%\lib\user\flex

Cómo cambiar de Tablespace a una tabla de Oracle

Para cambiar de TABLESPACE a una tabla se usa la siguiente instrucción SQL:

ALTER TABLE NOMBRE_TABLA MOVE TABLESPACE NUEVO_TABLESPACE;

Además, después de esto es importante reconstruir todos los índices que tenga la tabla usando la siguiente instrucción SQL:

ALTER INDEX NOMBRE_INDICE REBUILD;

Consulta SQL para conocer el espacio que ocupa una tabla de Oracle

A continuación comparto una consulta SQL para conocer el tamaño en Bytes, Kilobytes, Megabytes y Gigabytes que ocupa una tabla de Oracle 10g o superior.

SELECT segment_name AS "TABLE_NAME",
SUM (BYTES) AS "[Bytes]",
SUM (BYTES) / 1024 AS "[Kb]",
SUM (BYTES) / (1024*1024) AS "[Mb]",
SUM (BYTES) / (1024*1024*1024) AS "[Gb]"
FROM dba_segments
WHERE segment_name = 'NOMBRE_TABLA' and segment_type = 'TABLE'
GROUP BY segment_name;

En dónde en segment_name se especifica el nombre de la tabla que se desea consultar.

Cómo integrar Apache ActiveMQ y Apache Tomcat

En ésta publicación explico el procedimiento para poder conectarnos a un broker de mensajería ActiveMQ desde el contenedor de servlets Tomcat.

Para ésta configuración usaré las siguientes versiones de ActiveMQ y Tomcat:

• Apache Active MQ v5.5
• Apache Tomcat v5.5

Librerías necesarias

Suponiendo que TOMCAT_HOME=c:/Tomcat5.5 y ACTIVEMQ_HOME:c:/apache-activemq-5.5.0

Primero, se tiene que copiar las siguientes librerías al directorio TOMCAT_HOME/common/lib

• activemq-all-5.5.0.jar (ACTIVEMQ_HOME)
• slf4j-log4j12-1.5.11.jar (ACTIVEMQ_HOME/lib/optional)
• log4j-1.2.14.jar (ACTIVEMQ_HOME/lib/optional)

NOTA: asegurarse que no se encuentren otras librerías de activemq de versiones anteriores en las aplicaciones web que estén desplegadas en Tomcat.

Configuración del archivo server.xml

En el archivo server.xml que se encuentra en TOMCAT_HOME/conf incluir lo siguiente dentro del elemento GlobalNamingResources:

<GlobalNamingResources>

 <Resource name="jms/ConnectionFactory" 
  auth="Container" 
  type="org.apache.activemq.ActiveMQConnectionFactory" 
  description="JMS Connection Factory"
        factory="org.apache.activemq.jndi.JNDIReferenceFactory" 
  brokerURL="tcp://127.0.0.1:61616" 
  brokerName="activeMQBroker"/>
    
 <Resource auth="Container"
          name="jms/MiCola"
          type="org.apache.activemq.command.ActiveMQQueue"
          description="Cola de mensajes"
          factory="org.apache.activemq.jndi.JNDIReferenceFactory"
          physicalName="com.blogspot.ingmmurillo.queue"/>
    
</GlobalNamingResources>

Nótese que en brokerURL se especifica el servidor en dónde está corriendo Apache ActiveMQ, en este caso se encuentra en la misma máquina. Además, es necesario especificar todas las colas y tópicos a los cuáles se va a conectar, en este caso voy a conectarme a la cola com.blogspot.ingmmurillo.queue

Configuración del archivo context.xml

En el archivo context.xml que se encuentra en TOMCAT_HOME/conf incluir lo siguiente:

<Context>
    
 <ResourceLink global="jms/ConnectionFactory" name="jms/ConnectionFactory" type="javax.jms.ConnectionFactory"/>
 <ResourceLink global="jms/MiCola" name="jms/MiCola" type="javax.jms.Queue"/>
 
</Context>

Configuración del archivo web.xml

En el descriptor de despliegue web.xml que se encuentra en TOMCAT_HOME/conf incluir lo siguiente:

<resource-ref>
        <description>JMS Connection</description>
        <res-ref-name>jms/ConnectionFactory</res-ref-name>
        <res-type>javax.jms.ConnectionFactory</res-type>
        <res-auth>Container</res-auth>
        <res-sharing-scope>Shareable</res-sharing-scope>
    </resource-ref>

    <resource-ref>
        <res-ref-name>jms/MiCola</res-ref-name>
        <res-type>javax.jms.Queue</res-type>
        <res-auth>Container</res-auth>
        <res-sharing-scope>Shareable</res-sharing-scope>
    </resource-ref>

Cabe mencionar que con ésta configuración, la conexión a ActiveMQ será visible para cualquier aplicación web desplegada sobre Tomcat.

Código Java para conexión a ActiveMQ y envió de un mensaje

A continuación explico cómo sería el código Java para conectarnos al bróker de mensajería y envíar un mensaje de texto.

//...
Context initContext = new InitialContext();
Context jndiContext = (Context) initContext.lookup("java:comp/env");
ActiveMQConnectionFactory qFactory = (ActiveMQConnectionFactory)jndiContext.lookup("jms/ConnectionFactory");
QueueConnection qConnect = qFactory.createQueueConnection();
qConnect.start();
            
QueueSession qSession = qConnect.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
Queue requestQ = (Queue) jndiContext.lookup("jms/MiCola");
            
QueueSender qSender = qSession.createSender(requestQ);
ObjectMessage msg = qSession.createObjectMessage(new String("Hola, ActiveMQ"));
qSender.send(msg);
qConnect.stop();

Cómo ordenar elementos XML usando JAXB

En ésta publicación explicaré cómo ordenar los elementos XML cuando se usa JAXB, para lo que trabajaré con la versión 2.2.1.

Supongamos que tenemos el siguiente objeto de transferencia de datos (DTO), CustomerDTO:

package com.blogspot.ingmmurillo.jaxb;

import com.tandicorp.tandiesb.jaxb.XMLOutputStream;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.annotation.XmlRootElement;
import java.io.IOException;
import java.io.Serializable;
import java.util.Date;

@XmlRootElement
public class CustomerDTO implements Serializable {

    private String identification;
    private String internalIdentifier;
    private String firstName;
    private String lastName;
    private Date birthday;

    public String getIdentification() {
        return identification;
    }

    public void setIdentification(String identification) {
        this.identification = identification;
    }

    public String getInternalIdentifier() {
        return internalIdentifier;
    }

    public void setInternalIdentifier(String internalIdentifier) {
        this.internalIdentifier = internalIdentifier;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

   

    @Override
    public String toString() {
        XMLOutputStream xmlOutput = new XMLOutputStream();
        JAXBContext contextObj = null;
        Marshaller marshallerObj = null;
        try {
            contextObj = JAXBContext.newInstance(this.getClass());
            marshallerObj = contextObj.createMarshaller();
            marshallerObj.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
            marshallerObj.marshal(this, xmlOutput);
            xmlOutput.flush();
            xmlOutput.close();
        } catch (JAXBException e) {
            e.printStackTrace();
            return e.getMessage();
        } catch (IOException e) {
            e.printStackTrace();
            return e.getMessage();
        } finally {
            if (contextObj != null) {
                contextObj = null;
            }
            if (marshallerObj != null) {
                marshallerObj = null;
            }
        }

        return xmlOutput.toString();
    }
}

Cómo se puede observar se colocó la anotación @XmlRootElement y se sobrescribió el método toString(). Sí se crea una instancia del DTO y se lo imprime en consola se obtendrá lo siguiente:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<customerDTO>
    <birthday>1983-07-13T13:23:27.436-05:00</birthday>
    <firstName>Mauricio</firstName>
    <identification>1845122451</identification>
    <internalIdentifier>877441000001</internalIdentifier>
    <lastName>Murillo</lastName>
</customerDTO>

Por defecto el elemento raíz del documento XML es el mismo nombre de la clase con la primera letra minúscula (customerDTO) y los elementos XML se ordenan en orden alfabético: (birthday, firstName, identification, internalIdentifier, lastName)

Para cambiar el nombre del elemento raíz se asigna un valor a la variable name de la anotación @XmlRootElement y para ordenar los elementos XML se usa la anotación @XmlType asignando el orden a la propiedad propOrder como un arreglo de String. Por último, se usa la anotación @XmlTransient para evitar que el atributo internalIdentifier de la clase se muestre como elemento XML, como se muestra a continuación:

package com.blogspot.ingmmurillo.jaxb;

import com.tandicorp.tandiesb.jaxb.XMLOutputStream;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.XmlType;
import java.io.IOException;
import java.io.Serializable;
import java.util.Date;

@XmlRootElement(name = "customer")
@XmlType(propOrder = {"firstName", "lastName", "identification", "birthday"})
public class CustomerDTO implements Serializable {

    private String identification;
    private String internalIdentifier;

    //...
    
    @XmlTransient
    public String getInternalIdentifier() {
        return internalIdentifier;
    }

}

Sí se imprime en consola una instancia del objeto CustomerDTO ahora se obtendrá el siguiente resultado:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<customer>
    <firstName>Mauricio</firstName>
    <lastName>Murillo</lastName>
    <identification>1845122451</identification>
    <birthday>1983-07-13T14:28:48.079-05:00</birthday>
</customer> 

Referencias

• Utilización de JAXB para mapear clases Java a representaciones XML