How to persist a property of type List String in JPA

Question

What is the smartest way to get an entity with a field of type List persisted   Command java  package persistlistofstring   import java io Serializable  import java util ArrayList  import java util List  import javax persistence Basic  import javax persistence Entity  import javax persistence EntityManager  import javax persistence GeneratedValue  import javax persistence GenerationType  import javax persistence Id  import javax persistence Persistence    Entity public class Command implements Serializable         Id      GeneratedValue strategy   GenerationType AUTO      Long id       Basic     List lt String gt  arguments   new ArrayList lt String gt          public static void main String   args            Command command   new Command             EntityManager em   Persistence                  createEntityManagerFactory  pu                    createEntityManager            em getTransaction   begin            em persist command           em getTransaction   commit            em close             System out println  Persisted with id     command id               This code produces    gt  Exception in thread  main  javax persistence PersistenceException  No Persistence provider for EntityManager named pu  Provider named oracle toplink essentials PersistenceProvider threw unexpected exception at create EntityManagerFactory    gt  oracle toplink essentials exceptions PersistenceUnitLoadingException  gt  Local Exception Stack    gt  Exception  TOPLINK-30005   Oracle TopLink Essentials - 2 0 1  Build b09d-fcs  12 06 2007     oracle toplink essentials exceptions PersistenceUnitLoadingException  gt  Exception Description  An exception was thrown while searching for persistence archives with ClassLoader  sun misc Launcher AppClassLoader 11b86e7  gt  Internal Exception  javax persistence PersistenceException  Exception  TOPLINK-28018   Oracle TopLink Essentials - 2 0 1  Build b09d-fcs  12 06 2007     oracle toplink essentials exceptions EntityManagerSetupException  gt  Exception Description  predeploy for PersistenceUnit  pu  failed   gt  Internal Exception  Exception  TOPLINK-7155   Oracle TopLink Essentials - 2 0 1  Build b09d-fcs  12 06 2007     oracle toplink essentials exceptions ValidationException  gt  Exception Description  The type  interface java util List  for the attribute  arguments  on the entity class  class persistlistofstring Command  is not a valid type for a serialized mapping  The attribute type must implement the Serializable interface   gt          at oracle toplink essentials exceptions PersistenceUnitLoadingException exceptionSearchingForPersistenceResources PersistenceUnitLoadingException java 143   gt          at oracle toplink essentials ejb cmp3 EntityManagerFactoryProvider createEntityManagerFactory EntityManagerFactoryProvider java 169   gt          at javax persistence Persistence createEntityManagerFactory Persistence java 110   gt          at javax persistence Persistence createEntityManagerFactory Persistence java 83   gt          at persistlistofstring Command main Command java 30   gt  Caused by    gt

User · Answer

This answer was made pre-JPA2 implementations, if you're using JPA2, see the ElementCollection answer above:

Lists of objects inside a model object are generally considered "OneToMany" relationships with another object. However, a String is not (by itself) an allowable client of a One-to-Many relationship, as it doesn't have an ID.

So, you should convert your list of Strings to a list of Argument-class JPA objects containing an ID and a String. You could potentially use the String as the ID, which would save a little space in your table both from removing the ID field and by consolidating rows where the Strings are equal, but you would lose the ability to order the arguments back into their original order (as you didn't store any ordering information).

Alternatively, you could convert your list to @Transient and add another field (argStorage) to your class that is either a VARCHAR() or a CLOB. You'll then need to add 3 functions: 2 of them are the same and should convert your list of Strings into a single String (in argStorage) delimited in a fashion that you can easily separate them. Annotate these two functions (that each do the same thing) with @PrePersist and @PreUpdate. Finally, add the third function that splits the argStorage into the list of Strings again and annotate it @PostLoad. This will keep your CLOB updated with the strings whenever you go to store the Command, and keep the argStorage field updated before you store it to the DB.

I still suggest doing the first case. It's good practice for real relationships later.

User · Answer

According to Java Persistence with Hibernate     mapping collections of value types with annotations        At the time of writing it isn t part of the Java Persistence standard   If you were using Hibernate  you could do something like    org hibernate annotations CollectionOfElements      targetElement   java lang String class    JoinTable      name    foo       joinColumns    JoinColumn name    foo id      org hibernate annotations IndexColumn      name    POSITION   base   1    Column name    baz   nullable   false  private List lt String gt  arguments   new ArrayList lt String gt       Update  Note  this is now available in JPA2

User · Answer

When using the Hibernate implementation of JPA   I ve found that simply declaring the type as an ArrayList instead of List allows hibernate to store the list of data     Clearly this has a number of disadvantages compared to creating a list of Entity objects   No lazy loading  no ability to reference the entities in the list from other objects  perhaps more difficulty in constructing database queries   However when you are dealing with lists of fairly primitive types that you will always want to eagerly fetch along with the entity  then this approach seems fine to me    Entity public class Command implements Serializable         Id      GeneratedValue strategy   GenerationType AUTO      Long id       ArrayList lt String gt  arguments   new ArrayList lt String gt

User · Answer

This answer was made pre-JPA2 implementations, if you're using JPA2, see the ElementCollection answer above:

Lists of objects inside a model object are generally considered "OneToMany" relationships with another object. However, a String is not (by itself) an allowable client of a One-to-Many relationship, as it doesn't have an ID.

So, you should convert your list of Strings to a list of Argument-class JPA objects containing an ID and a String. You could potentially use the String as the ID, which would save a little space in your table both from removing the ID field and by consolidating rows where the Strings are equal, but you would lose the ability to order the arguments back into their original order (as you didn't store any ordering information).

Alternatively, you could convert your list to @Transient and add another field (argStorage) to your class that is either a VARCHAR() or a CLOB. You'll then need to add 3 functions: 2 of them are the same and should convert your list of Strings into a single String (in argStorage) delimited in a fashion that you can easily separate them. Annotate these two functions (that each do the same thing) with @PrePersist and @PreUpdate. Finally, add the third function that splits the argStorage into the list of Strings again and annotate it @PostLoad. This will keep your CLOB updated with the strings whenever you go to store the Command, and keep the argStorage field updated before you store it to the DB.

I still suggest doing the first case. It's good practice for real relationships later.

User · Answer

My fix for this issue was to separate the primary key with the foreign key  If you are using eclipse and made the above changes please remember to refresh the database explorer  Then recreate the entities from the tables

User · Answer

Use some JPA 2 implementation  it adds a  ElementCollection annotation  similar to the Hibernate one  that does exactly what you need  There s one example here   Edit  As mentioned in the comments below  the correct JPA 2 implementation is  javax persistence ElementCollection   ElementCollection Map lt Key  Value gt  collection    See  http   docs oracle com javaee 6 api javax persistence ElementCollection html

User · Answer

Here is the solution for storing a Set using  Converter and StringTokenizer  A bit more checks against  jonck-van-der-kogel solution   In your Entity class    Convert converter   StringSetConverter class   Column private Set lt String gt  washSaleTickers    StringSetConverter   package com model domain converters   import javax persistence AttributeConverter  import javax persistence Converter  import java util HashSet  import java util Set  import java util StringTokenizer    Converter public class StringSetConverter implements AttributeConverter lt Set lt String gt   String gt        private final String GROUP DELIMITER     IWILLNEVERHAPPEN          Override     public String convertToDatabaseColumn Set lt String gt  stringList            if  stringList    null                return new String                      return String join GROUP DELIMITER  stringList               Override     public Set lt String gt  convertToEntityAttribute String string            Set lt String gt  resultingSet   new HashSet lt  gt             StringTokenizer st   new StringTokenizer string  GROUP DELIMITER           while  st hasMoreTokens                resultingSet add st nextToken             return resultingSet

User · Answer

Ok i know its bit late  But for those brave souls that will see this as time passes    As written in documentation       Basic    The simplest type of mapping to a database column  The Basic annotation can be applied to a persistent property or instance variable of any of the following types  Java primitive types         enums  and any other type that implements java io Serializable    The important part is type that implements Serializable  So by far the most simple and easiest to use solution is simply using ArrayList instead of List  or any serializable container     Basic ArrayList lt Color gt  lovedColors    Basic ArrayList lt String gt  catNames    Remember however that this will use system serialization  so it will come with some price  such as     if serialized object model will change  u might not be able to restore data small overhead is added for each element stored    In short  it is quite simple to store flags or few elements  but i would not    recomend it to store data that might grow big

User · Answer

This answer was made pre-JPA2 implementations, if you're using JPA2, see the ElementCollection answer above:

Lists of objects inside a model object are generally considered "OneToMany" relationships with another object. However, a String is not (by itself) an allowable client of a One-to-Many relationship, as it doesn't have an ID.

So, you should convert your list of Strings to a list of Argument-class JPA objects containing an ID and a String. You could potentially use the String as the ID, which would save a little space in your table both from removing the ID field and by consolidating rows where the Strings are equal, but you would lose the ability to order the arguments back into their original order (as you didn't store any ordering information).

Alternatively, you could convert your list to @Transient and add another field (argStorage) to your class that is either a VARCHAR() or a CLOB. You'll then need to add 3 functions: 2 of them are the same and should convert your list of Strings into a single String (in argStorage) delimited in a fashion that you can easily separate them. Annotate these two functions (that each do the same thing) with @PrePersist and @PreUpdate. Finally, add the third function that splits the argStorage into the list of Strings again and annotate it @PostLoad. This will keep your CLOB updated with the strings whenever you go to store the Command, and keep the argStorage field updated before you store it to the DB.

I still suggest doing the first case. It's good practice for real relationships later.

User · Answer

We can also use this    Column name  arguments    ElementCollection targetClass String class  private List lt String gt  arguments

User · Answer

Thiago answer is correct  adding sample more specific to question   ElementCollection will create new table in your database  but without mapping two tables  It means that the collection is not a collection of entities  but a collection of simple types  Strings  etc   or a collection of embeddable elements  class annotated with  Embeddable     Here is the sample to persist list of String   ElementCollection private Collection lt String gt  options   new ArrayList lt String gt       Here is the sample to persist list of Custom object   Embedded  ElementCollection private Collection lt Car gt  carList   new ArrayList lt Car gt       For this case we need to make class Embeddable    Embeddable public class Car

User · Answer

My fix for this issue was to separate the primary key with the foreign key  If you are using eclipse and made the above changes please remember to refresh the database explorer  Then recreate the entities from the tables

User · Answer

I had the same problem so I invested the possible solution given but at the end I decided to implement my     separated list of String   so I have     a   separated list of arguments String arguments   public List lt String gt  getArguments         return Arrays asList arguments split            This way the list is easily readable editable in the database table

User · Answer

Thiago answer is correct  adding sample more specific to question   ElementCollection will create new table in your database  but without mapping two tables  It means that the collection is not a collection of entities  but a collection of simple types  Strings  etc   or a collection of embeddable elements  class annotated with  Embeddable     Here is the sample to persist list of String   ElementCollection private Collection lt String gt  options   new ArrayList lt String gt       Here is the sample to persist list of Custom object   Embedded  ElementCollection private Collection lt Car gt  carList   new ArrayList lt Car gt       For this case we need to make class Embeddable    Embeddable public class Car

User · Answer

When using the Hibernate implementation of JPA   I ve found that simply declaring the type as an ArrayList instead of List allows hibernate to store the list of data     Clearly this has a number of disadvantages compared to creating a list of Entity objects   No lazy loading  no ability to reference the entities in the list from other objects  perhaps more difficulty in constructing database queries   However when you are dealing with lists of fairly primitive types that you will always want to eagerly fetch along with the entity  then this approach seems fine to me    Entity public class Command implements Serializable         Id      GeneratedValue strategy   GenerationType AUTO      Long id       ArrayList lt String gt  arguments   new ArrayList lt String gt

User · Answer

Here is the solution for storing a Set using  Converter and StringTokenizer  A bit more checks against  jonck-van-der-kogel solution   In your Entity class    Convert converter   StringSetConverter class   Column private Set lt String gt  washSaleTickers    StringSetConverter   package com model domain converters   import javax persistence AttributeConverter  import javax persistence Converter  import java util HashSet  import java util Set  import java util StringTokenizer    Converter public class StringSetConverter implements AttributeConverter lt Set lt String gt   String gt        private final String GROUP DELIMITER     IWILLNEVERHAPPEN          Override     public String convertToDatabaseColumn Set lt String gt  stringList            if  stringList    null                return new String                      return String join GROUP DELIMITER  stringList               Override     public Set lt String gt  convertToEntityAttribute String string            Set lt String gt  resultingSet   new HashSet lt  gt             StringTokenizer st   new StringTokenizer string  GROUP DELIMITER           while  st hasMoreTokens                resultingSet add st nextToken             return resultingSet

User · Answer

It seems none of the answers explored the most important settings for a  ElementCollection mapping  When you map a list with this annotation and let JPA Hibernate auto-generate the tables  columns  etc   it ll use auto-generated names as well  So  let s analyze a basic example   Entity  Table name    quot sample quot   public class MySample         Id      GeneratedValue     private Long id        ElementCollection    1      CollectionTable name    quot my list quot   joinColumns    JoinColumn name    quot id quot       2      Column name    quot list quot      3     private List lt String gt  list           The basic  ElementCollection annotation  where you can define the known fetch and targetClass preferences  The  CollectionTable annotation is very useful when it comes to giving a name to the table that ll be generated  as well as definitions like joinColumns  foreignKey s  indexes  uniqueConstraints  etc   Column is important to define the name of the column that ll store the varchar value of the list   The generated DDL creation would be  -- table sample CREATE TABLE sample     id bigint 20  NOT NULL AUTO INCREMENT    PRIMARY KEY  id      -- table my list CREATE TABLE IF NOT EXISTS my list     id bigint 20  NOT NULL    list varchar 255  DEFAULT NULL    FOREIGN KEY  id  REFERENCES sample  id

User · Answer

It seems none of the answers explored the most important settings for a  ElementCollection mapping  When you map a list with this annotation and let JPA Hibernate auto-generate the tables  columns  etc   it ll use auto-generated names as well  So  let s analyze a basic example   Entity  Table name    quot sample quot   public class MySample         Id      GeneratedValue     private Long id        ElementCollection    1      CollectionTable name    quot my list quot   joinColumns    JoinColumn name    quot id quot       2      Column name    quot list quot      3     private List lt String gt  list           The basic  ElementCollection annotation  where you can define the known fetch and targetClass preferences  The  CollectionTable annotation is very useful when it comes to giving a name to the table that ll be generated  as well as definitions like joinColumns  foreignKey s  indexes  uniqueConstraints  etc   Column is important to define the name of the column that ll store the varchar value of the list   The generated DDL creation would be  -- table sample CREATE TABLE sample     id bigint 20  NOT NULL AUTO INCREMENT    PRIMARY KEY  id      -- table my list CREATE TABLE IF NOT EXISTS my list     id bigint 20  NOT NULL    list varchar 255  DEFAULT NULL    FOREIGN KEY  id  REFERENCES sample  id

User · Answer

Sorry to revive an old thread but should anyone be looking for an alternative solution where you store your string lists as one field in your database  here s how I solved that  Create a Converter like this  import java util Arrays  import java util List   import javax persistence AttributeConverter  import javax persistence Converter   import static java util Collections      Converter public class StringListConverter implements AttributeConverter lt List lt String gt   String gt        private static final String SPLIT CHAR    quot   quot             Override     public String convertToDatabaseColumn List lt String gt  stringList            return stringList    null   String join SPLIT CHAR  stringList     quot  quot               Override     public List lt String gt  convertToEntityAttribute String string            return string    null   Arrays asList string split SPLIT CHAR     emptyList             Now use it on your Entities like this   Convert converter   StringListConverter class  private List lt String gt  yourList   In the database  your list will be stored as foo bar foobar  and in your Java object you will get a list with those strings  Hope this is helpful to someone

User · Answer

When using the Hibernate implementation of JPA   I ve found that simply declaring the type as an ArrayList instead of List allows hibernate to store the list of data     Clearly this has a number of disadvantages compared to creating a list of Entity objects   No lazy loading  no ability to reference the entities in the list from other objects  perhaps more difficulty in constructing database queries   However when you are dealing with lists of fairly primitive types that you will always want to eagerly fetch along with the entity  then this approach seems fine to me    Entity public class Command implements Serializable         Id      GeneratedValue strategy   GenerationType AUTO      Long id       ArrayList lt String gt  arguments   new ArrayList lt String gt

User · Answer

Use some JPA 2 implementation  it adds a  ElementCollection annotation  similar to the Hibernate one  that does exactly what you need  There s one example here   Edit  As mentioned in the comments below  the correct JPA 2 implementation is  javax persistence ElementCollection   ElementCollection Map lt Key  Value gt  collection    See  http   docs oracle com javaee 6 api javax persistence ElementCollection html

User · Answer

According to Java Persistence with Hibernate     mapping collections of value types with annotations        At the time of writing it isn t part of the Java Persistence standard   If you were using Hibernate  you could do something like    org hibernate annotations CollectionOfElements      targetElement   java lang String class    JoinTable      name    foo       joinColumns    JoinColumn name    foo id      org hibernate annotations IndexColumn      name    POSITION   base   1    Column name    baz   nullable   false  private List lt String gt  arguments   new ArrayList lt String gt       Update  Note  this is now available in JPA2

User · Answer

When using the Hibernate implementation of JPA   I ve found that simply declaring the type as an ArrayList instead of List allows hibernate to store the list of data     Clearly this has a number of disadvantages compared to creating a list of Entity objects   No lazy loading  no ability to reference the entities in the list from other objects  perhaps more difficulty in constructing database queries   However when you are dealing with lists of fairly primitive types that you will always want to eagerly fetch along with the entity  then this approach seems fine to me    Entity public class Command implements Serializable         Id      GeneratedValue strategy   GenerationType AUTO      Long id       ArrayList lt String gt  arguments   new ArrayList lt String gt

User · Answer

This answer was made pre-JPA2 implementations, if you're using JPA2, see the ElementCollection answer above:

Lists of objects inside a model object are generally considered "OneToMany" relationships with another object. However, a String is not (by itself) an allowable client of a One-to-Many relationship, as it doesn't have an ID.

So, you should convert your list of Strings to a list of Argument-class JPA objects containing an ID and a String. You could potentially use the String as the ID, which would save a little space in your table both from removing the ID field and by consolidating rows where the Strings are equal, but you would lose the ability to order the arguments back into their original order (as you didn't store any ordering information).

Alternatively, you could convert your list to @Transient and add another field (argStorage) to your class that is either a VARCHAR() or a CLOB. You'll then need to add 3 functions: 2 of them are the same and should convert your list of Strings into a single String (in argStorage) delimited in a fashion that you can easily separate them. Annotate these two functions (that each do the same thing) with @PrePersist and @PreUpdate. Finally, add the third function that splits the argStorage into the list of Strings again and annotate it @PostLoad. This will keep your CLOB updated with the strings whenever you go to store the Command, and keep the argStorage field updated before you store it to the DB.

I still suggest doing the first case. It's good practice for real relationships later.

User · Answer

I had the same problem so I invested the possible solution given but at the end I decided to implement my     separated list of String   so I have     a   separated list of arguments String arguments   public List lt String gt  getArguments         return Arrays asList arguments split            This way the list is easily readable editable in the database table

User · Answer

Ok i know its bit late  But for those brave souls that will see this as time passes    As written in documentation       Basic    The simplest type of mapping to a database column  The Basic annotation can be applied to a persistent property or instance variable of any of the following types  Java primitive types         enums  and any other type that implements java io Serializable    The important part is type that implements Serializable  So by far the most simple and easiest to use solution is simply using ArrayList instead of List  or any serializable container     Basic ArrayList lt Color gt  lovedColors    Basic ArrayList lt String gt  catNames    Remember however that this will use system serialization  so it will come with some price  such as     if serialized object model will change  u might not be able to restore data small overhead is added for each element stored    In short  it is quite simple to store flags or few elements  but i would not    recomend it to store data that might grow big

User · Answer

According to Java Persistence with Hibernate     mapping collections of value types with annotations        At the time of writing it isn t part of the Java Persistence standard   If you were using Hibernate  you could do something like    org hibernate annotations CollectionOfElements      targetElement   java lang String class    JoinTable      name    foo       joinColumns    JoinColumn name    foo id      org hibernate annotations IndexColumn      name    POSITION   base   1    Column name    baz   nullable   false  private List lt String gt  arguments   new ArrayList lt String gt       Update  Note  this is now available in JPA2

User · Answer

Sorry to revive an old thread but should anyone be looking for an alternative solution where you store your string lists as one field in your database  here s how I solved that  Create a Converter like this  import java util Arrays  import java util List   import javax persistence AttributeConverter  import javax persistence Converter   import static java util Collections      Converter public class StringListConverter implements AttributeConverter lt List lt String gt   String gt        private static final String SPLIT CHAR    quot   quot             Override     public String convertToDatabaseColumn List lt String gt  stringList            return stringList    null   String join SPLIT CHAR  stringList     quot  quot               Override     public List lt String gt  convertToEntityAttribute String string            return string    null   Arrays asList string split SPLIT CHAR     emptyList             Now use it on your Entities like this   Convert converter   StringListConverter class  private List lt String gt  yourList   In the database  your list will be stored as foo bar foobar  and in your Java object you will get a list with those strings  Hope this is helpful to someone

User · Answer

We can also use this    Column name  arguments    ElementCollection targetClass String class  private List lt String gt  arguments

User · Answer

According to Java Persistence with Hibernate     mapping collections of value types with annotations        At the time of writing it isn t part of the Java Persistence standard   If you were using Hibernate  you could do something like    org hibernate annotations CollectionOfElements      targetElement   java lang String class    JoinTable      name    foo       joinColumns    JoinColumn name    foo id      org hibernate annotations IndexColumn      name    POSITION   base   1    Column name    baz   nullable   false  private List lt String gt  arguments   new ArrayList lt String gt       Update  Note  this is now available in JPA2

[java] How to persist a property of type List<String> in JPA?

Examples related to java

Examples related to orm

Examples related to jpa