欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Hibernate [email protected]共享主键关联

程序员文章站 2022-04-22 16:10:51
...

文章表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")
[email protected]
@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