hibernate联合主键

如何数据库表只有一个主键，咱们能够这样配置

<hibernate-mapping package="com.study.model">
<class name="Student" table="student12"> 
    <id name="id" column="id">
       <generator class="native"></generator>
    </id>
    <property name="name" column="name" type="java.lang.String"></property>
    <property name="age"  column="age" type="java.lang.Integer"></property>
</class>
</hibernate-mapping>

或者咱们用annotation：通常将@id写在get方法上，其实也可卸载field字段上，可是那样的话会破坏pojo原则

@Id
@GeneratedValue(strategy=GenerationType.IDENTITY) //指定id的生成策略 
public int getId() {
 return id;
}

可是如何咱们的数据库表有两个主键该怎么办呢？答案是：compose key联合主键

注意：（1）咱们必须用另外一个类做为咱们的主键类，在第一个pojo中调用这个主键类

          （2）在主键类中，咱们必须重写他的equals()和hashcode（）方法！

            理由：咱们的类都间接或者直接集成自object类，而在object中的equals和hashcode方法以下：

               hashcode介绍：  http://blog.csdn.net/jason_deng/article/details/7074230

 public boolean equals(Object obj) {
        return (this == obj);
    }

 public native int hashCode();

  既然equals方法只是比较两个类是否“==”，那么，对于主键类就是比较每一个字段是否相等。

  hashcode主要是表征对象的惟一性

         （3）主键类还必须实现serializable接口，主要考虑到类的在网络传递，在不一样存储介质上转存

下面咱们就来写咱们本身的联合主键：

一、主键pojo类：

public class composeIdPK implements Serializable {
 private String name;
 private int id;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 @Override
 public boolean equals(Object o) {
  composeIdPK pk = null;
  if (o instanceof composeIdPK)
   pk = (composeIdPK) o;
  if (pk.getId() == this.id && pk.getName().equals(this.name))
   return true;
  return false;
 }
 
 @Override
 public int hashCode()
 {   //重写hashcode方法，放回name的hashcode便可
  return this.name.hashCode();
 }
 
}

pojo类

package com.study.model;
public class composeId {
 
 //定义主键是由类承当 
 private composeIdPK pk;
 private int uid;
 private String title;
 private String address;
 
 public int getUid() {
  return uid;
 }
 public void setUid(int uid) {
  this.uid = uid;
 }
 public composeIdPK getPk() {
  return pk;
 }
 public void setPk(composeIdPK pk) {
  this.pk = pk;
 }
 public String getTitle() {
  return title;
 }
 public void setTitle(String title) {
  this.title = title;
 }
 public String getAddress() {
  return address;
 }
 public void setAddress(String address) {
  this.address = address;
 }
 
}

配置文件：

<hibernate-mapping package="com.study.model">
<class name="composeId" table="composeIDTest">
  //composite—id代表下面是一个联合主键 
 <composite-id name="pk" class="com.study.model.composeIdPK">
      <key-property name="id"></key-property>
      <key-property name="name"></key-property>
  </composite-id>
    <property name="title" column="title" type="java.lang.String"></property>
    <property name="address"  column="address" type="java.lang.String"></property>
</class>
</hibernate-mapping>

说明：

节点（composite-id）代表是一个联合主键，可是在<class name="composeId" table="composeIDTest">
的束缚下，代表是com.study.model.composeId下的联合主键，而且name=pk必须是和composeId下一致，由于在调用的时候会直接用pk的getter方法调用composeIdPK类从而取得该pojo类的主键

测试类：

@Test
 public  void test() {
try {
  composeIdPK pk=new composeIdPK();
  pk.setId(1);
  pk.setName("jackvin");
  composeId compose=new composeId();
 compose.setTitle("hah");
 compose.setAddress("sffds");
 compose.setPk(pk);
  //由Configuration拿到SessionFactory再难道session
//Configuratin用来读取配置文件 
 //Configuration cfg=new Configuration();
Configuration cfg=new AnnotationConfiguration();

  cfg.configure();//默认查找classpath下的hibernate.cfg.xml
//SessionFactory能够理解为取得connection的 工厂
  SessionFactory factory=cfg.buildSessionFactory(); 
//数据库的一个connection
  Session session=factory.openSession();
  session.beginTransaction();
     session.save(compose);
     session.getTransaction().commit(); 
     session.close();
     factory.close();

  } catch (Exception e) {

   // TODO: handle exception

   e.printStackTrace();

  }
  fail("Not yet implemented");

 }

ok测试经过