Hibernate annotation@OneToOne共享主键关联

文章表article表,文章内容表:article_data表

article_data表的主键同时也是外键对应的值是article表的主键

SQL:

CREATE TABLE `article` (                               
           `id` int(10) unsigned NOT NULL AUTO_INCREMENT,       
           `title` varchar(145) NOT NULL,                       
           `sub_title` varchar(145) NOT NULL,                   
           `add_time` datetime NOT NULL,                        
           PRIMARY KEY (`id`)                                   
         ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8


CREATE TABLE `article_data` (                                                            
                `article_id` int(10) unsigned NOT NULL DEFAULT '0',                                    
                `content` varchar(2045) NOT NULL DEFAULT '',                                           
                PRIMARY KEY (`article_id`),                                                            
                CONSTRAINT `FK_article_data_1` FOREIGN KEY (`article_id`) REFERENCES `article` (`id`)  
              ) ENGINE=InnoDB DEFAULT CHARSET=utf8     

 下面是两个domain类:

IdEntity类:

@MappedSuperclass
public class IdEntity<T extends java.io.Serializable> implements Serializable {
	private T id;
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	public T getId() {
		return id;
	}

	public void setId(T id) {
		this.id = id;
	}
	/**
	 * 指示其他某个对象是否与此对象“相等”
	 */
	@Override
	public boolean equals(Object obj) {
		// 自身比较
		if (obj == this) {
			return true;
		}
		// 类型相同
		if (obj.getClass() == this.getClass()) {
			// 当前类反射方法组
			Method[] thisMethodGroup = this.getClass().getMethods();
			
			try {
				// 遍历反射方法组并提取当前类属性的getter方法
				for (Method method : thisMethodGroup) {
					// 过滤与当前类属性无关的get方法
					if (method.getName().startsWith("get")
						&& !method.getName().equals("getClass")) {
						// 将当前类属性的getter方法与比较类属性的getter方法值作比较
						Method currentMethod = obj.getClass().getMethod(method.getName());
						// 执行方法以获取返回值比较(关键点：注意参数不相同)
						Object objReturnValue = currentMethod.invoke(obj);
						Object thisReturnValue = method.invoke(this);
						// 空值报异
						if (objReturnValue == null) {
							System.err.println("异常信息：类" + obj.getClass().getName() 
								+ "中的" + currentMethod.getName() + "方法为null值！无法进行对象比较！");
						}
						if (thisReturnValue == null) {
							System.err.println("异常信息：类" + this.getClass().getName() 
								+ "中的" + method.getName() + "方法为null值！无法进行对象比较！");
						}
						// 返回值不相等则返回逻辑假
						if (!objReturnValue.equals(thisReturnValue)) {
							return false;
						}
					}
				}					
			} catch (SecurityException ex) {
				System.err.println("异常信息：参数错误，安全管理器检测到安全侵犯！\r\n" + ex.getMessage());
			} catch (NoSuchMethodException ex) {
				System.err.println("异常信息：参数错误，无法找到某一特定的方法！\r\n" + ex.getMessage());
			} catch (IllegalArgumentException ex) {
				System.err.println("异常信息：参数错误，向方法传递了一个不合法或不正确的参数！\r\n" + ex.getMessage());
			} catch (IllegalAccessException ex) {
				System.err.println("异常信息：参数错误，对象定义无法访问，无法反射性地创建一个实例！\r\n" + ex.getMessage());
			} catch (InvocationTargetException ex) {
				System.err.println("异常信息：参数错误，由调用方法或构造方法所抛出异常的经过检查的异常！\r\n" + ex.getMessage());
			}
		}
		
		// 通过不相等比较则返回逻辑真
		return true;
		
	}

	/**
	 * 返回该对象的哈希码值
	 */
	@Override
	public int hashCode() {

		// 生成简单的位运算hash散列码
		String key = this.toString();
		int prime = key.hashCode();
		int hash = prime;
		for (int i = 0; i < key.length(); i++) {
		     hash ^= (hash << 23 >> 17) ^ key.charAt(i) * 13131;
		}
		// 返回结果
		return (hash % prime) * 33;
		
	}

	/**
	 * 返回该对象的字符串表示(类似数组的toString方法输出结果)
	 */
	@Override
	public String toString() {
		
		// 当前类反射方法组
		Method[] methodGroup = this.getClass().getMethods();
		// 保存内容
		StringBuffer content = new StringBuffer("[");
		// 保存属性的getter方法组
		List<Method> getMethodGroup = new Vector<Method>();
		
		try {
			// 遍历反射方法组并提取属性的getter方法
			for (Method method : methodGroup) {
				// 过滤与属性无关的get方法
				if (method.getName().startsWith("get")
					&& !method.getName().equals("getClass")) {
					// 保存属性的getter方法
					getMethodGroup.add(method);
				}
			}
			// 处理仅包含属性的getter方法
			for (int i = 0; i < getMethodGroup.size(); i++) {
				// 执行get方法并拼接获取到的返回值(如果底层方法返回类型为 void，则该调用返回 null)
				content.append(getMethodGroup.get(i).invoke(this) 
					+ ((i < getMethodGroup.size() - 1) ? ",\u0020" : "]"));
			}
		} catch (IllegalAccessException ex) {
			System.err.println("异常信息：参数错误，对象定义无法访问，无法反射性地创建一个实例！\r\n" + ex.getMessage());
		} catch (IllegalArgumentException ex) {
			System.err.println("异常信息：参数错误，向方法传递了一个不合法或不正确的参数！\r\n" + ex.getMessage());
		} catch (InvocationTargetException ex) {
			System.err.println("异常信息：参数错误，由调用方法或构造方法所抛出异常的经过检查的异常！\r\n" + ex.getMessage());
		}
		
		// 返回结果
		return content.toString();
		
	}
}

 Aricle类:

@Entity
@Table(name = "article")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Aricle extends IdEntity<Integer> {
	/**
	 * 
	 */
	private static final long serialVersionUID = -8056490229900614401L;
	private String title;
	private String subTitle;
	private Date addTime;

	private AricleDetail aricleDetail;

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getSubTitle() {
		return subTitle;
	}

	public void setSubTitle(String subTitle) {
		this.subTitle = subTitle;
	}

	@Temporal(TemporalType.TIMESTAMP)
	public Date getAddTime() {
		return addTime;
	}

	public void setAddTime(Date addTime) {
		this.addTime = addTime;
	}
	@OneToOne(fetch = FetchType.LAZY, optional = false)
	@PrimaryKeyJoinColumn
	public AricleDetail getAricleDetail() {
		return aricleDetail;
	}

	public void setAricleDetail(AricleDetail aricleDetail) {
		this.aricleDetail = aricleDetail;
	}

}

 

AricleDetail类:

@Entity
@Table(name = "article_data")
public class AricleDetail {
	private static final long serialVersionUID = 1782600851147896229L;
	@Id
	@GeneratedValue(generator = "pkGenerator")
	@GenericGenerator(name = "pkGenerator", strategy = "foreign", parameters = @Parameter(name = "property", value = "aricle"))
	@Column(name = "article_id")
	private Integer articleId;
	private String content;
	@OneToOne(mappedBy="aricleDetail",optional=false) 
	private Aricle aricle;

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

	public Integer getArticleId() {
		return articleId;
	}

	public void setArticleId(Integer articleId) {
		this.articleId = articleId;
	}

	public Aricle getAricle() {
		return aricle;
	}

	public void setAricle(Aricle aricle) {
		this.aricle = aricle;
	}
}

 

三、具体说明

(参考网络文章)
1.@PrimaryKeyJoinColumn

也可以这样写 @PrimaryKeyJoinColumn(name="id",referencedColumnName="article_id")
    告诉hibernate使用主键作为关联字段 大体相当于@JoinColumn(name="id",referencedColumnName="article_id")
2.@Id
@GeneratedValue(generator = "pkGenerator")
@GenericGenerator(name = "pkGenerator", strategy = "foreign", parameters = @Parameter(name = "property", value = "aricle"))
   这段注解的意思是 使用当前对象中aricle属性的主键来作为本对象的主键

3.@OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL, optional = false)
    optional很重要 指定关联属性不能为空
    如果想要实现延迟加载就一定要将这个属性设置为false
    这是因为JPA需要知道对应的数据是否存在后 才能决定是创建一个"延迟代理"还是"null引用"
    所以就不得不发起一条SQL请求来验证

参考:

http://exceedsun21320070508164500.iteye.com/blog/370806