In order use Spring Data JDBC you need the following:

1. An entity with an attribute marked as id using the spring datas @Id annotation.

    public class Person { @Id Integer id; }

2. A repository

   public interface PersonRepository extends CrudRepository<Person, Integer> {}

3. Add @EnableJdbcRepositories to your application context configuration.

4. Make sure your application context contains a bean of type DataSource.

Now you can get an instance of the repository interface injected into your beans and use it:

Spring Data JDBC uses the id to identify entities but also to determine if an entity is new or already existing in the database. If the id is null or of a primitive type and 0 or 0.0 the entity is considered new.

When your data base has some autoincrement column for the id column the generated value will get set in the entity after inserting it into the database.

There are few ways to tweak this behavior. If you don’t like the logic to distinguish between new and existing entities you can implement Persistable with your entity and overwrite isNew() with your own logic.

One important constraint is that after saving an entity the entity shouldn’t be new anymore. With autoincrement columns this happens automatically since the the id gets set by Spring Data with the value from the id column. If you are not using autoincrement columns you can use that using a BeforeSave-listener which sets the id of the entity (see below).

When you use the standard implementations of CrudRepository as provided by Spring Data JDBC it will expect a certain table structure. You can tweak that by providing a NamingStrategy in your application context.

Spring Data Jdbc triggers events which will get publish to any matching ApplicationListener in the application context. For example the following listener will get invoked before an aggregate gets saved.

For each operation in CrudRepository Spring Data Jdbc will execute multiple statements. If there is a SqlSessionFactory in the application context, it will checked if it offers a statement for each step. If one is found that statement will be used (including its configured mapping to an entity).

The name of the statement is constructed by concatenating the fully qualified name of the entity type with Mapper. and a string determining the kind of statement. E.g. if an instance of org.example.User is to be inserted Spring Data Jdbc will look for a statement named org.example.UserMapper.insert.

Upon execution of the statement an instance of [MyBatisContext] will get passed as an argument which makes various arguments available to the statement.

Just annotate a method with a SQL query to use this whenever the method gets called.

The current MyBatis supported is rather elaborate in that it allows to execute multiple statements for a single method call. But sometimes less is more and it should be possible to annotate a method with a simple annotation to identify a SQL statement in a MyBatis mapping to be executed.

Fast running tests can executed with a simple

This will execute unit tests and integration tests using an in-memory database.

To run the integration tests against a specific database you need to have the database running on your local machine and then execute.

This will also execute the unit tests.

Currently the following databasetypes are available:

• hsql (default, does not require a running database)

• mysql

• postgres

This will execute the unit tests, and all the integration tests with all the databases we currently support for testing. The databases must be running.