{"id":143,"date":"2011-07-07T07:10:43","date_gmt":"2011-07-07T14:10:43","guid":{"rendered":"http:\/\/sloanseaman.com\/wordpress\/?p=143"},"modified":"2011-07-07T07:11:49","modified_gmt":"2011-07-07T14:11:49","slug":"setting-on-a-set","status":"publish","type":"post","link":"http:\/\/sloanseaman.com\/wordpress\/2011\/07\/07\/setting-on-a-set\/","title":{"rendered":"Setting on a Set()"},"content":{"rendered":"

Maybe this post should be called ‘Setting on a Sunset()’ but Oracle now owns Java, and ‘Setting on an OracleSet()’ sounds programmatically correct but it just doesn’t have the same ring (or the feel of a nice drink in your hand while sitting on a beach….. writing java ;)) <\/p>\n

Anyway, there are many times when dealing with an ORM that you might want to call a setter on an object that exists in a 1-Many relationship and have that set() method do some other work.<\/p>\n

For instance, say you have two objects (using JPA Annotations):<\/p>\n

\r\n@Entity\r\n@Table(name="USER")\r\npublic class User {\r\n   @Id\r\n   @Column(name="ID")\r\n   private Long id;\r\n\r\n   @Column(name="NAME")\r\n   private String name;\r\n\r\n   @ManyToOne(fetch=FetchType.LAZY)\r\n   @JoinColumn(name = "COMPANY_ID", referencedColumnName = "ID", nullable = false)\r\n   private Company company;\r\n   \r\n   public Long getId() { return id; }\r\n   public void setId(Long id) { this.id = id; }\r\n\r\n   public String getName() { return name; }\r\n   public void setName(String name) { this.name = name; }\r\n\r\n   public Company getCompany() { return company; }\r\n   public void setCompany(Company company) { this.company = company }\r\n}\r\n\r\n@Entity\r\n@Table(name="COMPANY")\r\npublic class Company {\r\n   @Id\r\n   @Column(name="ID")\r\n   private Long id;\r\n\r\n   @Column(name="NAME")\r\n   private String name;\r\n\r\n   @OneToMany(fetch = FetchType.LAZY, mappedBy = "company", \r\n          cascade = { CascadeType.MERGE, CascadeType.PERSIST })\r\n   private Set<User> users = new HashSet<User>(0);\r\n\r\n   public Long getId() { return id; }\r\n   public void setId(Long id) { this.id = id; }\r\n\r\n   public String getName() { return name; }\r\n   public void setName(String name) { this.name = name; }\r\n\r\n   public Set<User> getUsers() { return users; }\r\n   public void setUsers(Set<User> users) { this.users = users; }\r\n}\r\n<\/pre>\n
This is a pretty straightforward, standard way of making a 1-Many relationship in an ORM (my experience is with Hibernate mainly).  <\/p>\n
Side note:
\nMy HashSet was initially set to a size of 0.  If a Collection has the possibility of staying empty you should initialize it to 0 because otherwise some implementation will immediate make it 10 spaces and you will waste memory.  However, initializing it to 0 also means that we take a small performance hit when we first put something into it since it has to allocate space.  I’m just suggesting that you put some thought into it \ud83d\ude09<\/p>\n
So lets start using our objects and set some things:<\/p>\n
\r\n... some method definition...\r\nCompany company = new Company();\r\ncompany.setName("World Wide Wicket");\r\n\r\nUser user = new User();\r\nuser.setName("Sloan");\r\nuser.setCompany(company);\r\ncompany.addUser(user);\r\n.... more code ...\r\n<\/pre>\n
Doesn’t that seem a bit annoying?  You set the Company in the User but then you have to add the User to the Companies list of Users.  Wouldn’t it be better to just call one method to accomplish this?  Shouldn’t you just have to set the Company in the User and that be it (or just add the User to the list of Users in the Company)?<\/p>\n
So I was thinking about this and I came up with a few different ways.  I’ll go over them and also what is good\/bad about them as well as any other pitfalls I have identified.<\/p>\n
Custom Set implementation<\/h3>\n
The first thing I thought was: Well, I can create my own collection so that when it is called it will do things for me.  That would look something like:<\/p>\n
\r\npublic class Company {\r\n@Id\r\n   @Column(name="ID")\r\n   private Long id;\r\n\r\n   @Column(name="NAME")\r\n   private String name;\r\n\r\n   @OneToMany(fetch = FetchType.LAZY, mappedBy = "company", \r\n          cascade = { CascadeType.MERGE, CascadeType.PERSIST })\r\n   private Set<User> users = new UserHashSet<User>(this);\r\n\r\n   public Long getId() { return id; }\r\n   public void setId(Long id) { this.id = id; }\r\n\r\n   public String getName() { return name; }\r\n   public void setName(String name) { this.name = name; }\r\n\r\n   public Set<User> getUsers() { return users; }\r\n   public void setUsers(Set<User> users) { this.users = users; }\r\n\r\n   public class UserHashSet extends HashSet<User> {\r\n      private Company company;\r\n\r\n      public UserHashSet(Company company) {\r\n         this.company = company;\r\n      }\r\n\r\n      public void add(User user) {\r\n         super.add(user);\r\n         user.setCompany(company);\r\n      }\r\n\r\n      ... do the same for addAll ...\r\n   }\r\n}\r\n<\/pre>\n
Pros:<\/h4>\n
    \n
  • The code is pretty straight forward for the developers when adding:\n<\/li>\n<\/ul>\n
    \r\ncompany.getUsers().add(user);\r\n<\/pre>\n
    Cons:<\/h4>\n
      \n
    • You have to code a whole other class<\/li>\n
    • If someone calls company.setUsers() they can override your UserHashSet and add() will no longer work correctly<\/li>\n
    • Developers, if playing it safe, would still probable do:<\/li>\n<\/ul>\n
      \r\ncompany.getUsers().add(user);\r\nuser.setCompany(company);\r\n<\/pre>\n
      So, as slick as this may be in some ways, I don’t think it’s the way to go because it allows the developers to still do additional work as well as really screw things up.<\/p>\n
      Code in set() and an add() method<\/h3>\n
      Another option is to put some code in the User.setCompany() and create a method in the Company called addUser().  Something like:<\/p>\n
      \r\n@Entity\r\n@Table(name="USER")\r\npublic class User {\r\n   @Id\r\n   @Column(name="ID")\r\n   private Long id;\r\n\r\n   @Column(name="NAME")\r\n   private String name;\r\n\r\n   @ManyToOne(fetch=FetchType.LAZY)\r\n   @JoinColumn(name = "COMPANY_ID", referencedColumnName = "ID", nullable = false)\r\n   private Company company;\r\n   \r\n   public Long getId() { return id; }\r\n   public void setId(Long id) { this.id = id; }\r\n\r\n   public String getName() { return name; }\r\n   public void setName(String name) { this.name = name; }\r\n\r\n   public Company getCompany() { return company; }\r\n   public void setCompany(Company company) { \r\n      this.company = company \r\n      company.getUsers().add(this);\r\n   }\r\n}\r\n\r\n@Entity\r\n@Table(name="COMPANY")\r\npublic class Company {\r\n   @Id\r\n   @Column(name="ID")\r\n   private Long id;\r\n\r\n   @Column(name="NAME")\r\n   private String name;\r\n\r\n   @OneToMany(fetch = FetchType.LAZY, mappedBy = "company", \r\n          cascade = { CascadeType.MERGE, CascadeType.PERSIST })\r\n   private Set<User> users = new HashSet<User>(0);\r\n\r\n   public Long getId() { return id; }\r\n   public void setId(Long id) { this.id = id; }\r\n\r\n   public String getName() { return name; }\r\n   public void setName(String name) { this.name = name; }\r\n\r\n   public Set<User> getUsers() { return users; }\r\n   public void setUsers(Set<User> users) { this.users = users; }\r\n\r\n   public void addUser(User user) {\r\n      user.setCompany(user);\r\n   }\r\n}\r\n<\/pre>\n
      Pros:<\/h4>\n