JVM articles

Inheritance types in JPA

In the previous article about JPA we discovered how to create Java objects inheritance tree directly from a single database table with discriminator annotations. In this occasion we discovered also another interesting annotation, used to define inheritance type - @Inheritance.

Continue Reading β†’

Single table inheritance with discriminator in JPA

Sometimes database data can be simply reflected in Java objects. But in other situations, when for example one database table stores several types of Java objects, it can be more difficult. And for these situations JPA uses discriminators.

Continue Reading β†’

Different temporal types in JPA

Temporal information is very precious for all marketing purposes, as birthday e-mailing or several other reminders. JPA has specific annotation to handle this type - @Temporal.

Continue Reading β†’

Embeddable objects in JPA

In some situations @Entity annotation can be useless and we can still need to use Java objects as objects managed by JPA provider. In these cases we can use embeddable objects, representing by @Embedded and @Embeddable annotations.

Continue Reading β†’

Splitters and aggregators

With more and more data to send, enterprise integration applications can become less and less usable if code and architecture don't evolve. Beside these two key elements to improve growing system performances, Spring Integration provides another one, called messages splitting and aggregation.

Continue Reading β†’

Routing

Beside static-looking XML configuration, Spring Integration provides some dynamic mechanisms. One of them is routing which allows one message to be received by dynamically resolved message channel.

Continue Reading β†’

Transformers

In one from first articles about Spring Integration we discovered the idea of conversion service. However, it's not only one element which can change message from one format to another one. The second element is message transformer, in integration world known also as message translator.

Continue Reading β†’

Message handler chain, filters and header enricher

New concept described in this article will be chaining. Exactly as in another domain of life, chaining in Spring Integration allows to group together a set of elements. At this occasion we'll also discover some of elements which can be defined inside chains: filters and header enrichers.

Continue Reading β†’

Messages and message handlers

This time we'll cover more core concepts of Spring Integration: messages and another concept with 'message' in the name, message handlers..

Continue Reading β†’

Messaging gateways

Previously we sent Spring Integration messages through message channels called input channels. However, it's not the single solution for it.

Continue Reading β†’

Priority channel and message store

From previous articles we could deduce that Spring Integration was a pretty basic enterprise integration framework. However, in this article we'll discover some of its features proving that it hides a lot of advanced features: messages prioritization and messages persistence.

Continue Reading β†’

Channel adapters

In previous articles we discovered some alternative ways to send messages. Another alternative feature to do that are channel adapters, covered here.

Continue Reading β†’

Rendezvous channel and message channel interceptors

Until now we're working with non-blocking message channels. However, Spring Integration provides an implementation for blocking message channels too. In additionally, it defines also the hooks for message handling.

Continue Reading β†’

Queue channel

Until now we're working with channels able only to send the messages. This time we'll discover message channel which can both send and receive messages.

Continue Reading β†’

Publish-subscribe channels

We already know a little bit about message handlers and message channels. This time we'll discover specific message channel, called publish subscribe channel.

Continue Reading β†’

Barriers in Java concurrency

A barrier in the real world helps to separate two different concepts, for example two countries. In programming, it's a technique to achieve threads synchronization. Java implements its own version of barriers in java.util.concurrent package.

Continue Reading β†’

Google Guava: event bus

In two previous articles we discovered key concepts and concurrency features of Google Guava. Both of them simplify the programming. Another useful thing of this library is a message dispatching system called event bus.

Continue Reading β†’

Direct channel and service activator

As announced in the introduction to Spring Integration, we'll write a series of articles about features of this project. We'll begin here by explaining the ideas of direct channel and service activator.

Continue Reading β†’

Tests in Play Framework

Until now we were writing our store without tests, in the goal to quickly discover some of Play basic features. However, a code without tests is as a car without wheels. It will exist but will be driveless. The code without tests exists too, but it less evolutionary than the code well covered by the tests.

Continue Reading β†’

JPA implementation in Spring Data

In some of previous article we discovered how Hibernate and its JPA implementation work. We can use them as components for native-developed solutions. But we can also use them with Spring Framework.

Continue Reading β†’