PostgreSQL DB（9.2）にJSON型の列を持つテーブルがあります。この列をJPA2エンティティフィールドタイプにマップするのに苦労しています。
Stringを使おうとしましたが、エンティティを保存すると、文字の変化をJSONに変換できないという例外が発生します。
JSON列を処理するときに使用する正しい値のタイプは何ですか？
@Entity
public class MyEntity {
private String jsonPayload; // this maps to a json column
public MyEntity() {
}
}
簡単な回避策は、テキスト列を定義することです。
回答:
PostgreSQLは、データ型の変換に関して過度に、煩わしいほど厳格です。text次のようなテキストのような値にも暗黙的にキャストされませんxmlやjson。
この問題を解決するための厳密に正しい方法は、JDBCを使用するカスタムHibernateマッピングタイプを作成することです。 setObjectメソッドすることです。これはかなり面倒な場合があるため、より弱いキャストを作成してPostgreSQLの厳密さを緩和したい場合があります。
コメントとこのブログ投稿で@markdsieversが指摘しているように、この回答の元のソリューションはJSON検証をバイパスします。だから、それは本当にあなたが望むものではありません。書く方が安全です：
CREATE OR REPLACE FUNCTION json_intext(text) RETURNS json AS $$
SELECT json_in($1::cstring);
$$ LANGUAGE SQL IMMUTABLE;
CREATE CAST (text AS json) WITH FUNCTION json_intext(text) AS IMPLICIT;
AS IMPLICIT 明示的に指示されることなく変換できることをPostgreSQLに通知し、次のような機能を可能にします。
regress=# CREATE TABLE jsontext(x json);
CREATE TABLE
regress=# PREPARE test(text) AS INSERT INTO jsontext(x) VALUES ($1);
PREPARE
regress=# EXECUTE test('{}')
INSERT 0 1
問題を指摘してくれた@markdsieversに感謝します。
cstringとにかく変換を行っているので、単純に使用できませんでしたCREATE CAST (text AS json) WITH INOUTか？
興味がある場合は、Hibernateカスタムユーザータイプを配置するためのコードスニペットをいくつか示します。まず、PostgreSQLダイアレクトを拡張してjsonタイプについて通知します。これは、JAVA_OBJECTポインターのCraigRingerのおかげです。
import org.hibernate.dialect.PostgreSQL9Dialect;
import java.sql.Types;
/**
* Wrap default PostgreSQL9Dialect with 'json' type.
*
* @author timfulmer
*/
public class JsonPostgreSQLDialect extends PostgreSQL9Dialect {
public JsonPostgreSQLDialect() {
super();
this.registerColumnType(Types.JAVA_OBJECT, "json");
}
}
次に、org.hibernate.usertype.UserTypeを実装します。以下の実装は、文字列値をjsonデータベースタイプにマップし、その逆も同様です。文字列はJavaでは不変であることを忘れないでください。より複雑な実装を使用して、カスタムJavaBeanをデータベースに格納されているJSONにマップすることもできます。
package foo;
import org.hibernate.HibernateException;
import org.hibernate.engine.spi.SessionImplementor;
import org.hibernate.usertype.UserType;
import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
/**
* @author timfulmer
*/
public class StringJsonUserType implements UserType {
/**
* Return the SQL type codes for the columns mapped by this type. The
* codes are defined on <tt>java.sql.Types</tt>.
*
* @return int[] the typecodes
* @see java.sql.Types
*/
@Override
public int[] sqlTypes() {
return new int[] { Types.JAVA_OBJECT};
}
/**
* The class returned by <tt>nullSafeGet()</tt>.
*
* @return Class
*/
@Override
public Class returnedClass() {
return String.class;
}
/**
* Compare two instances of the class mapped by this type for persistence "equality".
* Equality of the persistent state.
*
* @param x
* @param y
* @return boolean
*/
@Override
public boolean equals(Object x, Object y) throws HibernateException {
if( x== null){
return y== null;
}
return x.equals( y);
}
/**
* Get a hashcode for the instance, consistent with persistence "equality"
*/
@Override
public int hashCode(Object x) throws HibernateException {
return x.hashCode();
}
/**
* Retrieve an instance of the mapped class from a JDBC resultset. Implementors
* should handle possibility of null values.
*
* @param rs a JDBC result set
* @param names the column names
* @param session
* @param owner the containing entity @return Object
* @throws org.hibernate.HibernateException
*
* @throws java.sql.SQLException
*/
@Override
public Object nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner) throws HibernateException, SQLException {
if(rs.getString(names[0]) == null){
return null;
}
return rs.getString(names[0]);
}
/**
* Write an instance of the mapped class to a prepared statement. Implementors
* should handle possibility of null values. A multi-column type should be written
* to parameters starting from <tt>index</tt>.
*
* @param st a JDBC prepared statement
* @param value the object to write
* @param index statement parameter index
* @param session
* @throws org.hibernate.HibernateException
*
* @throws java.sql.SQLException
*/
@Override
public void nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session) throws HibernateException, SQLException {
if (value == null) {
st.setNull(index, Types.OTHER);
return;
}
st.setObject(index, value, Types.OTHER);
}
/**
* Return a deep copy of the persistent state, stopping at entities and at
* collections. It is not necessary to copy immutable objects, or null
* values, in which case it is safe to simply return the argument.
*
* @param value the object to be cloned, which may be null
* @return Object a copy
*/
@Override
public Object deepCopy(Object value) throws HibernateException {
return value;
}
/**
* Are objects of this type mutable?
*
* @return boolean
*/
@Override
public boolean isMutable() {
return true;
}
/**
* Transform the object into its cacheable representation. At the very least this
* method should perform a deep copy if the type is mutable. That may not be enough
* for some implementations, however; for example, associations must be cached as
* identifier values. (optional operation)
*
* @param value the object to be cached
* @return a cachable representation of the object
* @throws org.hibernate.HibernateException
*
*/
@Override
public Serializable disassemble(Object value) throws HibernateException {
return (String)this.deepCopy( value);
}
/**
* Reconstruct an object from the cacheable representation. At the very least this
* method should perform a deep copy if the type is mutable. (optional operation)
*
* @param cached the object to be cached
* @param owner the owner of the cached object
* @return a reconstructed object from the cachable representation
* @throws org.hibernate.HibernateException
*
*/
@Override
public Object assemble(Serializable cached, Object owner) throws HibernateException {
return this.deepCopy( cached);
}
/**
* During merge, replace the existing (target) value in the entity we are merging to
* with a new (original) value from the detached entity we are merging. For immutable
* objects, or null values, it is safe to simply return the first parameter. For
* mutable objects, it is safe to return a copy of the first parameter. For objects
* with component values, it might make sense to recursively replace component values.
*
* @param original the value from the detached entity being merged
* @param target the value in the managed entity
* @return the value to be merged
*/
@Override
public Object replace(Object original, Object target, Object owner) throws HibernateException {
return original;
}
}
残っているのは、エンティティに注釈を付けることだけです。エンティティのクラス宣言に次のようなものを配置します。
@TypeDefs( {@TypeDef( name= "StringJsonObject", typeClass = StringJsonUserType.class)})
次に、プロパティに注釈を付けます。
@Type(type = "StringJsonObject")
public String getBar() {
return bar;
}
Hibernateは、jsonタイプの列の作成を処理し、マッピングを前後に処理します。より高度なマッピングのために、ユーザータイプの実装に追加のライブラリを挿入します。
誰かがそれをいじりたい場合は、GitHubプロジェクトの簡単なサンプルを次に示します。
最初に行う必要があるのは、プロジェクト構成ファイルに次のHibernate TypesMaven依存関係をpom.xml設定することです。
<dependency>
<groupId>com.vladmihalcea</groupId>
<artifactId>hibernate-types-52</artifactId>
<version>${hibernate-types.version}</version>
</dependency>
ここで、PostgreSQLを使用している場合は、次のようJsonBinaryTypeに、クラスレベルまたはpackage-info.javaパッケージレベル記述子で宣言する必要があります。
@TypeDef(name = "jsonb", typeClass = JsonBinaryType.class)
また、エンティティマッピングは次のようになります。
@Type(type = "jsonb")
@Column(columnDefinition = "json")
private Location location;
Hibernate 5以降を使用している場合、JSONタイプはによって自動的に登録されます。Postgre92Dialect。
それ以外の場合は、自分で登録する必要があります。
public class PostgreSQLDialect extends PostgreSQL91Dialect {
public PostgreSQL92Dialect() {
super();
this.registerColumnType( Types.JAVA_OBJECT, "json" );
}
}
MySQLの場合、を使用してJSONオブジェクトをマップできますJsonStringType。
誰かが興味を持っている場合は、HibernateでJPA 2.1 @Convert/@Converter機能を使用できます。ただし、pgjdbc-ngJDBCドライバーを使用する必要があります。このように、フィールドごとに独自の拡張機能、方言、カスタムタイプを使用する必要はありません。
@javax.persistence.Converter
public static class MyCustomConverter implements AttributeConverter<MuCustomClass, String> {
@Override
@NotNull
public String convertToDatabaseColumn(@NotNull MuCustomClass myCustomObject) {
...
}
@Override
@NotNull
public MuCustomClass convertToEntityAttribute(@NotNull String databaseDataAsJSONString) {
...
}
}
...
@Convert(converter = MyCustomConverter.class)
private MyCustomClass attribute;
エンティティクラスがTypeDefsで注釈が付けられています。HQLで変換された同じクエリが問題なく実行されました。これを解決するには、JsonPostgreSQLDialectを次のように変更する必要がありました。
public class JsonPostgreSQLDialect extends PostgreSQL9Dialect {
public JsonPostgreSQLDialect() {
super();
this.registerColumnType(Types.JAVA_OBJECT, "json");
this.registerHibernateType(Types.OTHER, "myCustomType.StringJsonUserType");
}
myCustomType.StringJsonUserTypeは、jsonタイプを実装するクラスのクラス名です（上から、Tim Fulmerの回答）。
私はインターネットで見つけた多くの方法を試しましたが、それらのほとんどは機能せず、いくつかは複雑すぎます。以下のものは私にとってはうまくいきますが、PostgreSQLの型の検証に厳密な要件がない場合は、はるかに簡単です。
PostgreSQLjdbc文字列型を指定されていないものにします。
<connection-url>
jdbc:postgresql://localhost:test?stringtype=unspecified
</connection-url>
これを行うには、を使用して関数を作成する必要がない方が簡単です。 WITH INOUT
CREATE TABLE jsontext(x json);
INSERT INTO jsontext VALUES ($${"a":1}$$::text);
ERROR: column "x" is of type json but expression is of type text
LINE 1: INSERT INTO jsontext VALUES ($${"a":1}$$::text);
CREATE CAST (text AS json)
WITH INOUT
AS ASSIGNMENT;
INSERT INTO jsontext VALUES ($${"a":1}$$::text);
INSERT 0 1
私はこれに遭遇し、接続文字列を介してものを有効にし、暗黙の変換を許可したくありませんでした。最初は@Typeを使おうとしましたが、カスタムコンバーターを使用してマップをJSONとの間でシリアル化/逆シリアル化するため、@ Typeアノテーションを適用できませんでした。@ColumnアノテーションでcolumnDefinition = "json"を指定する必要があることがわかりました。
@Convert(converter = HashMapConverter.class)
@Column(name = "extra_fields", columnDefinition = "json")
private Map<String, String> extraFields;