JPA-JSON

A helper library for JPA Entity (de)serialization in JSON

License

License

Categories

Categories

JSON Data
GroupId

GroupId

com.github.friendlyjava
ArtifactId

ArtifactId

jpa-json
Last Version

Last Version

1.1.2
Release Date

Release Date

Type

Type

pom
Description

Description

JPA-JSON
A helper library for JPA Entity (de)serialization in JSON
Project URL

Project URL

https://github.com/friendlyjava/jpa-json
Source Code Management

Source Code Management

https://github.com/friendlyjava/jpa-json

Download jpa-json

Filename Size
jpa-json-1.1.2.pom 6 KB
Browse

How to add to project

<!-- https://jarcasting.com/artifacts/com.github.friendlyjava/jpa-json/ -->
<dependency>
    <groupId>com.github.friendlyjava</groupId>
    <artifactId>jpa-json</artifactId>
    <version>1.1.2</version>
    <type>pom</type>
</dependency>
// https://jarcasting.com/artifacts/com.github.friendlyjava/jpa-json/
implementation 'com.github.friendlyjava:jpa-json:1.1.2'
// https://jarcasting.com/artifacts/com.github.friendlyjava/jpa-json/
implementation ("com.github.friendlyjava:jpa-json:1.1.2")
'com.github.friendlyjava:jpa-json:pom:1.1.2'
<dependency org="com.github.friendlyjava" name="jpa-json" rev="1.1.2">
  <artifact name="jpa-json" type="pom" />
</dependency>
@Grapes(
@Grab(group='com.github.friendlyjava', module='jpa-json', version='1.1.2')
)
libraryDependencies += "com.github.friendlyjava" % "jpa-json" % "1.1.2"
[com.github.friendlyjava/jpa-json "1.1.2"]

Dependencies

There are no dependencies for this project. It is a standalone project that does not depend on any other jars.

Project Modules

  • core
  • jackson

Jbx4j - JSON Binding eXtension for JPA

A helper library for JPA Entity (de)serialization in JSON.

When we work with JPA and need to (de)serialize JPA entities to JSON (or any other format) we always encounter some problems:

  • Relationship attributes (OneToOne, ManyToOne, OneToMany and ManyToMany) that are Lazy and the JSON Binding framework (like Jackson, GSON, etc) will cause the JPA Provider to make unnecessary queries to the database;
  • Circular reference between JPA mapping;
  • Use of DTOs and Mapping frameworks (like ModelMapper, MapStruct, Dozer, etc.) to bypass the above problems, making development more complex and verbose;
  • Need to create DTOs and Mappers even for simple entities (with two or three attributes).

This library helps in the process of (de)serialization of the JPA entity, reducing the difficulties mentioned above.

Support

Initially we are providing support to the framework below:

Framework Type Minimal version Note
Hibernate JPA 5.2
EclipseLink JPA 2.5 Works only with Weaving enabled. Experimental support
Jackson JSON 2.9.4

Getting Started

  1. You must add a dependency in your project:

    <dependency>
        <groupId>com.github.microtweak</groupId>
        <artifactId>jbx4j-hibernate</artifactId>
        <version>${jbx4j.version}</version>
    </dependency>
    
    <dependency>
        <groupId>com.github.microtweak</groupId>
        <artifactId>jbx4j-jackson</artifactId>
        <version>${jbx4j.version}</version>
    </dependency>
  2. Now let's configure the application to use Jbx4j. Although the following examples are based on the CDI, it is not a requirement to use this library. Create a class that implements EntityResolver as in the example below. You can create multiple EntityResolvers as needed.

    @ApplicationScoped
    public class GenericEntityResolver implements EntityResolver<Object> {
    
        @Inject
        private EntityManager entityManager;
    
        @Override
        public boolean canResolve(Object declaredAt, Class<Object> rawType, JpaEntityData<Object> data, List<Annotation> annotations) {
            return rawType.isAnnotationPresent(Entity.class);
        }
    
        @Override
        public Object resolve(Object declaredAt, Class<Object> rawType, JpaEntityData<Object> data, List<Annotation> annotations) {
            Object primaryKey = data.get("id");
        
            if (primaryKey == null) {
                return null;
            }
        
            // Logic to solve the entity. You can use a find or a complex query JPQL
            return entityManager.find(rawType, primaryKey);
        }    
    
    }
  3. Instantiate the Jbx4j module and add all the EntityResolvers created in the module. After that, register the module in Jackson.

    public class JacksonProducer {
    
        // Ask the CDI to find all the EntityResolver in the application
        @Inject
        private Instance<EntityResolver<?>> resolvers;
        
        @Produces
        @Singleton
        public ObjectMapper createJacksonObjectMapper() {
            ObjectMapper mapper = new ObjectMapper();
            
            // Instances the Jbx4j module for Jackson
            Jbx4jJacksonModule jbx4jModule = new Jbx4jJacksonModule();
    
            // Adds all EntityResolvers found by CDI in the module created earlier
            resolvers.forEach(er -> jbx4jModule.getResolverManager().add(er));
            
            // Register the module in Jackson
            mapper.registerModule(jpaJacksonModule);
            
            return mapper;
        }
        
    }

After these steps, simply ask Jackson's ObjectMapper to (de)serialize your JPA entity as you are already accustomed to doing with other Java classes.

Versions

Version
1.1.2
1.1.1
1.1.0
1.0.0