Persistence on Micha Kops' Tech Notes

Java EE 7 Database Migrations with Liquibase and WildFly

Thu, 31 Jul 2014 00:00:00 +0200

I have written about other database migration frameworks before but in this article I’d like to cover the Liquibase framework in combination with WildFly as Java EE 7 compatible application server.

In the following tutorial, we’re going to write a full Java EE 7 book store application with a few steps and with Liquibase on board to create the database structure and insert example data into the database.

Thanks to the WildFly Maven Plug-in we even do not need to download and configure the application server but let Maven and the plug-in do the work for us.

Java Persistence API: Controlling the Second-Level-Cache

Mon, 21 Apr 2014 00:00:00 +0200

Using the Java Persistence API and a decent persistence provider allows us to configure and fine-tune when and how the second level cache is used in our application.

In the following short examples, we’re going to demonstrate those features written as JUnit test cases and running on a H2 in-memory database.

Figure 1. Persistence Unit Configuration

Setup

First of all we need some basic setup to run the following examples .. we need to select a JPA persistence provider and database, create a persistence-unit configuration and an environment to run tests on an in-memory database.

Creating elegant, typesafe Queries for JPA, mongoDB Morphia and Lucene using Querydsl

Thu, 13 Feb 2014 00:00:00 +0100

Querydsl is a framework that allows us to create elegant, type-safe queries for a variety of different data-sources like Java Persistence API (JPA) entities, Java Data Objects (JDO), mongoDB with Morphia, SQL, Hibernate Search up to Lucene.

In the following tutorial we’re implementing example queries for different environments – Java Persistence API compared with a JPQL and a criteria API query, mongoDB with Morphia and last but not least for Lucene.

Arquillian Transaction Extension: Transaction Rollback for your Java EE Integration Tests

Sun, 16 Jun 2013 00:00:00 +0200

I really love Arquillian to run integration tests for my Java EE applications – especially when running on different containers – and I also love the Arquillian tool stack from Arquillian Drone to the Arquillian Persistence Extensions.

Today I’d like to share a short snippet how to achieve transaction rollbacks when testing an EJB in combination with Arquillian and the Arquillian Transaction Extension…

Arquillian Basics

If you’ve never heard of the Arquillian framework before, please feel free to have a look at the Arquillian documentation or an article of mine: Arquillian Tutorial: Writing Java EE 6 Integration Tests and more...

Creating slim Database Projections using JPA2 Constructor Expressions

Sun, 14 Apr 2013 00:00:00 +0200

One common question that you may encounter one day when using object-relational-mapping in your application is how to slim down data that you’re retrieving from the persistence layer down to a specific subset for your use-case in an efficient manner and without using complex additional mapping frameworks. In some situations you might declare lazy loaded fields but another approach that I’d like to share with you here are JPA2 constructor expressions.

Adding multiple EntityListeners to an Entity in JPA 2

Mon, 25 Feb 2013 00:00:00 +0100

The ability to attach lifecycle events to an entity using simple annotations sometimes is a neat feature in the Java Persistence API.

The following short snippets demonstrate how to bind and trigger the different available lifecycle events using an embedded derby database and a bunch of annotations.

Dependencies

I’m using Hibernate as persistence manager here and Derby as an easy to setup database. In the last step we’ll be writing a test that’s why we’ve added JUnit and Hamcrest.

Hibernate Search Faceting: Discrete and Range Faceting by Example

Mon, 26 Mar 2012 00:00:00 +0200

In today’s tutorial we’re exploring the world of faceted searches like the one we’re used to see when we’re searching for an item on Amazon.com or other websites. We’re using Hibernate Search here that offers an API to perform discrete as well as range faceted searches on our persisted data.

Maven Dependencies Needed

For simplicity’s sake am I going to use an HSQL database for persistence, in addition the dependencies for hibernate-entitymanager and hibernate-search (of course) should be added to your pom.xml

JPA Persistence and Lucene Indexing combined in Hibernate Search

Sun, 05 Feb 2012 00:00:00 +0100

Often we’re writing an application that has to handle entities that – on the one side need to be persisted in a relational database using standards like the Java Persistence API (JPA) and using frameworks like Hibernate ORM or EclipseLink.

On the other side those entities and their fields are often stored in a highspeed indexer like Lucene. From this situation arises a bunch of common problems .. to synchronize both data sources, to handle special data mapped in an entity like an office document and so on..

Object-relational Mapping using Java Persistence API JPA 2

Mon, 11 Oct 2010 00:00:00 +0200

Today we’re going to take a look at the world of object-relational Mapping and how it is done using the Java Persistence API by creating some basic examples, mapping some relations and querying objects using JPQL or the Criteria API..

Prerequisites

Java 6 JDK
Maven >= 2
If you’d like to take a look behind the scenes e.g. how entities are mapped in your database you could install a RDBMS of your choice .. or just use Derby/JavaDB that is bundled with the JDK 6

Named Queries in Grails 1.2

Tue, 06 Apr 2010 00:00:00 +0200

They built a nice new feature in Grails 1.2 called “named queries“. Named queries can be defined in a domain class as static properties and support the criteria builder syntax.

Examples

package testapp

class User {
	String name
	int iq
	int age

	static namedQueries = {
		dumbUsers {
			int referenceIq = 60
			lt 'iq' , referenceIq
		}

		nameStartsWith { letter ->
			like 'name', '${letter}%'
		}

		midAges {
			between('age', 20, 40)
		}

	}
}

// count dumb users
println User.dumbUsers.count()

// print amount of users, usernames starting with an 'a'
User.nameStartsWith('a').count()

MyBatis Snippets

Mon, 01 Mar 2010 00:00:00 +0100

Use List of Parameters in Annotation-based Query

Possible using MyBatis Dynamic SQL feature

package com.hascode.example.mybatis;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper
public interface SampleMapper {

    @Select({"<script>",
             "SELECT sample.bar",
             "FROM sampletable sample",
             "WHERE sample.id IN",
            "<foreach item='item' index='index' collection='ids'",
            "open='(' separator=',' close=')'>",
            "#{item}",
            "</foreach>",
            "</script>"})
    List<Foo> getSamplesMatchingIds(@Param("ids") List<String> ids);
}

The mapper may now be used with a list of parameter objects:

var samples = sampleMapper.getSamplesMatchingIds(List.of("24059e5b-aa07-424d-855e-50f499b8f697", "65140fc0-fc9f-42d2-9531-5e5d6caeba30"));

Call a Procedure

package com.hascode.example.mybatis;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Options;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.mapping.StatementType;

@Mapper
public interface SampleMapper {

    @Select("CALL SCHEMA.CL.setScope(#{scope})")
    @Options(statementType = StatementType.CALLABLE)
    void setScope(int scope);
}

Spring Boot Snippets

Mon, 01 Mar 2010 00:00:00 +0100

Define and Configure Log Groups

This allows to configure a group of loggers at the same time

Define a log group named myaspect with two packages
application.properties
```
logging.group.myaspect=com.hascode.package1,com.hascode.package2
```
Configure the log group and set all loggers to level TRACE
application.properties
```
logging.level.myaspect=TRACE
```

This is also possible as parameter on startup

java -Dlogging.level.myaspect=TRACE myapp.jar

Use JUnit 5 with Spring Boot

Use newer versions of Surefire and Failsafe plugins:

<properties>
[..]
  <maven-failsafe-plugin.version>2.22.0</maven-failsafe-plugin.version>
  <maven-surefire-plugin.version>2.22.0</maven-surefire-plugin.version>
</properties>