Fusible JBoss - Guía rápida

En este capítulo, comenzaremos con los aspectos básicos de Enterprise Service Bus. A continuación se ofrece una explicación detallada sobre ESB junto con sus ventajas, desventajas y un par de diagramas para facilitar la comprensión.

¿Qué es ESB?

ESB son las siglas de Enterprise Service Bus. ESB en su forma más simple es un middleware que actúa como una autopista de información que ayuda a múltiples aplicaciones a comunicarse.

En el mundo empresarial, desarrollamos soluciones para muchas cosas. Estas soluciones pueden utilizar diferentes tecnologías y diferentes formatos de datos. Se vuelve engorroso utilizar estas soluciones juntas debido a la variación de compatibilidad del formato de comunicación o datos en estas tecnologías. Por tanto, necesitamos una tecnología que nos permitaloosely coupled integration entre estas diferentes soluciones.

ESB tiene como objetivo simplificar este problema de integración convirtiéndose en un 'HUB' que se encuentra en el medio de todas sus aplicaciones y facilita el enrutamiento de mensajes entre ellas. ESB actúa como mediador, actuando como autopista de la información, encargándose del enrutamiento de la transformación de datos, dejando que el codificador o el desarrollador se centren en su propia lógica de aplicación.

Comprender ESB se vuelve muy simple cuando entendemos el problema para el que fue diseñado especialmente y la solución se vuelve fácil. Uno debe tener una comprensión clara de cómo habilitar muchos sistemas dispares, escritos en diferentes idiomas y ejecutándose en diferentes máquinas usando diferentes formatos de datos para compartir información y formar una plataforma comercial integrada.

El problema de la integración

En la plataforma empresarial, es común que varias aplicaciones colaboren y brinden funcionalidad comercial en su conjunto, pero la integración de estas aplicaciones es el problema más recurrente. Incluso se vuelve difícil con el tiempo a medida que crecen las aplicaciones.

Cada aplicación puede ingresar y enviar datos en su propio formato. Este enfoque funciona bien si el número de aplicaciones es menor, pero a medida que aumenta el número de aplicaciones, las ruedas de integración también deben batirse con un enfoque mejor. Por ejemplo, si es necesario cambiar una aplicación particular para una empresa, se verá afectado su formato de datos de entrada o salida para todas las aplicaciones que dependen de esa aplicación Maestra.

Este enfoque constituye el mayor obstáculo para la integración, que espera una arquitectura estrechamente acoplada. Aquí es donde ESB entra en escena. Cada aplicación no necesita comunicarse directamente con otra aplicación; en cambio, todas las aplicaciones se comunican con el ESB y el ESB maneja el enrutamiento de información y la conversión de formato de datos internos.

¿Por qué ESB?

A continuación se presentan algunos puntos que explican por qué Enterprise Service Bus es esencial.

ESB tiene como objetivo simplificar el problema de la integración con aplicaciones compatibles variantes.
Actúa como un Middleware, que sirve como mediador de todas sus aplicaciones y facilita el enrutamiento de mensajes entre ellas.
En lugar de que cada aplicación interactúe directamente con las demás aplicaciones, cada aplicación ahora solo tiene una interfaz para el ESB.
El ESB es responsable de traducir los mensajes hacia / desde un formato común y de enrutarlos a sus destinos.
El mayor ahorro en este enfoque es una bendición si tiene que reemplazar cualquiera de sus aplicaciones existentes. En lugar de escribir un montón de nuevas interfaces, ahora solo tiene una interfaz de la que preocuparse (entre su aplicación y el ESB).

SOA y ESB?

SOA y ESB se usan comúnmente de manera intercambiable, pero son completamente diferentes.

SOA es un patrón de diseño que permite que la aplicación exponga sus funcionalidades como un servicio a través de la red a través de protocolos de comunicación, mientras que ESB es un modelo que facilita la comunicación entre sistemas dispares, pero ESB se puede utilizar como columna vertebral al implementar SOA.

JBoss Fuse es una solución ESB de código abierto de Redhat. Es una solución empresarial basada en un proyecto comunitario, Apache Servicemix.

Integración a Fuse

JBoss Fuse es una plataforma de integración ligera y flexible que permite una rápida integración de aplicaciones empresariales.

Fuse fue desarrollado inicialmente por Progressive software Inc., que fue adquirida por Redhat en 2012. JBoss Fuse 6.1.0.redhat-379 GA es una versión estable de Fuse que se puede descargar desde su sitio web oficial.

Arquitectura

Fuse combina varias tecnologías juntas como un solo producto.

Componentes

Apache CXF

Apache CXF es un marco de desarrollo de servicios web de código abierto que también admite el desarrollo de servicios web SOAP & Rest.

Camello apache

Apache Camel es un marco de integración basado en EIP. Los patrones de integración empresarial o EIP son soluciones identificadas para los problemas recurrentes en la integración empresarial. La solución de integración completa se puede lograr de manera meteórica con combinaciones de estos patrones predefinidos listos para usar.

Permite escribir lógica de enrutamiento en varios lenguajes específicos de dominio como Java, Spring DSL y Scala, etc.

Apache AMQ

Apache AMQ es un JMS que proporciona un sistema de mensajería confiable según los estándares JMS. No solo admite la especificación JMS, sino que también proporciona algunas características interesantes y útiles que no están incluidas en las especificaciones JMS.

Apache Karaf

Apache Karaf es un contenedor OSGi ligero que actúa como tiempo de ejecución para los artefactos. Apache Karaf es de naturaleza más dinámica en comparación con JVM. Permite instalar o desinstalar módulos en tiempo de ejecución. Todos los artefactos en Fuse se implementan en Karaf.

Tela

Fabric proporciona una forma sencilla de administrar las implementaciones de artefactos en un entorno grande y distribuido. Proporciona una gestión centralizada para todas las instancias de fusibles múltiples.

Instalación de fusible

Instalar Fuse es bastante simple. Al igual que otros productos JBoss, Fuse viene como un archivo zip que se puede extraer y después de algunos cambios menores de configuración, se puede iniciar directamente.

La instalación de Fuse es un proceso de cuatro pasos:

Descargar

Descargue Fuse 6.1.0 GA desde el siguiente enlace. http://www.jboss.org/

Abrir la cremallera

Como todos los demás productos de JBoss, Fuse también es un zip independiente de la plataforma.

Descomprima el archivo descargado en el directorio de destino que desea que sea el directorio de instalación de Fuse. Elija este directorio con prudencia, ya que debería permanecer igual durante la vida útil de la instancia de Fuse.

Note - Aunque Fuse se abre y se inicia como otros productos JBoss, no se recomienda mover la instalación de Fuse de un lugar a otro después de que se complete la instalación.

Configurar

Después de descomprimir Fuse, encontrará los siguientes directorios dentro del directorio extraído:

bin
etc
deploy
lib
licenses
extras
quickstarts

De los cuales vamos a utilizar solo dos directorios bin Y etc.

Prácticamente después de extraer Fuse, deberíamos poder iniciar Fuse directamente, pero esto iniciará Fuse con todas las configuraciones predeterminadas, lo que no es recomendable para el entorno de producción. Se recomienda encarecidamente realizar los siguientes cambios antes de iniciar Fuse.

Establecer variables de entorno

Establezca las siguientes variables de entorno: JAVA_HOME
La variable debe apuntar al directorio de instalación de Java - M2_HOME
La variable debe apuntar al directorio de instalación de Maven - PATH
Configure la variable de ruta para incluir ejecutables Java y Maven.

Ventanas

En Windows, la configuración se puede realizar siguiendo las instrucciones que se dan a continuación:

Inicio → Mi PC → Clic derecho → Propiedades → Configuración avanzada del sistema → Variables de entorno.

UNIX y clones

Para cada usuario hay un perfil bash en el *nixsistemas operativos. Podemos agregar o editar la variable del sistema existente cambiando este archivo.

$ vi ~/.bash_proflle

Note- Cualquier cambio en este archivo es permanente. Se recomienda realizar una copia de seguridad del archivo existente antes de cambiar el original.

Configuracion basica

Discutiremos sobre la configuración básica de JBoss Fuse y para eso tenemos que comenzar con el siguiente comando Edit $FUSE_INSTALLATION_DIR/etc/

En user.properties

#admin=admin,admin
Esto debe cambiarse de acuerdo con el primer administrador con el nombre de usuario que queremos, el segundo administrador con la contraseña, el tercero podría mantenerse como está porque indica un rol y no olvide eliminar #
Por ejemplo: FuseAdmin = FusePAss, admin

En System.properties
- karafName = raíz
  - Esto indica el nombre que desea darle a la instancia de Karaf.
  - Podemos nombrarlo como queramos como Cont1.
  - Asegúrese de que este nombre que proporcione sea un nombre único y que no esté siendo utilizado por otra instancia de Fuse.
En org.ops4j.pax.web.cfg
- Org.osgi.service.http.port = 8181
- Esta propiedad indica el puerto que se utilizará para acceder a la interfaz basada en navegador HAWTIO proporcionada por Fuse
- HAWTIO es una interfaz de navegador incorporada para Fuse que está disponible a partir de 6.0
En org.ops4j.pax.url.mvn.cfg
- org.ops4j.pax.url.mvn.localRepository = D: / repositorio
- Esta propiedad indica la ruta al repositorio local de nuestro Maven desde donde Fuse instalará sus artefactos.
- org.ops4j.pax.url.mvn.settings = D: /Maven/conf/settings.xml
- Esta propiedad indica settings.xml que Fuse debería usar para obtener artefactos de Maven.

Configurando Maven

Maven es un requisito previo para instalar Fuse. Si no sabe qué es maven, consulte

Maven es una herramienta construida que se utiliza para construir artefactos Fuse. Fuse las primeras búsquedas de artefactos en el repositorio local de Maven cuando emitimos un comando para instalar el artefacto. Por lo tanto, debemos informar a Fuse dónde está instalado Maven y la ruta del repositorio local de Maven.

Edite $ FUSE_INSTALLATION_DIR / etc /org.ops4j.paxurl.mvn.cfg

Actualice las siguientes dos propiedades:

org.ops4j.pax.url.mvn.settings = $ M2_HOME / conf /settings.xml
org.ops4j.pax.url.mvn.localRepository = $ local_repo

Note - Por favor cambie $local_repo con la ruta real de su repositorio local mencionado en Mavens settings.xml.

correr

Después de hacer cambios de configuración básicos, ahora podemos iniciar Fuse. Todos los archivos binarios para trabajar con Fuse se encuentran en$FUSE_INSTALLATION_DIR.

Hay dos formas de iniciar Fuse:

Utilizando ./fuse
- Esto le permitirá ver todo el progreso y los registros en la misma ventana en la que inició Fuse.
- Le dará la consola Karaf en la misma terminal que se muestra a continuación.

Note- Esto iniciará la fusión en el modo de consola, lo que significa que el proceso de fusión también se detendrá cuando el usuario cierre la sesión o cierre la Terminal, lo que no es deseable en un escenario de producción o desarrollo. Este script debe usarse solo para depurar Fuse.

Utilizando ./start
- Esto no mostrará ningún registro en la pantalla, ni siquiera el progreso, pero esto iniciará Fuse en segundo plano y el servicio Fuse no se detendrá cuando el usuario salga de la sesión o cierre la terminal.
- En la aplicación del mundo real, se desea este tipo de comportamiento. El fusible debería estar funcionando en segundo plano incluso si cerramos la terminal.
- Si desea conectarse a Fuse ejecutándose en segundo plano, puede usar client script que se encuentra en la misma carpeta.
- Debería obtener la pantalla como se muestra en la siguiente captura de pantalla.
- Salir del script del cliente no detendrá el servicio Fuse. Simplemente cerrará la consola Fuse.

HAWTIO

Fuse también proporciona acceso completo a la GUI mediante FMC (consola de gestión de fusibles). Puede encontrar GUI en la siguiente URLhttp://localhost:8181.

Todo lo que hicimos ejecutando comandos también se puede hacer accediendo a esta GUI basada en navegador. Se vuelve extremadamente útil cuando tenemos más de un contenedor y nos estamos ejecutando en un entorno Fabric.

En este capítulo, discutiremos sobre Apache Karaf y por qué se llama un contenedor OSGi ligero junto con sus beneficios y otras características importantes.

El problema de JVM

La máquina virtual JVM o Java no actúa como una máquina virtual real. Una máquina que le permitirá detener, iniciar o reiniciar los componentes que se ejecutan en su interior sobre la marcha. A veces puede permitir implementaciones en caliente a nivel de clase, pero no hay forma de que pueda implementar o anular la implementación de un componente de su aplicación en su máquina virtual sin reiniciarla.

Para resolver este problema y permitir la modularidad en la aplicación Java, Fuse utiliza un tiempo de ejecución basado en OSGi conocido como Apache Karaf.

OSGi

La tecnología OSGi es un conjunto de especificaciones que definen un sistema de componentes dinámicos para java. Estas especificaciones permiten un modelo de desarrollo en el que las aplicaciones están compuestas (dinámicamente) de muchos componentes diferentes (reutilizables).

Beneficios de OSGi

Reduced Complexity - La aplicación se construye como componentes de colaboración que ocultan los detalles de su implementación entre sí, lo que reduce la complejidad.
Reusability - Muchos componentes pueden aprovechar el mismo componente implementado en un contenedor.
Deployment - OSGi proporciona soporte para iniciar, detener y actualizar componentes sobre la marcha con sus API de administración del ciclo de vida sin reiniciar el contenedor.

Paquetes Vs Características

A continuación se muestra la comparación entre paquetes y características.

manojos

Los paquetes son equivalentes a OSGi, lo que los archivos jar a JVM. Los paquetes son artefactos que se pueden implementar en un contenedor OSGi. Los paquetes son componentes que trabajan juntos o independientemente para formar una aplicación.

Estos paquetes se pueden instalar, desinstalar, actualizar, iniciar o detener en tiempo de ejecución sin reiniciar el contenedor.

Caracteristicas

Las funciones son una forma de implementar varios paquetes juntos. A veces tiene más sentido implementar paquetes en grupo. Las características nos permiten implementar un grupo de paquetes con un solo comando.

¿Por qué otro contenedor?

Apache Karaf es un tiempo de ejecución basado en OSGi, es donde se ejecutan nuestros paquetes de aplicaciones. Fuse usa Apache Karaf como su tiempo de ejecución en el que los paquetes se ejecutan y colaboran para proporcionar funcionalidad comercial.

Karaf se basa en Felix y equinoccio, que son marcos OSGi.

Arquitectura Karaf

Apache Karaf agrega las siguientes funcionalidades adicionales al tiempo de ejecución básico de OSGi.

Implementación en caliente

Karaf admite la implementación en caliente. Contiene un directorio de implementación en caliente. Todo lo que se coloca en este directorio se implementa e instala automáticamente en Karaf como un paquete.

Inicio sesión

Karaf proporciona un registro centralizado mediante la generación de registros para todos los paquetes en $Fuse_home/data/log. Podemos editar la configuración del registrador enorg.ops4j.pax.logging.cfg en $Fuse_home/etc directory.

Consola de administración

Karaf proporciona una consola de administración lúcida y sofisticada para interactuar con la instancia en ejecución de fuse. También proporciona un conjunto de comandos preinstalados que se pueden usar para administrar y monitorear componentes (Bundle) en tiempo de ejecución. Esta consola es extensible por lo que nos permite agregar nuevos comandos a la consola agregando nuevos paquetes a la consola.

Acceso SSH

Karaf permite el acceso remoto a esta consola de administración con SSH. Cualquiera con credenciales válidas puede conectarse a la consola de administración de karaf a través del terminal SSH.

En este capítulo, discutiremos qué es Apache Camel y cómo enruta efectivamente los datos entre los puntos finales, junto con algunos ejemplos.

¿Qué es Apache Camel?

Apache Camel es un marco de integración de código abierto que se inició a principios de 2007.

Es un enfoque basado en EIP (patrón de integración empresarial) que proporciona varias implementaciones de patrones listos para usar que se pueden utilizar para resolver problemas de integración empresarial. Los EIP no son más que soluciones comprobadas para los problemas recurrentes y bien documentados de la integración empresarial.

Camel también se conoce como motor de enrutamiento y mediación, ya que enruta datos de manera efectiva entre puntos finales, mientras soporta cargas pesadas como la transformación de formatos de datos, conectividad de puntos finales y muchos más.

Ejemplo básico

Los requisitos previos para utilizar Apache Camel son:

Java
Maven
Fusible Redhat JBoss 6.1-GA-379

Crear esqueleto básico de aplicación

mvn:archetype generate 
–DgroupId = com.tutorialpoint.app 
–DartifactId = camel-first-app 
–DarchetypeGroupId = org.apache.camel.archetypes
–DarchetypeArtifactId = camel-archetype-spring 
–DinteractiveMode = false -X

Esto debería generar la siguiente estructura de directorios.

Este es un esqueleto básico de nuestra aplicación Camel que se está generando.

Editar camel-context.xml

Editar camel-first-app → src → main → resources → META-INF\spring\camel-context.xml para que coincida con la siguiente

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring
   http://camel.apache.org/schema/spring/camel-spring.xsd">

   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input file
         (leaving them in place - see the 'noop' flag) 
         then performs content based routing on the message using XPath -->
			
      <route>
         <from uri = "file:///d:/src/data?noop=false"/>
         <choice>
            <when>
               <xpath>/person/city = 'London'</xpath>
               <log message = "UK message"/>
               <to uri = "file:///d:/target/messages/uk"/>
            </when>
				
            <otherwise>
               <log message = "Other message"/>
               <to uri = "file:///d:/target/messages/others"/>
            </otherwise>
				
         </choice>
			
      </route>
   </camelContext>
</beans>

Editar pom.xml

Agregue el siguiente código dentro de <plugins> </plugins>

<plugin>
   <groupId>org.apache.felix</groupId>
   <artifactId>maven-bundle-plugin</artifactId>
   <version>2.3.4</version>
   <extensions>true</extensions>
	
   <configuration>
      <instructions>
         <Bundle-SymbolicName>
            ${project.artifactId}
         </Bundle-SymbolicName>
         <Import-Package>*</Import-Package>
      </instructions>
   </configuration>
	
</plugin>

Cambiar el tipo de embalaje de jar → bundle.

<packaging>bundle</packaging>

Construya el proyecto usando el siguiente comando:

mvn clean install

Instalar proyecto en Fuse

Inicie Fuse usando Fuse.bat/start.bat. Si comienza a usar Fusestart.bat, utilizar client.batpara conectarse a Fuse. Debería obtener la interfaz de usuario como se muestra en la siguiente captura de pantalla.

Esta es la CLI para acceder a los comandos Karaf y Fuse.

install –s mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

Pruebe si su proyecto se está ejecutando

Ahora su aplicación debería estar instalada en Fuse. Copie el directorio de datos dentrocamel-first-app y colocarlo en D:/src/ y debería copiar el mensaje que tiene city = London en D:/target/merssages/uk.

Coloque el archivo de entrada en D:/src/data

Input

Message1.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "james">
   <firstName>James</firstName>
   <lastName>Strachan</lastName>
   <city>London</city>
</person>

Message2.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "hiram">
   <firstName>Hiram</firstName>
   <lastName>Chirino</lastName>
   <city>Tampa</city>
</person>

Output

En D: / target / messages / uk

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "james">
   <firstName>James</firstName>
   <lastName>Strachan</lastName>
   <city>London</city>
</person>

En D: / target / messages / otros

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "hiram">
   <firstName>Hiram</firstName>
   <lastName>Chirino</lastName>
   <city>Tampa</city>
</person>

En este capítulo, entenderemos los diferentes conceptos de Camel. Comencemos por tomar un ejemplo básico para comprender los conceptos básicos.

CamelContext

Cada aplicación de camello tendrá al menos un CamelContext. Este es el lugar donde agregamos rutas en camello. Esto es similar aApplicationContext de primavera.

El contexto del camello puede pensarse como un contenedor que mantiene todas las cosas juntas. Un contexto de camello puede tener múltiples rutas dentro de él.

Rutas

CamelContext puede contener una o más rutas. Las rutas son la lógica de integración que define cómo fluirán los datos en el contexto de camello de un punto final a otro.

Punto final

El punto final es el final del canal a través del cual el sistema puede enviar o recibir mensajes. Esto es lo que llamamos destino o origen en el lenguaje de la comunicación.

Componentes

Los componentes son punto de extensión en Camel. Los componentes pueden ser una interfaz para tecnología, formato de datos, transformadores, etc. También pueden actuar como una fábrica de puntos finales.

EIP

EIP son las siglas de Enterprise Integration Pattern. Estas son soluciones identificadas y bien conocidas para un problema recurrente. Camel admite la mayoría de los patrones de integración empresarial.

Enrutador basado en contenido

Los patrones CBR nos permiten enrutar datos según el contenido del archivo de entrada.

Este patrón se usa cuando tenemos que enrutar valores en función del contenido del cuerpo de entrada.

El siguiente ejemplo leerá datos de D:/data/inputdirectorio. Después de leer, verificará la etiqueta de valor dentro de la etiqueta de datos. Si la etiqueta de valor contienevalue1, será enviado a D:/value1, Si contiene value2, será enviado a D:/value2 y si ninguno de estos dos, se enviará a otros.

<CamelContext xmlns = "http://camel.apache.org/schema/spring">
   <route>
      <from uri = "file:///D:/data/input"/>
      <choice>
         <when>
            <xpath>/data/value = 'value1'</xpath>
            <to uri = "file:///D:/value1"/>
         </when> 
         <when>
            <xpath>/data/value = 'value2'</xpath>
            <to uri = "file:///D:/value2"/>
         </when>  
			
         <otherwise>
            <to uri = "file:///D:/others "/>
         </otherwise>
			
      </choice>
   </route>
</camelContext>

Input

D: /data/input/message1.xml

<data>
   <value>value1</value>
</data>

D: /data/input/message2.xml

<data>
   <value>value2</value>
</data>

Output

D: / valor1 /

<data>
   <value>value1</value>
</data>

D: / valor2 /

<data>
   <value>value2</value>
</data>

Disidente

Se utiliza un patrón de división para dividir los datos de entrada en trozos más pequeños.

Este patrón se usa la mayoría de las veces con una gran cantidad de datos que deben dividirse en trozos, por lo que se puede procesar. Divide la entrada en fragmentos más pequeños según la cadena del token de entrada.

<CamelContext xmlns = "http://camel.apache.org/schema/spring">
   <route>
      <from uri = "file:///D:/inbox"/>
      <split streaming = "true">
         <tokenize token = "order" xml = "true"/>
         <to uri = "activemq:queue:order"/>
      </split>
   </route>
</CamelContext>

Input

D: /inbox/message.xml

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

Output

Si marca AMQ, encontrará 3 mensajes publicados.

<order>
   <data>
      <value>value4</value>
   </data>
</order>

Lista de recipientes

Se utiliza un patrón de lista de destinatarios cuando es necesario recuperar una lista de destinatarios del propio cuerpo del mensaje.

En el siguiente ejemplo, se enviará un mensaje a todos los destinatarios que figuran en la etiqueta de cliente como una lista de cadenas separada por comas.

<CamelContext xmlns = "http://camel.apache.org/schema/spring">
   <route>
      <from uri = "jms:xmlOrders" />
      <recipientList>
         <xpath>/order/customer</xpath>
      </recipientList>
   </route>
</camelContext>

Otros EIP

Camel brinda apoyo a casi todos los EIP identificados. Algunos de los EIP de uso común se mencionan a continuación.

Log - Para registrar el mensaje completo o parte de él
Message Filter - Filtrado de contenidos de mensajes
Re-Sequencer - Obtener todos los tokens en secuencia.
Wiretap - Inspeccionar mensajes de viaje.

La lista completa de EIP y su uso se puede encontrar en la documentación oficial de Camel http://camel.apache.org/eip.html

Manejo de excepciones en Camel

Using Error Handler - Esta es la forma más sencilla de gestionar las excepciones en camello.

Para usar esto, tenemos que configurar el bean de clase del manejador de errores y proporcionarlo como referencia a CamelContext errorHandlerRef atributo.

<bean id = "loggingErrorHandler" class = "org.apache.camel.builder.LoggingErrorHandler">
   <property name = "logName" value = "mylogger.name"/>
   <property name = "level" value = "DEBUG"/>
</bean>

<camelContext errorHandlerRef = ” loggingErrorHandler” >
   …
</camelContext>

Uso de Try Catch finalmente

Camel también es compatible con el estilo Java Try Catch Finally block para el manejo de errores.

Al igual que Java, tiene los siguientes tres bloques:

doTry El bloque contiene código que puede generar una excepción.
doCatch El bloque contiene código que debe ejecutarse en caso de excepción.
doFinallyEl bloque tiene código que debe ejecutarse independientemente de la excepción. Siempre se ejecutará sin importar si se generó una excepción o no.

Note- Mock es un componente de prueba y no se recomienda para otros fines. Es el componente de camel que se utiliza para realizar pruebas al igual que el componente jMOck en el desarrollo basado en pruebas.

<route>
   <from uri = "direct:start"/>
   <doTry>
      <process ref = "someProcesorThatmayFail"/>
      <to uri = "mock:result"/>
		
      <doCatch>
         <exception>java.io.IOException</exception>
         <exception>java.lang.IllegalStateException</exception>
         <to uri = "mock:catch"/>
      </doCatch>
		
      <doFinally>
         <to uri = "mock:finally"/>
      </doFinally>
		
   </doTry>
</route>

En el ejemplo anterior, podemos dar una lista de excepciones que deben ser manejadas por el bloque catch.

Implementación de paquete en Fuse

Inicie Fuse usando Fuse.bat/start.bat.

Si inicia Fuse usando start.bat, use client.bat para conectarse a Fuse. Debería obtener la interfaz de usuario como se muestra en la siguiente captura de pantalla.

Esta es la CLI para acceder a los comandos Karaf y Fuse.

install –s mvn:group.id /artifact.id/version 
e.g. install –s mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

En este capítulo, analicemos qué es Apache CXF y cómo puede ser útil para desarrollar SOAP y Rest Web Services.

¿Qué es Apache CXF?

Apache CXF es un marco de desarrollo de servicios web que se puede utilizar para desarrollar servicios web SOAP y Rest. CXF cumple totalmente conJAX-RS and JAX-Ws estándar.

Actualmente, es el marco de desarrollo de servicios web más utilizado. CXF ha aprendido y mejorado con respecto a Axis2, que ahora está siendo reemplazado gradualmente por CXF.

CXF frente a Axis2

	CXF	Eje2
Mejoras	CXF es el marco más utilizado a partir de ahora. Tiene muchas mejoras sobre Axis2	Axis2 está siendo reemplazado gradualmente por CXf. Requiere más código en comparación con CXF
Código requerido	CXF requiere menos código en comparación con Axis2	Axis2 requiere más código comparativamente
Cumplimiento de normas	CSF es totalmente compatible con JAX-RS y JAX-WS	Axis2 no es totalmente compatible con JAX-RS y JAX-WS
Compatible con Spring	si	No
Separación de frontales	Separación limpia del front-end del código JAX-WS	No se proporciona una separación limpia

JABÓN

SOAP significa Protocolo simple de acceso a objetos. Es un protocolo para intercambiar información estructurada a través de servicios web entre dos sistemas. Se basa principalmente en XML para estructurar datos y utiliza HTTP o SMTP para la negociación y transmisión de mensajes.

Hay dos enfoques para desarrollar servicios web SOAP:

Code first - En este enfoque, WSDL se genera a partir de código.
Contract first - En el contrato primero, el código se genera a partir de WSDL.

Desarrollo SOAP con CXF

Configurar Maven

Agregue el siguiente perfil a su settings.xml de Maven.

<profiles>
   <profile>
      <id>Jboss-Fuse</id>
		
      <activation>
         <activeByDefault>true</activeByDefault>
      </activation>
		
      <repositories>
         <repository>
            <id>fusesource</id>
            <url>http://repo.fusesource.com/nexus/content/groups/public/</url>
            <snapshots>
               <enabled>false</enabled>
            </snapshots>
            <releases>
               <enabled>true</enabled>
            </releases>
         </repository>
      </repositories>
		
   </profile>
</profiles>

Crear esqueleto

mvn archetype:generate
-DarchetypeGroupId = org.apache.servicemix.tooling 
-DarchetypeArtifactId = servicemix-cxf-code-first-osgi-bundle 
-DarchetypeVersion=2012.01.0.redhat-60024 
-DgroupId = org.fusesource.example 
-DartifactId = cxf-basic 
-Dversion = 1.0-SNAPSHOT

Build Web Service Project.

mvn clean install

Install web-service into Fuse using the following command.

JBossFuse:[email protected]>install -s mvn:org.fusesource.example/cxf-basic/1.0-SNAPSH

Check if bundle has registered SOQP web-service

Abrir URL http://localhost:8181/cxf

El servicio web debe aparecer de la siguiente manera.

Testing Web-Service

mvn -Pclient

INFO - Creación de servicio {http://ws.totorials.com/} PersonService de la clase com.to

torials.ws.Person
Invoking getPerson...
getPerson._getPerson_personId = Guillaume
getPerson._getPerson_ssn = 000-000-0000
getPerson._getPerson_name = Guillaume
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 30.668 s
[INFO] Finished at: 2016-02-15T21:01:20+05:30
[INFO] Final Memory: 10M/37M
[INFO] ------------------------------------------------------------------------

Para empezar, REST significa Transferencia de Estado Representacional. Es una forma de desarrollar servicios web basados en un protocolo cliente-servidor sin estado, almacenable en caché, que es HTTP en la mayoría de los casos.

Los servicios web REST utilizan solicitudes HTTP para publicar, obtener y eliminar datos de la red.

Desarrollo REST usando CXF

Cree un proyecto sencillo de inicio rápido de Maven

mvn archetype:generate 
-DgroupId = com.tuts.abhinav 
-DartifactId = rest-service
-DarchetypeArtifactId = maven-archetype-quickstart 
-DinteractiveMode = false

Agregar dependencias

<dependency>
   <groupId>org.apache.servicemix.specs</groupId>
   <artifactId>org.apache.servicemix.specs.jsr311-api-1.1.1</artifactId>
   <version>1.9.0</version>
   <scope>provided</scope>
</dependency>

<dependency>
   <groupId>org.apache.servicemix</groupId>
   <artifactId>servicemix-http</artifactId>
   <version>2013.01</version>
</dependency>

<dependency>
   <groupId>log4j</groupId>
   <artifactId>log4j</artifactId>
   <version>1.2.16</version>
</dependency>

Agregar instrucción de compilación

<build>
   <defaultGoal>install</defaultGoal>
   <plugins>
      <plugin>
         <groupId>org.apache.felix</groupId>
         <artifalctId>maven-bundle-plugin</artifactId>
         <version>2.3.4</version>
         <extensions>true</extensions>
			
         <configuration>
            <instructions>
               <Bundle-SymbolicName>rest-example-database-post-method
                  </Bundle-SymbolicName>
               <Import-Package>* </Import-Package>
            </instructions>
         </configuration>
			
      </plugin>
   </plugins>
</build>

Agregar repositorios de complementos de fusibles

<pluginRepositories>
   <pluginRepository>
      <id>fusesource.m2</id>
      <name>FuseSource Community Release Repository</name>
      <url>http://repo.fusesource.com/nexus/content/repositories/releases</url>
      <snapshots>
         <enabled>false</enabled>
      </snapshots>
		
      <releases>
         <enabled>true</enabled>
      </releases>
   </pluginRepository>
<pluginRepositories>

Agregar repositorios

<repositories>
   <repository>
      <id>fusesource.m2</id>
      <name>FuseSource Community Release Repository</name>
      <url>http://repo.fusesource.com/nexus/content/repositories/releases</url>
      <snapshots>
         <enabled>false</enabled>
      </snapshots>
		
      <releases>
         <enabled>true</enabled>
      </releases>
		
   </repository>
	
   <repository>
      <id>fusesource.ea</id>
      <name>FuseSource Community Early Access Release Repository</name>
      <url>http://repo.fusesource.com/nexus/content/groups/ea</url>
      <snapshots>
         <enabled>false</enabled>
      </snapshots>
      <releases>
         <enabled>true</enabled>
      </releases>
   </repository>
	
</repositories>

Crear clase de servicio

Cree la clase UserService.java en com / tuts /

package com.tuts;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/UserService_1")
public class UserService {
   @GET
   @Path("/get_data")
   @Produces(MediaType.APPLICATION_JSON)
	
   public String getUser() {
      String reponse = "This is standard response from REST";
      return reponse;
   }
}

Crear Blueprint.xml

Cree blueprint.xml en / src / main / resources / OSGI-INF / blueprint blueprint.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<blueprint xmlns = "http://www.osgi.org/xmlns/blueprint/v1.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:jaxrs = "http://cxf.apache.org/blueprint/jaxrs"
   xsi:schemaLocation = "http://www.osgi.org/xmlns/blueprint/v1.0.0 
   http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd
   http://cxf.apache.org/blueprint/jaxrs 
   http://cxf.apache.org/schemas/blueprint/jaxrs.xsd">
	
   <jaxrs:server id = "service" address = "/users">
      <jaxrs:serviceBeans>
         <ref component-id = "userService" />
      </jaxrs:serviceBeans>
   </jaxrs:server>
	
   <bean id = "userService" class = "com.tuts.UserService" />
</blueprint>

Instalar el servicio Rest en Fuse

install -s mvn:com.tuts.abhinav/rest-service/1.0-SNAPSHOT

Compruebe si Bundle tiene un servicio web registrado

Abrir URL http://localhost:8181/cxf

Servicio web de prueba

Abrir URL http://localhost:8181/cxf/users12/UserService_1/get_data

En este capítulo, conoceremos ActiveMQ y cómo actúa como intermediario de mensajes para permitir que las aplicaciones se comuniquen entre sí.

¿Qué es AMQ?

ActiveMQ es un agente de mensajes de código abierto escrito en Java. Es totalmente compatible con los estándares JMS 1.1.

JMS es una especificación que permite el desarrollo de un sistema basado en mensajes. ActiveMQ actúa como un intermediario de mensajes que se encuentra entre las aplicaciones y les permite comunicarse de manera asincrónica y confiable.

Tipos de mensajería

Hay dos tipos de opciones de mensajería que se explican a continuación para una mejor comprensión.

Punto a punto

En este tipo de comunicación, el corredor envía mensajes a un solo consumidor, mientras que los otros consumidores esperarán hasta recibir los mensajes del corredor. Ningún consumidor recibirá el mismo mensaje.

Si no hay consumidores, el corredor retendrá los mensajes hasta que obtenga un consumidor. Este tipo de comunicación también se denominaQueue based communicationdonde el productor envía mensajes a una cola y solo un consumidor recibe un mensaje de la cola. Si hay más de un consumidor, es posible que reciba el siguiente mensaje, pero no recibirá el mismo mensaje que el otro consumidor.

Publicar / Suscribirse

En este tipo de comunicación, el Broker envía la misma copia de mensajes a todos los consumidores activos. Este tipo de comunicación también se conoce comoTopic based communicationdonde el corredor envía el mismo mensaje a todos los consumidores activos que se han suscrito a un tema en particular. Este modelo admite la comunicación unidireccional donde no se espera la verificación de los mensajes transmitidos.

Crear cola y temas

Fuse viene incluido con ActiveMQ. Podemos acceder a ActiveMQ usando la consola FMC (la interfaz basada en navegador para trabajar con AMQ).

Inicie sesión en FMC usando localhost:8181 y seleccione ActiveMQ lengüeta.

Haga clic en + Crear
Ingrese el nombre de la cola / tema
Seleccione Cola / Tema del botón de opción
Haga clic en Crear cola / Crear tema

Ahora debería poder ver el TestQ creado en root → Cola →

Para comprobar el tema creado, siga root → Tema.

Examinar / eliminar contenido de la cola

Inicie sesión en FMC usando localhost:8181
Seleccione la pestaña ActiveMQ
Raíz → Cola → TestQ <seleccione la cola que desea explorar> → Examinar

Para verificar el contenido de este mensaje, haga clic en ese mensaje en particular.

Puede eliminar un mensaje en particular haciendo clic en el botón Eliminar que se muestra en la esquina superior derecha

En este capítulo, aprenderemos los conceptos básicos de cómo funciona ActiveMQ con Camel.

Configuración al componente ActiveMQ

Antes de que podamos usar la cola o el tema de ActiveMQ en nuestro código, tenemos que configurar ActiveMQComponent. La configuración mínima de ActiveMQComponent se puede realizar como se muestra en el siguiente programa:

<bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
   <property name = "brokerURL" value = "tcp://localhost:61616"/>
   <property name = "userName" value = "admin"/>
   <property name = "password" value = "admin"/>
</bean>

brokerURL - Especifica el host y el puerto para AMQ Broker.
username - Especifica el nombre de usuario que se utilizará para conectarse a AMQ Broker.
password : Especifica la contraseña para conectarse a AMQ Broker.

Conectando a la cola

Ahora que hemos configurado ActiveMQComponent, podemos usarlo en nuestro CamelContext como punto final.

Usaremos el punto final AMQ en el siguiente formato:

Activemq:[queue|topic]:[queueName|topicName]

Escribir mensajes en AMQ

<?xml version = "1.0" encoding="UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring
   http://camel.apache.org/schema/spring/camel-spring.xsd">

Después de implementar este paquete en el contenedor Fuse, debería poder ver los mensajes publicados en AMQ que se colocaron como archivos en D:/src/data.

Input

D: /src/data/input.txt

Test me

Output

Leyendo de AMQ

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring
   http://camel.apache.org/schema/spring/camel-spring.xsd">
	
   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
          then performs content based routing on the message using XPath -->
			 
      <route>
         <from uri = "activemq:queue:TestQ"/>
         <to uri = "file:///d:/src"/>
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value = "tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Input

Después de implementar este paquete, debería ver que se genera un archivo en D: / src y se consumen los mensajes. También se debe mostrar el consumidor para esa cola.

Output

D: / src

Test me

Escribiendo al tema

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring 
   http://camel.apache.org/schema/spring/camel-spring.xsd">
	
   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
          then performs content based routing on the message using XPath -->
			 
      <route>
         <from uri = "file:///d:/src"/>
         <to uri = "activemq:topic:TestTopic” />
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value = "tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Leyendo del tema

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring 
   http://camel.apache.org/schema/spring/camel-spring.xsd">
	
   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
         then performs content based routing on the message using XPath -->
			
      <route>
         <from uri = "activemq:topic:TestTopic"/>
         <to uri = "file:///d:/src2"/>
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value="tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Input

D: /src/file1.xml

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

Output

D: / src /

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

¿Qué es Fabric?

Fabric proporciona capacidades de administración y orquestación para múltiples instancias de Fuse. Fabric nos permite controlar todas las instancias de Fuse conectadas a él desde un único punto. Un contenedor de fusibles normal se puede convertir para actuar como una tela. Fabric tiene un registro de fabric que sirve como almacén de datos que contiene toda la información sobre los contenedores que administra.

¿Por qué Fabric?

Fabric tiene las siguientes habilidades especiales que lo convierten en un candidato ideal para su uso en entornos distribuidos.

Seguimiento del estado de todos los contenedores en la tela.
Iniciar y detener contenedores remotos.
Proporciona un contenedor remoto para ejecutar una aplicación en particular.
Actualización de aplicaciones e implementación de parches en el sistema en vivo.
Arrancar y aprovisionar nuevos contenedores rápidamente, por ejemplo, para hacer frente al aumento de carga en el sistema.

Configuración de la tela

Creando tela

El contenedor de fusibles normal se puede convertir a Fabric mediante el siguiente comando

fabric: create --clean --zookeeper-password myZooPass

Conectando otro contenedor a Fabric -

fabric:join --zookeeper-password myZooPass <fabric_host>:2181 Cont1

Note - Reemplace <fabric_host> con el nombre de host real en el que se ejecuta la estructura.

Cuando inicia sesión en Fuse Management Console desde su navegador usando localhost:8181, debería poder ver dos contenedores como se muestra en la siguiente captura de pantalla. El contenedor de tela se indica con un pequeño símbolo de nube delante de él.

Perfiles

Un perfil contiene la siguiente información:

Paquetes para instalar
Características a instalar
Configuraciones a aplicar

Un perfil proporciona una forma en el entorno de estructura para instalar el mismo conjunto de paquetes, características y configuración en varios servidores.

Si se aplica el mismo perfil a varios contenedores y hacemos cambios en ese perfil desde cualquier contenedor, los cambios similares se implementarán automáticamente en los contenedores restantes a los que se aplica.

Creando Perfiles

Iniciar sesión en FMC localhost:8181
Tiempo de ejecución → Administrar
En el lado izquierdo, en el menú Perfil, haga clic en +

Ingrese el nombre que desea darle al perfil y haga clic en crear.

Después de esto, se debe crear el perfil.

Aplicar perfil al contenedor

Tiempo de ejecución → Contenedores → raíz (seleccione el contenedor que desee)

Hacer clic Addlo que conducirá a un cuadro emergente. Busque el perfil que desee y vuelva a hacer clic enAdd.

El perfil debe aparecer en la lista como se muestra en la siguiente captura de pantalla.

Implementar un paquete

Para implementar un paquete, use la siguiente ruta:

Runtime → Contenedores → root (seleccione el contenedor que desee) → First_profile (seleccione perfil)

Haga clic en la pestaña Paquetes. Configure la ruta del paquete en el siguiente formato y luego haga clic en+.

mvn:group.id/artifact.id/version

Por ejemplo: mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

Se agregará un paquete al perfil y se implementará en todos los contenedores a los que está asignado el perfil.

Despliegue de un paquete

Para anular la implementación de un paquete, use la siguiente ruta:

Tiempo de ejecución → Contenedores → raíz (seleccione el contenedor que desee) → First_profile (seleccione el perfil)

Haga clic en la pestaña Paquetes y busque el paquete que desea eliminar y luego haga clic en X. El paquete se eliminará de todos los contenedores a los que se aplica el perfil.

Un contenedor infantil proporciona la forma más sencilla de gestionar la carga creciente. Cuando el sistema experimenta una carga repentina en el tráfico y un solo contenedor no puede hacer frente a la carga, podemos crear fácilmente un conjunto de contenedores secundarios y distribuir la carga entre ellos, en lugar de crear un contenedor completamente nuevo.

Crear un contenedor secundario

Inicie sesión en FMC usando localhost:8181

Ahora, siga la ruta: Tiempo de ejecución → contenedor → + Crear (botón en el lado derecho)

Ingrese detalles como nombre del niño, contenedor principal, número de instancias, etc.

Hacer clic Create And Start Container

Gestionar un contenedor secundario

Un contenedor para niños actúa únicamente como contenedor normal.

Detener un contenedor infantil

Para detener un contenedor secundario, siga la ruta: Tiempo de ejecución → Contenedor → Child1

Haga clic en Detener para detener el contenedor secundario.

Iniciar un contenedor infantil

Para iniciar un contenedor secundario, siga la ruta: Runtime → Container → Child1

Haga clic en Iniciar para iniciar el contenedor secundario.

En este capítulo, analizaremos algunos problemas conocidos que puede encontrar al trabajar con Fuse. También discutiremos cómo puede superar estos problemas.

Los cambios de código no se reflejan

Conéctese a la instancia de Fuse mediante un script de cliente. Busque el paquete para el que tiene un problema, usando el siguiente comando.

JBossFuse:[email protected] > list|grep <Bundle Description>
For Example:
JBossFuse:[email protected] > list|grep Camel
[ 255] [Active ] [ ] [ ] [ 60] Fabric8 :: Camel Component (1.0.0.redhat-379)
[ 266] [Active ] [ ] [Started] [ 60] A Camel Spring Route (1.0.0.SNAPSHOT)

Note - ID de paquete para el paquete de la salida del comando anterior y use el comando siguiente.

JBossFuse:[email protected] > update <bundle id>
JBossFuse:[email protected] > update 266

No se está descargando el paquete

Puede suceder por las siguientes dos razones:

Repositorio de Maven no especificado
Paquete no presente en el repositorio

Repositorio Maven no especificado

Maven es una herramienta construida que se utiliza para construir artefactos Fuse. Fusionar las búsquedas de artefactos en el repositorio local de Maven, cuando emitimos el comando para instalar el artefacto. Por lo tanto, debemos informar a Fuse dónde está instalado Maven y la ruta del repositorio local de Maven.

Edite $ FUSE_INSTALLATION_DIR / etc /org.ops4j.paxurl.mvn.cfg

Actualice las siguientes dos propiedades:

org.ops4j.pax.url.mvn.settings = $ M2_HOME / conf /settings.xml
org.ops4j.pax.url.mvn.localRepository = $ local_repo

Note - Cambie $ local_repo con la ruta real de su repositorio local mencionado en Mavens settings.xml

Paquete no presente en el repositorio

Si la configuración de Maven está en su lugar, pero aún así tiene problemas al descargar el paquete, asegúrese de que los paquetes JAR está presente en la ubicación correcta en Maven Repository.

Por ejemplo, si el siguiente paquete arroja errores durante la descarga:

mvn:com.tutorialpoint.app/camel-first-app/1.0-SNAPSHOT

Tenemos que comprobar en $ M2_REPO / com / tutorialpoint / app / camel-first-app / 1.0-SNAPSHOT si el JAR real está presente.

Note - $ M2_REPO debe reemplazarse con la ruta real del repositorio de Maven que tenemos Fuse configurado para usar.

No se puede iniciar sesión en FMC (GUI basada en navegador)

Users not Created - Si obtiene la siguiente interfaz de usuario pero no puede iniciar sesión con un mensaje que dice "No se pudo iniciar sesión, prohibido".

Compruebe si ha agregado usuarios en $FUSE_INSTALLATION_HOME/etc/users.properties

El formato correcto para agregar usuarios es:

Username = Password,Role

El puerto HAWTIO es diferente

Si ni siquiera puede obtener la interfaz de usuario en localhost: 8181 en el navegador, verifique si ha mencionado el puerto correcto en la URL.

$FUSE_INSTALLATION_HOME/etc/org.ops4j.pax.web.cfg

Edite la siguiente propiedad en el archivo para usar el puerto al que desea acceder.

org.osgi.service.http.port=8181

AMQ Broker no funciona

Asegúrese de que el puerto 61616 esté abierto y no esté siendo utilizado por otro puerto. Si desea cambiar el puerto 61616 predeterminado por el mismo, puede editarlo en$FUSE_INSTALLATION_HOME/etc/System.properties

activemq.port = 61616

↰ Previous page