Apache camel что это

Введение в Apache Camel

В этой статье мы представим Camel и рассмотрим одну из его основных концепций — маршрутизацию сообщений .

Мы начнем с рассмотрения этих основных понятий и терминологии, а затем представим два основных варианта определения маршрутов — Java DSL и Spring DSL.

Мы также продемонстрируем это на примере — определив маршрут, который использует файлы из одной папки и перемещает их в другую, добавляя временную метку к каждому имени файла.

2. Об Apache Camel​

Apache Camel — это среда интеграции с открытым исходным кодом, разработанная для простой и легкой интеграции систем.

Он позволяет конечным пользователям интегрировать различные системы с использованием одного и того же API, обеспечивая поддержку нескольких протоколов и типов данных, будучи расширяемым и позволяя вводить пользовательские протоколы.

3. Зависимости Maven​

Чтобы использовать Camel, нам нужно сначала добавить зависимость Maven:

 dependency>   groupId>org.apache.camelgroupId>   artifactId>camel-coreartifactId>   version>2.18.0version>   dependency> 

Последнюю версию артефакта Camel можно найти здесь .

3. Язык предметной области​

Маршруты и механизм маршрутизации являются центральной частью Camel. Маршруты содержат поток и логику интеграции между различными системами.

Для более простого и четкого определения маршрутов Camel предлагает несколько различных предметно-ориентированных языков (DSL) для таких языков программирования, как Java или Groovy. С другой стороны, он также обеспечивает определение маршрутов в XML с помощью Spring DSL.

Использование Java DSL или Spring DSL в основном является предпочтением пользователя, поскольку большинство функций доступны в обоих.

Java DSL предлагает немного больше функций, которые не поддерживаются в Spring DSL. Однако Spring DSL иногда более выгоден, поскольку XML можно изменить без необходимости перекомпилировать код.

4. Терминология и архитектура​

Давайте теперь обсудим основную терминологию и архитектуру Camel.

Во-первых, мы рассмотрим основные концепции Camel здесь:

• Сообщение содержит данные, которые передаются по маршруту. Каждое сообщение имеет уникальный идентификатор и состоит из тела, заголовков и вложений.
• Exchange — это контейнер сообщения, который создается при получении сообщения потребителем в процессе маршрутизации. Exchange допускает различные типы взаимодействия между системами — он может определять одностороннее сообщение или сообщение типа «запрос-ответ».
• Конечная точка — это канал, по которому система может получать или отправлять сообщения. Он может относиться к URI веб-службы, URI очереди, файлу, адресу электронной почты и т. д.
• Компонент действует как фабрика конечных точек. Проще говоря, компоненты предлагают интерфейс для различных технологий, используя один и тот же подход и синтаксис. Camel уже поддерживает множество компонентов в своих DSL практически для всех возможных технологий, но также дает возможность писать собственные компоненты.
• Процессор — это простой интерфейс Java, который используется для добавления пользовательской логики интеграции в маршрут. Он содержит один метод процесса , используемый для предварительной обработки пользовательской бизнес-логики в сообщении, полученном потребителем.

На высоком уровне архитектура Camel проста. CamelContext представляет систему времени выполнения Camel и связывает различные концепции, такие как маршруты, компоненты или конечные точки.

И ниже этого процессоры обрабатывают маршрутизацию и преобразования между конечными точками, в то время как конечные точки интегрируют разные системы.

5. Определение маршрута​

Маршруты могут быть определены с помощью Java DSL или Spring DSL.

Мы проиллюстрируем оба стиля, определив маршрут, который использует файлы из одной папки и перемещает их в другую папку, добавляя временную метку к каждому имени файла.

5.1. Маршрутизация с помощью Java DSL​

Чтобы определить маршрут с помощью Java DSL, нам сначала нужно создать экземпляр DefaultCamelContext . После этого нам нужно расширить класс RouteBuilder и реализовать метод configure , который будет содержать поток маршрута:

 private static final long DURATION_MILIS = 10000;   private static final String SOURCE_FOLDER = "src/test/source-folder";   private static final String DESTINATION_FOLDER   = "src/test/destination-folder";    @Test   public void moveFolderContentJavaDSLTest() throws Exception    CamelContext camelContext = new DefaultCamelContext();   camelContext.addRoutes(new RouteBuilder()    @Override   public void configure() throws Exception    from("file://" + SOURCE_FOLDER + "?delete=true").process(   new FileProcessor()).to("file://" + DESTINATION_FOLDER);   >   >);   camelContext.start();   Thread.sleep(DURATION_MILIS);   camelContext.stop();   > 

Метод configure можно прочитать так: читать файлы из исходной папки, обрабатывать их с помощью FileProcessor и отправлять результат в папку назначения. Установка delete=true означает, что файл будет удален из исходной папки после успешной обработки.

Чтобы запустить Camel, нам нужно вызвать метод start для CamelContext . Thread.sleep вызывается, чтобы дать Camel время, необходимое для перемещения файлов из одной папки в другую.

FileProcessor реализует интерфейс Processor и содержит единственный метод процесса , который содержит логику для изменения имен файлов:

 public class FileProcessor implements Processor    public void process(Exchange exchange) throws Exception    String originalFileName = (String) exchange.getIn().getHeader(   Exchange.FILE_NAME, String.class);    Date date = new Date();   SimpleDateFormat dateFormat = new SimpleDateFormat(   "yyyy-MM-dd HH-mm-ss");   String changedFileName = dateFormat.format(date) + originalFileName;   exchange.getIn().setHeader(Exchange.FILE_NAME, changedFileName);   >   > 

Чтобы получить имя файла, мы должны получить входящее сообщение от обмена и получить доступ к его заголовку. Аналогично этому, чтобы изменить имя файла, мы должны обновить заголовок сообщения.

5.2. Маршрутизация с помощью Spring DSL​

При определении маршрута с помощью Spring DSL мы используем файл XML для настройки наших маршрутов и процессоров. Это позволяет нам настраивать маршруты без использования кода с помощью Spring и, в конечном итоге, дает нам преимущество полной инверсии управления.

Это уже было описано в существующей статье , поэтому мы сосредоточимся на использовании как Spring DSL, так и Java DSL, который обычно является предпочтительным способом определения маршрутов.

В этом случае CamelContext определяется в XML-файле Spring с использованием пользовательского синтаксиса XML для Camel, но без определения маршрута, как в случае «чистого» Spring DSL с использованием XML:

 bean id="fileRouter" class="com.foreach.camel.file.FileRouter" />   bean id="fileProcessor"   class="com.foreach.camel.file.FileProcessor" />    camelContext xmlns="http://camel.apache.org/schema/spring">   routeBuilder ref="fileRouter" />   camelContext> 

Таким образом, мы говорим Camel использовать класс FileRouter , который содержит определение нашего маршрута в Java DSL:

 public class FileRouter extends RouteBuilder     private static final String SOURCE_FOLDER =   "src/test/source-folder";   private static final String DESTINATION_FOLDER =   "src/test/destination-folder";    @Override   public void configure() throws Exception    from("file://" + SOURCE_FOLDER + "?delete=true").process(   new FileProcessor()).to("file://" + DESTINATION_FOLDER);   >   > 

Чтобы проверить это, мы должны создать экземпляр ClassPathXmlApplicationContext , который загрузит наш CamelContext весной:

 @Test   public void moveFolderContentSpringDSLTest() throws InterruptedException    ClassPathXmlApplicationContext applicationContext =   new ClassPathXmlApplicationContext("camel-context.xml");   Thread.sleep(DURATION_MILIS);   applicationContext.close();   > 

При таком подходе мы получаем дополнительную гибкость и преимущества, предоставляемые Spring, а также все возможности языка Java за счет использования Java DSL.

6. Заключение​

В этой быстрой статье мы представили введение в Apache Camel и продемонстрировали преимущества использования Camel для задач интеграции, таких как маршрутизация файлов из одной папки в другую.

В нашем примере мы увидели, что Camel позволяет сосредоточиться на бизнес-логике и сокращает объем стандартного кода.

Код из этой статьи можно найти на GitHub .

Apache Camel – Обзор

Верблюд – это черный ящик, который получает сообщения от одной конечной точки и отправляет ее другой. Внутри черного ящика сообщения могут быть обработаны или просто перенаправлены.

Итак, почему есть рамки для этого? В практических ситуациях, как показано во вводном примере, может быть много отправителей и много получателей, каждый из которых следует своему собственному протоколу, такому как ftp, http и jms. Системе может потребоваться множество сложных правил, например, сообщение от отправителя A должно быть доставлено только в B & C. В ситуациях вам может потребоваться перевести сообщение в другой формат, который ожидает получатель. Этот перевод может быть предметом определенных условий, основанных на содержании сообщения. По сути, вам может потребоваться выполнять трансляцию между протоколами, склеивать компоненты, определять правила маршрутизации и обеспечивать фильтрацию на основе содержимого сообщения. Это показано на следующем рисунке –

Чтобы удовлетворить вышеупомянутые требования и спроектировать правильную архитектуру программного обеспечения для многих таких ситуаций, Грегор Хоуп и Бобби Вульф в 2003 году задокументировали шаблоны интеграции предприятия ( EIP ). Apache Camel обеспечивает реализацию этих шаблонов, и цель этого учебного пособия – научить Вы знаете, как использовать Camel в ситуациях, подобных описанной во введении.

Apache Camel – это фреймворк с открытым исходным кодом. Это промежуточное программное обеспечение, ориентированное на сообщения, которое предоставляет механизм маршрутизации и передачи на основе правил. Вы можете определить правила, например, если это «молочный» заказ, перенаправить его поставщику молока, а если это «нефтяной» заказ, перенаправить его поставщику масла и т. Д. Используя Camel, вы сможете реализовать эти правила и выполнить маршрутизацию в привычном Java-коде. Это означает, что вы можете использовать знакомую вам Java IDE для определения этих правил в безопасной среде. Нам не нужно использовать файлы конфигурации XML, которые обычно бывают громоздкими. Однако Camel поддерживает настройку XML через Spring Framework, если вы предпочитаете использовать XML для настройки правил. Вы можете даже использовать конфигурационные файлы Blueprint XML и даже Scala DSL, если вы любитель Scala. Это также означает, что вы можете использовать вашу любимую Java, Scala IDE или даже простой редактор XML для настройки правил.

Входными данными для этого механизма могут быть текстовый файл с разделителями-запятыми, POJO (простой старый Java-объект), XML – любой из нескольких других форматов, поддерживаемых Camel. Точно так же выходные данные механизма могут быть перенаправлены в файл, в очередь сообщений или даже на экран вашего монитора, чтобы вы могли просматривать заказы, отправленные соответствующим поставщикам. Они называются конечными точками, и Camel поддерживает шаблон EIP сообщения конечной точки. Конечные точки Camel обсуждаются позже в главе «Конечные точки».

Camel обычно используется с Apache ServiceMix , Apache ActiveMQ и Apache CXF для реализации сервис-ориентированных архитектур.

Apache Camel с Spring Boot

По своей сути Apache Camel представляет собой механизм интеграции, который, проще говоря, можно использовать для облегчения взаимодействия между широким и разнообразным набором технологий.

Эти мосты между сервисами и технологиями называются маршрутами. Маршруты реализованы на движке ( CamelContext ) и взаимодействуют с так называемыми «сообщениями обмена».

2. Зависимости Maven​

Для начала нам нужно включить зависимости для Spring Boot, Camel, Rest API с Swagger и JSON:

 dependencies>   dependency>   groupId>org.apache.camel.springbootgroupId>   artifactId>camel-servlet-starterartifactId>   version>3.15.0version>   dependency>   dependency>   groupId>org.apache.camel.springbootgroupId>   artifactId>camel-jackson-starterartifactId>   version>3.15.0version>   dependency>   dependency>   groupId>org.apache.camel.springbootgroupId>   artifactId>camel-swagger-java-starterartifactId>   version>3.15.0version>   dependency>   dependency>   groupId>org.apache.camel.springbootgroupId>   artifactId>camel-spring-boot-starterartifactId>   version>3.15.0version>   dependency>   dependency>   groupId>org.springframework.bootgroupId>   artifactId>spring-boot-starter-webartifactId>   dependency>   dependencies> 

Последние версии зависимостей Apache Camel можно найти здесь .

3. Основной класс​

Давайте сначала создадим приложение Spring Boot :

 @SpringBootApplication   @ComponentScan(basePackages="com.foreach.camel")   public class Application    public static void main(String[] args)    SpringApplication.run(Application.class, args);   >   > 

4. Верблюжьи конфигурации для Spring Boot​

Давайте теперь настроим наше приложение с помощью Spring, начиная с файлов конфигурации (свойств).

Например, давайте настроим журнал для нашего приложения в файле application.properties в src/main/resources :

 logging.config=classpath:logback.xml camel.springboot.name=MyCamel  server.address=0.0.0.0  management.address=0.0.0.0  management.port=8081  endpoints.enabled = true  endpoints.health.enabled = true 

В этом примере показан файл application.properties , который также устанавливает путь к конфигурации Logback. Установив IP-адрес «0.0.0.0», мы полностью ограничиваем доступ администратора и управления на веб-сервере, предоставляемом Spring Boot. Кроме того, мы обеспечиваем необходимый сетевой доступ к конечным точкам наших приложений, а также к конечным точкам проверки работоспособности.

Еще один файл конфигурации — application.yml . В нем мы добавим некоторые свойства, которые помогут нам вводить значения в наши маршруты приложений:

 server:  port: 8080  camel:  springboot:  name: ServicesRest management:  port: 8081  endpoints:  enabled: false   health:  enabled: true  quickstart:  generateOrderPeriod: 10s  processOrderPeriod: 30s 

5 . Настройка верблюжьего сервлета​

Один из способов начать использовать Camel — зарегистрировать его как сервлет, чтобы он мог перехватывать HTTP-запросы и перенаправлять их в наше приложение.

Как упоминалось ранее, начиная с версии Camel 2.18 и ниже, мы можем воспользоваться нашим application.yml , создав параметр для нашего конечного URL. Позже он будет внедрен в наш Java-код:

 foreach:  api:  path: '/camel' 

Вернемся к нашему классу Application . Нам нужно зарегистрировать сервлет Camel в корне нашего контекстного пути, который будет внедрен из ссылки foreach.api.path в application.yml при запуске приложения:

 @Value("$")   String contextPath;    @Bean   ServletRegistrationBean servletRegistrationBean()    ServletRegistrationBean servlet = new ServletRegistrationBean   (new CamelHttpTransportServlet(), contextPath+"/*");   servlet.setName("CamelServlet");   return servlet;   > 

Начиная с версии Camel 2.19, эта конфигурация была удалена, так как CamelServlet по умолчанию имеет значение «/camel» .

6. Построение маршрута​

Давайте начнем создавать маршрут, расширив класс RouteBuilder от Camel и установив его как @Component , чтобы процедура сканирования компонентов могла найти его во время инициализации веб-сервера:

 @Component   class RestApi extends RouteBuilder    @Override   public void configure()    CamelContext context = new DefaultCamelContext();    restConfiguration()...   rest("/api/")...   from("direct:remoteService")...   >   > 

В этом классе мы переопределяем метод configure() из класса Camel RouteBuilder .

Верблюду всегда нужен экземпляр CamelContext — основной компонент, в котором хранятся входящие и исходящие сообщения.

В этом простом примере достаточно DefaultCamelContext , так как он просто связывает сообщения и маршрутизирует их, как служба REST, которую мы собираемся создать.

6.1. Маршрут restConfiguration( )​

Затем мы создаем объявление REST для конечных точек, которые мы планируем создать в методе restConfiguration() :

 restConfiguration()   .contextPath(contextPath)   .port(serverPort)   .enableCORS(true)   .apiContextPath("/api-doc")   .apiProperty("api.title", "Test REST API")   .apiProperty("api.version", "v1")   .apiContextRouteId("doc-api")   .component("servlet")   .bindingMode(RestBindingMode.json) 

Здесь мы регистрируем контекстный путь с нашим внедренным атрибутом из файла YAML. Та же логика была применена к порту нашего приложения. CORS включен, что позволяет использовать эту веб-службу на нескольких сайтах. Режим привязки разрешает и преобразует аргументы в наш API.

Затем мы добавляем документацию Swagger к URI, заголовку и версии, которые мы ранее установили. По мере создания методов/конечных точек для нашей веб-службы REST документация Swagger будет автоматически обновляться.

Этот контекст Swagger сам по себе является маршрутом Camel, и мы можем увидеть некоторую техническую информацию о нем в журнале сервера во время процесса запуска. Наш пример документации по умолчанию находится по адресу http://localhost:8080/camel/api-doc.

6.2. Остальные () Маршрут​

Теперь давайте реализуем вызов метода rest() из метода configure() , указанного выше:

 rest("/api/")   .id("api-route")   .consumes("application/json")   .post("/bean")   .bindingMode(RestBindingMode.json_xml)   .type(MyBean.class)   .to("direct:remoteService"); 

Этот метод довольно прост для тех, кто знаком с API. Идентификатор — это идентификация маршрута внутри CamelContext . Следующая строка определяет тип MIME. Режим привязки определен здесь, чтобы показать, что мы можем установить режим в restConfiguration() .

Метод post() добавляет в API операцию, генерирующую конечную точку « POST/bean », а MyBean (обычный Java-бин с целочисленным идентификатором и строковым именем ) определяет ожидаемые параметры.

Точно так же действия HTTP, такие как GET, PUT и DELETE, также доступны в форме get() , put() , delete() .

Наконец, метод to() создает мост к другому маршруту. Здесь он говорит Camel искать внутри своего контекста/движка другой маршрут, который мы собираемся создать, названный и обнаруженный по значению/идентификатору « direct: … », совпадающий с маршрутом, определенным в методе from() .

6.3. Маршрут from() с функцией transform() ​

При работе с Camel маршрут получает параметры, а затем конвертирует, преобразовывает и обрабатывает эти параметры. После этого он отправляет эти параметры на другой маршрут, который перенаправляет результат на желаемый выход (файл, базу данных, SMTP-сервер или ответ REST API).

В этой статье мы создаем еще один маршрут только внутри метода configure() , который мы переопределяем. Это будет маршрут назначения для нашего последнего маршрута to() :

 from("direct:remoteService")   .routeId("direct-route")   .tracing()   .log(">>> $")   .log(">>> $")   .transform().simple("Hello $")   .setHeader(Exchange.HTTP_RESPONSE_CODE, constant(200)); 

Метод from() следует тем же принципам и имеет многие из тех же методов, что и метод rest() , за исключением того, что он использует контекстные сообщения Camel. Это причина для параметра « direct-route », который создает ссылку на вышеупомянутый метод rest().to() .

Доступны многие другие преобразования , в том числе извлечение в виде примитивов (или объектов) Java и их отправка на уровень сохраняемости. Обратите внимание, что маршруты всегда считываются из входящих сообщений, поэтому связанные маршруты будут игнорировать исходящие сообщения.

Наш пример готов, и мы можем попробовать его:

• Запустите команду приглашения: mvn spring-boot:run
• Сделайте POST-запрос к http://localhost:8080/camel/api/bean с параметрами заголовка: Content-Type: application/json и полезной нагрузкой
• Мы должны получить код возврата 201 и ответ: Hello, World

6.4. ПРОСТОЙ язык сценариев​

В этом примере журнал выводится с использованием метода tracing() . Обратите внимание, что мы использовали заполнители $<> ; они являются частью языка сценариев, который принадлежит Camel и называется SIMPLE. Он применяется к сообщениям, которыми обмениваются по маршруту, например к телу входящего сообщения.

В нашем примере мы используем SIMPLE для вывода в журнал атрибутов компонента, которые находятся внутри тела сообщения Camel.

Мы также можем использовать его для выполнения простых преобразований, как было показано с помощью метода transform() .

6.5. Маршрут from() с помощью process() ​

Давайте сделаем что-нибудь более осмысленное, например, вызовем сервисный уровень для возврата обработанных данных. SIMPLE не предназначен для тяжелой обработки данных, поэтому давайте заменим transform( ) методом process() :

 from("direct:remoteService")   .routeId("direct-route")   .tracing()   .log(">>> $")   .log(">>> $")   .process(new Processor()    @Override   public void process(Exchange exchange) throws Exception    MyBean bodyIn = (MyBean) exchange.getIn().getBody();   ExampleServices.example(bodyIn);   exchange.getIn().setBody(bodyIn);   >   >)   .setHeader(Exchange.HTTP_RESPONSE_CODE, constant(200)); 

Это позволяет нам извлекать данные в bean-компонент, тот же самый, который ранее был определен в методе type() , и обрабатывать его на нашем уровне ExampleServices .

Поскольку ранее мы установили для bindingMode() значение JSON, ответ уже имеет правильный формат JSON, сгенерированный на основе нашего POJO. Это означает, что для класса ExampleServices :

 public class ExampleServices    public static void example(MyBean bodyIn)    bodyIn.setName( "Hello, " + bodyIn.getName() );   bodyIn.setId(bodyIn.getId() * 10);   >   > 

Тот же HTTP-запрос теперь возвращается с кодом ответа 201 и телом: .

7. Заключение​

С помощью нескольких строк кода нам удалось создать относительно законченное приложение. Все зависимости создаются, управляются и запускаются автоматически с помощью одной команды. Более того, мы можем создавать API, связывающие воедино все виды технологий.

Этот подход также очень удобен для контейнеров, что приводит к очень простой серверной среде, которую можно легко реплицировать по запросу. Дополнительные возможности конфигурации можно легко включить в файл конфигурации шаблона контейнера.

Этот пример REST можно найти на GitHub .

Наконец, помимо API-интерфейсов filter() , process() , transform() и marshall() , в Camel доступно множество других шаблонов интеграции и манипуляций с данными:

• Шаблоны интеграции Camel
• Верблюд Руководство пользователя
• Верблюд ПРОСТОЙ Язык

What is Camel?

Apache Camel ™ is a versatile open-source integration framework based on known Enterprise Integration Patterns.

Camel empowers you to define routing and mediation rules in a variety of domain-specific languages (DSL, such as Java, XML, Groovy, Kotlin, and YAML). This means you get smart completion of routing rules in your IDE, whether in a Java or XML editor.

Apache Camel uses URIs to work directly with any kind of transport or messaging model such as HTTP, Kafka, JMS, JBI, SCA, MINA or CXF, as well as pluggable Components and Data Format options. Apache Camel is a small library with minimal dependencies for easy embedding in any Java application. Apache Camel lets you work with the same API regardless which kind of transport is used — so learn the API once and you can interact with all the Components provided out-of-box.

Apache Camel provides support for Bean Binding and seamless integration with popular frameworks such as Spring. Camel also has extensive support for unit testing your routes.

The following projects can leverage Apache Camel as a routing and mediation engine:

• Apache ServiceMix — a popular distributed open source ESB and JBI container
• Apache ActiveMQ — a mature, widely used open source message broker
• Apache CXF — a smart web services suite (JAX-WS and JAX-RS)
• Apache Karaf — a small OSGi based runtime in which applications can be deployed
• Apache MINA — a high-performance NIO-driven networking framework

So don’t get the hump — try Camel today! 🙂

Too many buzzwords — what exactly is Camel?

Okay, so the description above is technology focused. There’s a great discussion about Camel at Stack Overflow. We suggest you view the post, read the comments, and browse the suggested links for more details.

Overview ＋ Blog Documentation Community Download Documentation ＋ User Manual Components Camel-K Camel Kafka Connector Camel Quarkus Camel Spring Boot Camel Karaf FAQ Community ＋ Support Contributing Mailing Lists User stories Articles Books Team About ＋ Acknowledgments Apache Events License Security Sponsorship Thanks

© 2004-2024 The Apache Software Foundation.
Apache Camel, Camel, Apache, the Apache feather logo, and the Apache Camel project logo are trademarks of The Apache Software Foundation. All other marks mentioned may be trademarks or registered trademarks of their respective owners.