Java 如何防止在使用hibernate多对多注释时在数据库中插入重复记录

添加用户可以很好地工作。 面临的问题是 正在添加任务n也在添加相应的用户，但“每次添加新用户时”，即使他存在于用户表中。这导致了桥接表中taskid n userid的不匹配..有人能帮我吗..这真的很重要..在r my POJO Users n Tasks下面。调用是由JSP文件完成的…等待任何帮助

@Entity
@Table(name ="Tasks")
public class Tasks implements Serializable
{
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
@Column (name = "t_Id")
private int Id;
@Column (name = "t_Name")
private String TaskName;
@Column (name = "t_Details")
private String TaskDetails;
@Column (name = "t_Status")
private int TaskStatus;
@ManyToMany(targetEntity = org.Users.class, fetch = FetchType.LAZY, cascade =       {CascadeType.ALL, CascadeType.PERSIST})
//@Cascade({ CascadeType.ALL})
@JoinTable(name = "user_Tasks", joinColumns = {@JoinColumn(name = "t_Id")},  inverseJoinColumns = {@JoinColumn(name = "u_Id")})
private Set <Users> users = new HashSet<Users>(0);

public Tasks(){}
public Tasks(String TaskName) {
    this.TaskName = TaskName;
}

public Tasks( String TaskName, String TaskDetails, int TaskStatus) {
    this.TaskName = TaskName;
    this.TaskDetails = TaskDetails;
    this.TaskStatus = TaskStatus;
}

public Tasks(String TaskName, String TaskDetails, int TaskStatus, Set<Users> users)
{
    this.TaskName = TaskName;
    this.TaskDetails = TaskDetails;
    this.TaskStatus = TaskStatus;
    this.users = users;
}
public int getId() {
    return Id;
}
 public void setId(int Id) {
    this.Id = Id;
}
public String getTaskName() {
    return TaskName;
}
 public void setTaskName(String TaskName) {
    this.TaskName = TaskName;
}
public String getTaskDetails() {
    return TaskDetails;
}
public void setTaskDetails(String TaskDetails) {
    this.TaskDetails = TaskDetails;
}
 public int getTaskStatus() {
    return TaskStatus;
}
public void setTaskStatus(int TaskStatus) {
    this.TaskStatus = TaskStatus;
}
public Set<Users> getUsers() {
    return users;
}
public void setUsers(Set<Users> users) {
    this.users = users;
}

}
@Entity
@Table(name = "USERS")
public class Users implements Serializable {
@Id 
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "u_Id")
private int Id;
@Column (name ="u_Name")        
private String Name;
@Column (name ="u_Username")
private String Username;
@Column (name="u_Password")
private String password;
@ManyToMany(targetEntity =org.Tasks.class, fetch = FetchType.LAZY, mappedBy="users", cascade ={CascadeType.ALL, CascadeType.PERSIST})
// @Cascade({CascadeType.ALL})
@JoinTable(name = "user_Tasks", joinColumns = {@JoinColumn(name = "u_Id")}, inverseJoinColumns = {@JoinColumn(name = "t_Id")})
private Set<Tasks> task = new HashSet<Tasks>();
public Users(){}
public Users(String Name) {
    this.Name = Name;
}

public int getId() {
    return Id;
}
public void setId(int Id) {
    this.Id = Id;
}
public String getName() {
    return Name;
}
 public void setName(String Name) {
    this.Name = Name;
}
public String getUsername() {
    return Username;
}
public void setUsername(String Username) {
    this.Username = Username;
}
public String getPassword() {
    return password;
}  
public void setPassword(String password) {
    this.password = password;
}

public Set<Tasks> getTask() {
    return task;
}

public void setTask(Set<Tasks> task) {
    this.task = task;
}
@Override
public int hashCode() {
    int hash = 7;
    hash = 19 * hash + (this.Name != null ? this.Name.hashCode() : 0);
    hash = 19 * hash + (this.Username != null ? this.Username.hashCode() : 0);
    hash = 19 * hash + (this.password != null ? this.password.hashCode() : 0);
    return hash;
 }
 @Override
 public boolean equals(Object obj) {
    if (obj == null) {
        return false;
    }
    if (getClass() != obj.getClass()) {
        return false;
    }
    final Users other = (Users) obj;
    if ((this.Name == null) ? (other.Name != null) : !this.Name.equals(other.Name)) {
        return false;
    }
    if ((this.Username == null) ? (other.Username != null) : !this.Username.equals(other.Username)) {
        return false;
    }
    if ((this.password == null) ? (other.password != null) : !this.password.equals(other.password)) {
        return false;
    }
    return true;
 }

}

public class ManageTasks

  public static void main(String arg[])
  {
  try
  {
  SessionFactory factory = new AnnotationConfiguration().configure().addPackage("org").addAnnotatedClass(Tasks.class).addAnnotatedClass(Users.class).buildSessionFactory();        
  }catch(Exception e)
  {
  System.out.println(e);
  }

  }
  public Integer addTasks(String TaskName, String TaskDetails, int  TaskStatus, Set use)
   {
  SessionFactory factory = new AnnotationConfiguration().configure().addPackage("org").addAnnotatedClass(Tasks.class).addAnnotatedClass(Users.class).buildSessionFactory();
  Session session = factory.openSession();
  Transaction tx = null;
  Integer taskID = null;
  try
  {  
      tx = session.beginTransaction();  
      Tasks task = new Tasks(TaskName, TaskDetails, TaskStatus);
      task.setUsers(use);

      session.save(task);
      tx.commit();      
  }catch(HibernateException e)
  {
  if(tx!=null) tx.rollback();
  e.printStackTrace();
  }
  finally
          {
              session.close();
          }    
  return taskID;
  }      
  public void addUser(String name, String username, String password)
{
   SessionFactory factory = new AnnotationConfiguration().configure().addPackage("org").addAnnotatedClass(Users.class).
                   buildSessionFactory();
    Session session = null;
    session = factory.openSession();
    Transaction tx = null;
    Integer userID = null;  
  try
  {
     tx = session.beginTransaction();
     Users user = new Users();
     user.setName(name);
     user.setUsername(username);
     user.setPassword(password);
     userID = (Integer) session.save(user); 
     tx.commit();
  }catch (HibernateException e)
  {
     if (tx!=null) tx.rollback();
     e.printStackTrace(); 
  }
  finally
  {
     session.close(); 
  }

 }   

@实体
@表（name=“Tasks”）
公共类任务实现可序列化
{
@Id@GeneratedValue（策略=GenerationType.IDENTITY）
@列（name=“t_Id”）
私有int-Id；
@列（name=“t_name”）
私有字符串TaskName；
@列（name=“t_详细信息”）
私有字符串详细信息；
@列（name=“t_状态”）
私人身份；
@ManyToMany（targetEntity=org.Users.class，fetch=FetchType.LAZY，cascade={CascadeType.ALL，CascadeType.PERSIST}）
//@级联（{CascadeType.ALL}）
@JoinTable（name=“user\u Tasks”，joinColumns={@JoinColumn（name=“t\u Id”）}，inverseJoinColumns={@JoinColumn（name=“u Id”）}）
私有集用户=新哈希集（0）；
公共任务（）{}
公共任务（字符串TaskName）{
this.TaskName=TaskName；
}
公共任务（字符串TaskName、字符串TaskDetails、int TaskStatus）{
this.TaskName=TaskName；
this.TaskDetails=TaskDetails；
this.TaskStatus=任务状态；
}
公共任务（字符串TaskName、字符串TaskDetails、int TaskStatus、设置用户）
{
this.TaskName=TaskName；
this.TaskDetails=TaskDetails；
this.TaskStatus=任务状态；
this.users=用户；
}
公共int getId（）{
返回Id；
}
公共无效集合Id（内部Id）{
这个.Id=Id；
}
公共字符串getTaskName（）{
返回任务名；
}
public void setTaskName（字符串TaskName）{
this.TaskName=TaskName；
}
公共字符串getTaskDetails（）{
返回任务详细信息；
}
public void setTaskDetails（字符串TaskDetails）{
this.TaskDetails=TaskDetails；
}
公共int getTaskStatus（）{
返回任务状态；
}
public void setTaskStatus（int TaskStatus）{
this.TaskStatus=任务状态；
}
公共集getUsers（）{
返回用户；
}
公共void集合用户（集合用户）{
this.users=用户；
}
}
@实体
@表（name=“USERS”）
公共类用户实现可序列化{
@身份证
@GeneratedValue（策略=GenerationType.IDENTITY）
@列（name=“u\u Id”）
私有int-Id；
@列（name=“u_name”）
私有字符串名称；
@列（name=“u\u用户名”）
私有字符串用户名；
@列（name=“u\u密码”）
私有字符串密码；
@ManyToMany（targetEntity=org.Tasks.class，fetch=FetchType.LAZY，mappedBy=“users”，cascade={CascadeType.ALL，CascadeType.PERSIST}）
//@Cascade（{CascadeType.ALL}）
@JoinTable（name=“user\u Tasks”，joinColumns={@JoinColumn（name=“u Id”）}，inverseJoinColumns={@JoinColumn（name=“t\u Id”）}）
私有集任务=新HashSet（）；
公共用户（）{}
公共用户（字符串名称）{
this.Name=Name；
}
公共int getId（）{
返回Id；
}
公共无效集合Id（内部Id）{
这个.Id=Id；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.Name=Name；
}
公共字符串getUsername（）{
返回用户名；
}
public void setUsername（字符串用户名）{
this.Username=用户名；
}
公共字符串getPassword（）{
返回密码；
}  
public void setPassword（字符串密码）{
this.password=密码；
}
公共集getTask（）{
返回任务；
}
公共无效设置任务（设置任务）{
this.task=任务；
}
@凌驾
公共int hashCode（）{
int hash=7；
hash=19*hash+（this.Name！=null？this.Name.hashCode（）：0）；
hash=19*hash+（this.Username！=null？this.Username.hashCode（）：0）；
hash=19*hash+（this.password！=null？this.password.hashCode（）：0）；
返回散列；
}
@凌驾
公共布尔等于（对象obj）{
if（obj==null）{
返回false；
}
如果（getClass（）！=obj.getClass（））{
返回false；
}
最终用户其他=（用户）obj；
如果（（this.Name==null）？（other.Name！=null）：！this.Name.equals（other.Name））{
返回false；
}
如果（（this.Username==null）？（other.Username！=null）：！this.Username.equals（other.Username））{
返回false；
}
如果（（this.password==null）？（other.password！=null）：！this.password.equals（other.password））{
返回false；
}
返回true；
}
}
公共类管理任务
公共静态void main（字符串arg[]）
{
尝试
{
SessionFactory=newannotationconfiguration（）.configure（）.addPackage（“org”）.addAnnotatedClass（Tasks.class）.addAnnotatedClass（Users.class）.buildSessionFactory（）；
}捕获（例外e）
{
系统输出打印ln（e）；
}
}
public Integer addTasks（字符串TaskName、字符串TaskDetails、int TaskStatus、Set use）
{
SessionFactory=newannotationconfiguration（）.configure（）.addPackage（“org”）.addAnnotatedClass（Tasks.class）.addAnnotatedClass（Users.class）.buildSessionFactory（）；
Session Session=factory.openSession（）；
事务tx=null；
整数taskID=null；
尝试
{  
tx=session.beginTransaction（）；
任务任务=新任务（任务名称、任务详细信息、任务状态）；
task.setUsers（使用）；
session.save（任务）；
tx.commit（）；
}捕获（休眠异常e）
{
如果（tx！=null）tx.rollback（）；
e、 printStackTrace（）；
}
最后
{
session.close（）；
}    
返回taskID；
}      
public void addUser（字符串名称、字符串用户名、字符串密码）
{
SessionFactory factory=new AnnotationConfiguration（）.configure（）.addPackage（“org”）.addAnnotatedClass（Users.class）。
buildSessionFactory（）；
会话=空；
session=factory.openSession（）；
事务tx=null；
整数userID=null；
尝试
{
tx=session.beginTransaction（）；
用户=新用户（）；
user.setName（name）；
user.setUsername（用户名）；
user.setPassword（密码）；
userID=（整数）se
String taskname = request.getParameter("taskname");
String taskdetails = request.getParameter("taskdetails");
tring user1 = request.getParameter("user1");
String user2 = request.getParameter("user2");
String user3 = request.getParameter("user3");
Set <Users> user = new HashSet <Users>();
user.add(new Users(user1));
user.add(new Users(user2));
user.add(new Users(user3));
nt TaskStatus;
if(taskname == null && taskdetails == null)
TaskStatus = 0;
else
TaskStatus = 1;

ManageTasks mt = new ManageTasks();
mt.addTasks(taskname, taskdetails, TaskStatus, user);
out.println("Sucessfully added!!");