Apache camel что это

Apache Camel и Spring Boot

В этой статье рассмотрена интеграция Apache Camel со средой Spring Boot.

1. Введение

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

Но прежде чем обратиться к примеру со средой Spring Boot, разберемся с основными понятиями и терминами Camel.

1.1. Сообщение

Сообщение (message) — это объект данных, используемый системами для обмена информацией друг с другом.

1.2. Обмен

Объект обмена (exchange) — это контейнер, вмещающий сообщение и обеспечивающий взаимодействие между системами. Это контейнер сообщений, определяющий тип обмена сообщениями.

1.3. Контекст Camel

Контекст Camel (CamelContext) — это фундаментальная модель Camel, предоставляющая доступ к различным службам (маршрутам, конечным точкам и др.).

1.4. Маршруты

Маршруты (routes) — это абстракция, позволяющая клиентам и серверам работать независимо. Маршруты, описываемые на доменных языках DSL, представляют собой цепочку вызовов функций (процессоров).

1.5. Предметно-ориентированный язык

Процессоры и конечные точки соединяются друг с другом посредством описания на предметно-ориентированном языке (Domain-Specific Language, DSL) — такие описания и составляют маршруты. В нашем случае язык DSL — это Java Fluent API, но при использовании Camel с другими языками/фреймворками это может быть также XML или какой-то другой язык DSL.

1.6. Процессор

Процессоры (processor) выполняют операции обмена. Маршруты можно представить в качестве логического модуля, который соединяет процессоры, нужные для обработки сообщения.

1.7. Компонент

Компоненты (component) — это модули расширения Apache Camel. Именно они позволяют Camel легко обеспечивать интеграцию с другими системами. Здесь перечислены все основные компоненты, поддерживаемые Camel. Компоненты производят конечные точки с заданным универсальным кодом ресурса (URI).

1.8. Конечная точка

Конечные точки (endpoint) — это точки подключения служб, соединяющих одни системы с другими. Мы создаем конечные точки с помощью компонентов, используя определенный универсальный код ресурса (URI). Например, чтобы создать подключение FTP, в маршруте следует указать следующий URI: ftp://[имяпользователя@]имяхоста[:порт]/директория[?опции] — так компоненты будут создавать конечную точку FTP с заданной конфигурацией.

1.9. Производитель

Производители (producer) — это модули Camel, которые создают сообщения и отправляют их в конечную точку.

1.10. Потребитель

Потребители (consumer) — это модули Camel, которые получают сообщения, созданные производителем, инкапсулируют их внутри объекта exchange и отправляют процессорам.

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

2. Общие сведения о приложении

Мы создадим приложение со следующими свойствами:

• приложение включает объекты данных двух типов: продукты и скидки;
• продукты мы добавляем при начальной настройке;
• скидки автоматически применяются к продуктам по истечении определенного времени (Camel Timer + Camel JPA);
• имеется конечная точка REST для перечисления всех продуктов и скидок (Camel REST);
• используется документация Swagger (Camel Swagger).

Для этого мы используем H2, Spring Web, Spring JPA и Apache Camel.

3. Начальная настройка приложения

Создайте проект сборки кода со следующими зависимостями. Чтобы подготовить основу для приложения, можно использовать IDE или Spring Initializr. Ниже приведен полный файл pom.xml с пояснениями:

  4.0.0  org.apache.camel camel-dependencies 3.3.0  spring-boot-camel spring-boot-camel Spring Boot Camel integration tutorial 2.2.7.RELEASE dev     org.springframework.boot spring-boot-dependencies $ pom import   org.apache.camel.springboot camel-spring-boot-dependencies $ pom import      org.springframework.boot spring-boot-starter-web  org.springframework.boot spring-boot-starter-data-jpa   org.apache.camel.springboot camel-spring-boot-starter  org.apache.camel.springboot camel-servlet-starter  org.apache.camel.springboot camel-jackson-starter  org.apache.camel.springboot camel-swagger-java-starter  org.apache.camel.springboot camel-jpa-starter   com.h2database h2 runtime   org.springframework.boot spring-boot-starter-test test     org.springframework.boot spring-boot-maven-plugin $   repackage       

4. Подготовка объектов данных

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

4.1. Продукт

Создайте объект данных типа «продукт» со следующими полями: идентификатор, имя, цена и скидка. Также мы создадим именованный запрос, который можно вызвать из Camel по имени и получить в ответ результат. Именованный запрос «продукты со скидкой» возвращает все продукты, для которых назначена скидка.

@Entity @Table(name = "products") @NamedQuery(name = "discounted-products", query = "select product from Product product where product.discounted IS NOT NULL") public class Product < @Id @GeneratedValue private int id; private String name; private Integer price; private Integer discounted; // Getters and setters >

Создайте класс ProductRepository, который расширяется из интерфейса CrudRepository репозитория Spring Data. Такое расширение предоставляет в наше распоряжение готовые к вызову запросы: findAll, findById, save и т. д.

public interface ProductRepository extends CrudRepository

4.2. Класс службы

Создайте класс ProductService и снабдите его аннотацией службы (service). Чтобы извлечь ProductRepository из контекста Spring, прибегнем к внедрению зависимости через конструктор. Мы предоставляем основные функции findById , findAll и save , которые не нуждаются в пояснениях.

@Service public class ProductService < private final ProductRepository products; @Autowired public ProductService(ProductRepository products) < this.products = products; >public Product findById(Integer id) < Optional < Product >product = products.findById(id); if (!product.isPresent()) < throw new IllegalStateException("Product could not found for given id:" + id); >return product.get(); > public Iterable < Product >findAll() < return products.findAll(); >public void save(Product product) < products.save(product); >>

Наконец, создайте файл data.sql в src/main/resources и добавьте три продукта, как показано ниже. При запуске Spring автоматически выполнит data.sql . Подробнее о сценариях инициализации можно прочесть здесь.

INSERT INTO products (id, name, price, discounted) VALUES (1, 'Book', 25, NULL), (2, 'Watch', 100, NULL), (3, 'Shoes', 40, NULL);

4.3. Скидка

Создайте объект данных типа «скидка» со следующими полями: идентификатор, величина и продукт. Одномоментно к продукту может применяться только одна скидка, поэтому задайте для поля «продукт» отношение OneToOne.

@Entity @Table(name = "discounts") public class Discount < @Id @GeneratedValue private int id; private Integer amount; @OneToOne private Product product; // Getters and setters >

Создайте репозиторий DiscountRepository, как описано выше.

public interface DiscountRepository extends CrudRepository <>

Создайте класс DiscountService аналогично классу ProductService. Наряду с методом findDiscount , который работает аналогично методу findProduct , у нас есть также функция makeDiscount . Эта функция создает случайную скидку, извлекает из базы данных случайный продукт и применяет эту скидку к такому продукту.

@Service public class DiscountService < private final DiscountRepository discounts; private final ProductService productService; private final Random random = new Random(); @Autowired public DiscountService(DiscountRepository discounts, ProductService productService) < this.discounts = discounts; this.productService = productService; >public Discount makeDiscount() < // create a discount Discount discount = new Discount(); int discountRate = this.random.nextInt(100); discount.setAmount(discountRate); // select random product int productId = this.random.nextInt(3) + 1; Product product = productService.findById(productId); // set the discount to product and save int discountedPrice = product.getPrice() - (discountRate * product.getPrice() / 100); product.setDiscounted(discountedPrice); productService.save(product); discount.setProduct(product); return discount; >public Discount findDiscount(Integer id) < Optional < Discount >discount = discounts.findById(id); if (!discount.isPresent()) < throw new IllegalStateException("Discount could not found for given id:" + id); >return discount.get(); > >

5. Настройка приложения

Создайте application-dev.yml , чтобы настроить сопоставление contextPath для Camel. Добавьте нужные свойства скидок, которые будут использоваться в маршрутах.

camel: component: servlet: mapping: contextPath: /javadevjournal/* discount: newDiscountPeriod: 2000 listDiscountPeriod: 6000/pre>

6. Интеграция Apache Camel

Итак, мы подготовили данные для использования с Apache Camel. Можно приступать к интеграции.

6.1. Создание маршрутов

В Camel имеется базовый класс для создания маршрутов: RouteBuilder. Нам нужно его расширить и снабдить аннотацией @Component . Как уже говорилось выше, Apache Camel использует для создания ссылок на объекты собственный контекст. Однако при работе со SpringBoot сначала Camel выполняет поиск в контексте SpringBoot, а затем внедряет найденные в нем объекты в свой контекст CamelContext , как делает RouteBuilder в нашем примере.

После создания нашего класса маршрутов путем расширения из RouteBuilder необходимо переопределить его метод конфигурирования. Нам нужна логика, которая будет автоматически создавать скидки по истечении заданного периода. Сначала добавим к функции конфигурирования следующий маршрут с пояснением:

@Component class TimedJobs extends RouteBuilder < @Override public void configure() < from("timer:new-discount?delay=1000&period=>") .routeId("make-discount") .bean("discountService", "makeDiscount") .to("jpa:org.apache.camel.example.spring.boot.rest.jpa.Discount") .log("Created %$ discount for $"); // additional route will be added in the next step >

Опишем нашу работу со Spring Boot в терминологии Camel. Мы создаем маршруты, используя язык Java DSL. Затем мы используем таймер — компонент timer, предоставляемый Camel путем расширения. «Внутри» Camel при этом происходит следующее: при достижении конечной точки таймера (исходя из заданных нами настроек задержки и периода выполнения) запускается производитель.

Прежде чем идти дальше, стоит упомянуть, что Apache Camel поддерживает использование свойств Spring Boot, что мы здесь и делаем. Вы можете ссылаться на такие свойства напрямую, используя имя свойства и значение по умолчанию: > .

Теперь определим маршрут make-discount, который должен быть уникальным и на который мы будем ссылаться в дальнейшем. И вызовем функцию makeDiscount в bean-компоненте discountService. Для сообщения выполняется обмен, на который можно сослаться с помощью префикса к основному тексту, и средство ведения журнала потребляет это сообщение, записывая в журнал. Полный список выражений, которые вы можете использовать, приведен в документации по языку Simple. Добавим под имеющимся маршрутом еще один, позволяющий перечислить все продукты с обновленными ценами.

from("jpa:org.apache.camel.example.spring.boot.rest.jpa.Product" + "?namedQuery=discounted-products" + "&delay=>" + "&consumeDelete=false") .routeId("list-discounted-products") .log( "Discounted product $. Price dropped from $ to $");

Мы используем компонент JPA для объекта данных «продукт», вызывая его командой namedQuery . В настройках JPA мы определяем задержку, чтобы программа успела создать какие-то скидки, прежде чем будет сгенерирован список продуктов. Запрос consumeDelete означает, что мы не хотим удалять обработанный объект данных «продукт». Полный список возможных настроек представлен на странице компонента JPA. Вот так выглядят журналы нашего задания:

Created %27 discount for Watch Created %84 discount for Book Created %92 discount for Shoes Discounted product Book. Price dropped from 25 to 4 Discounted product Watch. Price dropped from 100 to 73 Discounted product Shoes. Price dropped from 40 to 4

6.2. Создание конечных точек REST

Мы уже настроили таймер для запуска функций. Теперь выполним интеграцию с конечными точками REST и создадим документацию Swagger. Создадим новый маршрут путем расширения RouteBuilder . Для настройки нашего приложения необходимо вызвать функцию Camel restConfiguration .

@Component class RestApi extends RouteBuilder < @Override public void configure() < restConfiguration() .contextPath("/javadevjournal") .apiContextPath("/api-doc") .apiProperty("api.title", "JAVA DEV JOURNAL REST API") .apiProperty("api.version", "1.0") .apiProperty("cors", "true") .apiContextRouteId("doc-api") .port(env.getProperty("server.port", "8080")) .bindingMode(RestBindingMode.json); rest("/products").description("Details of products") .get("/").description("List of all products") .route().routeId("products-api") .bean(ProductService.class, "findAll") .endRest() .get("discounts/").description("Discount of a product") .route().routeId("discount-api") .bean(DiscountService.class, "findDiscount($)"); > >

Указываем путь contextPath — javadevjournal — и контекст-путь API — api-doc , который используется для Swagger. По умолчанию режим привязки отключен. Поскольку мы добавили Jackson JSON в файл pom.xml, можно использовать формат привязки JSON. Здесь приведен полный список возможных конфигураций. Во второй части нашей конфигурации определяем конечную точку /products и возвращаемый результат ProductService.findAll. Расширяем конечную точку /products , добавляя к ней /discounts/ , и вызываем функцию DiscountService.findDiscount с идентификатором id, полученным в ответ на запрос. относится к входящим данным, которые упоминались выше в разделе о языке Simple, для заполнителя .

Перейдя по адресу http://localhost:8080/javadevjournal/api-doc , вы получите ответ Swagger. Введите http://localhost:8080/javadevjournal/products , и вы получите:

Аналогичным образом, перейдя по ссылке http://localhost:8080/javadevjournal/products/discounts/1 , вы получите:

Резюме

В этой статье мы рассмотрели, как интегрировать Apache Camel со Spring Boot. Мы кратко описали, что представляет из себя Apache Camel и как его можно интегрировать со Spring Boot на примере реалистичных сценариев. Исходный код приложения доступен на Github.

14 мая пройдет demo day курса — это отличная возможность задать все вопросы по курсу, узнать подробнее о программе курса, особенностях онлайн-формата, навыках, компетенциях и перспективах, которые ждут выпускников после обучения.

Введение в 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

Apache Camel — открытый кроссплатформенный java-фреймворк, который позволяет проводить интеграцию приложений в простой и понятной форме. Идеологически основан на Шаблонах Интеграции Корпоративных Приложений.

• Гибкая маршрутизация сообщений
• Более 70-ти различных компонентов для доступа к данным
• Не навязывается канонический формат данных на сообщения
• Маршруты описываются на Java DSL, XML DSL, Scala DSL
• Использование POJO-объектов возможно для любых целей, например для трансформации сообщений
• Минимальные требования к конфигурации
• Автоматическая конвертация сообщений между различными форматами
• Легко может быть встроен в существующие приложения
• В составе идут инструменты для тестирования готового интеграционного решения
• Готов к размещению в OSGi-окружении

Пример маршрута, записанного с помощью Java DSL

from("file:src/data?noop=true"). choice(). when(xpath("/person/city = 'London'")).to("file:target/messages/uk"). otherwise().to("file:target/messages/others");

Ссылки

• Официальный сайт
• Поддерживаемые компоненты и протоколы

Apache Commons	BCEL • BSF • JCS
Apache Lucene	Lucene Java • Lucene4c • Lucy• Solr
Apache DB	Derby • Torque • DdlUtils • OJB • JDO

• Программное обеспечение по алфавиту
• Java Enterprise Edition
• Проекты Apache
• Свободное программное обеспечение, написанное на Java

Wikimedia Foundation . 2010 .

• AnyDATA
• Apache JServ Protocol

Полезное

Смотреть что такое «Apache Camel» в других словарях:

• Apache Camel — Maintainer Apache Software Foundation Aktuelle Version 2.8.1[1] (16. September 2011) … Deutsch Wikipedia
• Apache Camel — est un moteur de routage et de médiation de messages prenant en compte un grand nombre de protocoles et de transports standards, et s appuyant sur des règles pour déterminer l acheminement de ces messages. L implémentation d Apache Camel est… … Wikipédia en Français
• Apache Camel — Infobox Software name = Apache Camel caption = developer = Apache Software Foundation latest release version = 1.4.0 latest release date = July 22, 2008 latest preview version = latest preview date = operating system = Cross platform programming… … Wikipedia
• Apache CXF — Developer(s) Apache Software Foundation Stable release 2.4.3 / October 12, 2011; 24 days ago (2011 10 12) Development status Active … Wikipedia
• Apache ServiceMix — Тип Сервисная шина предприятия Разработчик Apache Software Foundation Написана на Java Операционная система Кроссплатформенное ПО Последняя версия 4.4.1 (22 февраля 2012) Лицензия … Википедия
• Apache ActiveMQ — Тип Java Message Service Message Oriented … Википедия
• Camel (disambiguation) — Camels are a species of even toed ungulates within the genus Camelus .Camel may also refer to: * Camel (band), an English progressive rock band ** Camel (album), their debut album *CamelCase, lettering scheme * Camel (cigarette), an American… … Wikipedia
• Apache CXF — Entwickler Apache Software Foundation Aktuelle Version 2.4.0 (18. April 2011) Betriebssystem plattformübergreifend Programmier­sprache Java … Deutsch Wikipedia
• Apache MINA — Entwickler Apache Software Foundation Aktuelle Version 1.1.7 (19. April 2008) Aktuelle Vorabversion 2.0.0 RC1 (19. Oktober 2009) Betriebssystem plattformunabhängig … Deutsch Wikipedia
• Camel — (englisch für Kamel) ist: der Name einer britischen Rock Band, siehe Camel (Band) der Name einer US amerikanischen Zigarettenmarke, siehe Camel (Zigarettenmarke) der Spitzname eines Flugzeugs aus dem ersten Weltkrieg, siehe Sopwith F.1 Camel… … Deutsch Wikipedia

• Обратная связь: Техподдержка, Реклама на сайте

• �� Путешествия

Экспорт словарей на сайты, сделанные на PHP,
WordPress, MODx.

• Пометить текст и поделитьсяИскать в этом же словареИскать синонимы
• Искать во всех словарях
• Искать в переводах
• Искать в ИнтернетеИскать в этой же категории

Camel в вопросах и ответах

6-7 апреля в Москве в шестой раз пройдет JPoint – международная Java-конференция для опытных разработчиков. В этот раз в ней примет участие Клаус Ибсен (Claus Ibsen) – старший инженер Red Hat, гуру Apache. Ниже приводим перевод начала его книги «Camel in Action» – эксклюзивно для читателей нашего блога.

Знакомство c Camel

Создавать комплексные системы с чистого листа – дело затратное и почти всегда обреченное на провал. Гораздо эффективнее и безопаснее собирать их как паззл из уже имеющихся и проверенных компонентов. В повседневной жизни мы часто полагаемся на такие интегрированные системы: от телефонной связи и финансовых транзакций до медицинских услуг и планирования поездок и развлечений.

Паззл можно собрать, только если у вас есть все его фрагменты, и они легко и надежно соединяются друг с другом. То же верно и для проектов по интеграции систем. Но если кусочки настоящего паззла созданы для того, чтобы сложиться в единую картинку, то с ИТ-системами дело обстоит, как правило, наоборот. Как разработчика, вас, как правило, не очень волнует внутреннее устройство и работа интегрируемых систем, вам гораздо интереснее, как взаимодействовать с ним извне. Хороший фреймворк (платформа) интеграции предполагает две вещи: во-первых, простой и удобный аппарат абстракций для описания сложных интегрируемых систем, а во-вторых, связующий механизм, позволяющий объединить их в единое целое.

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

Готовы? Тогда встречайте Camel.

Представляем Camel

Camel – это платформа интеграции приложений, созданная для того, чтобы работать продуктивно и с удовольствием. История Camel началась в 2007 году, и сегодня это зрелый проект с открытым кодом, который распространяется по лицензии Apache 2 и вокруг которого сложилось мощное сообщество разработки.

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

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

Что такое Camel

Ядром платформы Camel является механизм маршрутизации, точнее говоря, компоновщик механизмов маршрутизации. С помощью компоновщика вы можете задавать собственные правила маршрутизации, решать, из каких источников принимать сообщения, и определять, как обрабатывать и отправлять эти сообщения дальше. Интеграционный язык Camel позволяет задавать сложные правила маршрутизации, близкие к бизнес-процессам. Как показано на Рис. 1.1, Camel – это связующее звено между не связанными друг с другом системами.

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

Рис. 1.1 Camel – это связующее звено между не связанными друг с другом системами.

Благодаря абстракциям высокого уровня Camel позволяет применять одни и те же API для взаимодействия с разными системами, использующими разные протоколы и типы данных. API для конкретных протоколов и типов данных реализуются в виде соответствующих компонентов. По умолчанию, Camel поддерживает более 280 протоколов и типов данных, и благодаря расширяемой модульной архитектуре позволяет самостоятельно реализовать поддержку необходимых протоколов, как проприетарных, так и открытых. Это избавляет от ненужного преобразования данных и делает Camel не только более быстрым, но и менее прожорливым. Как следствие, Camel отлично подходит для встраивания в проекты, где требуются развитые возможности обработки. В частности, Camel уже используются для задач интеграции в таких проектах с открытым кодом, как Apache ServiceMix, Karaf и ActiveMQ.

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

Если при упоминании ESB вам сразу же приходят на ум сложные монструозные системы, то спешим успокоить: Camel с тем же успехом можно применять и в совсем маленьких вещах, наподобие микросервисов или шлюзов IoT (интернета вещей).

Чтобы понять, чем же является Camel, рассмотрим его основные функции.

Зачем использовать Camel

Camel – это практическое воплощение новых идей в области интеграции. Далее мы подробно рассмотрим возможности Camel, а пока что перечислим их:

• Механизм посредничества и маршрутизации
• Расширяемая библиотека компонентов
• Шаблоны интеграции корпоративных приложений (EIP)
• Предметно-ориентированный язык (DSL)
• Маршрутизатор, не зависящий от формата полезной нагрузки
• Архитектура на основе подключаемых модулей
• Модель Plain Old Java Object (POJO)
• Простота конфигурирования
• Автоматические конверторы типов
• Легковесное ядро, пригодное для встраивания в микросервисы
• Поддержка облачных технологий
• Пакет средств тестирования
• Активное сообщество разработки

Механизм посредничества и маршрутизации

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

Расширяемая библиотека компонентов

Camel имеет обширную библиотеку из более чем 280 компонентов, позволяющих ему подключаться через разнообразные транспорты, использовать различные API и понимать разные форматы данных. На Рис. 1.2. вы наверняка найдете технологии, которые уже использовали или хотели бы использовать. Разумеется, в рамках этой книги невозможно рассмотреть все компоненты Camel, но два десятка основных из них мы все же обсудим.

Рис. 1.2 Возможность подключиться к чему угодно: Camel поддерживает более 280 транспортов, API и форматов данных.

Шаблоны интеграции корпоративных приложений (EIP)

При всем разнообразии проблем интеграции многие из них, как заметили Грегор Хоп (Gregor Hohpe) и Бобби Вульф (Bobby Woolf), имеют сходные решения. Эти двое выпустили книгу «Enterprise Integration Patterns» (переведена на русский – «Шаблоны интеграции корпоративных приложений»), которую должен прочесть каждый, кто считает себя специалистом в области интеграции приложений. Кроме того, эта книга поможет вам гораздо быстрее и легче понять концепции Camel.

Шаблоны интеграции (EIP) полезны не только тем, что предлагают проверенные решения для тех или иных проблем интеграции, но также и потому, что упрощают описание и представление самих этих проблем, предоставляя соответствующую семантику. Camel в значительной степени основан на шаблонах EIP. Однако, хотя шаблоны EIP и описывают проблемы и решения, а также предоставляют общий словарь, этот словарь не формализован. Camel устраняет этот пробел, предоставляя язык для описания интеграционных решений. Между шаблонами, описанными в книге «Enterprise Integration Patterns», и предметным языком CamelDSL имеется почти взаимно однозначное соотношение.

Предметно-ориентированный язык (DSL)

На момент появления Camel его главным вкладом в дело интеграции стал предметно-ориентированный язык (DSL). Со временем этому примеру последовали и другие интеграционные фреймворки, и теперь DSL есть в Java, XML и других языках программирования. DSL позволяет разработчику сфокусироваться на задачах интеграции, не отвлекаясь на особенности используемого инструмента (языка программирования). Рассмотрим парочку примеров DSL, которые используют разные форматы, но полностью эквивалентны по функциональности:

1 from("file:data/inbox").to("jms:queue:order"); 

1 2 3 4 

Это реальный код, и по нему видно, насколько просто отправить файл из нужной папки в очередь JMS (Java Message Service). Поскольку в основе DSL лежит популярный язык программирования, разработчику по-прежнему доступны привычные и удобные инструменты IDE-среды, наподобие автозавершения при вводе или обнаружения ошибок компилятора, как показано на Рис. 1.3.

Рис. 1.3 DSL-языки Camel построены на основе популярных языков программирования вроде Java, поэтому вам доступны удобные и привычные функции IDE-среды.

На рисунке показано, как функция автозавершения при вводе в Eclipse IDE предлагает список возможных DSL-выражений.

Маршрутизатор, не зависящий от формата полезной нагрузки

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

Архитектура на основе подключаемых модулей

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

Модель POJO

Bean-компоненты Java (или Plain Old Java Objects, POJO) в Camel являются гражданами первого сорта, поэтому в интеграционных проектах их можно использовать почти где угодно и когда угодно. Во многих случаях вы даже можете расширить встроенную функциональность Camel с помощью своего кода.

Простота конфигурирования

Конфигурирование в Camel сведено к минимуму везде, где только можно. Чтобы задавать конечные точки непосредственно в маршрутах, используется простая и понятная конфигурация URI.

Например, вы можете настроить маршрут Camel, который будет начинаться от файловой конечной точки и рекурсивно сканировать вложенные папки на предмет файлов .txt, всего лишь написав следующее:

1 from("file:data/inbox?recursive=true&include=.*txt$"). 

Автоматические конверторы типов

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

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

Легковесное ядро, пригодное для встраивания в микросервисы

Ядро Camel действительно весит совсем немного: размер библиотеки составляет около 4,9 МБ, еще около 1,3 МБ занимают runtime-зависимости. Поэтому Camel легко встраивается куда угодно и развертывается где угодно, включая автономные приложения, микросервисы, веб-приложения, приложения Spring, приложения Java EE, OSGi, Spring Boot, WildFly, а также облачные платформы, такие как AWS, Kubernetes или Cloud Foundry. Camel изначально создавался не как серверная система или решение ESB, а как то, что можно встраивать в любые исполняемые вещи, где есть Java.

Поддержка облачных технологий

Camel не только ориентирован на облачное использование, но и предлагает множество компонентов для подключения к облачным сервисам, таким как:

• Amazon DynamoDB, EC2, Kinesis, SimpleDB, SES, SNS, SQS, SWF и S3
• Braintree (PayPal, Apple, Android Pay, и т. п.)
• Dropbox
• Facebook
• GitHub
• Google Big Query, Calendar, Drive, Mail и Pub Sub
• HipChat
• LinkedIn
• Salesforce
• Twitter
• и многим другим

Пакет средств тестирования

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

Активное сообщество разработки

У проекта Camel активное и деятельное сообщество, которое на момент написания этой книги живет и развивается уже более 10 лет. Наличие такого сообщества – это важный фактор при выборе ПО с открытым кодом для построения собственных приложений. Если проект неактивен, вы вряд ли можете рассчитывать на поддержку сообщества и остаетесь со своими проблемами один на один. И наоборот, участники активного проекта, такого как Camel, причем, как разработчики, так и простые пользователи, всегда готовы прийти на помощь.

Теперь, когда мы вкратце рассмотрели основные особенности Camel, пора перейти к практике: получить его дистрибутив и рассмотреть несколько примеров.

Приступая к работе

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

Начнем с дистрибутива.

Загрузка и установки Camel

Camel доступен на сайте проекта Apache Camel. Там вы найдете список всех версий и ссылки для загрузки последнего релиза Camel.

В этой книге мы используем Camel 2.20.1. Чтобы получить эту версию, воспользуйтесь соответствующей ссылкой на странице загрузки. В конце этой страницы есть ссылки на два дистрибутива: zip-файл для Windows и tar.gz для macOS/Linux. Загрузите нужный файл и распакуйте его на локальный диск.

Откройте консоль и перейдите в папку, куда вы распаковали дистрибутив Camel. В ней будут следующие файлы:

1 [janstey@ghost apache-camel-2.20.1]$ ls 2 doc examples lib LICENSE.txt NOTICE.txt README.txt

Как видите, дистрибутив имеет простую и понятную структуру, а именно:

• doc – папка с руководством по Camel в формате HTML. Это просто копия сайта Camel на момент выпуска релиза. Она пригодится в те моменты, когда у вас нет доступа к сайту или нет под рукой этой книги
• examples – папка с 97 примерами Camel
• lib – папка со всеми библиотеками Camel. Позже мы покажем, как использовать Maven для простой загрузки зависимостей для компонентов, не входящих в ядро
• LICENSE.txt – файл с текстом лицензии на дистрибутив Camel. Поскольку это проект Apache, лицензия представляет собой Apache License, version 2.0
• NOTICE.txt – файл с информацией о авторских правах на сторонние зависимости, входящие в состав дистрибутива Camel
• README.txt – файл с кратким введением в Camel и перечнем ссылок, которые помогут новичкам быстро приступить к работе

Первый запуск Camel

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

Однако в этой книге мы вообще не будем использовать дистрибутив. Все приведенные здесь примеры исходного кода задействуют Apache Maven, который автоматически загружает все необходимые библиотеки Camel. Поэтому вам не нужно будет контролировать, чтобы они прописывались в classpath.

Все примеры кода из этой книги можно найти на сайте GitHub.

Первый пример, который мы рассмотрим – это такой «hello world» в реалиях интеграции, иначе говоря, это маршрутизация файлов. Допустим, надо прочитать файлы в одной папке (data/inbox), обработать их определенным образом и записать результаты в другую папку (data/outbox). Для простоты опустим обработку, и тогда задача сведется к копированию исходных файлов, как показано на Рис. 1.4.

Рис. 1.4 Маршрутизация файлов из папки data/inbox в папку data/outbox.

Проще некуда, верно? Вот как выглядит реализация этой задачи на «чистой» Java, без использования Camel.

Листинг 1.1 Маршрутизация файлов из одной папки в другую на «чистой» Java

1 import java.io.File; 2 import java.io.FileInputStream; 3 import java.io.FileOutputStream; 4 import java.io.IOException; 5 import java.io.OutputStream; 6 7 public class FileCopier < 8 9 public static void main(String args[]) throws Exception < 10 File inboxDirectory = new File("data/inbox"); 11 File outboxDirectory = new File("data/outbox"); 12 outboxDirectory.mkdir(); 13 File[] files = inboxDirectory.listFiles(); 14 for (File source : files) < 15 if (source.isFile()) < 16 File dest = new File( 17 outboxDirectory.getPath() 18 + File.separator 19 + source.getName()); 20 copyFile(source, dest); 21 >22 > 23 > 24 25 private static void copyFile(File source, File dest) 26 throws IOException < 27 OutputStream out = new FileOutputStream(dest); 28 byte[] buffer = new byte[(int) source.length()]; 29 FileInputStream in = new FileInputStream(source); 30 in.read(buffer); 31 try < 32 out.write(buffer); 33 >finally < 34 out.close(); 35 in.close(); 36 >37 > 38 > 

Казалось бы, совсем простая задача, но в FileCopier уже целых 37 строк кода. К тому же, пришлось использовать низкоуровневые файловые API, и – что важно – надо было не забыть правильно закрыть ресурсы. Теперь представим, что копировать из папки data/inbox надо только новые файлы. Тогда потребуется установить таймер и отслеживать, какие файлы уже были скопированы. Сложность растет прямо на глазах.

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

Листинг 1.2 Маршрутизация файлов из одной папки в другую на Apache Camel

1 import org.apache.camel.CamelContext; 2 import org.apache.camel.builder.RouteBuilder; 3 import org.apache.camel.impl.DefaultCamelContext; 4 5 public class FileCopierWithCamel < 6 7 public static void main(String args[]) throws Exception < 8 CamelContext context = new DefaultCamelContext(); 9 context.addRoutes(new RouteBuilder() < 10 public void configure() < 11 from("file:data/inbox?noop=true") 12 .to("file:data/outbox"); 13 >14 >); 15 context.start(); 16 Thread.sleep(10000); 17 context.stop(); 18 > 19 > 

Большинство кода в этом примере – шаблон. Любое приложение Camel использует CamelContext, который впоследствии запускается и затем останавливается. Мы также добавили метод sleep, чтобы дать приложению Camel время на копирование файлов. Главное, на что надо обратить внимание в листинге1.2 – маршрут.

Маршруты в Camel определяются в том же порядке, в каком они читаются. Например, маршрут из примера выше можно прочесть следующим образом: принять сообщения из файла (from file) в папке data/inbox с параметром noop и отправить в файл (to file) в папке data/outbox. Параметр noop означает, что исходные файлы надо оставить на месте, иначе Camel перенесет их. Большинство людей, которые никогда не сталкивались с Camel, вполне могут понять, что делает этот маршрут. Кроме того, обратите внимание, что если отбросить шаблонный код, то вся задача сводится к двум строкам кода на Java.

Для запуска этого примера потребуется загрузить и установить Apache Maven. После того, как он будет готов, откройте консоль и перейдите в папку chapter1/file-copy в каталоге с исходными текстами примеров из этой книги. В ней вы найдете:

• data – в этой папке есть папка inbox с единственным файлом message1.xml
• src – папка с исходным кодом примеров из этой главы
• pom.xml – файл с информацией для сборки примеров, а именно XML-файл Maven POM (Project Object Model)

При написании это книги использовался Maven 3.5.0. Другие версии Maven могут работать не совсем так, как здесь показано.

Содержимое файла POM приводится на листинге ниже.

Листинг 1.3 Файл Maven POM, необходимый для использования основной библиотеки Camel

1 5 4.0.0 6 7 com.camelinaction 8 chapter1 9 2.0.0 10 11 12 chapter1-file-copy 13 Camel in Action 2 :: Chapter 1 :: File Copy Example 14 15 16 17 org.apache.camel 18 camel-core 19 20 21 org.slf4j 22 slf4j-log4j12 23 24 25 

Maven – это отдельная большая тема, и здесь мы коснемся ее по самому минимуму лишь для того, чтобы вы могли работать с примерами.

POM-файл Maven на Листинге 1.3 – это, возможно, один из самых коротких POM-файлов в вашей жизни, поскольку в нем используются практически все настройки POM по умолчанию. Помимо них, некоторые настройки задаются в родительском (parent) POM. Пожалуй, самая важная часть здесь – это зависимость от библиотеки Camel. Используя этот POM, Maven делает следующее:

1. Создает search path на основе groupId, artifactId и version. Для элемента version задано свойство camel-version, определенное в POM, на который ссылается элемент parent, и равное в итоге 2.20.1. Тип зависимости не задан, поэтому считается, что это файл JAR. Search path таким образом превращается в org/apache/camel/camel-core/2.20.1/camel-core-2.20.1.jar.
2. Поскольку листинг 1.3 не содержит никаких указаний, где искать зависимости Camel, Maven ищет их в своем центральном репозитории по адресу.
3. Объединив search path и URL репозитория, Maven пытается загрузить файл.
4. JAR-файл сохраняется в локальный кэш Maven, который обычно находится в домашнем каталоге .m2/repository. В Linux/macOS это папка ~/.m2/repository, в Windows – C:\Users\[Username]\.m2\repository.
5. При запуске кода приложения из листинга 1.2 JAR-файл Camel добавляется в classpath.

1 mvn compile exec:java

В результате Maven скомпилирует исходник в каталоге src и выполнит класс FileCopierWithCamel с JAR-файлом camel-core в classpath.

Все примеры в этой книге рассчитаны на то, что вы подключены к интернету, поскольку Apache Maven будет активно загружать JAR-зависимости. Общий размер скачанных по итогам выполнения всех примеров из этой книги библиотек составит несколько сот мегабайт.

Запустите команду Maven из папки chapter1/file-copy и после ее завершения перейдите в папку data/outbox, чтобы убедиться, что файл скопировался. Поздравляем, вы только что выполнили свой первый пример. Да, он очень простой, но теперь вы знаете, как запускать почти все остальные примеры из этой книги.

• Блог компании Red Hat
• Open source
• Apache
• Читальный зал