mappedby=?,后面的这个问号跟拥有方,以下是实例。
Role.java
package com.nbg.nuskin.oa.domain;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
/**
*
*
* @author Administrator
*
*/
@Entity
public class Role {
private long id;
private Set<Privilege> privileges = new HashSet<Privilege>();
@Id
@GeneratedValue
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
//大家一定要注意这里,没有mappedby,拥有方是属于privilege的
@ManyToMany
public Set<Privilege> getPrivileges() {
return privileges;
}
public void setPrivileges(Set<Privilege> privileges) {
this.privileges = privileges;
}
}
Privilege.java
package com.nbg.nuskin.oa.domain;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OrderBy;
@Entity
public class Privilege {
private Long id;
private Set<Role> roles = new HashSet<Role>();
@Id
@GeneratedValue
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
//拥有方是Privilege.java
@ManyToMany(mappedBy = "privileges")
public Set<Role> getRoles() {
return roles;
}
public void setRoles(Set<Role> roles) {
this.roles = roles;
}
}
下面是RoleAction.java对Role的操作
package com.nbg.nuskin.oa.action;
import java.util.HashSet;
import java.util.List;
import javax.annotation.Resource;
import com.nbg.nuskin.oa.domain.Privilege;
import com.nbg.nuskin.oa.domain.Role;
import com.nbg.nuskin.oa.service.PrivilegeService;
import com.nbg.nuskin.oa.service.RoleService;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
public class RoleAction extends ActionSupport implements ModelDriven<Role> {
private RoleService roleService;
protected Role model = new Role();
public RoleService getRoleService() {
return roleService;
}
@Resource(name = "roleService")
public void setRoleService(RoleService roleService) {
this.roleService = roleService;
}
/**
* 设置权限
*
* @return
*/
public String setPrivilege() {
Role role = roleService.getById(model.getId());
System.out.println(role.getName()+";"+role.getDescription());
List<Privilege> privileges = privilegeService.getByIds(privilegeIds);
role.setPrivileges(new HashSet<Privilege>(privileges));
roleService.update(role);
return "toList";
}
public Long[] getPrivilegeIds() {
return privilegeIds;
}
public void setPrivilegeIds(Long[] privilegeIds) {
this.privilegeIds = privilegeIds;
}
}
只有这样设置mappeby,在上面的action中才能够操作相应的privilege
mappedby原理:被拥有方改变,即拥有方主动关联操作关联关系;拥有方改变,不一定操作相关的关联关系
上面的mappedby如果设在roles这边,privileges就不会进行sql的update操作。
版权声明:本文为博主原创文章,未经博主允许不得转载。
分享到:
相关推荐
在双向关联中,需要在两个实体类的属性上分别添加`@OneToMany`和`@ManyToOne`注解,并通过`mappedBy`属性指定关联的另一端。 ```java @Entity public class User { @Id private Integer id; // ... @OneToMany...
每个关联注解都有各自的属性,如mappedBy、cascade、fetch等,用于控制关联的细节。 7. **懒加载和立即加载注解(@LazyCollection and @Fetch)** Hibernate提供了懒加载和立即加载两种机制。`@LazyCollection`用于...
在其中一个实体类中,`@OneToOne`注解通常会与`mappedBy`属性一起使用,指定另一方实体的属性作为关联的导航字段。在另一个实体类中,直接在对应的属性上使用`@OneToOne`注解即可。 例如,我们有`Student`和`...
这里的`mappedBy`属性指定了在另一端的实体字段名,`@JoinColumn`则定义了外键所在的列名。 **双向关联** 在上述例子中,我们定义了一个双向关联,即`Student`能够访问其关联的`Course`列表,同时`Course`也能知道...
`mappedBy`所在的那一方是`inverse`,不负责维护关联关系,而`owner`则负责维护关联关系。 在实际开发中,我们还需要注意以下几点: 1. **级联操作**:通过`CascadeType`可以指定在操作一个实体时,是否同时对关联...
此外,还需要通过`mappedBy`属性指定关联的字段。 ### 3. 多对一关系 多对一关系与一对多关系相反,即多个实体对应一个实体。例如,多个订单可以属于一个客户。在Hibernate中,`@ManyToOne`注解用于多方实体,`@...
在以上代码中,`Student`实体的`courses`属性通过`mappedBy`指定了`Course`实体的`students`属性作为反向引用。而`Course`实体的`students`属性则通过`@JoinTable`定义了中间表`student_course`以及两个外键列`...
这个注解通常会配合`mappedBy`属性使用,指定多方实体中的引用字段,表明多方如何回指一方。 接着,我们讨论双向关联。在一对多关联的基础上,如果双方都能看到对方,那么就形成了双向关联。双向关联使得在操作一方...
`mappedBy`属性指定了反向引用的属性名,`@JoinColumn`用于指定外键所在的列。 接下来,我们来看多对多关联映射。在数据库中,多对多关系表示两个表中的记录都可以相互关联。在Hibernate中,这通常通过中间表(或...
在Hibernate中,我们通常通过在一方的类中添加`@OneToOne`注解,并指定`mappedBy`属性来映射到另一方的主键。例如,Person类的配置可能是这样的: ```java @Entity public class Person { @Id private int id; ...
Spring JPA ManyToMany 原理及用法详解 Spring JPA 中的 ManyToMany 关系是...在使用 ManyToMany 关系时,我们需要使用 @ManyToMany 注解,并结合 @JoinTable 使用,并且需要使用 mappedBy 属性来指定拥有关系的字段。
@OneToOne(mappedBy = "person", cascade = CascadeType.ALL) private Address address; // ... } @Entity public class Address { @Id @GeneratedValue(strategy=GenerationType.AUTO) private Long id; ...
@OneToMany(mappedBy = "table1", fetch = FetchType.LAZY) private List<Table2> table2List; // ... } Session session = HibernateUtil.getSessionFactory().openSession(); Transaction tx = session.begin...
在这里,`mappedBy`属性用于指定对方实体中的字段,而`@JoinColumn`则用于指定外键所在的表和列。 2. **XML配置方式** 如果不使用注解,我们可以在`hibernate.cfg.xml`或`persistence.xml`中进行配置。例如: `...
使用`@OneToMany`注解,可以通过`mappedBy`属性指定多的一方维护关系,或者在一方使用`@JoinColumn`指定外键。 3. **多对一(Many-to-One)**:多个实体可以关联到一个实体,例如多个学生属于一个班级。使用`@...
这里,`mappedBy`属性用于指定另一端的属性名,`joinColumns`和`inverseJoinColumns`分别表示当前实体在中间表中的外键。 ### 3. 添加关联 添加关联可以通过调用`add`方法向集合中添加元素。例如,将学生添加到...
2. 在"多"端,需要定义一个引用"一"端的字段,并添加`@ManyToOne`注解,同时`mappedBy`属性应与"一"端的`@OneToMany`注解中的`mappedBy`值相同。 ```java @Entity public class Course { @ManyToOne @JoinColumn...
可以通过`mappedBy`属性指定关联的反向属性。 6. `@JoinColumn`: 在一对多或一对一关系中,这个注解用于定义外键所在的列。`@JoinTable`在多对多关系中用于定义连接表的相关属性。 7. `@OrderBy`: 可以在一对多...