~SingleForum~无废话记录~: Recent Topics

~SingleForum~无废话记录~: Recent Topics http://www.ll19.com/bb/ ~19~记录点有用的好吗？少说废话少装b~ en Sat, 31 Jul 2010 18:09:02 +0000 admin on "innodb和myisam" http://www.ll19.com/bb/topic/123#post-123 Tue, 12 Jan 2010 03:13:54 +0000 admin 123@http://www.ll19.com/bb/ myisam属于非事务安全型，innodb和bdb属于事务安全型，在使用上，包括建立表，insert，select等等操作上有没有什么区别。但是myisam引擎速度比较快、比较简单、而InnoDB支持外键、其速度相对就慢了。 MyISAM类型的表强调的是性能，其执行数度比InnoDB类型更快，但是不提供事务支持，而InnoDB提供事务支持已经外部键等高级数据库功能。这样就可以根据数据表不同的用处是用不同的存储类型。另外，MyISAM类型的二进制数据文件可以在不同操作系统中迁移。也就是可以直接从Windows系统拷贝到linux系统中使用。所以我一般都是使用myisam，因为这次用的也不是很深入的。 如果把这类型从MyISAM转成 InnoDB会不会有问题、但是全文索引失效. 使用两种的选择：如果你的数据执行大量的INSERT或UPDATE，出于性能方面的考虑，应该使用InnoDB表。如果执行大量的SELECT，MyISAM是更好的选择。若需要使用事务处理，但是原来的数据表使用的是myisam，就需要改为bdb或者innodb，这样基于myisam的程序，将类型改为innodb后，其程序不用改动…… admin on "MySQL 更改表的字符编码" http://www.ll19.com/bb/topic/122#post-122 Tue, 12 Jan 2010 02:41:06 +0000 admin 122@http://www.ll19.com/bb/ MySQL 更改表的字符编码

PLAIN TEXT

SQL:

ALTER TABLE privilege(1) convert TO character SET utf8 collate utf8_general_ci(2);

(1)表示要改的表的字符编码 (2)表示要改成什么样的字符编码 admin on "js array的排序" http://www.ll19.com/bb/topic/121#post-121 Mon, 11 Jan 2010 03:51:51 +0000 admin 121@http://www.ll19.com/bb/ 简单的排序

PLAIN TEXT

JAVASCRIPT:

var arrayValue=new Array();
arrayValue[0]=10;
arrayValue[1]=5;
arrayValue[2]=4;
arrayValue.sort(function(a,b){return b-a;});
alert (arrayValue[0]);

数组的排序:sort()方法. 但sort()方法本身是按ASCII字符代码从小到大排列的.所以说,如果是数字的话,可能会有问题，但是: sort()方法可以接收一个比较函数的参数。 下面的例子：

PLAIN TEXT

JAVASCRIPT:

function compareint(int1, int2){
var iNum1 = parseInt(int1);//强制转换成int 型;
var iNum2 = parseInt(int2);
if(iNum1 &lt; iNum2){
return -1;
}else if(iNum1 &gt; iNum2){
return 1;
}else{
return 0;
}
}
var arr = [3, 32, 2, 5];
arr.sort(compareint);
alert(arr.toString());//输出:2,3,5,32

admin on "关于onsubmit不执行 - -" http://www.ll19.com/bb/topic/120#post-120 Mon, 11 Jan 2010 03:49:31 +0000 admin 120@http://www.ll19.com/bb/ button执行的函数中，执行document.forms[0].submit();是不执行onsubmit事件的。 只有点击submit按钮的时候才执行 即form 中的onsubmit="return check();" 或 document.test.onsubmit = function () { alert (3322); return false; }; 之类~ 即使是在form中加入了 onsubmit="return check();" 用button执行函数来document.forms[0].submit(); 也不会执行onsubmit事件 admin on "获取浏览器可视方法" http://www.ll19.com/bb/topic/119#post-119 Mon, 11 Jan 2010 03:46:39 +0000 admin 119@http://www.ll19.com/bb/ 获取浏览器可视方法 var de=document.documentElement; var db=document.body; var viewW=de.clientWidth==0 ? db.clientWidth : de.clientWidth; var viewH=de.clientHeight==0 ? db.clientHeight : de.clientHeight; 可以全屏显示FLASH用 admin on "jquery的Unbind" http://www.ll19.com/bb/topic/118#post-118 Mon, 11 Jan 2010 03:40:23 +0000 admin 118@http://www.ll19.com/bb/ Unbind只是用来解除bind上去的函数的 所以如果你想这么去删的话那就不要直接写onclick 而是 jQuery(document).ready(function(){ 用bind去加 admin on "Spring调用存储过程一个小记录" http://www.ll19.com/bb/topic/117#post-117 Sun, 03 Jan 2010 16:38:05 +0000 admin 117@http://www.ll19.com/bb/ Spring调用存储过程一个小记录

PLAIN TEXT

JAVA:

public void testSpringPackage() {
SpringStoredProce springStoredProce = new SpringStoredProce(this
.getJdbcTemplate());
List&lt;Map&gt; resultList = springStoredProce.execute(0, 10,
" and t.seed_name_cn like '%竹%' ");
for (int i = 0; i &lt; resultList.size(); i++) {
Map rowMap = resultList.get(i);
final String userId = rowMap.get("seed_name_cn").toString();
final String name = rowMap.get("g_name_cn").toString();
final String password = rowMap.get("tagsids").toString();
System.out.println("USER_ID=" + userId + "\t name=" + name
+ "\t password=" + password);
}
}

PLAIN TEXT

JAVA:

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.CallableStatementCallback;
import org.springframework.jdbc.core.CallableStatementCreator;
import org.springframework.jdbc.core.JdbcTemplate;
import com.rizon.eiss.util.StringUtils;
public class SpringStoredProce {
private JdbcTemplate jdbcTemplate;
public SpringStoredProce(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
public List&lt;Map&gt; execute(long start_no, long end_no, String filter) {
List&lt;Map&gt; resultList = null;
try {
resultList = (List&lt;Map&gt;) this.jdbcTemplate.execute(
new ProcCallableStatementCreator(start_no, end_no, filter),
new ProcCallableStatementCallback());
} catch (DataAccessException e) {
throw new RuntimeException(
"execute method error : DataAccessException "
+ e.getMessage());
}
return resultList;
}
/**
* Create a callable statement in this connection.
*/
private class ProcCallableStatementCreator implements
CallableStatementCreator {
private long start_no;
private long end_no;
private String filter;
public ProcCallableStatementCreator(long start_no, long end_no,
String filter) {
this.start_no = start_no;
this.end_no = end_no;
this.filter = filter;
}
public CallableStatement createCallableStatement(Connection conn) {
CallableStatement cs = null;
try {
cs = conn.prepareCall("{call TREE_PACKAGE.TREE_FIND(?,?,?,?)}");
cs.registerOutParameter(1, oracle.jdbc.OracleTypes.CURSOR);
cs.setLong(2, start_no);
cs.setLong(3, end_no);
cs.setString(4, filter);
} catch (SQLException e) {
throw new RuntimeException(
"createCallableStatement method Error : SQLException "
+ e.getMessage());
}
return cs;
}
}
private class ProcCallableStatementCallback implements
CallableStatementCallback {
public ProcCallableStatementCallback() {
}
public Object doInCallableStatement(CallableStatement cs) {
List&lt;Map&gt; resultsMap = new ArrayList&lt;Map&gt;();
try {
cs.execute();
ResultSet rs = (ResultSet) cs.getObject(1);
while (rs.next()) {
Map&lt;String, Object&gt; rowMap = new HashMap&lt;String, Object&gt;();
rowMap.put("t_id", rs.getLong("t_id"));
rowMap.put("status", StringUtils.Trim(rs.getString("status")));
rowMap.put("tree_name", StringUtils.Trim(rs.getString("tree_name")));
rowMap.put("seed_name_cn", StringUtils.Trim(rs.getString("seed_name_cn")));
rowMap.put("seed_name_en", StringUtils.Trim(rs.getString("seed_name_en")));
rowMap.put("seed_comment", StringUtils.Trim(rs.getString("seed_comment")));
rowMap.put("gid", StringUtils.Trim(rs.getString("gid")));
rowMap.put("g_name_cn", StringUtils.Trim(rs.getString("g_name_cn")));
rowMap.put("g_name_en", StringUtils.Trim(rs.getString("g_name_en")));
rowMap.put("g_class", StringUtils.Trim(rs.getString("g_class")));
rowMap.put("tagsname", StringUtils.Trim(rs.getString("tagsname")));
rowMap.put("tagsids", StringUtils.Trim(rs.getString("tagsids")));
rowMap.put("tags_des", StringUtils.Trim(rs.getString("tags_des")));
resultsMap.add(rowMap);
}
rs.close();
} catch (SQLException e) {
throw new RuntimeException(
"doInCallableStatement method error : SQLException "
+ e.getMessage());
}
return resultsMap;
}
}
}

admin on "DWR返回LIST" http://www.ll19.com/bb/topic/116#post-116 Sun, 03 Jan 2010 16:32:16 +0000 admin 116@http://www.ll19.com/bb/ DWR返回LIST list中如果装载的不是基本类型的数据，而是java bean的话，需要在dwr.xml中配置convert参数，才能在页面上将数据转换成js对象。 如果配置了这个参数的话，在页面上使用data.XXX来访问该对象中的属性。比如有个user对象里面有name属性，和getName方法，则只需要使用data.name来取得该值。 LIST中的BEAN其实就是转换成了JSON 具体做法如下（网络搜索的例子） dwr.xml里的代码如下：

PLAIN TEXT

XML:

&lt;dwr&gt;
&lt;allow&gt;
&lt;create creator="new" javascript="DwrTest"&gt;
&lt;param name="class" value="com.Dao.DwrTest"/&gt;
&lt;/create&gt;
&lt;convert match="com.Action.Admin" converter="bean" &gt;
&lt;param name="include" value="id,admin_Name,admin_Pwd,mark_id" /&gt; // Admin的bean中包含这四个属性，bean文件内容我就不贴出来了，
&lt;/convert&gt;
&lt;/allow&gt;
&lt;/dwr&gt;

TestDao类的内容如下：

PLAIN TEXT

JAVA:

public class TestDao{
private static Connection conn = Conn.GetConn(); //获得数据库连接
public List&lt;Admin&gt; Send(int mark){
List&lt;Admin&gt; list = new ArrayList&lt;Admin&gt;();
try {
Statement stat = conn.createStatement();
String QueryStr = "select * from admin_info where mark_id="+mark+"";
ResultSet rs = stat.executeQuery(QueryStr);
while(rs.next()){
Admin admin = new Admin();
admin.setId(rs.getInt(1));
admin.setAdmin_Name(rs.getString(2));
admin.setAdmin_Pwd(rs.getString(3));
admin.setMark_id(rs.getInt(4));
list.add(admin);
}
} catch (SQLException e) {
e.printStackTrace();
}
return list;
}
}

DwrTest类内容如下： [java] public class DwrTest{ TestDao dao= new TestDao(); public List<Admin> Send(int mark) { return dao.Send(mark); } } [java] jsp文件内容如下：

PLAIN TEXT

HTML:

&lt;html&gt;
&lt;head&gt;
&lt;meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"&gt;
&lt;TITLE&gt;DWR返回list的一个简单例子&lt;/TITLE&gt;
&lt;meta http-equiv=Content-Type content="text/html; charset=gb2312"&gt;
&lt;script src="dwr/engine.js"&gt;&lt;/script&gt;
&lt;script src="dwr/util.js"&gt;&lt;/script&gt;
&lt;script src="dwr/interface/DwrTest.js"&gt;&lt;/script&gt;
&lt;SCRIPT LANGUAGE="JavaScript"&gt;
function CallBack(data) {
if (data.length == 0) {
alert("参数传递出现错误!");
}else{
for(var i=0;i&lt;data.length;i++){
addRow(data[i].admin_Name,data[i].admin_Pwd,data[i].mark_id); // 表格添加一行
}
}
}
function Send(mark){
DwrTest.Send(mark,CallBack);
}
function showTable(mark){
var i=1;
for(i=form1.maxrow.value; i&gt;0 ; i--)
{
deleteRow(i);
}
form1.maxrow.value = 0;
Send(mark); // 通过mark参数来判断要动态显示的内容
}
function deleteRow(index){
var tableObj=document.getElementById("mytable");
tableObj.deleteRow(index);
}
function addRow(username,password,mark_id){
var tableObj=document.getElementById("mytable");
var newRowObj=tableObj.insertRow(tableObj.rows.length);
var newColName=newRowObj.insertCell(newRowObj.cells.length);
var newColPwd=newRowObj.insertCell(newRowObj.cells.length);
var newColMrk=newRowObj.insertCell(newRowObj.cells.length);
newColName.innerHTML=username;
newColPwd.innerHTML=password;
newColMrk.innerHTML=mark_id;
form1.maxrow.value = parseInt(form1.maxrow.value) + 1;
}
&lt;/SCRIPT&gt;
&lt;BODY&gt;
&lt;form name="form1" &gt;
&lt;p align="center"&gt;
&lt;input type="button" value="用户类别一 " onmouseover="showTable(1)"&gt; // 传参数 mark=1
&lt;input type="button" value="用户类别二" onmouseover="showTable(2)"&gt;
&lt;input type="button" value="用户类别三" onmouseover="showTable(3)"&gt;
&lt;input type="button" value="用户类别四" onmouseover="showTable(4)"&gt;
&lt;/p&gt;
&lt;table width="50%" id="mytable" border="1" bordercolor="whitesmoke"&gt;
&lt;tr align="center"&gt;&lt;td&gt;用户名&lt;/td&gt;&lt;td&gt;密码&lt;/td&gt;&lt;td类别&lt;/td&gt;&lt;/tr&gt;
&lt;/table&gt;
&lt;input type="hidden" name="maxrow" value="0"&gt;
&lt;/form&gt;
&lt;/body&gt;
&lt;/html&gt;

admin on "DWR调用的java代码中使用Session,Request,Responsed" http://www.ll19.com/bb/topic/115#post-115 Sun, 03 Jan 2010 16:29:56 +0000 admin 115@http://www.ll19.com/bb/ 在Java的服务方法中定义这些类型的参数,让DWR自动传入相应的对象： HttpServletRequest,HttpServletResponse,HttpSession,ServletContext,ServletConfig. 示例如下: Java端定义方法: saveOrder(String id, String name, HttpSession session) Javascript调用: OrderService.saveOrder(jsID,jsName,callBack) 注意,这里不需要传入session这个参数,DWR会自动传入,在Java端可以直接使用. admin on "DWR提交整个表单" http://www.ll19.com/bb/topic/114#post-114 Sun, 03 Jan 2010 16:28:28 +0000 admin 114@http://www.ll19.com/bb/

PLAIN TEXT

JAVASCRIPT:

function callBackFun() {
// formMap是整个表单
var formMap = DWRUtil.getValues("aform");
dwrTree.addTags(formMap, result);
function result(data) {
if (data == "success") {
alert ("添加成功！");
//jQuery("#ajax-response").show().html("添加成功！").fadeOut(5000);
jQuery("#name").val("");
jQuery("#slug").val("");
jQuery("#order").val("");
} else {
alert (data);
//jQuery("#ajax-response").show().html(data).fadeOut(5000);
}
}
}

admin on "Hibernate复合主键的配置及调用" http://www.ll19.com/bb/topic/113#post-113 Sun, 03 Jan 2010 16:24:53 +0000 admin 113@http://www.ll19.com/bb/ 实体

PLAIN TEXT

JAVA:

import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.Table;
@Entity
@Table(name = "FOR_GD_CONFIG")
public class DbConfigEntity implements Serializable {
@EmbeddedId
private DbConfigPk allPk;
// @AttributeOverrides( {
// @AttributeOverride(name = "fid", column = @Column(name = "FLOWID",
// nullable = false)),
// @AttributeOverride(name = "m", column = @Column(name = "MARK", nullable =
// false)) })
public DbConfigPk getAllPk() {
return this.allPk;
}
public void setAllPk(DbConfigPk allPk) {
this.allPk = allPk;
}
@Column(name = "MARK_CN", nullable = true)
private String mC;
public String getMc() {
return this.mC;
}
public void setMc(String mC) {
this.mC = mC;
}
@Column(name = "COLUMN_NAME", nullable = false)
private String cn;
public String getCn() {
return this.cn;
}
public void setCn(String cn) {
this.cn = cn;
}
}

实体中的复合主键

PLAIN TEXT

JAVA:

package com.rizon.lyj.gwgd.db;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Embeddable;
/**
* - 19. -
*
* 复合主键~good luck~
*
* @author <a href="http://www.LL19.com/">LL19.com</a>
* @version 1.0
*/
@Embeddable
public class DbConfigPk implements Serializable {
@Column(name = "FLOWID", nullable = false)
private Long fid;
public Long getFId() {
return this.fid;
}
public void setFId(Long fid) {
this.fid = fid;
}
@Column(name = "MARK", nullable = false)
private String m;
public String getM() {
return this.m;
}
public void setM(String m) {
this.m = m;
}
}

BEAN

PLAIN TEXT

JAVA:

public class DbConfigBean {
private Long fid;
public Long getFId() {
return this.fid;
}
public void setFId(Long fid) {
this.fid = fid;
}
private String m;
public String getM() {
return this.m;
}
public void setM(String m) {
this.m = m;
}
private String mC;
public String getMc() {
return this.mC;
}
public void setMc(String mC) {
this.mC = mC;
}
private String cn;
public String getCn() {
return this.cn;
}
public void setCn(String cn) {
this.cn = cn;
}
}

实体和BEAN的转换类

PLAIN TEXT

JAVA:

public class DbTools {
public static DbConfigEntity toDbConfigEntity(DbConfigBean bean) {
if (bean == null) {
return null;
}
DbConfigEntity entity = new DbConfigEntity();
entity.setCn(bean.getCn());
DbConfigPk dbConfigPk = new DbConfigPk();
dbConfigPk.setFId(bean.getFId());
dbConfigPk.setM(bean.getM());
entity.setAllPk(dbConfigPk);
entity.setMc(bean.getMc());
return entity;
}
public static DbConfigBean toDbConfigBean(DbConfigEntity entity) {
if (entity == null) {
return null;
}
DbConfigBean bean = new DbConfigBean();
bean.setCn(entity.getCn());
bean.setFId(entity.getAllPk().getFId());
bean.setM(entity.getAllPk().getM());
bean.setMc(entity.getMc());
return bean;
}
}

调用

PLAIN TEXT

JAVA:

System.out.println(service.find0().size());
DbConfigBean dbConfigBean = (DbConfigBean) service.find0().get(0);
System.out.println(dbConfigBean.getFId());
System.out.println(dbConfigBean.getM());
System.out.println(service.findMark("WHN").size());

SERVICE中

PLAIN TEXT

JAVA:

public List&lt;DbConfigBean&gt; find0() {
Criterion[] criterion = new Criterion[1];
criterion[0] = Comparison.eq("allPk.fid", (long) 0);
List&lt;DbConfigEntity&gt; entitys = this.gbConfigDao.find(criterion);
List&lt;DbConfigBean&gt; beans = new ArrayList&lt;DbConfigBean&gt;(entitys.size());
for (DbConfigEntity entity : entitys) {
beans.add(DbTools.toDbConfigBean(entity));
}
return beans;
}
public List&lt;DbConfigBean&gt; findMark(String Mark) {
Criterion[] criterion = new Criterion[1];
criterion[0] = Comparison.eq("allPk.m", Mark);
OrderBy[] orders = new OrderBy[1];
orders[0] = (OrderBy.asc("allPk.fid"));
List&lt;DbConfigEntity&gt; entitys = this.gbConfigDao.find(orders, criterion);
List&lt;DbConfigBean&gt; beans = new ArrayList&lt;DbConfigBean&gt;(entitys.size());
for (DbConfigEntity entity : entitys) {
beans.add(DbTools.toDbConfigBean(entity));
}
return beans;
}

admin on "SPRING事务管理的一个例子" http://www.ll19.com/bb/topic/112#post-112 Sun, 03 Jan 2010 16:21:01 +0000 admin 112@http://www.ll19.com/bb/ SPRING事务管理的一个例子

PLAIN TEXT

JAVA:

/***
*
* 删除TAGS 需要同时删除tree_posts_tags表中的相关信息
*/
public int removeTagsandPost(final String tagsID) {
String countTags = "";
final InvocationResult result = new InvocationResult();
DataSourceTransactionManager tran = new DataSourceTransactionManager(
getDataSource());
TransactionTemplate trantemplate = new TransactionTemplate(tran);
countTags = (String) trantemplate.execute(new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
try {
String sqlTags = "delete from tree_tags t where t.t_id = "
+ NumberUtils.toLong(tagsID);
String sqlPostTags = "delete from tree_posts_tags t where t.t_id = "
+ NumberUtils.toLong(tagsID);
int count = getJdbcTemplate().update(sqlTags,
new Object[] {}, new int[] {});
int countPostTags = getJdbcTemplate().update(sqlPostTags,
new Object[] {}, new int[] {});
return String.valueOf(count + countPostTags);
} catch (TransactionException te) {
status.setRollbackOnly();
if (result.getException() == null) {
throw te;
} else {
}
return 0;
}
}
});
return NumberUtils.toInt(countTags);

admin on "HIBERNATE复合主键的配置" http://www.ll19.com/bb/topic/111#post-111 Sun, 03 Jan 2010 16:17:59 +0000 admin 111@http://www.ll19.com/bb/ 1.通常将复合主键单独建一个类； 2.复合主键类必须实现java.io.Serializable接口，必须重写hashCode和 equals方法； 3.在映射文件中配置复合主键： <composite-id name="复合主键类名"& gt; <key-property name="复合主键属性1" column="对应字段名" /> <key- property name="复合主键属性2" column="对应字段名" /> </composite-id> hibernate.cfg.xml: <?xml version='1.0' encoding='UTF-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  <hibernate-configuration> <session-factory> <property name="connection.username">scott</property> <property name="connection.url"> jdbc:oracle:thin:@127.0.0.1:1521:MGC </property> <property name="dialect"> org.hibernate.dialect.Oracle9Dialect </property> <property name="myeclipse.connection.profile">MGC</property> <property name="connection.password">tiger</property> <property name="connection.driver_class"> oracle.jdbc.driver.OracleDriver </property> <property name="show_sql">true</property> <mapping resource="cn/edu/ahau/mgc/hibernate/pojo/YearPeriod.hbm.xml" /> </session-factory> </hibernate-configuration> YearPeriodPK.java: package cn.edu.ahau.mgc.hibernate.pojo; import java.io.Serializable; public class YearPeriodPK implements Serializable{ private int year; private int period; public int getYear() { return year; } public void setYear(int year) { this.year = year; } public int getPeriod() { return period; } public void setPeriod(int period) { this.period = period; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + period; result = prime * result + year; return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; final YearPeriodPK other = (YearPeriodPK) obj; if (period != other.period) return false; if (year != other.year) return false; return true; } } YearPeriod.java: package cn.edu.ahau.mgc.hibernate.pojo; import java.util.Calendar; public class YearPeriod { private YearPeriodPK yearPeriodPK; private Calendar beginDate; private Calendar endDate; public YearPeriodPK getYearPeriodPK() { return yearPeriodPK; } public void setYearPeriodPK(YearPeriodPK yearPeriodPK) { this.yearPeriodPK = yearPeriodPK; } public Calendar getBeginDate() { return beginDate; } public void setBeginDate(Calendar beginDate) { this.beginDate = beginDate; } public Calendar getEndDate() { return endDate; } public void setEndDate(Calendar endDate) { this.endDate = endDate; } } YearPeriod.hbm.xml: <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  <hibernate-mapping> <class name="cn.edu.ahau.mgc.hibernate.pojo.YearPeriod" table="YEARPERIOD" schema="SCOTT"> <composite-id name="YearPeriodPK"> <key-property name="year" column="YEAR" /> <key-property name="Period" column="PERIOD" /> </composite-id> <property name="beginDate" type="java.util.Calendar" column="BEGINDATE" /> <property name="endDate" type="java.util.Calendar" column="ENDDATE" /> </class> </hibernate-mapping> HibernateSessionFactory.java: package cn.edu.ahau.mgc.hibernate.many2one.factory; import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.cfg.Configuration; /** * Configures and provides access to Hibernate sessions, tied to the * current thread of execution. Follows the Thread Local Session * pattern, see {@link <a href="http://hibernate.org/42.html" rel="nofollow">http://hibernate.org/42.html</a> }. */ public class HibernateSessionFactory { /** * Location of hibernate.cfg.xml file. * Location should be on the classpath as Hibernate uses * #resourceAsStream style lookup for its configuration file. * The default classpath location of the hibernate config file is * in the default package. Use #setConfigFile() to update * the location of the configuration file for the current session. */ private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml"; private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>(); private static Configuration configuration = new Configuration(); private static org.hibernate.SessionFactory sessionFactory; private static String configFile = CONFIG_FILE_LOCATION; static { try { configuration.configure(configFile); sessionFactory = configuration.buildSessionFactory(); } catch (Exception e) { System.err .println("%%%% Error Creating SessionFactory %%%%"); e.printStackTrace(); } } private HibernateSessionFactory() { } /** * Returns the ThreadLocal Session instance. Lazy initialize * the <code>SessionFactory</code> if needed. * * @return Session * @throws HibernateException */ public static Session getSession() throws HibernateException { Session session = (Session) threadLocal.get(); if (session == null || !session.isOpen()) { if (sessionFactory == null) { rebuildSessionFactory(); } session = (sessionFactory != null) ? sessionFactory.openSession() : null; threadLocal.set(session); } return session; } /** * Rebuild hibernate session factory * */ public static void rebuildSessionFactory() { try { configuration.configure(configFile); sessionFactory = configuration.buildSessionFactory(); } catch (Exception e) { System.err .println("%%%% Error Creating SessionFactory %%%%"); e.printStackTrace(); } } /** * Close the single hibernate session instance. * * @throws HibernateException */ public static void closeSession() throws HibernateException { Session session = (Session) threadLocal.get(); threadLocal.set(null); if (session != null) { session.close(); } } /** * return session factory * */ public static org.hibernate.SessionFactory getSessionFactory() { return sessionFactory; } /** * return session factory * * session factory will be rebuilded in the next call */ public static void setConfigFile(String configFile) { HibernateSessionFactory.configFile = configFile; sessionFactory = null; } /** * return hibernate configuration * */ public static Configuration getConfiguration() { return configuration; } } ExportToDBCreate.java: package cn.edu.ahau.mgc.hibernate.export; import org.hibernate.cfg.Configuration; import org.hibernate.tool.hbm2ddl.SchemaExport; public class ExportToDBCreate { public static void main(String[] args) { Configuration cfg = new Configuration().configure(); SchemaExport export = new SchemaExport(cfg); export.create(true, true); } } InitData.java: package cn.edu.ahau.mgc.hibernate.export; import java.util.Calendar; import org.hibernate.Session; import cn.edu.ahau.mgc.hibernate.factory.HibernateSessionFactory; import cn.edu.ahau.mgc.hibernate.pojo.YearPeriod; import cn.edu.ahau.mgc.hibernate.pojo.YearPeriodPK; public class InitData { public static void main(String[] args) { Session session = null; try { session = HibernateSessionFactory.getSession(); session.beginTransaction(); YearPeriodPK yearPeriodPK = new YearPeriodPK(); yearPeriodPK.setYear(2008); yearPeriodPK.setPeriod(1); YearPeriod yearPeriod = new YearPeriod(); yearPeriod.setYearPeriodPK(yearPeriodPK); Calendar beginDate = Calendar.getInstance(); beginDate.set(2008, 2, 1); Calendar endDate = Calendar.getInstance(); endDate.set(2008, 6, 1); yearPeriod.setBeginDate(beginDate); yearPeriod.setEndDate(endDate); session.save(yearPeriod); session.getTransaction().commit(); } catch (Exception e) { session.getTransaction().rollback(); e.printStackTrace(); } finally { HibernateSessionFactory.closeSession(); } } } LoadData.java: package cn.edu.ahau.mgc.hibernate.export; import java.text.SimpleDateFormat; import org.hibernate.Session; import cn.edu.ahau.mgc.hibernate.factory.HibernateSessionFactory; import cn.edu.ahau.mgc.hibernate.pojo.YearPeriod; import cn.edu.ahau.mgc.hibernate.pojo.YearPeriodPK; public class LoadData { public static void main(String[] args) { Session session = null; try { session = HibernateSessionFactory.getSession(); YearPeriodPK yearPeriodPK = new YearPeriodPK(); yearPeriodPK.setYear(2008); yearPeriodPK.setPeriod(1); YearPeriod yearPeriod = (YearPeriod) session.load(YearPeriod.class, yearPeriodPK); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); System.out.println("Begin Date:" + sdf.format(yearPeriod.getBeginDate().getTime())); System.out.println("End Date:" + sdf.format(yearPeriod.getEndDate().getTime())); } catch (Exception e) { e.printStackTrace(); } finally { HibernateSessionFactory.closeSession(); } } } admin on "Hibernate Annotation中BLOB、CLOB注解写法" http://www.ll19.com/bb/topic/110#post-110 Sun, 03 Jan 2010 16:16:48 +0000 admin 110@http://www.ll19.com/bb/ Hibernate Annotation中BLOB、CLOB注解写法 在hibernate Annotation中，实体BLOB、CLOB类型的注解与普通的实体属性有些不同，具体操作如下：BLOB类型，类型声明为byte[]： private byte[] content； 注解： @Lob @Basic(fetch = FetchType.LAZY) @Column(name = "CONTENT", columnDefinition = "BLOB",nullable=true) public byte[] getContent() { return this.content; } public void setContent(byte[] content) { this.content = content; } CLOB类型，类型声明为String即可： private String remark； 注解： @Lob @Basic(fetch = FetchType.EAGER) @Column(name="REMARK", columnDefinition="CLOB", nullable=true) public String getRemark() { return this.remark; } public void setRemark(String recvdocRemark) { this.remark = remark; } 按照以上的设置实体类的注解就搞定了。 admin on "Hibernate的Ejb3注释进行映射" http://www.ll19.com/bb/topic/109#post-109 Sun, 03 Jan 2010 16:15:56 +0000 admin 109@http://www.ll19.com/bb/ 参考文档 3.2.0 CR1 2.2.5. 映射实体Bean的关联关系 2.2.5.1. 一对一(One-to-one) 使用@OneToOne注解可以建立实体 bean之间的一对一的关联. 一对一关联有三种情况：一是关联的实体都共享同样的主键, 二是其中一个实体通过外键关联到另一个实体的主键 (注意要模拟一对一关联必须在外键列上添加唯一约束). 三是通过关联表来保存两个实体之间的连接关系 (注意要模拟一对一关联必须在每一个外键上添加唯一约束). 首先,我们通过共享主键来进行一对一关联映射: @Entity public class Body { @Id public Long getId() { return id; } @OneToOne(cascade = CascadeType.ALL) @PrimaryKeyJoinColumn public Heart getHeart() { return heart; } ... } @Entity public class Heart { @Id public Long getId() { ...} } 上面的例子通过使用注解@PrimaryKeyJoinColumn定义了一对一关联. 下面这个例子使用外键列进行实体的关联. @Entity public class Customer implements Serializable { @OneToOne(cascade = CascadeType.ALL) @JoinColumn(name="passport_fk") public Passport getPassport() { ... } @Entity public class Passport implements Serializable { @OneToOne(mappedBy = "passport") public Customer getOwner() { ... } 上面这个例子中,Customer 通过Customer 表中名为的passport_fk 外键列和 Passport关联. @JoinColumn注解定义了联接列(join column). 该注解和@Column注解有点类似, 但是多了一个名为referencedColumnName的参数. 该参数定义了所关联目标实体中的联接列. 注意,当referencedColumnName关联到非主键列的时候, 关联的目标类必须实现Serializable, 还要注意的是所映射的属性对应单个列(否则映射无效). 一对一关联可能是双向的.在双向关联中, 有且仅有一端是作为主体(owner)端存在的：主体端负责维护联接列(即更新). 对于不需要维护这种关系的从表则通过mappedBy属性进行声明. mappedBy的值指向主体的关联属性. 在上面这个例子中,mappedBy的值为 passport. 最后,不必也不能再在被关联端(owned side)定义联接列了,因为已经在主体端进行了声明. 如果在主体没有声明@JoinColumn, 系统自动进行处理：在主表(owner table)中将创建联接列, 列名为：主体的关联属性名＋下划线＋被关联端的主键列名. 在上面这个例子中是passport_id, 因为Customer中关联属性名为passport, Passport的主键是id. The third possibility (using an association table) is very exotic. 第三种方式也许是最另类的(通过关联表). @Entity public class Customer implements Serializable { @OneToOne(cascade = CascadeType.ALL) @JoinTable(name = "CustomerPassports", joinColumns = @JoinColumn(name="customer_fk"), inverseJoinColumns = @JoinColumn(name="passport_fk") ) public Passport getPassport() { ... } @Entity public class Passport implements Serializable { @OneToOne(mappedBy = "passport") public Customer getOwner() { ... } Customer通过名为 CustomerPassports的关联表和 Passport关联; 该关联表拥有名为passport_fk的外键列,该外键指向Passport表,该信息定义为inverseJoinColumn的属性值, 而customer_fk外键列指向Customer表, 该信息定义为 joinColumns的属性值. 这种关联可能是双向的.在双向关联中, 有且仅有一端是作为主体端存在的：主体端负责维护联接列(即更新). 对于不需要维护这种关系的从表则通过mappedBy属性进行声明. mappedBy的值指向主体的关联属性. 在上面这个例子中,mappedBy的值为 passport. 最后,不必也不能再在被关联端(owned side)定义联接列了,因为已经在主体端进行了声明. 你必须明确定义关联表名和关联列名. 2.2.5.2. 多对一(Many-to-one) 在实体属性一级使用@ManyToOne注解来定义多对一关联: @Entity() public class Flight implements Serializable { @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} ) @JoinColumn(name="COMP_ID") public Company getCompany() { return company; } ... } 其中@JoinColumn是可选的,关联字段默认值和一对一 (one to one)关联的情况相似, 列名为：主体的关联属性名＋下划线＋被关联端的主键列名. 在这个例子中是company_id, 因为关联的属性是company, Company的主键是id. @ManyToOne注解有一个名为targetEntity的参数, 该参数定义了目标实体名.通常不需要定义该参数, 因为在大部分情况下默认值(表示关联关系的属性类型)就可以很好的满足要求了. 不过下面这种情况下这个参数就显得有意义了：使用接口作为返回值而不是常见的实体. @Entity() public class Flight implements Serializable { @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE}, targetEntity=CompanyImpl.class ) @JoinColumn(name="COMP_ID") public Company getCompany() { return company; } ... } public interface Company { ... 对于多对一也可以通过关联表的方式来映射。通过@JoinTable注解可定义关联表，该关联表包含了指回实体表的外键(通过@JoinTable.joinColumns) 以及指向目标实体表的外键(通过@JoinTable.inverseJoinColumns). @Entity() public class Flight implements Serializable { @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} ) @JoinTable(name="Flight_Company", joinColumns = @JoinColumn(name="FLIGHT_ID"), inverseJoinColumns = @JoinColumn(name="COMP_ID") ) public Company getCompany() { return company; } ... } 2.2.5.3. 集合类型 2.2.5.3.1. 概况 你可以对 Collection ,List (指有序列表, 而不是索引列表), Map和Set这几种类型进行映射. EJB3规范定义了怎么样使用@javax.persistence.OrderBy 注解来对有序列表进行映射：该注解接受的参数格式：用逗号隔开的(目标实体)属性名及排序指令, 如firstname asc, age desc,如果该参数为空,则默认以id对该集合进行排序. 如果某个集合在数据库中对应一个关联表(association table)的话,你不能在这个集合属性上面使用@OrderBy注解. 对于这种情况的处理方法,请参考Hibernate Annotation Extensions. EJB3 允许你利用目标实体的一个属性作为Map的key, 这个属性可以用@MapKey(name="myProperty")来声明. 如果使用@MapKey注解的时候不提供属性名, 系统默认使用目标实体的主键. map的key使用和属性相同的列：不需要为map key定义专用的列，因为map key实际上就表达了一个目标属性。注意一旦加载,key不再和属性保持同步, 也就是说,如果你改变了该属性的值,在你的Java模型中的key不会自动更新 (请参考Hibernate Annotation Extensions). 很多人被<map>和@MapKey弄糊涂了。其他它们有两点区别.@MapKey目前还有一些限制,详情请查看论坛或者我们的JIRA缺陷系统。注意一旦加载,key不再和属性保持同步, 也就是说,如果你改变了该属性的值,在你的Java模型中的key不会自动更新. (Hibernate 3中Map支持的方式在当前的发布版中还未得到支持). Hibernate将集合分以下几类. 表 2.1. 集合语义 语义 Java实现类注解 Bag 语义 java.util.List, java.util.Collection @org.hibernate.annotations.CollectionOfElements 或 @OneToMany 或 @ManyToMany List 语义 java.util.List (@org.hibernate.annotations.CollectionOfElements 或 @OneToMany 或 @ManyToMany) 以及 @org.hibernate.annotations.IndexColumn Set 语义 java.util.Set @org.hibernate.annotations.CollectionOfElements 或 @OneToMany 或 @ManyToMany Map 语义 java.util.Map (@org.hibernate.annotations.CollectionOfElements 或 @OneToMany 或 @ManyToMany) 以及 (空或 @org.hibernate.annotations.MapKey/MapKeyManyToMany(支持真正的map), 或 @javax.persistence.MapKey 从上面可以明确地看到,没有@org.hibernate.annotations.IndexColumn 注解的java.util.List集合将被看作bag类. EJB3规范不支持原始类型,核心类型,嵌入式对象的集合.但是Hibernate对此提供了支持 (详情参考 Hibernate Annotation Extensions). @Entity public class City { @OneToMany(mappedBy="city") @OrderBy("streetName") public List<Street> getStreets() { return streets; } ... } @Entity public class Street { public String getStreetName() { return streetName; } @ManyToOne public City getCity() { return city; } ... } @Entity public class Software { @OneToMany(mappedBy="software") @MapKey(name="codeName") public Map<String, Version> getVersions() { return versions; } ... } @Entity @Table(name="tbl_version") public class Version { public String getCodeName() {...} @ManyToOne public Software getSoftware() { ... } ... } 上面这个例子中,City 中包括了以streetName排序的Street的集合. 而Software中包括了以codeName作为 key和以Version作为值的Map. 除非集合为generic类型,否则你需要指定targetEntity. 这个注解属性接受的参数为目标实体的class. 2.2.5.3.2. 一对多(One-to-many) 在属性级使用 @OneToMany注解可定义一对多关联.一对多关联可以是双向关联. 2.2.5.3.2.1. 双向(Bidirectional) 在EJB3规范中多对一这端几乎总是双向关联中的主体(owner)端, 而一对多这端的关联注解为@OneToMany( mappedBy=... ) @Entity public class Troop { @OneToMany(mappedBy="troop") public Set<Soldier> getSoldiers() { ... } @Entity public class Soldier { @ManyToOne @JoinColumn(name="troop_fk") public Troop getTroop() { ... } Troop 通过troop 属性和Soldier建立了一对多的双向关联. 在mappedBy端不必也不能再定义任何物理映射 对于一对多的双向映射,如果要一对多这一端维护关联关系, 你需要删除mappedBy元素并将多对一这端的 @JoinColumn的 insertable和updatable设置为false. 很明显,这种方案不会得到什么明显的优化,而且还会增加一些附加的UPDATE语句. @Entity public class Troop { @OneToMany @JoinColumn(name="troop_fk") //we need to duplicate the physical information public Set<Soldier> getSoldiers() { ... } @Entity public class Soldier { @ManyToOne @JoinColumn(name="troop_fk", insertable=false, updatable=false) public Troop getTroop() { ... } 2.2.5.3.2.2. 单向(Unidirectional) 通过在被拥有的实体端(owned entity)增加一个外键列来实现一对多单向关联是很少见的,也是不推荐的. 我们强烈建议通过一个联接表(join table)来实现这种关联(下一节会对此进行解释). 可以通过@JoinColumn注解来描述这种单向关联关系. @Entity public class Customer implements Serializable { @OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER) @JoinColumn(name="CUST_ID") public Set<Ticket> getTickets() { ... } @Entity public class Ticket implements Serializable { ... //no bidir } Customer 通过 CUST_ID列和Ticket 建立了单向关联关系. 2.2.5.3.2.3. 通过关联表处理单向关联 通过联接表处理单向一对多关联是首选方式.这种关联通过@JoinTable注解来进行描述. @Entity public class Trainer { @OneToMany @JoinTable( name="TrainedMonkeys", joinColumns = @JoinColumn( name="trainer_id"), inverseJoinColumns = @JoinColumn( name="monkey_id") ) public Set<Monkey> getTrainedMonkeys() { ... } @Entity public class Monkey { ... //no bidir } 上面这个例子中,Trainer通过 TrainedMonkeys表和 Monkey 建立了单向关联. 其中外键trainer_id关联到Trainer (joinColumns), 而外键monkey_id关联到 Monkey (inversejoinColumns). 2.2.5.3.2.4. 默认处理机制 通过联接表来建立单向一对多关联不需要描述任何物理映射. 表名由以下三个部分组成:主表(owner table)表名+下划线+从表(the other side table)表名. 指向主表的外键名：主表表名+下划线+主表主键列名指向从表的外键名：主表所对应实体的属性名+下划线+从表主键列名指向从表的外键定义为唯一约束,用来表示一对多的关联关系. @Entity public class Trainer { @OneToMany public Set<Tiger> getTrainedTigers() { ... } @Entity public class Tiger { ... //no bidir } 上面这个例子中,Trainer和Tiger 通过联接表 Trainer_Tiger建立单向关联关系, 其中外键trainer_id关联到Trainer (主表表名, _(下划线), trainer id), 而外键trainedTigers_id关联到Tiger (属性名称, _(下划线), Tiger表的主键列名). 2.2.5.3.3. 多对多(Many-to-many) 2.2.5.3.3.1. 定义 你可以通过@ManyToMany注解可定义的多对多关联. 同时,你也需要通过注解@JoinTable描述关联表和关联条件. 如果是双向关联,其中一段必须定义为owner,另一端必须定义为inverse(在对关联表进行更新操作时这一端将被忽略): @Entity public class Employer implements Serializable { @ManyToMany( targetEntity=org.hibernate.test.metadata.manytomany.Employee.class, cascade={CascadeType.PERSIST, CascadeType.MERGE} ) @JoinTable( name="EMPLOYER_EMPLOYEE", joinColumns=@JoinColumn(name="EMPER_ID"), inverseJoinColumns=@JoinColumn(name="EMPEE_ID") ) public Collection getEmployees() { return employees; } ... } @Entity public class Employee implements Serializable { @ManyToMany( cascade = {CascadeType.PERSIST, CascadeType.MERGE}, mappedBy = "employees", targetEntity = Employer.class ) public Collection getEmployers() { return employers; } } 至此,我们已经展示了很多跟关联有关的声明定义以及属性细节. 下面我们将深入介绍@JoinTable注解,该注解定义了联接表的表名, 联接列数组(注解中定义数组的格式为{ A, B, C }), 以及inverse联接列数组. 后者是关联表中关联到Employee主键的列(the "other side"). 正如前面所示,被关联端不必也不能描述物理映射: 只需要一个简单的mappedBy参数,该参数包含了主体端的属性名,这样就绑定双方的关系. 2.2.5.3.3.2. 默认值 和其他许多注解一样,在多对多关联中很多值是自动生成. 当双向多对多关联中没有定义任何物理映射时,Hibernate根据以下规则生成相应的值. 关联表名:主表表名+_下划线+从表表名, 关联到主表的外键名:主表名+_下划线+主表中的主键列名. 关联到从表的外键名:主表中用于关联的属性名+_下划线+从表的主键列名. 以上规则对于双向一对多关联同样有效. @Entity public class Store { @ManyToMany(cascade = CascadeType.PERSIST) public Set<City> getImplantedIn() { ... } } @Entity public class City { ... //no bidirectional relationship } 上面这个例子中,Store_Table作为联接表. Store_id列是联接到Store表的外键. 而implantedIn_id列则联接到City表. 当双向多对多关联中没有定义任何物理映射时, Hibernate根据以下规则生成相应的值关联表名: :主表表名+_下划线+从表表名, 关联到主表的外键名:从表用于关联的属性名+_下划线+主表中的主键列名. 关联到从表的外键名:主表用于关联的属性名+_下划线+从表的主键列名. 以上规则对于双向一对多关联同样有效. @Entity public class Store { @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE}) public Set<Customer> getCustomers() { ... } } @Entity public class Customer { @ManyToMany(mappedBy="customers") public Set<Store> getStores() { ... } } 在上面这个例子中,Store_Customer作为联接表. stores_id列是联接到Store表的外键, 而customers_id列联接到City表. 2.2.5.4. 用cascading实现传播性持久化(Transitive persistence) 也许你已经注意到了cascade属性接受的值为CascadeType数组. 在EJB3中的cascade的概念和Hibernate中的传播性持久化以及cascade操作非常类似, 但是在语义上有细微的区别,支持的cascade类型也有点区别: • CascadeType.PERSIST: 如果一个实体是受管状态, 或者当persist()函数被调用时, 触发级联创建(create)操作 • CascadeType.MERGE: 如果一个实体是受管状态, 或者当merge()函数被调用时, 触发级联合并(merge)操作 • CascadeType.REMOVE: 当delete()函数被调用时, 触发级联删除(remove)操作 • CascadeType.REFRESH: 当refresh()函数被调用时, 触发级联更新(refresh)操作 • CascadeType.ALL: 以上全部 关于cascading, create/merge的语义请参考EJB3规范的6.3章节. 2.2.5.5. 关联关系获取 通过Hibernate你可以获得直接或者延迟获取关联实体的功能. fetch参数可以设置为FetchType.LAZY 或者 FetchType.EAGER. EAGER通过outer join select直接获取关联的对象, 而LAZY(默认值)在第一次访问关联对象的时候才会触发相应的select操作. EJBQL提供了fetch关键字,该关键字可以在进行特殊查询的时候覆盖默认值. 这对于提高性能来说非常有效,应该根据实际的用例来判断是否选择fetch关键字. 2.2.6. 映射复合主键与外键 组合主键使用一个可嵌入的类作为主键表示,因此你需要使用@Id 和@Embeddable两个注解. 还有一种方式是使用@EmbeddedId注解. 注意所依赖的类必须实现 serializable以及实现equals()/hashCode()方法. 你也可以如Mapping identifier properties一章中描述的办法使用@IdClass注解. @Entity public class RegionalArticle implements Serializable { @Id public RegionalArticlePk getPk() { ... } } @Embeddable public class RegionalArticlePk implements Serializable { ... } 或者 @Entity public class RegionalArticle implements Serializable { @EmbeddedId public RegionalArticlePk getPk() { ... } } public class RegionalArticlePk implements Serializable { ... } @Embeddable 注解默认继承了其所属实体的访问类型, 除非显式使用了Hibernate的@AccessType注解(这个注解不是EJB3标准的一部分). 而@JoinColumns, 即@JoinColumn数组, 定义了关联的组合外键(如果不使用缺省值的话). 显式指明referencedColumnNames是一个好的实践方式, 否则,Hibernate认为你使用的列顺序和主键声明的顺序一致. @Entity public class Parent implements Serializable { @Id public ParentPk id; public int age; @OneToMany(cascade=CascadeType.ALL) @JoinColumns ({ @JoinColumn(name="parentCivility", referencedColumnName = "isMale"), @JoinColumn(name="parentLastName", referencedColumnName = "lastName"), @JoinColumn(name="parentFirstName", referencedColumnName = "firstName") }) public Set<Child> children; //unidirectional ... } @Entity public class Child implements Serializable { @Id @GeneratedValue public Integer id; @ManyToOne @JoinColumns ({ @JoinColumn(name="parentCivility", referencedColumnName = "isMale"), @JoinColumn(name="parentLastName", referencedColumnName = "lastName"), @JoinColumn(name="parentFirstName", referencedColumnName = "firstName") }) public Parent parent; //unidirectional } @Embeddable public class ParentPk implements Serializable { String firstName; String lastName; ... } 注意上面的 referencedColumnName显式使用方式. 2.2.7. 映射二级表(secondary tables) 使用类一级的 @SecondaryTable 或 @SecondaryTables 注解可以实现单个实体到多个表的映射. 使用 @Column 或者 @JoinColumn 注解中的 table 参数可指定某个列所属的特定表. @Entity @Table(name="MainCat") @SecondaryTables({ @SecondaryTable(name="Cat1", pkJoinColumns={ @PrimaryKeyJoinColumn(name="cat_id", referencedColumnName="id") ), @SecondaryTable(name="Cat2", uniqueConstraints={@UniqueConstraint(columnNames={"storyPart2"})}) }) public class Cat implements Serializable { private Integer id; private String name; private String storyPart1; private String storyPart2; @Id @GeneratedValue public Integer getId() { return id; } public String getName() { return name; } @Column(table="Cat1") public String getStoryPart1() { return storyPart1; } @Column(table="Cat2") public String getStoryPart2() { return storyPart2; } 在上面这个例子中,name保存在MainCat表中, storyPart1保存在Cat1表中, storyPart2保存在Cat2表中. Cat1表通过外键cat_id和MainCat表关联, Cat2表通过id列和MainCat表关联 (和MainCat的id列同名). 对storyPart2列还定义了唯一约束. 在JBoss EJB 3指南和Hibernate Annotations单元测试代码中还有更多的例子.