The scenario that the memory issue may happen:

• One EntityManagerFactory and One EntityManager are used throughout the whole session;
• The session contains a lot of queries, they are all read-only queries;
• Most queries are to retrieve database records based on primary keys;
• The records retrieved are approximately evenly distributed across primary keys;
• The database being queried has a large amount of data.

It seems that OpenJPA keeps references to data retrieved from the queries as cache. This prevents JVM garbage collecting them. Eventually, out of memory error happens.

This time, it seems that the call to clear method on EntityManager does not even work. Finally, we added the following properties and it seemed to solve the issue:

openjpa.AutoDetach=nontx-read

In fact, it is not a good practice to use EntityManager as shown in the scenario. Maybe the initial consideration is to re-use the single EntityManager as much as possible to help improve the performance of the session that is created in a batch process.

In general, the EntityManager object should not live in the whole long session. Instead it should be created on demand and closed and disregarded when finishing its unit of work. However, i haven’t got time to test how worse the performance can degrade if it is implemented this way.

Java beans in Spring can also have their collection properties populated in the beans.xml file. The collection properties here mean things like List, Map and Array.

For example, if you want to create a JPA EntityManagerFactory with a set of connection properties, these properties can be configured in beans.xml like this:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xmlns:p="http://www.springframework.org/schema/p"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
    <bean id="entityManagerFactoryCreator" 
    class="com.mytechtip.example.EntityManagerFactoryCreator">
    <property name="persistenceUnitName" value="HRMN_Repository"/>
    <property name="jpaProperties">
      <props>
        <prop key="openjpa.ConnectionURL">the_url</prop>
        <prop key="openjpa.ConnectionDriverName">the_driver_class_name</prop> 
        <prop key="openjpa.ConnectionUserName">the_user_name</prop>
        <prop key="openjpa.ConnectionPassword">the_password</prop>
      </props>
    </property>
  </bean>
</beans>

Here, jpaProperties in the actual java class “EntityManagerFactoryCreator” is an instance of Properties. And you can just use this properties to create EntityManagerFactory.

    // ...
    private Properties jpaProperties;
    //...
    public void setJpaProperties(Properties prop) {
        this.jpaProperties = prop;
    }
    // ...
    public EntityManagerFactory create() {
        return Persistence.createEntityManagerFactory("myPersistenceUnit", prop);
    }

Actually, Spring already have something similar for you to access EntityManagerFactory with ease. The beans used for the task are:

• org.springframework.orm.jpa.LocalEntityManagerFactoryBean
• org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean

More information / examples can be found here about the support of JPA entity manager factory creatation in Spring.

Change the default storage engine

By default, OpenJPA uses innodb as the storage engine. While my application does not need to support transactions and other fancy db features, i’d like to use more plain and “traditional” myisam storage engine. To do so, I just need to set the property “openjpa.jdbc.DBDictionary” with the value “TableType=myisam”. This property object is the one passed to the method “Persistence.createEntityManagerFactory(String, Properties)”.

Allow to store bigger objects (blobs)
By default, OpenJPA maps the java object to mysql data type “blob”. However, as you may be aware of, blob type in mysql only can store up to 65536(2¹⁶) bytes of data (check http://dev.mysql.com/doc/refman/5.0/en/storage-requirements.html), which is quite smaller than the blob in JavaDB or Derby (2G).

Mysql does provide other data types which supports larger storage. mediumblob supports up to 16M while longblob up to 4G. So if I want to store objects other than 64K, I need to change the mapping in OpenJPA. To change the mapping, just set the same property “openjpa.jdbc.DBDictionary”, but with value “blobTypeName=mediumblob”.

If I want both myisam as storage engine and mediumblob as mapped blob type, the property should be set as: “TableType=myisam,blobTypeName=mediumblob”.

Avoid the error “Packet too large”
Now i can save objects up to 16M in size to the database. I run my program, only to find another exception popped up. It says something like “Packet too large”.

This requires the change of mysql server setting as indicated in mysql documentation. The setting “max_allowed_packet“, default to 1M bytes, is too small in my case.