JPA map JSON column to Java Object

Question

Abbiamo una tabella grande con un sacco di colonne. Dopo ci siamo trasferiti a MySQL Cluster, la tabella non può essere creato a causa di:

ERROR 1118 (42000): dimensioni Row troppo grande. La dimensione massima della riga per il tipo di tabella utilizzato, senza contare i BLOB, è 14000. Ciò include l'overhead di archiviazione, controllare il manuale. È necessario modificare alcune colonne al testo o BLOB

Ad esempio:

@Entity @Table (name = "appconfigs", schema = "myproject") 
public class AppConfig implements Serializable 
{ 
    @Id @Column (name = "id", nullable = false) 
    @GeneratedValue (strategy = GenerationType.IDENTITY) 
    private int id; 

    @OneToOne @JoinColumn (name = "app_id") 
    private App app; 

    @Column(name = "param_a") 
    private ParamA parama; 

    @Column(name = "param_b") 
    private ParamB paramb; 
} 

È una tabella per memorizzare parametri di configurazione. Stavo pensando che possiamo combinare alcune colonne in una e archiviarla come oggetto JSON e convertirla in qualche oggetto Java.

Ad esempio:

@Entity @Table (name = "appconfigs", schema = "myproject") 
public class AppConfig implements Serializable 
{ 
    @Id @Column (name = "id", nullable = false) 
    @GeneratedValue (strategy = GenerationType.IDENTITY) 
    private int id; 

    @OneToOne @JoinColumn (name = "app_id") 
    private App app; 

    @Column(name = "params") 
    //How to specify that this should be mapped to JSON object? 
    private Params params; 
} 

Dove abbiamo definito:

public class Params implements Serializable 
{ 
    private ParamA parama; 
    private ParamB paramb; 
} 

Utilizzando questo possiamo combinare tutte le colonne in un unico e creare il nostro tavolo. Oppure possiamo dividere l'intera tabella in più tabelle. Personalmente preferisco la prima soluzione.

In ogni caso la mia domanda è come mappare la colonna Params che è testo e contiene una stringa JSON di un oggetto Java?

Answer 1

È possibile utilizzare un convertitore di APP a mappare l'Entità al database. Basta aggiungere un'annotazione simile a questo per il vostro campo params:

@Convert(converter = JpaConverterJson.class) 

e quindi creare la classe in un modo simile (questo converte un oggetto generico, si può decidere di specializzarsi esso):

public class JpaConverterJson implements AttributeConverter<Object, String> { 

    private final static ObjectMapper objectMapper = new ObjectMapper(); 

    @Override 
    public String convertToDatabaseColumn(Object meta) { 
    try { 
     return objectMapper.writeValueAsString(meta); 
    } catch (JsonProcessingException ex) { 
     return null; 
     // or throw an error 
    } 
    } 

    @Override 
    public Object convertToEntityAttribute(String dbData) { 
    try { 
     return objectMapper.readValue(dbData, Object.class); 
    } catch (IOException ex) { 
     // logger.error("Unexpected IOEx decoding json from database: " + dbData); 
     return null; 
    } 
    } 

} 

Ecco: è possibile utilizzare questa classe per serializzare qualsiasi oggetto su json nella tabella.

Answer 2

Ho avuto un problema simile e l'ho risolto usando l'annotazione @Externalizer e Jackson per serializzare/deserializzare i dati (@Externalizer è un'annotazione specifica di OpenJPA, quindi è necessario verificare con l'implementazione JPA una simile possibilità).

@Persistent 
@Column(name = "params") 
@Externalizer("toJSON") 
private Params params; 

Parametri implementazione della classe:

public class Params { 
    private static final ObjectMapper mapper = new ObjectMapper(); 

    private Map<String, Object> map; 

    public Params() { 
     this.map = new HashMap<String, Object>(); 
    } 

    public Params (Params another) { 
     this.map = new HashMap<String, Object>(); 
     this.map.putAll(anotherHolder.map); 
    } 

    public Params(String string) { 
     try { 
      TypeReference<Map<String, Object>> typeRef = new TypeReference<Map<String, Object>>() { 
      }; 
      if (string == null) { 
       this.map = new HashMap<String, Object>(); 
      } else { 
       this.map = mapper.readValue(string, typeRef); 
      } 
     } catch (IOException e) { 
      throw new PersistenceException(e); 
     } 
    } 

    public String toJSON() throws PersistenceException { 
     try { 
      return mapper.writeValueAsString(this.map); 
     } catch (IOException e) { 
      throw new PersistenceException(e); 
     } 
    } 

    public boolean containsKey(String key) { 
     return this.map.containsKey(key); 
    } 

    // Hash map methods 
    public Object get(String key) { 
     return this.map.get(key); 
    } 

    public Object put(String key, Object value) { 
     return this.map.put(key, value); 
    } 

    public void remove(String key) { 
     this.map.remove(key); 
    } 

    public Object size() { 
     return map.size(); 
    } 
} 

HTH

Answer 3

Come ho spiegato nel this article, l'APP AttributeConverter è troppo limitata per mappare tipi di oggetti JSON, soprattutto se si desidera salvare loro come JSON binario.

Non è necessario creare tutti questi tipi manualmente, è possibile ottenere semplicemente loro via Maven centrale utilizzando la seguente dipendenza:

<dependency> 
    <groupId>com.vladmihalcea</groupId> 
    <artifactId>hibernate-types-52</artifactId> 
    <version>${hibernate-types.version}</version> 
</dependency> 

Per ulteriori informazioni, visitate il hibernate-types open-source project.

Ora, per spiegare come funziona.

Ho scritto an article su come mappare oggetti JSON sia su PostgreSQL che su MySQL.

per PostgreSQL, è necessario inviare l'oggetto JSON in forma binaria:

public class JsonBinaryType 
    extends AbstractSingleColumnStandardBasicType<Object> 
    implements DynamicParameterizedType { 

    public JsonBinaryType() { 
     super( 
      JsonBinarySqlTypeDescriptor.INSTANCE, 
      new JsonTypeDescriptor() 
     ); 
    } 

    public String getName() { 
     return "jsonb"; 
    } 

    @Override 
    public void setParameterValues(Properties parameters) { 
     ((JsonTypeDescriptor) getJavaTypeDescriptor()) 
      .setParameterValues(parameters); 
    } 

} 

Il JsonBinarySqlTypeDescriptor assomiglia a questo:

public class JsonBinarySqlTypeDescriptor 
    extends AbstractJsonSqlTypeDescriptor { 

    public static final JsonBinarySqlTypeDescriptor INSTANCE = 
     new JsonBinarySqlTypeDescriptor(); 

    @Override 
    public <X> ValueBinder<X> getBinder(
     final JavaTypeDescriptor<X> javaTypeDescriptor) { 
     return new BasicBinder<X>(javaTypeDescriptor, this) { 
      @Override 
      protected void doBind(
       PreparedStatement st, 
       X value, 
       int index, 
       WrapperOptions options) throws SQLException { 
       st.setObject(index, 
        javaTypeDescriptor.unwrap(
         value, JsonNode.class, options), getSqlType() 
       ); 
      } 

      @Override 
      protected void doBind(
       CallableStatement st, 
       X value, 
       String name, 
       WrapperOptions options) 
        throws SQLException { 
       st.setObject(name, 
        javaTypeDescriptor.unwrap(
         value, JsonNode.class, options), getSqlType() 
       ); 
      } 
     }; 
    } 
} 

e JsonTypeDescriptor in questo modo:

public class JsonTypeDescriptor 
     extends AbstractTypeDescriptor<Object> 
     implements DynamicParameterizedType { 

    private Class<?> jsonObjectClass; 

    @Override 
    public void setParameterValues(Properties parameters) { 
     jsonObjectClass = ((ParameterType) parameters.get(PARAMETER_TYPE)) 
      .getReturnedClass(); 

    } 

    public JsonTypeDescriptor() { 
     super(Object.class, new MutableMutabilityPlan<Object>() { 
      @Override 
      protected Object deepCopyNotNull(Object value) { 
       return JacksonUtil.clone(value); 
      } 
     }); 
    } 

    @Override 
    public boolean areEqual(Object one, Object another) { 
     if (one == another) { 
      return true; 
     } 
     if (one == null || another == null) { 
      return false; 
     } 
     return JacksonUtil.toJsonNode(JacksonUtil.toString(one)).equals(
       JacksonUtil.toJsonNode(JacksonUtil.toString(another))); 
    } 

    @Override 
    public String toString(Object value) { 
     return JacksonUtil.toString(value); 
    } 

    @Override 
    public Object fromString(String string) { 
     return JacksonUtil.fromString(string, jsonObjectClass); 
    } 

    @SuppressWarnings({ "unchecked" }) 
    @Override 
    public <X> X unwrap(Object value, Class<X> type, WrapperOptions options) { 
     if (value == null) { 
      return null; 
     } 
     if (String.class.isAssignableFrom(type)) { 
      return (X) toString(value); 
     } 
     if (Object.class.isAssignableFrom(type)) { 
      return (X) JacksonUtil.toJsonNode(toString(value)); 
     } 
     throw unknownUnwrap(type); 
    } 

    @Override 
    public <X> Object wrap(X value, WrapperOptions options) { 
     if (value == null) { 
      return null; 
     } 
     return fromString(value.toString()); 
    } 

} 

Ora, è necessario dichiarare il nuovo tipo su entrambe le classe vel o in un package-info.java pacchetto di livello descriptior:

@TypeDef(name = "jsonb", typeClass = JsonBinaryType.class) 

E la mappatura entità sarà simile a questa:

@Type(type = "jsonb") 
@Column(columnDefinition = "json") 
private Location location; 

Se stai usando Hibernate 5 o versione successiva, quindi il tipo JSON è registered automatically by Postgre92Dialect.

In caso contrario, è necessario registrarsi da soli:

public class PostgreSQLDialect extends PostgreSQL91Dialect { 

    public PostgreSQL92Dialect() { 
     super(); 
     this.registerColumnType(Types.JAVA_OBJECT, "json"); 
    } 
}