JBoss EAP에 배포

Camel CDI 통합을 사용하면 @ImportResource 주석을 통해 기존 XML DSL 파일을 가져올 수 있습니다.

@ImportResource("camel-context.xml")
class MyBean {
}

@XmlRootElement(name = "customer")
@XmlAccessorType(XmlAccessType.FIELD)
public class Customer implements Serializable {

    private String firstName;
    private String lastName;

    public Customer() {
    }

    public Customer(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    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;
    }
}

<customer xmlns="http://org/wildfly/test/jaxb/model/Customer">
    <firstName>John</firstName>
    <lastName>Doe</lastName>
</customer>

WildFlyCamelContext camelctx = contextFactory.createCamelContext(getClass().getClassLoader());

final JaxbDataFormat jaxb = new JaxbDataFormat();
jaxb.setContextPath("org.wildfly.camel.test.jaxb.model");

camelctx.addRoutes(new RouteBuilder() {
    @Override
    public void configure() throws Exception {
        from("direct:start")
        .unmarshal(jaxb);
    }
});
camelctx.start();

ProducerTemplate producer = camelctx.createProducerTemplate();

// Send an XML representation of the customer to the direct:start endpoint
Customer customer = producer.requestBody("direct:start", readCustomerXml(), Customer.class);
Assert.assertEquals("John", customer.getFirstName());
Assert.assertEquals("Doe", customer.getLastName());

WildFlyCamelContext camelctx = contextFactory.createCamelContext();

final JaxbDataFormat jaxb = new JaxbDataFormat();
jaxb.setContextPath("org.wildfly.camel.test.jaxb.model");

camelctx.addRoutes(new RouteBuilder() {
    @Override
    public void configure() throws Exception {
        from("direct:start")
        .marshal(jaxb);
    }
});
camelctx.start();

ProducerTemplate producer = camelctx.createProducerTemplate();
Customer customer = new Customer("John", "Doe");
String customerXML = producer.requestBody("direct:start", customer, String.class);
Assert.assertEquals(readCustomerXml(), customerXML);

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

    <cxf:rsClient id="cxfProducer"
                  address="http://localhost:8080/rest"
                  serviceClass="org.wildfly.camel.examples.cxf.jaxrs.GreetingService" />

    <camelContext id="cxfrs-camel-context" xmlns="http://camel.apache.org/schema/spring">
        <route>
            <from uri="direct:start" />
            <setHeader headerName="operationName">
                <simple>greet</simple>
            </setHeader>
            <setHeader headerName="CamelCxfRsUsingHttpAPI">
                <constant>false</constant>
            </setHeader>
            <to uri="cxfrs:bean:cxfProducer" />
        </route>
    </camelContext>
</beans>

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

    <cxf:rsServer id="cxfConsumer"
                  address="http://localhost:8080/rest"
                  serviceClass="org.wildfly.camel.examples.cxf.jaxrs.GreetingService" />

    <camelContext id="cxfrs-camel-context" xmlns="http://camel.apache.org/schema/spring">
        <route>
            <from uri="cxfrs:bean:cxfConsumer" />
            <setBody>
                <constant>Hello world</constant>
            </setBody>
        </route>
    </camelContext>
</beans>

Camel REST DSL은 Cryostat-RS 소비자 역할을 하는 Camel 경로를 작성할 수 있는 기능을 제공합니다. 다음 RouteBuilder 클래스는 이를 보여줍니다.

@Startup
@ApplicationScoped
@ContextName("rest-camel-context")
public class RestConsumerRouteBuilder extends RouteBuilder {
  @Override
  public void configure() throws Exception {

    // Use the camel-undertow component to provide REST integration
    restConfiguration().component("undertow")
      .contextPath("/rest").port(8080).bindingMode(RestBindingMode.json);

    rest("/customer")
      // GET /rest/customer
      .get()
        .produces(MediaType.APPLICATION_JSON)
        .to("direct:getCustomers")
      // GET /rest/customer/1
      .get("/{id}")
        .produces(MediaType.APPLICATION_JSON)
        .to("direct:getCustomer")
      // POST /rest/customer
      .post()
        .type(Customer.class)
        .to("direct:createCustomer");
      // PUT /rest/customer
      .put()
        .type(Customer.class)
        .to("direct:updateCustomer");
      // DELETE /rest/customer/1
      .delete("/{id}")
        .to("direct:deleteCustomer");
  }
}

Camel은 바인딩 모드를 설정하여 'produces()' 또는 'type()' 구성 단계를 지정하여 JSON 데이터를 마샬링하고 해제할 수 있습니다.

Cryostat -RS 보안 섹션을 참조하십시오.

빠른 시작 예제는 빠른 시작/camel/camel-cxf-jaxrs 디렉터리에 있는 EAP 설치의 Fuse에서 사용할 수 있습니다.

다음 코드 예제에서는 CXF를 사용하여 WildFly 웹 서비스 하위 시스템에서 배포한 웹 서비스를 사용합니다.

// Service interface
@WebService(name = "greeting")
public interface GreetingService {
    @WebMethod(operationName = "greet", action = "urn:greet")
    String greet(@WebParam(name = "message") String message, @WebParam(name = "name") String name);
}

// Service implementation
public class GreetingServiceImpl implements GreetingService{
    public String greet(String message, String name) {
        return message + " " + name ;
    }
}

@Startup
@ApplicationScoped
@ContextName("cxf-camel-context")
public class CxfRouteBuilder extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        from("direct:start")
        .to("cxf://http://localhost:8080/example-camel-cxf/greeting?serviceClass=" + GreetingService.class.getName());
    }
}

String message = "Hello"
String name = "Kermit"

ProducerTemplate producer = camelContext.createProducerTemplate();
Object[] serviceParams = new Object[] {message, name};
String result = producer.requestBody("direct:start", serviceParams, String.class);

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

    <cxf:cxfEndpoint id="cxfConsumer"
                     address="http://localhost:8080/webservices/greeting"
                     serviceClass="org.wildfly.camel.examples.cxf.jaxws.GreetingService" />

    <camelContext id="cxfws-camel-context" xmlns="http://camel.apache.org/schema/spring">
        <route>
            <from uri="cxf:bean:cxfConsumer" />
            <to uri="log:ws" />
        </route>
    </camelContext>

</beans>

Cryostat -WS 보안 섹션을 참조하십시오.

빠른 시작 예제는 빠른 시작/camel/camel-cxf-jaxws 디렉터리에 있는 EAP 설치의 Fuse에서 사용할 수 있습니다.

표준 JBoss EAP XML 구성 파일을 통해 JBoss EAP 메시징 하위 시스템을 구성할 수 있습니다. 예를 들면 standalone.xml 또는 domain.xml입니다.

예를 들어 메모리 인스턴스에서 포함된 ActiveMQ Artemis를 사용합니다. 먼저 jms-destinations 섹션에 다음 XML 구성을 추가하여 메시징 하위 시스템에서 새 JMS 큐를 구성합니다.

<jms-queue name="WildFlyCamelQueue">
  <entry name="java:/jms/queue/WildFlyCamelQueue"/>
</jms-queue>

또는 CLI 스크립트를 사용하여 큐를 추가할 수도 있습니다.

$ jms-queue add --queue-address=WildFlyCamelQueue --entries=queue/WildFlyCamelQueue,java:/jms/queue/WildFlyCamelQueue

또한 사용자 지정 jms.xml 배포 설명자 내에 messaging-deployment 구성을 생성할 수 있습니다. 자세한 내용은 JBoss EAP 메시징 하위 시스템 설명서의 'jms.xml 파일' 섹션을 참조하십시오.

다음 JMS 생산자 및 소비자 예제는 JBoss EAP의 포함된 ActiveMQ Artemis 서버를 사용하여 대상에 메시지를 게시하고 사용합니다.

이 예제에서는 camel-cdi 구성 요소와 함께 CDI를 사용합니다. JMS ConnectionFactory 인스턴스는 JNDI 조회를 통해 Camel RouteBuilder에 삽입됩니다.

5.6.2.1. JMS Producer

DefaultJMSConnectionFactory 연결 팩토리가 JNDI의 RouteBuilder에 삽입됩니다. JBoss EAP XML 구성에서 메시징 하위 시스템 내에서 연결 팩토리를 찾을 수 있습니다.

다음으로 타이머 끝점은 10초마다 실행되어 이전에 구성된 WildFlyCamelQueue 대상에 XML 페이로드를 보냅니다.

@Startup
@ApplicationScoped
@ContextName("jms-camel-context")
public class JmsRouteBuilder extends RouteBuilder {

  @Resource(mappedName = "java:jboss/DefaultJMSConnectionFactory")
  private ConnectionFactory connectionFactory;

  @Override
  public void configure() throws Exception {
    JmsComponent component = new JmsComponent();
    component.setConnectionFactory(connectionFactory);

    getContext().addComponent("jms", component);

    from("timer://sendJMSMessage?fixedRate=true&period=10000")
    .transform(constant("<?xml version='1.0><message><greeting>hello world</greeting></message>"))
    .to("jms:queue:WildFlyCamelQueue")
    .log("JMS Message sent");
  }
}

JMS 메시지가 WildFlyCamelQueue 대상에 추가될 때마다 로그 메시지가 콘솔에 출력됩니다. 메시지가 큐에 실제로 배치되었는지 확인하려면 JBoss EAP 관리 콘솔을 사용할 수 있습니다.

@Override
public void configure() throws Exception {
  JmsComponent component = new JmsComponent();
  component.setConnectionFactory(connectionFactory);

  getContext().addComponent("jms", component);

  from("jms:queue:WildFlyCamelQueue")
  .to("log:jms?showAll=true");
}

@Named("transactionManager")
public class CdiTransactionManager extends JtaTransactionManager {

  @Resource(mappedName = "java:/TransactionManager")
  private TransactionManager transactionManager;

  @Resource
  private UserTransaction userTransaction;

  @PostConstruct
  public void initTransactionManager() {
    setTransactionManager(transactionManager);
    setUserTransaction(userTransaction);
  }
}

@Named("PROPAGATION_REQUIRED")
public class CdiRequiredPolicy extends SpringTransactionPolicy {
  @Inject
  public CdiRequiredPolicy(CdiTransactionManager cdiTransactionManager) {
    super(new TransactionTemplate(cdiTransactionManager,
      new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRED)));
  }
}

@Startup
@ApplicationScoped
@ContextName("jms-camel-context")
public class JMSRouteBuilder extends RouteBuilder {

  @Resource(mappedName = "java:/JmsXA")
  private ConnectionFactory connectionFactory;

  @Inject
  CdiTransactionManager transactionManager;

  @Override
  public void configure() throws Exception {
    // Creates a JMS component which supports transactions
    JmsComponent jmsComponent = JmsComponent.jmsComponentTransacted(connectionFactory, transactionManager);
    getContext().addComponent("jms", jmsComponent);

    from("jms:queue:queue1")
      .transacted("PROPAGATION_REQUIRED")
      .to("jms:queue:queue2");

    // Force the transaction to roll back. The message will end up on the Wildfly 'DLQ' message queue
    from("jms:queue:queue2")
      .to("log:end")
      .rollback();
  }

<jms-queue name="RemoteQueue">
  <entry name="java:jboss/exported/jms/queues/RemoteQueue"/>
</jms-queue>

@Override
public void configure() throws Exception {
  Context initialContext = configureInitialContext();
  ConnectionFactory connectionFactory = (ConnectionFactory) initialContext.lookup("java:jms/RemoteConnectionFactory");

  JmsComponent component = new JmsComponent();
  component.setConnectionFactory(connectionFactory);

  getContext().addComponent("jms", component);

  from("timer://foo?fixedRate=true&period=10000")
  .transform(constant("<?xml version='1.0><message><greeting>hello world</greeting></message>"))
  .to("jms:queue:RemoteQueue?username=admin&password=secret")
  .to("log:jms?showAll=true");
}

private Context configureInitialContext() throws NamingException {
  final Properties env = new Properties();
  env.put(Context.INITIAL_CONTEXT_FACTORY, "org.jboss.naming.remote.client.InitialContextFactory");
  env.put(Context.PROVIDER_URL, System.getProperty(Context.PROVIDER_URL, "http-remoting://my-remote-host:8080"));
  env.put(Context.SECURITY_PRINCIPAL, System.getProperty("username", "admin"));
  env.put(Context.SECURITY_CREDENTIALS, System.getProperty("password", "secret"));
  return new InitialContext(env);
}

JMS 보안 섹션을 참조하십시오.

빠른 시작 예제는 빠른 시작/camel/camel-jms 디렉터리에 있는 EAP 설치의 Fuse에서 사용할 수 있습니다.

다음 예제에서는 JBoss EAP standalone.xml 구성 파일 내에서 구성된 JBoss EAP in-memory ExampleDS 데이터 소스를 사용할 수 있습니다.

<persistence version="2.0"
    xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

    <persistence-unit name="camel">
        <jta-data-source>java:jboss/datasources/ExampleDS</jta-data-source>
        <class>org.wildfly.camel.test.jpa.model.Customer</class>
        <properties>
            <property name="hibernate.hbm2ddl.auto" value="create-drop"/>
            <property name="hibernate.show_sql" value="true"/>
        </properties>
    </persistence-unit>

</persistence>

@Entity
@Table(name = "customer")
public class Customer implements Serializable {
    @Id
    @GeneratedValue
    private Long id;
    private String firstName;
    private String lastName;

    public Customer() {
    }

    public Customer(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public Long getId() {
        return id;
    }

    public void setId(final Long id) {
        this.id = id;
    }

    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;
    }
}

JPA를 구성하면 CDI를 사용하여 EntityManager 및 UserTransaction 인스턴스를 RouteBuilder 클래스 또는 테스트 케이스에 삽입할 수 있습니다.

@PersistenceContext
EntityManager em;

@Inject
UserTransaction userTransaction;

이제 Camel 경로 및 JPA 끝점을 구성합니다.

WildFlyCamelContext camelctx = contextFactory.createCamelContext(getClass().getClassLoader());

EntityManagerFactory entityManagerFactory = em.getEntityManagerFactory();

// Configure a transaction manager
JtaTransactionManager transactionManager = new JtaTransactionManager();
transactionManager.setUserTransaction(userTransaction);
transactionManager.afterPropertiesSet();

// Configure the JPA endpoint to use the correct EntityManagerFactory and JtaTransactionManager
final JpaEndpoint jpaEndpoint = new JpaEndpoint();
jpaEndpoint.setCamelContext(camelctx);
jpaEndpoint.setEntityType(Customer.class);
jpaEndpoint.setEntityManagerFactory(entityManagerFactory);
jpaEndpoint.setTransactionManager(transactionManager);

camelctx.addRoutes(new RouteBuilder() {
@Override
public void configure() throws Exception {
    from("direct:start")
    .to(jpaEndpoint);
}
});

camelctx.start();

마지막으로 '고객' 엔터티를 'direct:start' 엔드포인트에 보낸 다음 ExampleDS 데이터 소스를 쿼리하여 레코드가 저장되었는지 확인할 수 있습니다.

Customer customer = new Customer("John", "Doe");
ProducerTemplate producer = camelctx.createProducerTemplate();
producer.sendBody("direct:start", customer);

// Query the in memory database customer table to verify that a record was saved
CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
CriteriaQuery<Long> query = criteriaBuilder.createQuery(Long.class);
query.select(criteriaBuilder.count(query.from(Customer.class)));

long recordCount = em.createQuery(query).getSingleResult();

Assert.assertEquals(1L, recordCount);

ActiveMQ 리소스 어댑터 rar 파일을 다운로드합니다. 다음 단계에서는 ActiveMQ 리소스 어댑터를 구성하는 방법을 간략하게 설명합니다.

<subsystem xmlns="urn:jboss:domain:resource-adapters:2.0">
     <resource-adapters>
         <resource-adapter id="activemq-rar.rar">
             <archive>
                 activemq-rar.rar
             </archive>
             <transaction-support>XATransaction</transaction-support>
             <config-property name="UseInboundSession">
                 false
             </config-property>
             <config-property name="Password">
                 defaultPassword
             </config-property>
             <config-property name="UserName">
                 defaultUser
             </config-property>
             <config-property name="ServerUrl">
                 tcp://localhost:61616?jms.rmIdFromConnectionId=true
             </config-property>
             <connection-definitions>
                 <connection-definition class-name="org.apache.activemq.ra.ActiveMQManagedConnectionFactory" jndi-name="java:/ActiveMQConnectionFactory" enabled="true" pool-name="ConnectionFactory">
                     <xa-pool>
                         <min-pool-size>1</min-pool-size>
                         <max-pool-size>20</max-pool-size>
                         <prefill>false</prefill>
                         <is-same-rm-override>false</is-same-rm-override>
                     </xa-pool>
                 </connection-definition>
             </connection-definitions>
             <admin-objects>
                 <admin-object class-name="org.apache.activemq.command.ActiveMQQueue" jndi-name="java:/queue/HELLOWORLDMDBQueue" use-java-context="true" pool-name="HELLOWORLDMDBQueue">
                     <config-property name="PhysicalName">
                         HELLOWORLDMDBQueue
                     </config-property>
                 </admin-object>
                 <admin-object class-name="org.apache.activemq.command.ActiveMQTopic" jndi-name="java:/topic/HELLOWORLDMDBTopic" use-java-context="true" pool-name="HELLOWORLDMDBTopic">
                     <config-property name="PhysicalName">
                         HELLOWORLDMDBTopic
                     </config-property>
                 </admin-object>
             </admin-objects>
         </resource-adapter>
     </resource-adapters>
 </subsystem>

리소스 어댑터 아카이브 파일 이름이 activemq-rar.rar와 다른 경우 아카이브 파일의 이름과 일치하도록 이전 구성의 아카이브 요소 내용을 변경해야 합니다.

외부 브로커에 있는 유효한 사용자의 자격 증명과 일치하도록 UserName 및 Password 구성 속성 값을 선택해야 합니다.

외부 브로커가 노출하는 실제 호스트 이름 및 포트와 일치하도록 ServerUrl 구성 속성 값을 변경해야 할 수 있습니다.

4) JBoss EAP를 시작합니다. 모든 항목이 올바르게 구성된 경우 다음과 같은 JBoss EAP server.log에 메시지가 표시됩니다.

13:16:08,412 INFO  [org.jboss.as.connector.deployment] (MSC service thread 1-5) JBAS010406: Registered connection factory java:/AMQConnectionFactory`

다음 ActiveMQ 생산자 및 소비자 예제에서는 ActiveMQ 포함 브로커 및 'vm' 전송(외부 ActiveMQ 브로커의 필요성을 방지)을 사용합니다.

예에서는 camel-cdi 구성 요소와 함께 CDI를 사용합니다. JMS ConnectionFactory 인스턴스는 JNDI 조회를 통해 Camel RouteBuilder에 삽입됩니다.

6.1.2.1. ActiveMQ Producer

@Startup
@ApplicationScoped
@ContextName("activemq-camel-context")
public class ActiveMQRouteBuilder extends RouteBuilder {

  @Override
  public void configure() throws Exception {
    from("timer://sendJMSMessage?fixedRate=true&period=10000")
    .transform(constant("<?xml version='1.0><message><greeting>hello world</greeting></message>"))
    .to("activemq:queue:WildFlyCamelQueue?brokerURL=vm://localhost")
    .log("JMS Message sent");
  }
}

메시지가 WildFlyCamelQueue 대상에 추가될 때마다 로그 메시지가 콘솔에 출력됩니다. 메시지가 실제로 큐에 배치되는지 확인하려면 EAP 하위 시스템에서 Camel에서 제공하는 ../features/hawtio.md[Hawtio 콘솔,window=_blank]을 사용할 수 있습니다.

@Override
public void configure() throws Exception {
  from("activemq:queue:WildFlyCamelQueue?brokerURL=vm://localhost")
  .to("log:jms?showAll=true");
}

<subsystem xmlns="urn:jboss:domain:resource-adapters:2.0">
  <resource-adapters>
    <resource-adapter id="activemq-rar.rar">
      ...
      <admin-objects>
        <admin-object class-name="org.apache.activemq.command.ActiveMQQueue" jndi-name="java:/queue/queue1" use-java-context="true" pool-name="queue1pool">
          <config-property name="PhysicalName">queue1</config-property>
        </admin-object>
        <admin-object class-name="org.apache.activemq.command.ActiveMQQueue" jndi-name="java:/queue/queue2" use-java-context="true" pool-name="queue2pool">
          <config-property name="PhysicalName">queue2</config-property>
        </admin-object>
      </admin-objects>
    </resource-adapter>
  </resource-adapters>
</subsystem>

@Named("transactionManager")
public class CdiTransactionManager extends JtaTransactionManager {

  @Resource(mappedName = "java:/TransactionManager")
  private TransactionManager transactionManager;

  @Resource
  private UserTransaction userTransaction;

  @PostConstruct
  public void initTransactionManager() {
    setTransactionManager(transactionManager);
    setUserTransaction(userTransaction);
  }
}

@Named("PROPAGATION_REQUIRED")
public class CdiRequiredPolicy extends SpringTransactionPolicy {
  @Inject
  public CdiRequiredPolicy(CdiTransactionManager cdiTransactionManager) {
    super(new TransactionTemplate(cdiTransactionManager,
      new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRED)));
  }
}

@Startup
@ApplicationScoped
@ContextName("activemq-camel-context")
public class ActiveMQRouteBuilder extends RouteBuilder {

  @Resource(mappedName = "java:/ActiveMQConnectionFactory")
  private ConnectionFactory connectionFactory;

  @Inject
  private CdiTransactionManager transactionManager;

  @Override
  public void configure() throws Exception {
    ActiveMQComponent activeMQComponent = ActiveMQComponent.activeMQComponent();
    activeMQComponent.setTransacted(false);
    activeMQComponent.setConnectionFactory(connectionFactory);
    activeMQComponent.setTransactionManager(transactionManager);

    getContext().addComponent("activemq", activeMQComponent);

      errorHandler(deadLetterChannel("activemq:queue:ActiveMQ.DLQ")
      .useOriginalMessage()
      .maximumRedeliveries(0)
      .redeliveryDelay(1000));

    from("activemq:queue:queue1F")
      .transacted("PROPAGATION_REQUIRED")
      .to("activemq:queue:queue2");

    from("activemq:queue:queue2")
      .to("log:end")
      .rollback();
  }
}

JMS 보안 섹션을 참조하십시오.

GitHub에서 camel-activemq 애플리케이션 예를 사용할 수 있습니다.

JBoss EAP의 Fuse 7.9는 JBoss EAP에서 메시징 구성에 설명된 리소스 어댑터를 사용하여 외부 메시징 브로커에 액세스합니다.

JBoss EAP의 Fuse 7.9 메시징에 사용할 수 있는 외부 브로커, JCA 어댑터 및 Camel 구성 요소 조합에 대한 자세한 내용은 지원 구성을 참조하십시오.

JMS를 사용하여 JBoss EAP에서 Fuse를 사용하여 외부 브로커에 연결하는 방법에 대한 자세한 내용은 6.2절. “camel-jms” 을 참조하십시오.

이 빠른 시작에서 Camel 경로는 EAP_HOME/standalone/data/orders 의 파일을 사용하고 OrdersQueue 라는 메모리 내 ActiveMQ Artemis 큐에 콘텐츠를 배치합니다. 그런 다음 다른 Camel 경로는 OrdersQueue 내용을 사용하고 주문을 EAP_HOME/standalone/data/orders/processed 내의 개별 국가 디렉터리로 정렬합니다.

CLI 명령은 OrdersQueue CLI 스크립트를 생성 및 삭제합니다. 애플리케이션이 배포 및 배포 취소될 때 JMS OrdersQueue 를 생성하고 제거합니다. 이러한 스크립트는 EAP_HOME/quickstarts/camel-jms/src/main/resources/cli 디렉터리에 있습니다.

외부 AMQ 7 브로커에 연결하려면 원격 JMS communication에 JBoss AMQ 사용 지침도 따라야 합니다. 그런 다음 기본 연결 팩토리와 마찬가지로 연결 팩토리를 삽입할 수 있습니다.

@Resource(mappedName = "java:jboss/RemoteJmsXA")
ConnectionFactory connectionFactory;

'Orders Received'라는 페이지가 표시됩니다. 예제 애플리케이션에 주문을 보내면 국가당 주문 목록이 이 페이지에 나열됩니다.

콘솔은 각 주문에 발생한 작업을 자세히 설명하는 메시지를 출력합니다. 출력은 다음과 같습니다.

JmsConsumer[OrdersQueue]) Sending order to the UK
JmsConsumer[OrdersQueue]) Sending order to another country
JmsConsumer[OrdersQueue]) Sending order to the US

파일이 소비되면 http://localhost:8080/example-camel-jms/orders 로 돌아갈 수 있습니다. 각 국가에 대한 주문 수는 1로 증가해야합니다.

처리된 모든 주문은 다음 대상으로 나뉩니다.

EAP_HOME/standalone/data/orders/processed/uk
EAP_HOME/standalone/data/orders/processed/us
EAP_HOME/standalone/data/orders/processed/other

먼저 메일 서버에 대한 JBoss EAP 메일 하위 시스템을 구성합니다. 다음 예제에서는 Google Mail Cryostat 및 SMTP에 대한 구성을 추가합니다.

추가 mail-session은 'default' 세션 후에 구성됩니다.

<subsystem xmlns="urn:jboss:domain:mail:2.0">
    <mail-session name="default" jndi-name="java:jboss/mail/Default">
      <smtp-server outbound-socket-binding-ref="mail-smtp"/>
    </mail-session>

    <mail-session debug="true" name="gmail" jndi-name="java:jboss/mail/gmail">
      <smtp-server outbound-socket-binding-ref="mail-gmail-smtp" ssl="true" username="your-username-here" password="your-password-here"/>
      <imap-server outbound-socket-binding-ref="mail-gmail-imap" ssl="true" username="your-username-here" password="your-password-here"/>
    </mail-session>
</subsystem>

다음 단계는 이러한 소켓 바인딩을 구성하는 것입니다. socket-binding-group 구성에 다음과 같이 바인딩을 추가할 수 있습니다.

<outbound-socket-binding name="mail-gmail-smtp">
  <remote-destination host="smtp.gmail.com" port="465"/>
</outbound-socket-binding>

<outbound-socket-binding name="mail-gmail-imap">
  <remote-destination host="imap.gmail.com" port="993"/>
</outbound-socket-binding>

이렇게 하면 포트 465 및 포트 993의 imap.gmail.com의 호스트 smtp.gmail.com에 연결하도록 메일 세션이 구성됩니다. 다른 메일 호스트를 사용하는 경우 이 세부 정보가 달라집니다.

POP3 세션을 구성해야 하는 경우 원칙이 위의 예제에 정의된 것과 동일합니다.

<!-- Server configuration -->
<pop3-server outbound-socket-binding-ref="mail-pop3" ssl="true" username="your-username-here" password="your-password-here"/>

<!-- Socket binding configuration -->
<outbound-socket-binding name="mail-gmail-imap">
  <remote-destination host="pop3.gmail.com" port="993"/>
</outbound-socket-binding>

예제 camel-mail 애플리케이션은 GitHub에서 이메일 전송을 시도하거나 이메일을 수신해 볼 수 있습니다.

다음 Spring JDBC XML 구성 지원이 지원됩니다.

jdbc:embedded-database

<jdbc:embedded-database id="datasource" type="H2">
  <jdbc:script location="db-schema.sql"/>
</jdbc:embedded-database>

jdbc:initialize-database

<jdbc:initialize-database data-source="datasource">
  <jdbc:script location="classpath:db-init.sql"/>
</jdbc:initialize-database>

제공된 경로가 보안 Jarkarta EE 구성 요소를 호출할 때 클라이언트 역할을 하며 호출과 관련된 적절한 자격 증명을 제공해야 합니다.

다음과 같이 ClientAuthorizationPolicy 를 사용하여 경로를 분리할 수 있습니다.

CamelContext camelctx = new DefaultCamelContext();
camelctx.addRoutes(new RouteBuilder() {
    @Override
    public void configure() throws Exception {
        from("direct:start")
        .policy(new ClientAuthorizationPolicy())
        .to("ejb:java:module/AnnotatedSLSB?method=doSelected");
    }
});

이는 camel 메시지 처리의 일부로 인증 및 권한 부여를 수행하지 않습니다. 대신 Camel Exchange와 함께 제공되는 인증 정보를 OpenSCAP3 계층 호출과 연결합니다.

메시지 소비자를 호출하는 클라이언트는 다음과 같이 AUTHENTICATION 헤더에 적절한 자격 증명을 제공해야 합니다.

ProducerTemplate producer = camelctx.createProducerTemplate();
Subject subject = new Subject();
subject.getPrincipals().add(new DomainPrincipal(domain));
subject.getPrincipals().add(new EncodedUsernamePasswordPrincipal(username, password));
producer.requestBodyAndHeader("direct:start", "Kermit", Exchange.AUTHENTICATION, subject, String.class);

Jarkarta EE 계층에서 인증 및 권한 부여가 수행됩니다.

Camel 경로를 보호하려면 DomainAuthorizationPolicy 를 경로와 연결할 수 있습니다. 이 정책은 지정된 보안 도메인과 "Role2"에 대한 권한 부여에 대해 성공적으로 인증해야 합니다.

CamelContext camelctx = new DefaultCamelContext();
camelctx.addRoutes(new RouteBuilder() {
    @Override
    public void configure() throws Exception {
        from("direct:start")
        .policy(new DomainAuthorizationPolicy().roles("Role2"))
        .transform(body().prepend("Hello "));
    }
});
camelctx.start();

또한 메시지 소비자를 호출하는 클라이언트는 다음과 같이 AUTHENTICATION 헤더에 적절한 자격 증명을 제공해야 합니다.

ProducerTemplate producer = camelctx.createProducerTemplate();
Subject subject = new Subject();
subject.getPrincipals().add(new DomainPrincipal(domain));
subject.getPrincipals().add(new EncodedUsernamePasswordPrincipal(username, password));
producer.requestBodyAndHeader("direct:start", "Kermit", Exchange.AUTHENTICATION, subject, String.class);