I have been using Play Framework from version 1.2. Currently I’m using 2.2, which comes with a simple Ebean ORM but after reading few comments I realized it won’t be good enough for more complex projects. There is nothing worse than to realize in the middle of the project that some bug is causing your app not to work.
I looked around and noticed Spring Data. At first I didn’t put much effort in it but after checking the docs I realized it’s awesome solution. Only problem is that I doesn’t work out of the box with the Play Framework. There are few example projects on github, for me the only working was https://github.com/jamesward/play-java-spring.
I strongly advise you to check the code, because it’s show how to combine Play Framework with Spring Data. At the same time it shows how Dependency Injection works, how you define repositories and how to use them in controllers.
How it works
The basic logic is that Spring Data offers basic repositories for basic operations like saving, finding, deleting etc. Let’s imagine we have an entity Post.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
package models; import java.util.Date; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.Table; @Entity @Table(name = "posts") public class Post { @Id @GeneratedValue(strategy = GenerationType.AUTO) public Long id; @Column(nullable = false) public String title; @Column(nullable = false, name = "created_at") public Date created_at; @Column(name = "is_active") public boolean isActive; } |
I’m not going into details how to create an entity. There are many great tutorials around. For the entity we create a repository
|
1 2 3 4 5 6 7 8 9 10 11 |
package repositories; import org.springframework.data.repository.CrudRepository; import org.springframework.stereotype.Repository; import models.Post; @Repository public interface PostRepository extends CrudRepository<Post, Long> { } |
1. We extended CrudRepository. CRUD stands for Create, Read, Update and Delete. It’s means that CrudRepository probably has some methods for creating, reading, updating and deleting posts. If we check the source of CrudRepository, it enables us to that.
|
1 2 3 4 5 6 7 8 9 |
public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID>; { S save(S entity); T findOne(ID primaryKey); Iterable findAll(); Long count(); void delete(T entity); boolean exists(ID primaryKey); } |
2. We added annotation @Repository so Spring knows to find it correctly and inject it.
3. We extended CrudRepository
Let’s take it for a spin
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
... import repositories.PostRepository; @org.springframework.stereotype.Controller("users") public class Users { @AutoWired private PostRepository postRepository; public Result index() { // retrieve all posts Iterable<Post> posts = this.postRepository.findAll(); // retrieve an existing post by primary key (in our case Long:id) Post post = this.postRepository.findOne(1L); // let's update it and save back to batabase post.title = "hey, it works"; this.postRepository.save(post); // and for last step delete it this.postRepository.delete(post); } } |
We put the example in 1 method for the sake of simplicity. Point is that we can simply retrieve, insert, update and delete Post entity. Spring handles building the queries, converting to objects and all other things. Again, check the example on github I mentined before so you know how to correctly define Controller, what @AutoWired does and why method index() is not static any more.
I have been using Spring Data for some time and there was not a single situation I couldn’t solve. I think the guys at Spring did a really good job. The simplicity on one side and ability to solve even most complex scenarios makes it really awesome.
More to come
In the next part we are going to check how to make a more complex queries by just defining methods name. We will also check how to include paging, sorting and how to run really really really complex queries.
