Question:Why is person_emails empty once PopulateData.afterPropertiesSet() runs?
Database contents after PopulateData.afterPropertiesSet() runs:Code:
mysql> select * from person_emails;
Empty set (0.00 sec)
mysql> select * from emails;
+----+---------------------+-------------+----------+----------------+
| id | created | description | name | value |
+----+---------------------+-------------+----------+----------------+
| 1 | 2009-07-01 13:21:19 | NULL | Other |
[email protected] |
| 2 | 2009-07-01 13:21:19 | NULL | Work |
[email protected] |
| 3 | 2009-07-01 13:21:19 | NULL | Personal |
[email protected] |
| 4 | 2009-07-01 13:21:19 | NULL | Admin |
[email protected] |
+----+---------------------+-------------+----------+----------------+
4 rows in set (0.01 sec)
mysql> select * from persons;
+----+---------------------+-------+-------+--------+------+--------+
| id | created | birth | first | gender | last | middle |
+----+---------------------+-------+-------+--------+------+--------+
| 1 | 2009-07-01 13:21:19 | NULL | Test | NULL | User | NULL |
| 2 | 2009-07-01 13:21:19 | NULL | Admin | NULL | User | NULL |
+----+---------------------+-------+-------+--------+------+--------+
2 rows in set (0.01 sec)
mysql> select * from members;
+----+---------------------+----------+----------+--------+
| id | created | password | username | person |
+----+---------------------+----------+----------+--------+
| 1 | 2009-07-01 13:21:19 | test | test | 1 |
| 2 | 2009-07-01 13:21:19 | admin | admin | 2 |
+----+---------------------+----------+----------+--------+
2 rows in set (0.00 sec)
mysql> show create table person_emails;
| person_emails | CREATE TABLE `person_emails` (
`persons_id` bigint(20) NOT NULL,
`emails_id` bigint(20) NOT NULL,
PRIMARY KEY (`persons_id`,`emails_id`),
KEY `FKADA310811EAC00B6` (`persons_id`),
KEY `FKADA31081C962EC01` (`emails_id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 |
mysql> desc person_emails;
+------------+------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+------------+------------+------+-----+---------+-------+
| persons_id | bigint(20) | NO | PRI | NULL | |
| emails_id | bigint(20) | NO | PRI | NULL | |
+------------+------------+------+-----+---------+-------+
2 rows in set (0.00 sec)
Code:
@Repository("populateData")
@Transactional
public class PopulateData implements InitializingBean {
private static final Logger log = LoggerFactory.getLogger(PopulateData.class);
private SessionFactory sessionFactory;
@Autowired
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
// @Transactional(propagation=Propagation.REQUIRES_NEW)
public void afterPropertiesSet() throws Exception {
log.debug("Building Member Data");
Session sess = sessionFactory.openSession();
for (int i = 0; i < MEMBERS.length; i++) {
Member m= new Member();
m.setUsername(MEMBERS[i][0]);
m.setPassword(MEMBERS[i][0]);
m.setCreated(new Date());
Person p = new Person();
p.setMember(m);
p.setCreated(new Date());
p.setFirst(MEMBERS[i][1]);
p.setLast(MEMBERS[i][2]);
m.setPerson(p);
for (int j = 0; j < EMAILS[i].length; j++) {
Email email = new Email();
String data[] = EMAILS[i][j].split("[|]");
email.setCreated(new Date());
email.setName(data[0]);
email.setValue(data[1]);
p.addEmail(email);
}
sess.save(m);
}
}
private static final String[][] MEMBERS = {
{"test","Test","User"},
{"admin","Admin","User"}
};
private static final String[][] EMAILS = {
{"Personal|
[email protected]","Work|
[email protected]","Other|
[email protected]"},
{"Admin|
[email protected]"}
};
}
Code:
@Entity
@Table(name="members")
@Cache(usage= CacheConcurrencyStrategy.READ_WRITE)
public class Member extends AbstractEntity {
private static final long serialVersionUID = 1L;
private String username;
private String password;
private Person person;
public Member() {
super();
}
@Basic(optional=false)
@Column(length=100)
@Index(name="idx_members_username")
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
@Basic(optional=false)
@Column(length=255)
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@OneToOne(cascade = CascadeType.ALL)
@JoinColumn(name = "person")
// @PrimaryKeyJoinColumn
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
}
Person.javaCode:
@Entity
@Table(name="persons")
@Cache(usage= CacheConcurrencyStrategy.READ_WRITE)
public class Person extends AbstractEntity {
private static final long serialVersionUID = 1L;
private String first;
private String last;
private Member member;
private Set<Email> emails = new HashSet<Email>();
public Person() {
super();
}
@Basic(optional=false)
@Column(length=50)
@Index(name="idx_person_first")
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
@Basic(optional=false)
@Column(length=50)
@Index(name="idx_person_last")
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
@OneToOne(mappedBy = "person")
public Member getMember() {
return member;
}
public void setMember(Member member) {
this.member = member;
}
@ManyToMany(cascade = CascadeType.ALL)
@JoinTable(name="person_emails")
@Cache(usage=CacheConcurrencyStrategy.READ_WRITE)
public Set<Email> getEmails() {
return this.emails;
}
public void setEmails(Set<Email> emails) {
this.emails = emails;
}
public Email hasEmail(Email email) {
if (this.emails.contains(email)) {
return email;
}
return null;
}
public boolean addEmail(Email email) {
return this.emails.add(email);
}
public boolean removeEmail(Email email) {
return this.emails.remove(email);
}
}
Email.javaCode:
@Entity
@Table(name="emails")
@Cache(usage= CacheConcurrencyStrategy.READ_WRITE)
public class Email extends NamedEntity {
private static final long serialVersionUID = 1L;
private String value;
public Email() {
}
@Basic
@Column(length=255)
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
}
NamedEntity.javaCode:
@MappedSuperclass
@Cache(usage= CacheConcurrencyStrategy.READ_WRITE)
public abstract class NamedEntity extends AbstractEntity {
private static final long serialVersionUID = 1L;
private String name;
private String description;
public NamedEntity() {
super();
}
@Basic(optional=false)
@Column(length=100)
@Index(name="idx_name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Lob
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
}
AbstractEntity.javaCode:
@MappedSuperclass
@Cache(usage= CacheConcurrencyStrategy.READ_WRITE)
public abstract class AbstractEntity implements IEntity {
private static final long serialVersionUID = 1L;
private Long id;
private Date created;
public AbstractEntity() {
super();
}
@Id
@GeneratedValue
public Long getId() {
return this.id;
}
@SuppressWarnings("unused")
private void setId(Long id) {
this.id = id;
}
@Temporal(TemporalType.TIMESTAMP)
@Index(name="idx_entity_created")
public Date getCreated() {
return created;
}
public void setCreated(Date created) {
this.created = created;
}
}
Login
FAQ
Search
