Play provides a set of very useful helpers to simplify the management of your JPA entities.

Note that you can still go back to the plain JPA API whenever you want.

Starting the JPA entity manager

Play will automatically start the Hibernate entity manager when it finds one or more classes annotated with the @javax.persistence.Entity annotation. However, make sure that you have correctly configured a JDBC datasource or it will fail.

Obtaining the JPA entity manager

When the JPA entity manager is started you can get it from the application code, using the JPA helper. For example:

public static index() {
Query query = JPA.em().createQuery("select * from Article");
List<Article> articles = query.getResultList();
render(articles);
}

Transaction management

Play will automatically manage transactions for you. It will start a transaction for each HTTP request and commit it when the HTTP response is sent. If your code throws an exception, the transaction will automatically rollback.

If you need to force transaction rollback from the application code, you can use theJPA.setRollbackOnly() method.

You can also use annotations to specify how transactions should be handled.

If you annotated the method in the controller with @play.db.jpa.Transactional(readOnly=true), then the transaction will be read-only.

If you want to prevent Play from starting a transaction at all, you can annotated the method with@play.db.jpa.NoTransaction.

To prevent transactions for all methods, you can annotate the Controller-class with@play.db.jpa.NoTransaction.

When using @play.db.jpa.NoTransaction, Play does not get a connection from the connection pool at all – which improves speed.

The play.db.jpa.Model support class

This is the main helper class for JPA. If you make one of your JPA entities extend theplay.db.jpa.Model class, it will give you a lot of helper methods to simplify the JPA access.

For example, look at this Post model object:

@Entity
public class Post extends Model {

public String title; public String content; public Date postDate; @ManyToOne public Author author; @OneToMany public List comments; }

The play.db.jpa.Model class automatically provides an autogenerated Long id field. We think that it’s generally a good idea to keep an auto-generated Long id as primary key for JPA models (the technical primary key) and manage your functional primary key using another field.

Note that we have used the fact that Play automatically considers the Post class’ public members asproperties. So we don’t need to write all setter/getter methods for this object.

Custom id mapping with GenericModel

Nothing forces you to base your entities on play.db.jpa.Model. Your JPA entities can also extend theplay.db.jpa.GenericModel class. This is required if you do not want to use a Long id as the primary key for your entity.

For example, here is a mapping for a very simple User entity. The id is a UUID, the name and mailproperties are required, and we use Play Validation to enforce simple business rules.

@Entity
public class User extends GenericModel {
@Id
@GeneratedValue(generator = "system-uuid")
@GenericGenerator(name = "system-uuid", strategy = "uuid")
public String id;

@Required public String name; @Required @MaxSize(value=255, message = “email.maxsize”) @play.data.validation.Email public String mail; }

Finding objects

The play.db.jpa.Model gives you several ways to find data. For example:

Find by ID

The simplest way to find an object.

Post aPost = Post.findById(5L);

Find all

List<Post> posts = Post.findAll();

This is the simplest way to retrieve all posts, but you can do the same using:

List<Post> posts = Post.all().fetch();

This allows you to paginate results:

List<Post> posts = Post.all().fetch(100); // 100 max posts

or even,

List<Post> posts = Post.all().from(50).fetch(100); // 100 max posts start at 50

Find using a simplified query

That allows you to create very expressive finders, but will only work for simple queries.

Post.find("byTitle", "My first post").fetch();
Post.find("byTitleLike", "%hello%").fetch();
Post.find("byAuthorIsNull").fetch();
Post.find("byTitleLikeAndAuthor", "%hello%", connectedUser).fetch();

Simple queries follow the following syntax “[Property][Comparator]And?” where Comparator can be the following:

  • LessThan – less than the given value
  • LessThanEquals – less than or equal a give value
  • GreaterThan – greater than a given value
  • GreaterThanEquals – greater than or equal a given value
  • Like – Equivalent to a SQL like expression, except that the property will always convert to lower case.
  • Ilike – Similar to a Like, except case insensitive, meaning that your argument will convert to lower case too.
  • Elike – Equivalent to a SQL like expression, no conversion.
  • NotEqual – Negates equality
  • Between – Between two values (requires two arguments)
  • IsNotNull – Not a null value (doesn’t require an argument)
  • IsNull – Is a null value (doesn’t require an argument)

Find using a JPQL query

You can use a JPQL query:

Post.find(
"select p from Post p, Comment c where c.post = p and c.subject like ?", "%hop%"
);

or even a part of:

Post.find("title", "My first post").fetch();
Post.find("title like ?", "%hello%").fetch();
Post.find("author is null").fetch();
Post.find("title like % and author is null", "%hello%").fetch();
Post.find("title like % and author is null order by postDate", "%hello%").fetch();

You can even specify only the order by statement:

Post.find("order by postDate desc").fetch();

Counting objects

You can easily count objects.

long postCount = Post.count();

Or even count using a query:

long userPostCount = Post.count("author = ?", connectedUser);

Explicit save

Hibernate maintains a cache of Objects that have been queried from the database. These Objects are referred to as persistent Objects as long as the EntityManager that was used to fetch them is still active. That means that any changes to these Objects within the bounds of a transaction are automatically persisted when the transaction is committed. In standard JPA, these updates are implicit within the transaction’s boundary; you don’t have to explicitly call any method to persist the values.

The main downside is that we must manage all of our Objects manually. Instead of telling the EntityManager to update an Object (which would be far more intuitive), we must tell the EntityManager which Objects NOT to update. We do this by calling refresh(), which essentially rolls back a single entity. We do this just prior to calling commit on the transaction or when we realise the Object shouldn’t be updated.

Here is a common use case, when editing a persistent object after a form submit:

public static void save(Long id) {
User user = User.findById(id);
user.edit("user", params.all());
validation.valid(user);
if(validation.hasErrors()) {
// Here we have to explicitly discard the user modifications...
user.refresh();
edit(id);
}
show(id);
}

From what I’ve seen, most developers are not aware of this, and forget to discard the object state in case of errors, assuming that the object will not be saved without an explicit call to save().

So that’s exactly what we’ve changed in Play. All the persistent objects extending the JPASupport/JPAModel will not be saved without an explicit call to the save() method. So you can actually rewrite the previous code as:

public static void save(Long id) {
User user = User.findById(id);
user.edit("user", params.all());
validation.valid(user);
if(validation.hasErrors()) {
edit(id);
} else{
user.save(); // explicit save here
show(id);
}
}

This is far more intuitive. Moreover since it could be tedious to explicitly call save() on a large object graph, the save() call is automatically cascaded to the relationships annotated with thecascade=CascadeType.ALL attribute.

More about generic typing problems

The play.db.jpa.Model defines a set of generic methods. These generic methods use a type parameter to specify the method’s return type. When using those methods, the concrete type to be used as return value is derived from the invocation context using type inference.

For example, the findAll method is defined as:

<T> List<T> findAll();

And you use it as:

List<Post> posts = Post.findAll();

Here the Java compiler resolves the actual type of T using the fact that you assign the method result to a List<Post>. So T is resolved as a Post type.

Unfortunately, this doesn’t work if the generic method’s return value is directly used as a parameter for another method invocation or used in a loop. So the following code fails with a compiler error saying “Type mismatch: cannot convert from element type Object to Post”:

for(Post p : Post.findAll()) {
p.delete();
}

Of course you can resolve this issue using a temporary local variable, as:

List<Post> posts = Post.findAll(); // type inference works here!
for(Post p : posts) {
p.delete();
}

But wait, there is a better way. You can use a practical but somewhat unknown Java language feature, which makes the code shorter while more readable at the same time:

for(Post p : Post.<Post>findAll()) {
p.delete();
}

Continuing the discussion

Now we’ll check some Play libraries.

JPA persistence的更多相关文章

  1. IntellJ 13.x JPA Persistence Sample

    跟上一篇差不多,一些基本的东西. 这次是JPA + Spring MVC 3.0 1.建立Project 2.Add JPA Support 3.我们以Hibernate为例,设置JPA的Provid ...

  2. Spring data jpa persistence .xml 配置文件

    <?xml version="1.0" encoding="UTF-8"?><persistence xmlns="http://j ...

  3. jpa注解

    http://www.oracle.com/technetwork/cn/middleware/ias/toplink-jpa-annotations-100895-zhs.html#ManyToOn ...

  4. JPA 批注参考

    body, p, th, td, li, ul, ol, h1, h2, h3, h4, h5, h6, pre { font-family: simsun; line-height: 1.4; } ...

  5. 摘抄JPA官方文档原文 防呆

    Spring Data JPA - Reference Documentation Oliver GierkeThomas DarimontChristoph StroblMark PaluchVer ...

  6. Spring Boot:整合Spring Data JPA

    综合概述 JPA是Java Persistence API的简称,是一套Sun官方提出的Java持久化规范.其设计目标主要是为了简化现有的持久化开发工作和整合ORM技术,它为Java开发人员提供了一种 ...

  7. [转] JPA 2.0 with EclipseLink - 教程

    原文: http://www.vogella.com/articles/JavaPersistenceAPI/article.html Lars Vogel Version 2.2 Copyright ...

  8. 领域对象模型(domain object model)

    在Play程序中,模型(model)占据了核心地位.它是程序操作的信息的特定领域的表现方式. Martin Fowler这样定义模型: 负责表达业务概念,业务状态信息以及业务规则.尽管保存业务状态的技 ...

  9. 【原】Kryo序列化篇

    Kryo是一个快速有效的对象图序列化Java库.它的目标是快速.高效.易使用.该项目适用于对象持久化到文件或数据库中或通过网络传输.Kryo还可以自动实现深浅的拷贝/克隆. 就是直接复制一个对象对象到 ...

随机推荐

  1. java中如何生成可执行的jar文件

    java中如何生成可执行的jar文件 最简单的方法就是: jar -cfe Card.jar CardLayoutDemo CardLayoutDemo$1.class CardLayoutDemo$ ...

  2. A/B 测试之前必须要了解的 10 件事

    如今,转化率优化(CRO)已是营销人员必须具备的技能,并且与 ROI 直接挂钩.但是在优化网页的转化率方面又有太多因素要考量,如果你已经不堪其忧,请专心做一件事-- A/B 测试. A/B测试,即你设 ...

  3. web开发者谷歌浏览器常用插件

    1.Allow-Control-Allow-Origin    安装此插件解决跨域问题,在本地起服务器可访别的域的数据. 需在Access-Control-Expose-Headers加上Allow- ...

  4. 从重置input file标签中看jQuery的 .val() 和 .attr(“value”) 区别

    背景: 在清空input file标签选中值时,分别用了以下方法,发现有的对有的错: [√]$("#file")[0].value = ""; [√]$(&qu ...

  5. 《Inside UE4》-0-开篇

    <Inside UE4>-0-开篇 InsideUE4   前言 VR行业发展是越来越火热了,硬件设备上有HTC VIVE,Oculus rift,PS VR,各种魔镜:平台上有Steam ...

  6. View绘制过程理解

    假期撸了几篇自定义View相关的东西,后两天下雨呆在家里还是效率太低Orz   每个Activity都包含一个Window对象,这个Window对象通常由PhoneWindow来实现[1],而每个Wi ...

  7. Visual Studio开发Cordova应用示例

    作者:Grey 原文地址:http://www.cnblogs.com/greyzeng/p/5455728.html 本文的GIF动画均使用ScreenToGif进行录制. Cordova是什么? ...

  8. SQL Server数字辅助表的实现

        数字辅助表是一个连续整数的数列,通常用来实现多种不同的查询任务.大多分两类:足够大物理数字表和表函数,前者可以称为静态的,后者可以称为动态且按需生产. 物理数字表     物理数字表通常存在一 ...

  9. SQL--分页查询

     SELECT *  FROM   ( SELECT    ROW_NUMBER() OVER ( ORDER BY EmployeeID DESC ) AS Rownumber ,          ...

  10. 30天C#基础巩固----查找XML文件元素

    一:XML文档 了解xml文档. 利用代码来创建XML文档. //引用命名空间+using System.Xml; XmlDocument xdoc=new XmlDocument(); XmlDec ...