K.L Repository

在Hibernate手册中是这样描述 Lazy Initialization－延迟加载的

集合(不包括数组)是可以延迟初始化的,意思是仅仅当应用程序需要访问时，才载入他们的值。对于使用者来说，初始化是透明的, 因此应用程序通常不需要关心这个(事实上,透明的延迟加载也就是为什么Hibernate需要自己的集合实现的主要原因)。

另外一种选择是不使用延迟初始化集合。既然延迟初始化可能引起上面这样错误,默认是不使用延迟初始化的。但是, 为了效率的原因, 我们希望对绝大多数集合(特别是实体集合)使用延迟初始化。


如果你不描述，则Lazy的属性为False(即不使用延迟加载！这让我想到原来我们的一位同事没有Load出List就怪罪于Hibernate，看来是子虚乌有的！) 所以Lazy属性的设置与你内存的大小是有很大关系的，如果你采用Hibernate默认的设置，也许不经意（就是Hibernate"透明持久化"）Load出主表的记录就连带着将子表的一个上千万的List给Load进内存中，你的服务器不崩溃才怪呢！！

Javaeye的那些个高手总是不解释"透明持久化"这个概念，让很多初学者非常的疑惑（比如我），在打印出Hibernate的调试信息后，一切都变得自然。。。
你可以尝试着将Lazy更换成true|false
<list name="currentSteps" cascade="all-delete-orphan" lazy="false" >
<key column="entry_Id"/>
<index column="stepIndex"/>
<one-to-many class="com.company.engine.workflow.po.HibernateCurrentStep"/>
</list>

当你将lazy更改成false(也就是默认值)时，并在Load出主记录后关闭session,比如如下程序
try
{
List result = session.find(ENTRY_SEARCH_SQL, new Long(entryId), Hibernate.LONG);
return (WorkflowEntry) result.get(0);
}
catch (HibernateException he)
{
throw new StoreException(he);
}finally
{
if(session != null)
try
{
session.close();
}
catch (HibernateException he)
{
throw new StoreException(he);
}
}

当你执行如下测试的时候
try
{
HibernateWorkflowEntry entry = (HibernateWorkflowEntry) store.findEntry(0);
logger.debug("find entry by id - " + entry);
assertNotNull(entry);

List cl = entry.getCurrentSteps();
for(int i=0;i<cl.size();i++)
{
HibernateCurrentStep step = (HibernateCurrentStep) cl.get(i);
logger.debug("get entry current steps["+i+"] = " + step);
logger.debug("get entry current steps["+i+"] = " + step.getEntry());

}

}
catch (Exception e)
{
e.printStackTrace();
assertTrue(false);
}

就会接受到如下的异常信息

net.sf.hibernate.LazyInitializationException: Failed to lazily initialize a collection - no session or session was closed
at net.sf.hibernate.collection.PersistentCollection.initialize(PersistentCollection.java:209)
at net.sf.hibernate.collection.PersistentCollection.read(PersistentCollection.java:71)
at net.sf.hibernate.collection.List.size(List.java:79)
at test.com.company.engine.workflow.store.ExtHibernateWorkflowStoreTest.testFindEntry(ExtHibernateWorkflowStoreTest.java:82)
........

net.sf.hibernate.collection.List
/**
* @see java.util.List#size()
*/
public int size() {
read();
return list.size();
}

这里的read()就会反向的再次读取数据库记录，目的是再次的Load出子记录来！可是这个时候你已经将Session关闭了！！所以Hibernate也就无法完成加载的任务，LazyInitializationException异常自然就扔了出来


但是现在就有一个问题:当list执行read()方法的时候，给它的session是什么？（答案肯定是你Open的那个session）但是hibernate如何确保session的唯一性呢？这个问题比较的BT，需要看SessionFactoryImpl这个构造函数到底怎么维护session的

URL : http://java.sun.com/docs/books/tutorial/java/javaOO/nested.html

网上的一些关于内部类的概念是不完整的，还是看看SUN的文档上的标准答案。
...

Like other members, a nested class can be declared static (or not). A static nested class is called just that: a static nested class. A nonstatic nested class is called an inner class.

－ Nested class分为静态Static nested class 的和非静态的 inner class, 在SUN的眼里只有Nested Class！！


As with static methods and variables, which we call class methods and variables, a static nested class is associated with its enclosing class. And like class methods, a static nested class cannot refer directly to instance variables or methods defined in its enclosing class — it can use them only through an object reference.

－ 静态的Static nested class是不可以直接调用它的外部类enclosing class的，但是可以通过外部类的引用来调用，就像你在一个类中写了main方法一样。
...

As with instance methods and variables, an inner class is associated with an instance of its enclosing class and has direct access to that object's instance variables and methods. Also, because an inner class is associated with an instance, it cannot define any static members itself.

－非静态类inner class 可以自由的引用外部类的属性和方法，但是它与一个实例绑定在了以其，不可以定义静态的属性、方法（这点不是很理解，可能需要看JVM的类实现）

...
class EnclosingClass {
...
class InnerClass {
...
}
}


The interesting feature about the relationship between these two classes is not that InnerClass is syntactically defined within EnclosingClass. Rather, it's that an instance of InnerClass can exist only within an instance of EnclosingClass and that it has direct access to the instance variables and methods of its enclosing instance. The next figure illustrates this idea.


－图形化的嵌入类与外部类的关系

url : http://www.frontfree.net/view/article_704.html

初识Java内部类
原创：morgan83 2002年12月31日



提起Java内部类（Inner Class）可能很多人不太熟悉，实际上类似的概念在C++里也有，那就是嵌套类（Nested Class），关于这两者的区别与联系，在下文中会有对比。内部类从表面上看，就是在类中又定义了一个类（下文会看到，内部类可以在很多地方定义），而实际上并没有那么简单，乍看上去内部类似乎有些多余，它的用处对于初学者来说可能并不是那么显著，但是随着对它的深入了解，你会发现Java的设计者在内部类身上的确是用心良苦。学会使用内部类，是掌握Java高级编程的一部分，它可以让你更优雅地设计你的程序结构。下面从以下几个方面来介绍：

第一次见面
public interface Contents {
int value();
}

public interface Destination {
String readLabel();
}

public class Goods {
private class Content implements Contents {
private int i = 11;
public int value() {
return i;
}
}

protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}

public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}

class TestGoods {
public static void main(String[] args) {
Goods p = new Goods();
Contents c = p.cont();
Destination d = p.dest("Beijing");
}
}

在这个例子里类Content和GDestination被定义在了类Goods内部，并且分别有着protected和private修饰符来控制访问级别。Content代表着Goods的内容，而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里，直接用 Contents c和Destination d进行操作，你甚至连这两个内部类的名字都没有看见！这样，内部类的第一个好处就体现出来了——隐藏你不想让别人知道的操作，也即封装性。
同时，我们也发现了在外部类作用范围之外得到内部类对象的第一个方法，那就是利用其外部类的方法创建并返回。上例中的cont()和dest()方法就是这么做的。那么还有没有别的方法呢？当然有，其语法格式如下：

outerObject=new outerClass(Constructor Parameters);

outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);


注意在创建非静态内部类对象时，一定要先创建起相应的外部类对象。至于原因，也就引出了我们下一个话题——

非静态内部类对象有着指向其外部类对象的引用
对刚才的例子稍作修改：

public class Goods {

private valueRate=2;

private class Content implements Contents {
private int i = 11*valueRate;
public int value() {
return i;
}
}

protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}

public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}


修改的部分用蓝色显示了。在这里我们给Goods类增加了一个private成员变量valueRate，意义是货物的价值系数，在内部类Content的方法value()计算价值时把它乘上。我们发现，value()可以访问valueRate，这也是内部类的第二个好处——一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！这是一个非常有用的特性，为我们在设计时提供了更多的思路和捷径。要想实现这个功能，内部类对象就必须有指向外部类对象的引用。Java编译器在创建内部类对象时，隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象，同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。

有人会问，如果内部类里的一个成员变量与外部类的一个成员变量同名，也即外部类的同名成员变量被屏蔽了，怎么办？没事，Java里用如下格式表达外部类的引用：

outerClass.this

有了它，我们就不怕这种屏蔽的情况了。

静态内部类
和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。这实际上和C++中的嵌套类很相像了，Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用这一点上，当然从设计的角度以及以它一些细节来讲还有区别。

除此之外，在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。

局部内部类
是的，Java内部类也可以是局部的，它可以定义在一个方法甚至一个代码块之内。

public class Goods1 {
public Destination dest(String s) {
class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() { return label; }
}
return new GDestination(s);
}

public static void main(String[] args) {
Goods1 g= new Goods1();
Destination d = g.dest("Beijing");
}
}


上面就是这样一个例子。在方法dest中我们定义了一个内部类，最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并创给外部，就可以这样做。当然，定义在方法中的内部类可以使设计多样化，用途绝不仅仅在这一点。

下面有一个更怪的例子：

public class Goods2{
private void internalTracking(boolean b) {
if(b) {
class TrackingSlip {
private String id;
TrackingSlip(String s) {
id = s;
}
String getSlip() { return id; }
}
TrackingSlip ts = new TrackingSlip("slip");
String s = ts.getSlip();
}
}

public void track() { internalTracking(true); }

public static void main(String[] args) {
Goods2 g= new Goods2();
g.track();
}
}


你不能在if之外创建这个内部类的对象，因为这已经超出了它的作用域。不过在编译的时候，内部类TrackingSlip和其他类一样同时被编译，只不过它由它自己的作用域，超出了这个范围就无效，除此之外它和其他内部类并没有区别。

匿名内部类
java的匿名内部类的语法规则看上去有些古怪，不过如同匿名数组一样，当你只需要创建一个类的对象而且用不上它的名字时，使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的：

new interfacename(){......}; 或 new superclassname(){......};

下面接着前面继续举例子：

public class Goods3 {
public Contents cont(){
return new Contents(){
private int i = 11;
public int value() {
return i;
}
};
}
}

这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象，看上去的确十分简洁。

在java的事件处理的匿名适配器中，匿名内部类被大量的使用。例如在想关闭窗口时加上这样一句代码：

frame.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});

有一点需要注意的是，匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。如果你想要初始化它的成员变量，有下面几种方法：

如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须被声明为final。
将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。
在这个匿名内部类中使用初始化代码块。
为什么需要内部类？
java内部类有什么好处？为什么需要内部类？

首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。

不过你可能要质疑，更改一下方法的不就行了吗？

的确，以此作为设计内部类的理由，实在没有说服力。

真正的原因是这样的，java中的内部类和接口加在一起，可以的解决常被C++程序员抱怨java中存在的一个问题——没有多继承。实际上，C++的多继承设计起来很复杂，而java通过内部类加上接口，可以很好的实现多继承的效果。

本文的目的只是向大家介绍一下内部类的概念以及使用方法，在后续文章里，将会针对本文中的内容举更多具体的例子，以及介绍如何使用内部类构建一个Applicaton Framework。

workflow接口划分

1。应用接口 Application Interface
－－interface1 工作流自身提供的服务接口
－－interface2 工作流与应用之间的接口（主要是提供相关数据的调用接口）

2。扩展接口 PlugIn Interface
－－interface3 工作流与组织机构之间的接口
－－interface4 工作流与其他工作流之间的接口

将接口划分成应用接口与扩展接口主要是依据工作流与相关应用的调用关系，比如工作流与组织机构之间，是工作流调用组织机构中的人员信息，所以主动者是WORKFLOW、被动方是组织机构，所以应该采用扩展接口来实现

在扩展接口上应该采用Adapter模式，从而使工作流不局限于某个特定的实现

目前的进展
0。Application Interface接口已经基本实现了
PlugIn Interface接口目前基本完工，但OSWorkflow的实现实在是非常的丑陋，需要更改的地方太多，而且对于Interface3不可以使用它采用的User / Group模型（而且它使用了OSUser这个框架，对于多数的应用程序基本可以说不适合，而且它的User类竟然是Final ?!而且我发现它的很多类的属性都是Protected！也就是说除了他们自己根本没有办法扩展，即使扩展也是很丑陋的方式）

1。现在最大的问题是它的WorkStore接口的扩展，我采用DB2的方式实现了它的接口，但这样的方式会与DB2绑定在一起，如果自己写实现就要根据不同的DB采用不同的SQL语言－也就是不同的方言策略？！而且考虑到性能估计不是什么好主意，看来明天需要更换成HibernateWorkStore的形式，这样工作流的持久层接口将工作在Hibernate之上，看来很完美的解决了这个问题。

2。而且我扩展了它的PropertySet，使其不再依靠JNDI寻找DataSource，而是通过嵌入在程序内部采用JDBC的形式寻找数据库连接，这样我就不必为了验证一个问题去建立那该死的数据库缓冲池了（而且JNDI的形式也就不可避免的要用到容器，太重了！）

3。我编写了UserGroupCondition的实现类，这个类的作用就是调用Interface3的方法，从而判断某个用户是否属于某个组（现在的做法是让WorkStore实现Interface3的偷懒办法，但很乱，看来还是要写一个Adapter去实现interface3才对！）

4。目前工作流引擎的工厂类已经实现完工并测试通过。


用了近一个月的时间完成了这些工作，看起来很少但是基本上大量的时间花费在熟悉工作流规范、WFMC标准、以及学习和扩展OSWorkflow接口上，不过对OSWorkflow的实现基本上掌握了，如果抛开OSWorkflow自己也可以采用自己的方式去实现，或者会考虑使用Spring的方式（Interface3的Adapter不行就采用Spring实现）。

BTW:
OSWorkflow的实现其实比较的丑陋！而且编码根本没有什么规范，接口的定义也是天马行空，看来Heni除了他的大嘴外应该好好的提高自己的技术修养。－实在不敢恭维这位"大师"的编码水平！

在Google查询了一个下午，寻找到的资料要麽运行不了，要麽就是没有DB2的配置信息，以下是参考OSWorkflow以及Tomcat的关于Oracle的配置信息，测试通过的实例
测试环境
OS:WindowxXP Professional
DB:DB2 8.1
Web Server: Tomcat5.0



1。首先要下载DB2的驱动程序 db2java.zip ，将db2java.zip更改成db2java.jar(因为tomcat只认识*.jar文件)拷贝到%TOMCAT%/common/lib下

2。修改%TOMCAT%/conf/server.xml 。寻找到<Host>项，添加如下的信息（copy from osworkflow）

<Context path="/osworkflow_example" docBase="osworkflow-2.7.0-example"
debug= "99" reloadable="true" crossContext="true"

verbosity="DEBUG">
<!- debug level is set to paranoid, to know what is happening,
turn it off once you do not need it ->

<Logger className="org.apache.catalina.logger.FileLogger"
prefix="OSWorkflow." suffix=".log" timestamp="true"/>
<!-
put log4j.jar into:
TOMCAT_ROOT/webapp/osworkflow-2.7.0-example/WEB-INF/lib
if you want to use it for logging
->

<Resource name="jdbc/DefaultDS" auth="Container"
type="javax.sql.DataSource"/>
<!- name="jdbc/DefaultDS" is used in other components of the
Example App, do not change it here! ->

<ResourceParams name="jdbc/DefaultDS">
<parameter>
<name>factory</name>
<value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
</parameter>
<parameter>
<name>driverClassName</name>
<value>oracle.jdbc.driver.OracleDriver</value>
</parameter>
<parameter>
<name>url</name>
<value>jdbc:oracle:thin:@yourserver.com:port:SID</value>
</parameter>
<parameter>
<name>username</name>
<value>your_database_user_name_here</value>
</parameter>
<parameter>
<name>password</name>
<value>your_password_here</value>
</parameter>
<parameter>
<name>maxActive</name>
<value>20</value>
</parameter>
<parameter>
<name>maxIdle</name>
<value>10</value>
</parameter>
<parameter>
<name>maxWait</name>
<value>-1</value>
</parameter>
</ResourceParams>
</Context>

<!- OSWorkflow JNDI Data Source ->
3。在应用的web.xml文件中添加(其实这个步骤可以省略！)
<resource-ref> <description>DB Connection</description> <res-ref-name>jdbc/workflow</res-ref-name> <res-type>javax.sql.DataSource</res-type> <res-auth>Container</res-auth> </resource-ref>
4。编写测试文件**.jsp
　<%@page import="javax.naming.InitialContext"%><%@page import="java.sql.*"%><%@page import="javax.sql.DataSource"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"><HTML><HEAD><META NAME="Generator" CONTENT="EditPlus"><META NAME="Author" CONTENT=""><META NAME="Keywords" CONTENT=""><META NAME="Description" CONTENT=""></HEAD>
<BODY>
<%try{InitialContext ctx=new InitialContext();DataSource ds=(DataSource)ctx.lookup("java:/comp/env/jdbc/workflow");Connection conn = ds.getConnection();
Statement stmt = conn.createStatement();out.println("Connection = " + conn);out.println("Statement = " + stmt);}catch(Exception ex) { out.print(" error , info = "+ ex.getMessage()); ex.printStackTrace();}%>
</BODY></HTML>
注意：
如果是Tomcat5.0之前的版本，可能需要在执行1之前
Jakarta-Commons DBCP 1.0 Jakarta-Commons Collections 2.0 Jakarta-Commons Pool 1.0
将上面的jar包下载到%TOMCAT%/common/lib下


总结：
1。DB2的连接池其实和Oracle的配置没有区别，关键是Tomcat的比较麻烦

2。在遇到问题的时候最好参考标准的文档，而不是网上的垃圾文章，这样可以省去很多的弯路