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

~SingleForum~无废话记录~: Recent Posts http://www.ll19.com/bb/ ~19~记录点有用的好吗？少说废话少装b~ en Wed, 08 Feb 2012 17:09:54 +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单元测试代码中还有更多的例子. admin on "Hibernate Annotation几种关联映射" http://www.ll19.com/bb/topic/108#post-108 Sun, 03 Jan 2010 16:14:29 +0000 admin 108@http://www.ll19.com/bb/ Hibernate Annotation几种关联映射 一对一(One-To-One) 使用@OneToOne注解建立实体Bean之间的一对一关联。一对一关联有三种情况：(1).关联的实体都共享同样的主键，(2).其中一个实体通过外键关联到另一个实体的主键(注意要模拟一对一关联必须在外键列上添加唯一约束)，(3).通过关联表来保存两个实体之间的连接关系(要模拟一对一关联必须在每一个外键上添加唯一约束)。 1.共享主键的一对一关联映射： @Entity @Table(name="Test_Body") public class Body { private Integer id; private Heart heart; @Id public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } @OneToOne @PrimaryKeyJoinColumn public Heart getHeart() { return heart; } public void setHeart(Heart heart) { this.heart = heart; } } @Entity @Table(name="Test_Heart") public class Heart { private Integer id; @Id public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } } 通过@PrimaryKeyJoinColumn批注定义了一对一关联 2.使用外键进行实体一对一关联： @Entity @Table(name="Test_Trousers") public class Trousers { @Id public Integer id; @OneToOne @JoinColumn(name = "zip_id") public TrousersZip zip; } @Entity @Table(name="Test_TrousersZip") public class TrousersZip { @Id public Integer id; @OneToOne(mappedBy = "zip") public Trousers trousers; } 上面的例子是指Trousers通过Trousers的外键列zip_id和TrousersZip关联，@JoinColumn批注定义了联接列，该批注和@Column批注有点类似，但是多了一个名为referencedColumnName的参数。该参数定义了所关联目标实体中的联接列，注意，当referencedColumnName关联到非主键列的时候，关联的目标类必须实现Serializable，还要注意的是所映像的属性对应单个列（否则映射无效） 一对一关联可能是双向的，在双向关联中，有且仅有一端作为主体（owner）端存在：主体端负责维护联接列（即更新），对于不需要维护这种关系的从表则通过mappedNy属性进行声明。mappedBy的值指向主体的关联属性。例子中，mappedBy的值为zip。最后，不必也不能再在被关联端（ownedside）定义联接列了，因为已经在主体端声明了。 如果在主体没有声明@JoinColumn，系统自动进行处理：在主表（owner table）中将创建联接列，列名为：主体的关联属性名+下划线+被关联端的主键列名。上面的例子中是zip_id,因为Trousers中的关联属性名为zip，TrousersZip的主键是id。 3.通过关联表定义一对一关联 @Entity @Table(name="Test_People") public class People { @Id public Integer id; @OneToOne @JoinTable(name ="TestPeoplePassports", joinColumns =@JoinColumn(name="people_fk"), inverseJoinColumns =@JoinColumn(name="passport_fk") ) public Passport passport; } @Entity @Table(name="Test_Passport") public class Passport { @Id public Integer id; @OneToOne(mappedBy = "passport") public People people; } People通过名为TestPeoplePassports的关联表和Passport关联。该关联表拥有名为passport_fk的外键列，该外键指向Passport表，该信息定义为inverseJoinColoumns的属性值，而people_fk外键列指向People表，该信息定义为joinColumns的属性值。 这种关联可能是双向的，在双向关联中，有且仅有一端作为主体（owner）端存在：主体端负责维护联接列（即更新），对于不需要维护这种关系的从表则通过mappedNy属性进行声明。mappedBy的值指向主体的关联属性。例子中，mappedBy的值为passport。最后，不必也不能再在被关联端（ownedside）定义联接列了，因为已经在主体端声明了。 以上是一对一关联的三种形式，下面介绍多对一关联。 多对一(Many-to-One) 使用@ManyToOne批注来实现多对一关联。 @ManyToOne批注有一个名为targetEntity的参数，该参数定义了目标实体名，通常不需要定义该参数，因为在大部分情况下默认值 (表示关联关系的属性类型)就可以很好的满足需求了。不过下面这种情况下这个参数就显得有意义了：使用接口作为返回值而不是常见的实体。 @ManyToOne(targetEntity=CompanyImpl.class) @JoinColoumn(name=”COPM_ID”) Public Company getCompany(){ return company; } 多对一的配置方式有两种：(1)通过@JoinColoumn映像(2)通过关联表的方式来映像 (1)通过@JoinColoumn映射 SRD Framework中Company,Category例子： Company： @ManyToOne @JoinColumn(name = "CATEGORY_OPTION_ID") private Category category = null; Category： @DiscriminatorValue("Category") public class Category extends Option { } (2)通过关联表映射 通过@JoinTable批注定义关联表，该关联表包含了指回实体表的外键(通过@JoinTable.joinColoumns)以及指向目标实体表的外键(通过@JoinTable.inverseJoinColoumns) @Entity @Table(name="Test_TreeType") public class TreeType { private Integer id; private String name; private ForestType forestType; @ManyToOne(fetch = FetchType.LAZY) @JoinTable(name="Test_Tree_Forest", joinColumns = @JoinColumn(name="tree_id"), inverseJoinColumns = @JoinColumn(name="forest_id") ) public ForestType getForestType() {// forestType的getter，setter方法必须在这里，否则会出错 return forestType; } public void setForestType(ForestType forestType) { this.forestType = forestType; } @Id @GeneratedValue public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } } @Entity @Table(name="Test_ForestType") public class ForestType { private Integer id; private String name; private Set<TreeType> trees; @OneToMany(mappedBy="forestType") public Set<TreeType> getTrees() {// trees的getter，setter方法必须在这里，否则会出错 return trees; } public void setTrees(Set<TreeType> trees) { this.trees = trees; } @Id @GeneratedValue public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } } 一对多(One-to-Many) 使用@OneToMany批注可定义一对多关联，一对多关联可以是双向关联。 在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元素并将多对一这端的@JoinColoumn的 insertable和updatabel设置为false。这种方案不会得到什么明显的优化，而且还会增加一些附加的UPDATE语句。 单向： 通过在被拥有的实体端(owned entity)增加一个外键列来实现一对多单向关联是很少见的，也是不推荐的，建议通过一个联接表来实现这种关联(下面会讲到)。 @JoinColoumn批注来描述这种单向关联关系 @Entity Public class Customer{ @OneToMany @JoinColoumn(name=”CUST_ID”) Public Set<ticket> getTickets() { ...... } @Entity Public class Ticket{ ... } Customer通过CUST_ID列和Ticket建立了单向关联关系 通过关联表处理单向关联： 通过联接表处理单向一对多关联是首选方式，这种关联通过@JoinTable批注进行描述 @Entity Public class Trainer{ @OneToMany @JoinTable( name = "TrainedMonkeys", jonColumns = {@JoinColumn(name = "trainer_id")}, inverseJoinColumns = @JoinColumn(name = "monkey_id") ) public Set<Monkey> getTrainedMonkeys() { return trainedMonkeys; } ...... } @Entity public class Monkey { ...//no bidir } 上面这个例子中，Trainer通过TrainedMonkeys表和Monkey建立了单向关联，其中外键trainer_id关联到 Trainer(joinColoumn),而外键monkey_id关联到Monkey(inversejionColoumns) 默认处理机制： 通过联接表来建立单向一对多关联不需要描述任何物理映像，表名由以下三个部分组成：主表(ownertable)表名+从表(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,而外键trainedTigers_id关联到Tiger 多对多(Many-to-Many) 使用@ManyToMany批注可定义多对多关联，同时，你也许要通过批注@JoinTable描述关联表和关联条件。如果是双向关联，其中一段必须定义为Owner，另一端必须定义为inverse(在对关联表进行更新操作时这一端将被忽略) @Entity() public class Employer implements Serializable { private Integer id; private Collection employees; @ManyToMany( targetEntity = org.hibernate.test.annotations.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<Employer> getEmployers() { return employers; } .. .. } @JoinTable批注定义了联接表的表名，联接列数组，以及invers联接列数组，后者是关联表中关联到Employee主键的列(the “other side”)。 被关联端不必也不能描述物理映射：只需要一个简单的mappedBy参数，该参数包含了主体端的属性名，这样就绑定了双方的关系。 默认值： 和其它许多批注一样，在多对多关联中很多值是自动生成，党双向多对多关联中没有定义任何物理映射时，Hibernate根据以下规则生成相应的值，关联表名：主表表名+下划线+从表表名，关联到主表的外键名：主表名+下划线+主表中的主键列名，关联到从表的外键名：主表中用于关联的属性名+下划线+ 从表的主键列名，以上规则对于双向一对多关联同样一样。 admin on "log4j配置日志信息输出目的地" http://www.ll19.com/bb/topic/107#post-107 Sun, 03 Jan 2010 16:13:23 +0000 admin 107@http://www.ll19.com/bb/ log4j.appender.appenderName = fully.qualified.name.of.appender.class // "fully.qualified.name.of.appender.class" 可以指定下面五个目的地中的一个： 1.org.apache.log4j.ConsoleAppender（控制台） 2.org.apache.log4j.FileAppender（文件） 3.org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件） 4.org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件） 5.org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方） 1.ConsoleAppender选项 Threshold=WARN:指定日志消息的输出最低层次。 ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。 Target=System.err：默认情况下是：System.out,指定输出控制台 2.FileAppender 选项 Threshold=WARN:指定日志消息的输出最低层次。 ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。 File=mylog.txt:指定消息输出到mylog.txt文件。 Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。 3.DailyRollingFileAppender 选项 Threshold=WARN:指定日志消息的输出最低层次。 ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。 File=mylog.txt:指定消息输出到 mylog.txt文件。 Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。 DatePattern='.'yyyy-ww:每周滚动一次文件，即每周产生一个新的文件。当然也可以指定按月、周、天、时和分。即对应的格式如下： 1)'.'yyyy-MM: 每月 2)'.'yyyy-ww: 每周 3)'.'yyyy-MM-dd: 每天 4)'.'yyyy-MM-dd-a: 每天两次 5)'.'yyyy-MM-dd-HH: 每小时 6)'.'yyyy-MM-dd-HH-mm: 每分钟 4.RollingFileAppender 选项 Threshold=WARN:指定日志消息的输出最低层次。 ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。 File=mylog.txt:指定消息输出到mylog.txt文件。 Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。 MaxFileSize=100KB: 后缀可以是KB, MB 或者是 GB. 在日志文件到达该大小时，将会自动滚动，即将原来的内容移到mylog.log.1文件。 MaxBackupIndex=2:指定可以产生的滚动文件的最大数。 admin on "Hibernate操作BLOB" http://www.ll19.com/bb/topic/106#post-106 Sun, 03 Jan 2010 16:10:53 +0000 admin 106@http://www.ll19.com/bb/ 这是Cat对象定义 　　package com.fankai; 　　import java.sql.Blob; 　　public class Cat { 　　private String id; 　　private String name; 　　private char sex; 　　private float weight; 　　private Blob image; 　　public Cat() { } 　　public String getId() { return id; } 　　public void setId(String id) { this.id = id; } 　　public String getName() { return name; } 　　public void setName(String name) { this.name = name; } 　　public char getSex() { return sex; } 　　public void setSex(char sex) { this.sex = sex; } 　　public float getWeight() { return weight; } 　　public void setWeight(float weight) { this.weight = weight; } 　　public Blob getImage() { return image; } 　　public void setImage(Blob image) { this.image = image;} 　　} 　　这是Cat.hbm.xml 　　＜?xml version="1.0"?＞ 　　＜!DOCTYPE hibernate-mapping SYSTEM "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"＞ 　　＜hibernate-mapping＞ 　　＜class name="com.fankai.Cat" table="cat"＞ 　　＜!--jcs-cache usage="read-only"/--＞ 　　＜id name="id" unsaved-value="null"＞ 　　＜generator class="uuid.hex"/＞ 　　＜/id＞ 　　＜property name="name" length="16" not-null="true"/＞ 　　＜property name="sex" length="1" not-null="true"/＞ 　　＜property name="weight" /＞ 　　＜property name="image" /＞ 　　＜/class＞ 　　＜/hibernate-mapping＞ 　　下面是完整的用Hibernate写入Blob的例子，相比JDBC，已经简单轻松多了，也不用写那些Oracle特殊的sql了： 　　package com.fankai; 　　import java.sql.Blob; 　　import net.sf.hibernate.*; 　　import oracle.sql.*; 　　import java.io.*; 　　public class TestCatHibernate { 　　public static void testBlob() { 　　Session s = null; 　　byte[] buffer = new byte[1]; 　　buffer[0] = 1; 　　try { 　　　SessionFactory sf = HibernateSessionFactory.getSessionFactory(); 　　　s = sf.openSession(); 　　　Transaction tx = s.beginTransaction(); 　　　Cat c = new Cat(); 　　　c.setName("Robbin"); 　　　c.setImage(Hibernate.createBlob(buffer)); 　　　s.save(c); 　　　s.flush(); 　　　s.refresh(c, LockMode.UPGRADE); 　　　BLOB blob = (BLOB) c.getImage(); 　　　OutputStream out = blob.getBinaryOutputStream(); 　　　String fileName = "oraclejdbc.jar"; 　　　File f = new File(fileName); 　　　FileInputStream fin = new FileInputStream(f); 　　　int count = -1, total = 0; 　　　byte[] data = new byte[(int)fin.available()]; 　　　fin.read(data); 　　　out.write(data); 　　　fin.close(); 　　　out.close(); 　　　s.flush(); 　　　tx.commit(); 　　} catch (Exception e) { 　　　System.out.println(e.getMessage()); 　　} finally { 　　　if (s != null) 　　　try { 　　　　s.close(); 　　　} catch (Exception e) {} 　　} 　　} 　　} admin on "JDBC实现oracle blob 出库入库" http://www.ll19.com/bb/topic/105#post-105 Sun, 03 Jan 2010 16:09:40 +0000 admin 105@http://www.ll19.com/bb/ JDBC实现oracle blob 出库入库 1，首先建一个足够简单的表imageTable id varchar（20） image blob 2，blob入库 拷贝Sunset.jpg图片在C盘根目录下 一般是先通过select ... for update锁定blob列，然后写入blob值，然后提交。要用到特定的Oracle BLOB类。 1 DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver()); 2 Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:beyondduke","duke","duke"); 3 conn.setAutoCommit(false); 4 BLOB blob = null; 5 PreparedStatement pstmt = conn.prepareStatement("insert into imageTable(id,image) values(?,empty_blob())"); 6 pstmt.setString(1,"10001"); 7 pstmt.executeUpdate(); 8 pstmt.close(); 9 pstmt = conn.prepareStatement("select content from imageTable where id= ? for update"); 10 pstmt.setString(1,"10001"); 11 ResultSet rs = pstmt.executeQuery(); 12 if (rs.next()) blob = (BLOB) rs.getBlob(1); 13 String fileName = "c://Sunset.jpg"; 14 File f = new File(fileName); 15 FileInputStream fin = new FileInputStream(f); 16 System.out.println("file size = " + fin.available()); 17 pstmt = conn.prepareStatement("update imageTable set image=? where id=?"); 18 OutputStream out = blob.getBinaryOutputStream(); 19 byte[] data = new byte[(int)fin.available()]; 20 fin.read(data); 21 out.write(data); 22 out.close(); 23 fin.close(); 24 25 pstmt.setBlob(1,blob); 26 pstmt.setString(2,"fankai"); 27 28 pstmt.executeUpdate(); 29 pstmt.close(); 30 31 conn.commit(); 32 conn.close(); 浏览数据库的数据，发现image项中数据大小与图片大小一致，说明入库了！ 1 DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver()); 2 Connection conn = DriverManager.getConnection( "jdbc:oracle:thin:@localhost:1521:beyondduke", "duke","duke"); conn.setAutoCommit( false); 3 Statement stmt = conn.createStatement(); 4 /* 查询BLOB对象 */ 5 ResultSet rs = stmt.executeQuery("SELECT content FROM javatest WHERE id='1001'"); 6 while (rs.next()) { 7 /* 取出此BLOB对象 */ 8 oracle.sql.BLOB blob = (oracle.sql.BLOB) rs.getBlob("image"); 9 BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("d://Sunset.jpg")); BufferedInputStream in = new BufferedInputStream(blob .getBinaryStream()); 10 int c; 11 while ((c = in.read()) != -1) { out.write(c); 12 } 13 in.close(); 14 out.close(); 15 rs.close(); 16 stmt.close(); 17 conn.close(); 18 检查D盘根目录，会发现Sunset.jpg文件，跟C盘下是一样的，说明入库出库成功！ admin on "LONG CLOB BLOB LONG RAW 区别" http://www.ll19.com/bb/topic/104#post-104 Sun, 03 Jan 2010 16:08:22 +0000 admin 104@http://www.ll19.com/bb/ 要保存图片、文本文件、Word文件各自最好用哪种数据类型? BLOB最好，LONG　RAW也不错，但Long是 oracle将要废弃的类型，因此建议用BLOB。 个人理解，基本上来说可以理解LONG存储大于4000的字符而BLOB用于存储附件流的二进制数据 LONG: 可变长的字符串数据，最长2G，LONG具有VARCHAR2列的特性，可以存储长文本一个表中最多一个LONG列 LONG RAW: 可变长二进制数据，最长2G（注意是二进制不是字符） 　　CLOB: 字符大对象Clob 用来存储单字节的字符数据 　　NCLOB: 用来存储多字节的字符数据 BLOB: 用于存储二进制数据 ORACLE建议在存储大字段使用LOB型 　　BFILE: 存储在文件中的二进制数据，这个文件中的数据只能被只读访。但该文件不包含在数据库内。 bfile字段实际的文件存储在文件系统中,字段中存储的是文件定位指针.bfile对oracle来说是只读的,也不参与事务性控制和数据恢复. 　　 　　CLOB，NCLOB，BLOB都是内部的LOB(Large Object)类型，最长4G，没有LONG只能有一列的限制 admin on "JAVA对EXCEL解析" http://www.ll19.com/bb/topic/103#post-103 Sun, 03 Jan 2010 16:07:19 +0000 admin 103@http://www.ll19.com/bb/ package testexcel; import java.io.FileInputStream; import java.io.FileOutputStream; import java.text.DecimalFormat; import org.apache.poi.hssf.usermodel.HSSFCell; import org.apache.poi.hssf.usermodel.HSSFRow; import org.apache.poi.hssf.usermodel.HSSFSheet; import org.apache.poi.hssf.usermodel.HSSFWorkbook; /** * * @author shiwt * * java读取excel文件 * * 一个Excel文件的层次：Excel文件->工作表->行->单元格对应到POI中，为：workbook->sheet->row->cell * */ public class POItest { public static String outputFile = "f:\\test\\tels.xls"; public static String fileToBeRead = "f:\\test\\tels.xls"; public void CreateExcel() { try { // 创建新的Excel 工作簿 HSSFWorkbook workbook = new HSSFWorkbook(); // 在Excel工作簿中建一工作表，其名为缺省值 // 如要新建一名为"效益指标"的工作表，其语句为： // HSSFSheet sheet = workbook.createSheet("效益指标"); HSSFSheet sheet = workbook.createSheet(); // 在索引0的位置创建行（最顶端的行） HSSFRow row = sheet.createRow((short) 0); //在索引0的位置创建单元格（左上端） HSSFCell cell = row.createCell((short) 0); // 定义单元格为字符串类型 cell.setCellType(HSSFCell.CELL_TYPE_STRING); // 在单元格中输入一些内容 cell.setCellValue("sweater"); // 新建一输出文件流 FileOutputStream fOut = new FileOutputStream(outputFile); // 把相应的Excel 工作簿存盘 workbook.write(fOut); fOut.flush(); // 操作结束，关闭文件 fOut.close(); System.out.println("文件生成..."); } catch (Exception e) { System.out.println("已运行 xlCreate() : " + e); } } /** * * 读取excel，遍历各个小格获取其中信息，并判断其是否是手机号码，并对正确的手机号码进行显示 * 注意： 1.sheet，以0开始，以workbook.getNumberOfSheets()-1结束 2.row， * 以0开始(getFirstRowNum)，以getLastRowNum结束 3.cell， * 以0开始(getFirstCellNum)，以getLastCellNum结束, 结束的数目不知什么原因与显示的长度不同，可能会偏长 * */ public void readExcel() { //将被表示成1.3922433397E10的手机号转化为13922433397,不一定是最好的转换方法 DecimalFormat df = new DecimalFormat("#"); try { // 创建对Excel工作簿文件的引用 HSSFWorkbook workbook = new HSSFWorkbook(new FileInputStream(fileToBeRead)); /** *获取sheet的个数 *workbook.getNumberOfSheets() **/ //System.out.println("===SheetsNum===" + workbook.getNumberOfSheets());//获取sheet数 for (int numSheets = 0; numSheets < workbook.getNumberOfSheets(); numSheets++) { if (null != workbook.getSheetAt(numSheets)) { HSSFSheet aSheet = workbook.getSheetAt(numSheets);//获得一个sheet //System.out.println("+++getFirstRowNum+++" + // aSheet.getFirstRowNum());// //System.out.println("+++getLastRowNum+++" + // aSheet.getLastRowNum()); for (int rowNumOfSheet = 0; rowNumOfSheet <= aSheet .getLastRowNum(); rowNumOfSheet++) { if (null != aSheet.getRow(rowNumOfSheet)) { HSSFRow aRow = aSheet.getRow(rowNumOfSheet); //System.out.println(">>>getFirstCellNum<<<"+ // aRow.getFirstCellNum()); //System.out.println(">>>getLastCellNum<<<"+ // aRow.getLastCellNum()); for (short cellNumOfRow = 0; cellNumOfRow <= aRow .getLastCellNum(); cellNumOfRow++) { if (null != aRow.getCell(cellNumOfRow)) { HSSFCell aCell = aRow.getCell(cellNumOfRow); int cellType = aCell.getCellType(); //System.out.println(cellType); switch (cellType) { case <a href="0://Numeric" rel="nofollow">0://Numeric</a> String strCell = df.format(aCell .getNumericCellValue()); System.out.println(strCell); break; case <a href="1://String" rel="nofollow">1://String</a> strCell = aCell.getStringCellValue(); System.out.println(strCell); break; default: //System.out.println("格式不对不读");//其它格式的数据 } } } } } } } } catch (Exception e) { System.out.println("ReadExcelError" + e); } } public static void main(String[] args) { POItest poi = new POItest(); //poi.CreateExcel(); poi.readExcel(); } } admin on "equalsIgnoreCase" http://www.ll19.com/bb/topic/102#post-102 Sun, 03 Jan 2010 16:05:15 +0000 admin 102@http://www.ll19.com/bb/ boolean equals(Object anObject) 比较此字符串与指定的对象。 boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 进行比较，不考虑大小写。 admin on "ArrayList的排序" http://www.ll19.com/bb/topic/101#post-101 Sun, 03 Jan 2010 16:04:03 +0000 admin 101@http://www.ll19.com/bb/ package com.ll19.util; /** * - 19. - ArrayList的排序 * * @author <a href="http://www.LL19.com/">LL19.com</a> * @version 1.0 */ import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; public class ListPX implements Comparator<String> { private final static int DOWM = -1; private int state; public ListPX(int state) { this.state = state; } public ListPX() { } public int compare(String o1, String o2) { if (state == ListPX.DOWM) { return sortDown(o1, o2); } return sortUp(o1, o2); } private int sortUp(String o1, String o2) { if (o1.compareTo(o2) < 0) { return -1; } else if (o1.compareTo(o2) > 0) { return 1; } else { return 0; } } private int sortDown(String o1, String o2) { if (o1.compareTo(o2) > 0) { return -1; } else if (o1.compareTo(o2) < 0) { return 1; } else { return 0; } } public static void main(String[] args) { ArrayList<String> array = new ArrayList<String>(); array.add("000001"); array.add("000003"); array.add("000005"); array.add("000004"); array.add("000002"); Collections.sort(array, new ListPX(ListPX.DOWM)); for (String str : array) { System.out.println(str); } } } 下面是一个高级排序 ------------------------------------------------ package com.ll19.util; import java.util.Comparator; public class Mycomparator implements Comparator { public int compare(Object o1, Object o2) { Person p1 = (Person) o1; Person p2 = (Person) o2; if (p1.age < p2.age) return 1; else return 0; } } package com.ll19.util; public class Person { String name; int age; public Person(String name, int age) { this.name = name; this.age = age; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } } package com.ll19.util; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; public class ListSort { public static void main(String[] args) { ArrayList list = new ArrayList(); list.add(new Person("lcl", 28)); list.add(new Person("fx", 23)); list.add(new Person("wqx", 29)); Comparator comp = new Mycomparator(); Collections.sort(list, comp); for (int i = 0; i < list.size(); i++) { Person p = (Person) list.get(i); System.out.println(p.getName()); } } } admin on "System.Properties记录" http://www.ll19.com/bb/topic/100#post-100 Sun, 03 Jan 2010 16:03:07 +0000 admin 100@http://www.ll19.com/bb/ System.Properties System可以有对标准输入，标准输出，错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。 System.getProperties()可以确定当前的系统属性,返回值是一个Properties; System.load(String filename)等同于：System.getProperties().load(String filename)它们的作用是可以从作为动态库德本地文件系统中指定的文件名加载代码文件。 System.setProperties(Properties propes):将系统属性设置为Properties参数； System.setProperties(String key,String value)等同于System.getProperties().setProperties(String key,String value):设置指定键指示的系统属性似乎类似于WEB的APPLICATION 对于在程序中如果我们想得到一个资源文件中对应的键值对的内容，可以有两种方法： 1）使用Properties的load方法，将这个文件先加载进来，之后使用getProperty方法将对应键的值得到，比如： System.getProperties().load("System.Properties.txt");先加载System.Properties.txt文件 System.getProperties().getProperty("DBType");后将文件中键为DBType的值得到。 2）使用第一种方法键对应的值得灵活性比较大。还有一种方法是将不从文件中得到键对应的值。在程序中去设一个属性，比如： System.getProperties().setProperty("DBType","SQLServer");先设置一个键位DBType的属性 System.getProperties().getProperty("DBType");后通过getProperty方法得到DBType的值。 另外使用Properties.getProperty方法的参数也可以使用系统的一些环境变量，列表如下： Key Meaning ------------------- ------------------------------ "file.separator" File separator (e.g., "/") "java.class.path" Java classpath "java.class.version" Java class version number "java.home" Java installation directory "java.vendor" Java vendor-specific string "java.vendor.url" Java vendor URL "java.version" Java version number "line.separator" Line separator "os.arch" Operating system architecture "os.name" Operating system name "path.separator" Path separator (e.g., ":") "user.dir" User's current working directory "user.home" User home directory "user.name" User account name 使用其中的key可以得到一些属性，供我们在程序中使用 admin on "关于serialVersionUID" http://www.ll19.com/bb/topic/99#post-99 Sun, 03 Jan 2010 16:02:05 +0000 admin 99@http://www.ll19.com/bb/ SERVLET经常会提示需要生成serialVersionUID serialVersionUID 用来表明类的不同版本间的兼容性 简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。 当实现java.io.Serializable接口的实体（类）没有显式地定义一个名为serialVersionUID，类型为long的变量时，Java序列化机制会根据编译的class自动生成一个serialVersionUID作序列化版本比较用，这种情况下，只有同一次编译生成的 class才会生成相同的serialVersionUID 。 如果我们不希望通过编译来强制划分软件版本，即实现序列化接口的实体能够兼容先前版本，未作更改的类，就需要显式地定义一个名为serialVersionUID，类型为long的变量，不修改这个变量值的序列化实体都可以相互进行串行化和反串行化。 admin on "使用urlencode" http://www.ll19.com/bb/topic/98#post-98 Sun, 03 Jan 2010 16:01:02 +0000 admin 98@http://www.ll19.com/bb/ 使用urlencode 　　UrlEncode 　　将字符串以 URL 编码。 　　返回值: 字符串 　　函数种类: 编码处理 　　内容说明 　　本函数将字符串以 URL 编码。例如空格就会变成加号。Homepage 中 form 资料传送就是用 urlencode 编码后再送出。 　　ASP中的用法: 　　Server.URLEncode("内容") 　　例: 　　<% 　　response.write Server.UrlEncode("七七IT中国") 　　%> 　　PHP中的用法: 　　urlencode("内容"); 　　例: 　　<? 　　echo urlencode("七七IT中国"); 　　?> 　　JSP中的用法: 　　URLEncoder.encode("七七IT中国"); 　　<% 　　java.net.URLEncoder.encode("七七IT中国"); 　　%> admin on "从jar包中读取配置文件信息" http://www.ll19.com/bb/topic/97#post-97 Sun, 03 Jan 2010 15:59:45 +0000 admin 97@http://www.ll19.com/bb/ kk.jar的目录结构如下 +kk.jar +META-INF MANIFEST.MF +config database.properties 目标：读取database.properties中的参数信息 types=mysql mysql.url=jdbc:mysql://127.0.0.1:3306/tjtz mysql.user=root mysql.password=root mysql.driver=com.mysql.jdbc.Driver mysql.maxCounts=5 代码如下： /* * @(#)JarFileReader.java Oct 9, 2008 * * Copyright (c) 2008 by jadmin. All Rights Reserved. */ package file.jar; import java.io.IOException; import java.io.InputStream; import java.util.Properties; import java.util.Set; import java.util.jar.JarEntry; import java.util.jar.JarFile; /** * 从jar包中读取配置文件信息 * * @author <a href="mailto:jadmin@yeah.net">jadmin</a> * @version 1.00 Oct 9, 2008 1:10:44 AM */ public class JarReader { public static void main(String[] args) { String jarPath = "C:\\Documents and Settings\\Administrator\\桌面\\新建文件夹\\kk.jar"; String entryFile = "config/database.properties"; doRead(jarPath,entryFile); } public static void doRead(String jarPath, String entryFile) { try { JarFile jarFile = new JarFile(jarPath); JarEntry entry = jarFile.getJarEntry(entryFile); InputStream input = jarFile.getInputStream(entry); process(input); jarFile.close(); } catch (IOException e) { e.printStackTrace(); } } private static void process(InputStream input) { Properties p = new Properties(); try { p.load(input); Set<?> set = p.keySet(); for (Object name : set) System.out.println(name + "=" + p.getProperty((String) name)); } catch (IOException e) { e.printStackTrace(); } } } 方法2 1. String fileName = "/config/abcd.config"; 2. InputStream in = getClass().getResourceAsStream(fileName); 3. BufferedReader br = null; 4. try{ 5. br = new BufferedReader(new InputStreamReader(in)); 6. String line; 7. while ((line = br.readLine()) != null){ 8. System.out.println(line); 9. } 10. br.close(); 11. } catch (Exception e){ 12. // TODO Auto-generated catch block 13. e.printStackTrace(); 14. } finally{ 15. if (br != null){ 16. try{ 17. br.close(); 18. } catch (IOException e){ 19. // TODO Auto-generated catch block 20. e.printStackTrace(); 21. } 22. } 23. } admin on "MAVEN2的配置" http://www.ll19.com/bb/topic/96#post-96 Sun, 03 Jan 2010 15:56:14 +0000 admin 96@http://www.ll19.com/bb/ maven是一个java项目管理工具，深化了ant，但又有自己一整套的项目集成策略。目前的版本是2.0.2。 1. maven网站下载maven2，解压缩 2. 配置环境变量:maven_home、path 3. cmd-> mvn --version 检查是否安装成功 [显示版本号，则说明安装成功] 4. 配置,Maven的配置分为三个层次: * - pom.xml:针对某个项目的配置 * Installation * User -针对某个用户的配置 我们首先配置主要是user级别的，主要包括两点:设置本地的资源库和代理服务器[如果需要的话] 在%maven_home%/conf/setting.xml中配置: <localRepository>d:/repo</localRepository> <proxy> <id>proxy1</id> <active>true</active> <protocol>http</protocol> <username></username> <password></password> <host>222.136.91.1</host> <port>80</port> <nonProxyHosts></nonProxyHosts> </proxy> 修改之后copy一份到${home}/.m2 5. 建立新的项目 mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=my-app * 首先，程序会从远程下载必要的jar包到你的localRepository,即我们刚刚设置的[d:/repo] * 然后，会在当前目录下面生成my-app文件夹，包括简单的包结构[java,test]和一个HelloWorld程序及测试,以及pom.xml文件。 注意：pom.xml contains the Project Object Model (POM) for this project.The POM is the basic unit of work in Maven。 6. 编译 mvn compile 第一次运行会下载很多jar包,而且机器负荷会很重。运行这个命令需要在pom.xml相同目录下面, 这个编译只编译主程序，不会编译test下面的程序。如果需要单独编译test,请运行： mvn test-compile compile之后会生成target文件夹，主程序编译在classes下面，测试程序放在test-classes下 7. 测试 mvn test 会自动先编译再运行测试 8. 打包 mvn package 打包之前会进行编译，测试 9. 安装 mvn install 会将package之后的jar包copy到 <local-repository>/com/mycompany/app/my-app/1.0-SNAPSHOT/my-app-1.0-SNAPSHOT.jar 10. 其他 mvn site 注意,还可以: deploy site 在pom.xml中加入 <distributionManagement> <site> <id> website </id> < url> <a href="scp://www.mycompany.com/www/docs/project/" rel="nofollow">scp://www.mycompany.com/www/docs/project/</a> </url> </site> </distributionManagement> 当然你需要设置server mvn site-deploy mvn clean mvn idea:idea [为IDE工具idea生成项目文件] 11. Resource ${basedir}/src/main/resources都会编译到jar文件中,而且该目录下的内容将直接位于jar文件的顶部。 测试用资源文件-> ${basedir}/src/test/resources，引用时如下例： InputStream is = getClass().getResourceAsStream( "/test.properties" ); 文件位于 ${basedir}/src/test/resources/test.properties。 12. 如何filter我们的资源文件 < build > < resources > < resource > < directory > src/main/resources </ directory > < filtering > true </ filtering > </ resource > </ resources > </ build > 因为原来默认的filter为false所以要加上上面的代码 eg:我们在src/main/resources下面建立application.properties文件 # application.properties application.name=${pom.name} application.version=${pom.version} 运行：mvn process-resources 在target/classes下面的application.properties结果为： # application.properties application.name=Maven Quick Start Archetype application.version=1.0-SNAPSHOT 这就是所谓的filter。当然filter还可以用其他的外部文件，不一定来自pom.xml[ ${pom.name} ]以及setting.xml[ ${settings.localRepository }] e.g src/main/filters/filter.properties: # filter.properties my.filter.value=hello! pom.xml: < build > < filters > < filter > src/main/filters/filter.properties </ filter > </ filters > < resources > < resource > < directory > src/main/resources </ directory > < filtering > true </ filtering > </ resource > </ resources > </ build > # application.properties application.name=${pom.name} application.version=${pom.version} message=${my.filter.value} 这样在运行mvn process-resources 会得到类似的效果,当然我们也可以直接在pom.xml中定义： < build > < resources > < resource > < directory > src/main/resources </ directory > < filtering > true </ filtering > </ resource > </ resources > </ build > < properties > < my .filter.value > hello </ my.filter.value > </ properties > 效果同样，这样就不需要外部文件了。另外filter还可以来自系统设置以及可以自定义： # application.properties java.version=${java.version} command.line.prop=${command.line.prop} 13. jar包依赖 我们在mvn install后在local repo中生成的jar包也可以被其他项目所引用 <dependency> <groupId>com.mycompany.app</groupId> <artifactId>my-app</artifactId> <version>1.0-SNAPSHOT</version> <scope>compile</scope> </dependency> 注意scope,这里是compile,如果使用junit，scope是test。 举例说明：如果我们的project需要用到log4j包，那么我们可以先google--"site:www.ibiblio.org maven2 log4j"。Index of /maven2/log4j/log4j 下面有maven-metadata.xml 描述了groupId,artifactId,version等等。获取了这些信息之后，你就可以在pom.xml中添加依赖 <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.12</version> <scope>compile</scope> </dependency> 14. 如何发布我的jar包到我的remote repository 你需要在setting.xml中间设置server: <servers> <server> <id>mycompany-repository</id> <username>jvanzyl</username>  <privateKey>/path/to/identity</privateKey> <passphrase>my_key_passphrase</passphrase> </server> </servers> 然后在pom.xml中设置远程url: <distributionManagement> <repository> <id>mycompany-repository</id> <name>MyCompany Repository</name> <url>scp://repository.mycompany.com/repository/maven2</url> </repository> </distributionManagement> 1.2. Maven2的Eclipse插件安装和使用 1.2.1. 安装 你可以从http://m2eclipse.codehaus.orgupdate安装Maven2的Eclipse插件，具体安装步骤请看该网站提供的Flash Demo: <a href="http://m2eclipse.codehaus.org/Installing_Maven_2.0_plugin_for_Eclipse.html" rel="nofollow">http://m2eclipse.codehaus.org/Installing_Maven_2.0_plugin_for_Eclipse.html</a> 1.2.2. 使用 该插件的使用请看该网站提供的Flash Demo: <a href="http://m2eclipse.codehaus.org/Maven_2.0_Plugin_for_Eclipse.html" rel="nofollow">http://m2eclipse.codehaus.org/Maven_2.0_Plugin_for_Eclipse.html</a> admin on "ORACLE行转列" http://www.ll19.com/bb/topic/95#post-95 Sun, 03 Jan 2010 15:54:32 +0000 admin 95@http://www.ll19.com/bb/ 物料需要数量需要仓库现存量仓库现存量仓库数量批次 A1 2 C1 C1 20 123 A1 2 C1 C2 30 111 A1 2 C1 C2 20 222 A1 2 C1 C3 10 211 A2 3 C4 C1 40 321 A2 3 C4 C4 50 222 A2 3 C4 C4 60 333 A2 3 C4 C5 70 223 我需要把上面的查询结果转换为下面的。 物料需要数量需要仓库 C1 C2 C3 C4 C5 A1 2 C1 20 50 10 0 0 A2 3 C4 40 0 0 110 70 */ ---------------------------------------------------------------建表 ----------------判断表是否存在 declare num number; begin select count(1) into num from user_tables where table_name='TEST'; if num>0 then execute immediate 'drop table TEST'; end if; end; ----------------建表 CREATE TABLE TEST( WL VARCHAR2(10), XYSL INTEGER, XYCK VARCHAR2(10), XCLCK VARCHAR2(10), XCLCKSL INTEGER, PC INTEGER ); ----------------第一部分测试数据 INSERT INTO TEST VALUES('A1', 2, 'C1', 'C1' , 20, 123); INSERT INTO TEST VALUES('A1', 2, 'C1', 'C2' , 30, 111); INSERT INTO TEST VALUES('A1', 2, 'C1', 'C2' , 20, 222); INSERT INTO TEST VALUES('A1', 2, 'C1', 'C3' , 10, 211); INSERT INTO TEST VALUES('A2', 3, 'C4', 'C1' , 40, 321); INSERT INTO TEST VALUES('A2', 3, 'C4', 'C4' , 50, 222); INSERT INTO TEST VALUES('A2', 3, 'C4', 'C4' , 60, 333); INSERT INTO TEST VALUES('A2', 3, 'C4', 'C5' , 70, 223); COMMIT; --select * from test; ---------------------------------------------------------------行转列的存储过程 CREATE OR REPLACE PROCEDURE P_TEST IS V_SQL VARCHAR2(2000); CURSOR CURSOR_1 IS SELECT DISTINCT T.XCLCK FROM TEST T ORDER BY XCLCK; BEGIN V_SQL := 'SELECT WL,XYSL,XYCK'; FOR V_XCLCK IN CURSOR_1 LOOP V_SQL := V_SQL || ',' || 'SUM(DECODE(XCLCK,''' || V_XCLCK.XCLCK || ''',XCLCKSL,0)) AS ' || V_XCLCK.XCLCK; END LOOP; V_SQL := V_SQL || ' FROM TEST GROUP BY WL,XYSL,XYCK ORDER BY WL,XYSL,XYCK'; --DBMS_OUTPUT.PUT_LINE(V_SQL); V_SQL := 'CREATE OR REPLACE VIEW RESULT AS '|| V_SQL; --DBMS_OUTPUT.PUT_LINE(V_SQL); EXECUTE IMMEDIATE V_SQL; END; ----------------------------------------------------------------结果 ----------------执行存储过程，生成视图 BEGIN P_TEST; END; ----------------结果 SELECT * FROM RESULT T; WL XYSL XYCK C1 C2 C3 C4 C5 ---------- --------------------------------------- ---------- ---------- ---------- ---------- ---------- ---------- A1 2 C1 20 50 10 0 0 A2 3 C4 40 0 0 110 70 ----------------第二部分测试数据 INSERT INTO TEST VALUES('A1', 2, 'C1', 'C6' , 20, 124); INSERT INTO TEST VALUES('A2', 2, 'C1', 'C7' , 30, 121); INSERT INTO TEST VALUES('A3', 2, 'C1', 'C8' , 20, 322); COMMIT; ----------------报告存储过程，生成视图 BEGIN P_TEST; END; ----------------结果 SELECT * FROM RESULT T; WL XYSL XYCK C1 C2 C3 C4 C5 C6 C7 C8 ----- ----- -------- ------- -------- ---------- ---------- ---------- ---------- ---------- ---------- A1 2 C1 20 50 10 0 0 20 0 0 A2 2 C1 0 0 0 0 0 0 30 0 A2 3 C4 40 0 0 110 70 0 0 0 A3 2 C1 0 0 0 0 0 0 0 20 --------------- 删除实体 DROP VIEW RESULT; DROP PROCEDURE P_TEST; DROP TABLE TEST; admin on "ORACLE多行合并" http://www.ll19.com/bb/topic/94#post-94 Sun, 03 Jan 2010 15:53:17 +0000 admin 94@http://www.ll19.com/bb/ 例如有如下数据：m_researcher_stock_rel表 N_SEC_CODE C_RESEARCHER_CODE 000297 chenpeng 000297 liusu 合并处理后需显示为： 000297 chenpeng,liusu wmsys.wm_concat 的用法 select N_SEC_CODE, wmsys.wm_concat(C_RESEARCHER_CODE) p from m_researcher_stock_rel GROUP BY N_SEC_CODE admin on "存储过程返回结果集" http://www.ll19.com/bb/topic/93#post-93 Sun, 03 Jan 2010 15:50:08 +0000 admin 93@http://www.ll19.com/bb/ 首先要明确一个概念 PROCEDURE TRIGGER PACKAGE 的区别 简单的说，PROCEDURE, TRIGGER都是一段程序 但PROCEDURE需要手工调用，TRIGGER满足你设定的条件会自动执行 PACKAGE是把几个程序封装在一起，和JAVA里的PACKAGE的概念差不多。 得到返回的结果集需要建立PACKAGE，并且返回列表需要通过返回游标实现 由于oracle存储过程没有返回值，它的所有返回值都是通过out参数来替代的，列表同样也不例外，但由于是集合，所以不能用一般的参数，必须要用pagkage了.所以要分两部分。 1、在SQL*PLUS中建一个程序包（在包中定义了一个类型游标） CREATE OR REPLACE PACKAGE TESTPACKAGE AS TYPE Test_CURSOR IS REF CURSOR; procedure TESTC(cur_ref out Test_CURSOR); end TESTPACKAGE; 2、建立包之后建立存储过程 create or replace package body TESTPACKAGE as procedure TESTC(cur_ref out Test_CURSOR) is begin OPEN cur_ref FOR select * from test; end TESTC; END TESTPACKAGE; 可以看到，它是把游标(cursor)（可以理解为一个指针），作为一个out 参数来返回值的。 JAVA调用程序如下：

PLAIN TEXT

JAVA:

package com.rizon.tree.excelApi;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
public class CursorTest {
public static void main(String[] args) throws ClassNotFoundException,
SQLException {
Connection conn = null;
ResultSet rs = null;
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
conn = DriverManager.getConnection(
"jdbc:oracle:thin:@10.0.41.100:1521:orcl", "forestrytree",
"forestrytree");
oracle.jdbc.OracleCallableStatement stmt = (oracle.jdbc.OracleCallableStatement) conn
.prepareCall("{call TESTPACKAGE.TESTC(?)}");
// stmt.setString(1, "1");
stmt.registerOutParameter(1, oracle.jdbc.OracleTypes.CURSOR);
stmt.execute();
rs = stmt.getCursor(1);
for (int i = 0; rs.next();) {
System.out.println(" ----[" + i + "]name:" + rs.getString(1)
+ "telephone:" + rs.getString(2));
}
} catch (Exception ex) {
ex.printStackTrace();
} finally {
if (conn != null) {
conn.close();
conn = null;
}
if (rs != null) {
rs.close();
rs = null;
}
}
}
}

admin on "有输入参数和输出参数的存储过程JAVA调用例子" http://www.ll19.com/bb/topic/92#post-92 Sun, 03 Jan 2010 15:48:08 +0000 admin 92@http://www.ll19.com/bb/

PLAIN TEXT

JAVA:

public class TestProcedureTWO {
public TestProcedureTWO() {
}
public static void main(String args ){
String driver = "oracle.jdbc.driver.OracleDriver";
String strUrl = "jdbc:oracle:thin:@192.168.10.216:1521:ctbu";
Statement stmt = null;
ResultSet rs = null;
Connection conn = null;
try {
Class.forName(driver);
conn = DriverManager.getConnection(strUrl, "dbname", "password");
CallableStatement proc = null;
proc = conn.prepareCall("{ call TESTB(?,?) }");
proc.setString(1, 1);
proc.registerOutParameter(2, Types.VARCHAR);
proc.execute();
String testPrint = proc.getString(2);
System.out.println("=testPrint=is="+testPrint);
}
catch (SQLException ex2) {
ex2.printStackTrace();
}
catch (Exception ex2) {
ex2.printStackTrace();
}
finally{
try {
if(rs != null){
rs.close();
if(stmt!=null){
stmt.close();
}
if(conn!=null){
conn.close();
}
}
}
catch (SQLException ex1) {
}
}
}
}
}

admin on "存储过程记录（只有输入参数）" http://www.ll19.com/bb/topic/91#post-91 Sun, 03 Jan 2010 15:46:05 +0000 admin 91@http://www.ll19.com/bb/ 过程 过程是为了执行一定任务而组合在一起的SQL语句和PLSQL语句。（个人理解过程就是ORACLE的程序（或者说是方法、函数）） 只有输入参数时候的例子 创建存储过程 创建或替换一个存储过程myproc 参数为id ORACLE中参数默认为输入参数 in （之后用is 或者 as 都可以） CREATE or replace procedure myproc(id in varchar2) Is 定义一个变量注意：定义变量一定要给出长度，参数可以不给出长度 Name varchar2(10); Begin 将books_name放置到变量里面 Select books_name into Name form books where books_id = id; Dbms_Output.put_line(Name); End myproc; 执行存储过程 Declare 定义变量 Tid vachar2(10); Begin 赋值 Tid := ‘001’; Myproc(Tid); End; 完整内容： CREATE or replace procedure myproc(idcs in varchar2) Is Namebl varchar2(10); Begin select name into Namebl from test where id = idcs; Dbms_Output.put_line(Namebl); End myproc; Declare Tid integer(10); Begin Tid := 1; Myproc(Tid); End; 或者 Begin Myproc(1); End; JAVA程序 import java.sql.*; import java.io.OutputStream; import java.io.Writer; import java.sql.PreparedStatement; import java.sql.ResultSet; import oracle.jdbc.driver.*; public class TestProcedureOne { public TestProcedureOne() { } public static void main(String args ){ String driver = "oracle.jdbc.driver.OracleDriver"; String strUrl = "jdbc:oracle:thin:@192.168.10.216:1521:ctbu"; Statement stmt = null; ResultSet rs = null; Connection conn = null; CallableStatement cstmt = null; try { Class.forName(driver); conn = DriverManager.getConnection(strUrl, "dbname", "password"); CallableStatement proc = null; proc = conn.prepareCall("{ call TESTA(?,?) }"); proc.setString(1, 1); proc.setString(2, "232323"); proc.execute(); } catch (SQLException ex2) { ex2.printStackTrace(); } catch (Exception ex2) { ex2.printStackTrace(); } finally{ try { if(rs != null){ rs.close(); if(stmt!=null){ stmt.close(); } if(conn!=null){ conn.close(); } } } catch (SQLException ex1) { } } } } admin on "游标的记录" http://www.ll19.com/bb/topic/90#post-90 Sun, 03 Jan 2010 15:42:39 +0000 admin 90@http://www.ll19.com/bb/ 游标的作用 游标可以对数据进行逐条的控制 平常写SELECT语句的时候得到的是一个统一的结果集，无法对结果进行逐条的控制，游标便可以实现逐条的控制。 游标通过操作结果集中的数据，逐行进行处理来达某种目的。 游标的使用方法 比如需要对BOOKS表的每条记录进行逐条处理，首先在内存中申请空间，例如需要处理的select语句是Select * form books；，则： Declare CURSOR mycur is Select * form books； 需要对此结果进行逐行的处理，则将游标对应的数据取出放在一个变量里，事先需要准备好一个变量，由于是表的所有字段，则这么写： Myrecord books%ROWTYPE; 接着就是将结果集打开 Begin Open mycur; 打开之后则把数据放到事先声明的变量里面 FETCH mycur INTO Myrecord; 之后循环判断取数据 WHILE mycur%FOUND 表示当游标中有数据可取 %FOUND为游标的四个属性的一个返回布尔值 之后循环取值将数据显示： WHILE mycur%FOUND LOOP Dbms_Output.put_line(Myrecord.id || Myrecord.name); FETCH mycur INTO Myrecord; END LOOP; Close mycur; End; / 其中id就是BOOKS表中的字段id name同样 当数据量很大，不建议使用游标，比较消耗资源。 admin on "varchar2的参数(byte和char)" http://www.ll19.com/bb/topic/89#post-89 Sun, 03 Jan 2010 15:38:53 +0000 admin 89@http://www.ll19.com/bb/ 由于一个汉字在我的GBK系统里占用2个字节，所以byte的只能插入2个汉字，而char的可以插入5个汉字。 所以byte 就是字节数，对于汉字，GBK占用2个字节，如果是UTF-8则占用3个字节。 为了充分利用4000个的上限，给自己减少麻烦，建议存储含有中文文字的字段时，采用char类型。 下面是测试 SQL> create table test(name varchar(5 byte),namec varchar(5 char)); 表已创建。 -----------------------byte测试------------------------------------ SQL> insert into test(name) values('12345'); 已创建 1 行。 SQL> insert into test(name) values('123456'); insert into test(name) values('123456') 第 1 行出现错误: ORA-12899: 列 "SCOTT"."TEST"."NAME" 的值太大 (实际值: 6, 最大值: 5) SQL> insert into test(name) values('天津'); 已创建 1 行。 SQL> insert into test(name) values('天津市'); insert into test(name) values('天津市') 第 1 行出现错误: ORA-12899: 列 "SCOTT"."TEST"."NAME" 的值太大 (实际值: 6, 最大值: 5) -----------------------char测试------------------------------------ SQL> insert into test(namec) values('12345'); 已创建 1 行。 SQL> insert into test(namec) values('123456'); insert into test(namec) values('123456') 第 1 行出现错误: ORA-12899: 列 "SCOTT"."TEST"."NAMEC" 的值太大 (实际值: 6, 最大值: 5) SQL> insert into test(namec) values('天津'); 已创建 1 行。 SQL> insert into test(namec) values('天津市'); 已创建 1 行。 SQL> insert into test(namec) values('天津市北京'); 已创建 1 行。 SQL> insert into test(namec) values('天津市北京市'); insert into test(namec) values('天津市北京市') 第 1 行出现错误: ORA-12899: 列 "SCOTT"."TEST"."NAMEC" 的值太大 (实际值: 6, 最大值: 5) -------------------------结果------------------------------------ SQL> select * from test; NAME NAMEC ----- ---------- 12345 天津 12345 天津 天津市 天津市北京 已选择6行。 -------------------------分析------------------------------------ 由于一个汉字在我的GBK系统里占用2个字节，所以byte的只能插入2个汉字，而char的可以插入5个汉字。 所以byte 就是字节数，对于汉字，GBK占用2个字节，如果是UTF-8则占用3个字节。 为了充分利用4000个的上限，给自己减少麻烦，建议存储含有中文文字的字段时，采用char类型。