java工厂类

Java工厂类
Chapter 01
工厂模式定义:提供创建对象的接口.
为何使用?
工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。

为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑实用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

我们以类Sample为例， 如果我们要创建Sample的实例对象:
Sample sample=new Sample();
可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值 查询数据库等。

首先，我们想到的是，可以使用Sample的构造函数，这样生成实例就写成:
Sample sample=new Sample(参数);
但是，如果创建sample实例时所做的初始化工作不是象赋值这样简单的事，可能
or 是很长一段代码，如果也写入构造函数中，那你的代码很难看了（就需要Refact
重整）。

为什么说代码很难看，初学者可能没有这种感觉，我们分析如下，初始化工作如果是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有背于Java面向对象的原则，面向对象的封装(Encapsulation)和分派(Delegation)告诉我们，尽量将长的代码分派“切割”成每段，将每段再“封装”起来(减少段和段之间偶合联系性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。

在本例中，首先，我们需要将创建实例的工作与使用实例的工作分开, 也就是说，让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。

这时我们就需要Factory工厂模式来生成对象了，不能再用上面简单new Sample(参数)。

还有,如果Sample有个继承如MySample, 按照面向接口编程,我
们需要将Sample抽象成一个接口.现在Sample是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下:
Sample mysample=new MySample();
Sample hissample=new HisSample();
随着项目的深入,Sample可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个实例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传统程序中是无法避免的.
但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了.
工厂方法
你会建立一个专门生产Sample实例的工厂:
public class Factory{
public static Sample creator(int which){
//getClass 产生Sample 一般可使用动态类装载装入类。

if (which==1)
return new SampleA();
else if (which==2)
return new SampleB();
}
}
那么在你的程序中,如果要实例化Sample时.就使用
Sample sampleA=Factory.creator(1);
这样,在整个就不涉及到Sample的具体子类,达到封装效果,也就减少错误修改的机会,这个原理可以用很通俗的话来比喻:就是具体事情做得越多,越容易范错误.这每个做过具体工作的人都深有体会,相反,官做得越高,说出的话越抽象越笼统,范错误可能性就越少.好象我们从编程序中也能悟出人生道理?呵呵.
使用工厂方法 要注意几个角色，首先你要定义产品接口，如上面的Sample,产品接口下有Sample接口的实现类,如SampleA,其次要有一个factory类，用来生成产品Sample，如下图，最右边是生产的对象Sample：
进一步稍微复杂一点，就是在工厂类上进行拓展，工厂类也有继承它的实现类concreteFactory了。

抽象工厂
工厂模式中有: 工厂方法(Factory Method) 抽象工厂(Abstract Factory).
这两个模式区别在于需要创建对象的复杂程度上。

如果我们创建对象的方法变得复杂了,如上面工厂方法中是创建一个对象Sample,如果我们还有新的产品接口Sample2.
这里假设：Sample有两个concrete类SampleA和SamleB，而Sample2也有两个concrete类Sample2A和SampleB2
那么，我们就将上例中Factory变成抽象类,将共同部分封装在抽象类中,不同部分使用子类实现，下面就是将上例中的Factory拓展成抽象工厂:
public abstract class Factory{
public abstract Sample creator();
public abstract Sample2 creator(String name);
}
public class SimpleFactory extends Factory{
public Sample creator(){
.........
return new SampleA
}
public Sample2 creator(String name){
.........
return new Sample2A
}
}
public class BombFactory extends Factory{
public Sample creator(){
......
return new SampleB
}
public Sample2 creator(String name){
......
return new Sample2B
}
}
从上面看到两个工厂各自生产出一套Sample和Sample2,也许你会疑问，为什么我不可以使用两个工厂方法来分别生产Sample和Sample2?
抽象工厂还有另外一个关键要点，是因为 SimpleFactory内，生产Sample和生产Sample2的方法之间有一定联系，所以才要将这两个方法捆绑在一个类中，这个工厂类有其本身特征，也许制造过程是统一的，比如：制造工艺比较简单，所以名称叫SimpleFactory。

在实际应用中，工厂方法用得比较多一些，而且是和动态类装入器组合在一起应用，
举例
我们以Jive的ForumFactory为例，这个例子在前面的Singleton模式中我们讨论过，现在再讨论其工厂模式:
public abstract class ForumFactory {
private static Object initLock = new Object();
private static String className =
"com.jivesoftware.forum.database.DbForumFactory";
private static ForumFactory factory = null;
public static ForumFactory getInstance(Authorization
authorization) {
//If no valid authorization passed in, return null.
if (authorization == null) {
return null;
}
//以下使用了Singleton 单态模式
if (factory == null) {
synchronized(initLock) {
if (factory == null) {
......
try {
//动态转载类
Class c = Class.forName(className);
factory = (ForumFactory)c.newInstance();
}
catch (Exception e) {
return null;
}
}
}
}
//Now, 返回 proxy.用来限制授权对forum的访问
return new ForumFactoryProxy(authorization, factory,
factory.getPermissions(authorization));
}
//真正创建forum的方法由继承forumfactory的子类去完成.
public abstract Forum createForum(String name, String description) throws UnauthorizedException, ForumAlreadyExistsException;
....
}
因为现在的Jive是通过数据库系统存放论坛帖子等内容数据,如果希望更改为通过文件系统实现,这个工厂方法ForumFactory就提供了提供动态接口:
private static String className =
"com.jivesoftware.forum.database.DbForumFactory";
你可以使用自己开发的创建forum的方法代替
com.jivesoftware.forum.database.DbForumFactory就可以.
在上面的一段代码中一共用了三种模式,除了工厂模式外,还有Singleton单态模式,以及proxy模式,proxy模式主要用来授权用户对forum的访问,因为访问forum有两种人:一个是注册用户 一个是游客guest,那么那么相应的权限就不一样,而且这个权限是贯穿整个系统的,因此建立一个proxy,类似网关的概念,可以很好的达到这个效果.
看看Java宠物店中的CatalogDAOFactory:
public class CatalogDAOFactory {
/**
* 本方法制定一个特别的子类来实现DAO模式。

* 具体子类定义是在J2EE的部署描述器中。

*/
public static CatalogDAO getDAO() throws CatalogDAOSysException {
CatalogDAO catDao = null;
try {
InitialContext ic = new InitialContext();
//动态装入CATALOG_DAO_CLASS
//可以定义自己的CATALOG_DAO_CLASS，从而在无需变更太多代码
//的前提下，完成系统的巨大变更。

String className =(String)
ic.lookup(JNDINames.CATALOG_DAO_CLASS);
catDao = (CatalogDAO)
Class.forName(className).newInstance();
} catch (NamingException ne) {
throw new CatalogDAOSysException("
CatalogDAOFactory.getDAO: NamingException while
getting DAO type : \n" + ne.getMessage());
} catch (Exception se) {
throw new CatalogDAOSysException("
CatalogDAOFactory.getDAO: Exception while getting
DAO type : \n" + se.getMessage());
}
return catDao;
}
}
CatalogDAOFactory是典型的工厂方法，catDao是通过动态类装入器className 获得CatalogDAOFactory具体实现子类，这个实现子类在Java宠物店是用来操作catalog数据库，用户可以根据数据库的类型不同，定制自己的具体实现子类，将自己的子类名给与CATALOG_DAO_CLASS变量就可以。

由此可见，工厂方法确实为系统结构提供了非常灵活强大的动态扩展机制，只要我们更换一下具体的工厂方法，系统其他地方无需一点变换，就有可能将系统功能进行改头换面的变化。

Chapter 02
2 Jive与设计模式
Jive论坛系统使用大量设计模式巧妙地实现了一系列功能。

因为设计模式的通用性和可理解性，将帮助更多人很快地理解 Jive论坛源码，从而可以依据一种“协定”来动态地扩展它。

那么使用设计模式还有哪些好处？
2.1 设计模式
设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。

使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

毫无疑问，设计模式于己于他人于系统都是多赢的。

设计模式使代码编制真正工程化，设计模式是软件工程的基石。

GOF（设计模式作者简称）《设计模式》这本书第一次将设计模式提升到理论高度，并将之规范化，该书提出了23种基本设计模式。

自此，在可复用面向对象软件的发展过程中，新的大量的设计模式不断出现。

很多人都知道Java是完全面向对象的设计和编程语言，但是由于接受教育以及经验的原因，大多数程序员或设计人员都是从传统的过程语言转变而来，因此在思维习惯上要完全转变为面向对象的设计和开发方式是困难的，而学习设计模式可以更好地帮助和坚固这种转变。

凡是学习完成设计模式的人都有一种类似重生的感觉，这种重生可以从很多方面去解释。

换一种新的角度来看待和解决问题应该是一种比较贴切的解释，而这种新的思维角度培养属于基础培训，因此，设计模式是学习Java的必读基础课程之一。

由于设计模式概念比较抽象，对于初学者学习有一定的难度，因此结合Jive论坛系统学习设计模式将是一种很好的选择。

掌握了设计模式，将会帮助程序员或设计人员以更加可重用性、可伸缩性的眼光来开发应用系统，甚至开发通用的框架系统。

框架系统是构成一类特定软件可复用设计的一组相互协作的类，主要是对应用系统中反复重用部分的提炼，类似一种模板，这是一种结构性的模板。

框架通常定义了应用体系的整体结构、类和对象的关系等设计参数，以便于具体应用实现者能集中精力于应用本身的特定细节。

框架强调设计复用，而设计模式最小的可重用单位，因此框架不可避免地会反复使用到设计模式。

关于通用框架系统的设计开发将在以后章节中讨论。

其实Jive论坛本身也形成了一个基于Web结构的通用框架系统，因为它很多设计思想是可以重用的，例如设定一个总体入口，通过入口检查用户的访问控制权限，当然还有其他各方面的功能实现方式都是值得在其他系统中借鉴的，也正因为它以模式的形式表现出来，这种可重用性和可借鉴性就更强。

2.2 ForumFactory与工厂模式
工厂模式是GOF设计模式的主要常用模式，它主要是为创建对象提供了一种接口，工厂模式主要是封装了创建对象的细节过程，从而使得外界调用一个对象时，根本无需关心这个对象是如何产生的。

在GOF设计模式中，工厂模式分为工厂方法模式和抽象工厂模式。

两者主要区别是，工厂方法是创建一种产品接口下的产品对象，而抽象工厂模式是创建多种产品接口下的产品对象，非常类似Builder生成器模式。

在平时实践中，使用较多的基本是工厂方法模式。

以类SampleOne为例，要创建SampleOne的对象实例:
SampleOne sampleOne = new SampleOne();
如果Sample类有几个相近的类：SampleTwo或SampleThree，那么创建它们的实例分别是：
SampleTwo sampleTwo = new SampleTwo();
SampleThree sampleThree = new SampleThree();
其实这3个类都有一些共同的特征，如网上商店中销售书籍、玩具或者化妆品。

虽然它们是不同的具体产品，但是它们有一个共同特征，可以抽象为“商品”。

日常生活中很多东西都可以这样高度抽象成一种接口形式。

上面这3个类如果可以抽象为一个统一接口SampleIF，那么上面语句就可以成为：
SampleIF sampleOne = new SampleOne();
SampleIF sampleTwo = new SampleTwo();
SampleIF sampleThree = new SampleThree();
在实际情况中，有时并不需要同时生成3种对象，而是根据情况在3者之中选一个。

在这种情况下，需要使用工厂方法来完成了，创建一个叫SampleFactory
的抽象类：
public class SampleFactory{
public abstract SampleIF creator();
}
在这个抽象工厂类中有一个抽象方法creator，但是没有具体实现，而是延迟到它的子类中实现，创建子类SampleFactoryImp：
public class SampleFactoryImp extends SampleFactory{
public SampleIF creator(){
//根据其他因素综合判断返回具体产品
//假设应该返回SampleOne对象
return new SampleOne();
}
}
在SampleFactoryImp中根据具体情况来选择返回SampleOne、SampleTwo或SampleThree。

所谓具体情况有很多种：上下文其他过程计算结果；直接根据配置文件中配置。

上述工厂方法模式中涉及到一个抽象产品接口Sample，如果还有其他完全不同的产品接口，如Product等，一个子类SampleFactoryImp只能实现一套系列产品方案的生产，如果还需要另外一套系统产品方案，就可能需要另外一个子类SampleFactoryImpTwo来实现。

这样，多个产品系列、多个工厂方法就形成了抽象工厂模式。

前面已经讨论在Jive中设置了论坛统一入口，这个统一入口就是ForumFactory，以下是ForumFactory的主要代码：
public abstract class ForumFactory {
private static Object initLock = new Object();
private static String className = "
com.Yasna.forum.database.DbForumFactory";
private static ForumFactory factory = null;
public static ForumFactory getInstance(Authorization authorization) {
if (authorization == null) {
return null;
}
//以下使用了Singleton 单态模式，将在2.3节讨论
if (factory == null) {
synchronized(initLock) {
if (factory == null) {
... //从配置文件中获得当前className
try {
//动态装载类
Class c = Class.forName(className);
factory = (ForumFactory)c.newInstance();
}
catch (Exception e) {
return null;
}
}
}
}
//返回 proxy.用来限制授权对forum的访问
return new ForumFactoryProxy(authorization,
factory,factory.getPermissions(authorization));
}
//创键产品接口Forum的具体对象实例
public abstract Forum createForum(String name, String description) throws UnauthorizedException, ForumAlreadyExistsException;
//创键产品接口ForumThread的具体对象实例
public abstract ForumThread createThread(ForumMessage rootMessage) throws UnauthorizedException;
//创键产品接口ForumMessage的具体对象实例
public abstract ForumMessage createMessage();
....
}
ForumFactory中提供了很多抽象方法如createForum、createThread和createMessage()等，它们是创建各自产品接口下的具体对象，这3个接口就是前面分析的基本业务对象Forum、ForumThread和ForumMessage，这些创建方法在ForumFactory中却不立即执行，而是推迟到ForumFactory子类中实现。

ForumFactory的子类实现是com.Yasna.forum.database.DbForumFactory，这是一种数据库实现方式。

即在DbForumFactory中分别实现了在数据库中createForum、createThread和createMessage()等3种方法，当然也提供了动态扩展到另外一套系列产品的生产方案的可能。

如果使用XML来实现，那么可以编制一个XmlForumFactory的具体工厂子类来分别实现3种创建方法。

因此，Jive论坛在统一入口处使用了抽象工厂模式来动态地创建论坛中所需要的各种产品，如图3-4所示。

图3-4 ForumFactory抽象工厂模式图
图3-4中，XmlForumFactory和DbForumFactory作为抽象工厂ForumFactory的两个具体实现，而Forum、ForumThread和ForumMessage分别作为3个系列抽象产品接口，依靠不同的工厂实现方式，会产生不同的产品对象。

从抽象工厂模式去理解Jive论坛统一入口处，可以一步到位掌握了几个类之间的大概关系。

因为使用了抽象工厂模式这种通用的设计模式，可以方便源码阅读者快速地掌握整个系统的结构和来龙去脉，图3-4这张图已经初步展示了Jive 的主要框架结构。

细心的读者也许会发现，在上面ForumFactory有一个getInstance比较令人费解，这将在2.3节进行讨论。

2.3 统一入口与单态模式
在上面ForumFactory的getInstance方法使用单态（SingleTon）模式。

单态模式是保证一个类有且仅有一个对象实例，并提供一个访问它的全局访问点。

前面曾提到ForumFactory是Jive提供客户端访问数据库系统的统一入口。

为了保证所有的客户端请求都要经过这个ForumFactory，如果不使用单态模式，客户端下列调用语句表示生成了ForumFactory实例：
ForumFactory factory = new DbForumFactory();
客户端每发生一次请求都调用这条语句，这就会发生每次都生成不同factory 对象实例，这显然不符合设计要求，因此必须使用单态模式。

一般在Java实现单态模式有几种选择，最常用而且安全的用法如下：
public class Singleton {
private Singleton(){}
//在自己内部定义自己一个实例，是不是很奇怪
//注意这是private，只供内部调用
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}
单态模式一共使用了两条语句实现：第一条直接生成自己的对象，第二条提供一个方法供外部调用这个对象，同时最好将构造函数设置为private，以防止其他程序员直接使用new Singleton生成实例。

还有一种Java单态模式实现：
public class Singleton {
private Singleton(){}
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
if (instance==null)
instance＝new Singleton()
return instance;
}
｝
在上面代码中，使用了判断语句。

如果instance为空，再进行实例化，这成为lazy initialization。

注意getInstance()方法的synchronized，这个synchronized很重要。

如果没有synchronized，那么使用getInstance()在第一次被访问时有可能得到多个Singleton实例。

关于lazy initialization的Singleton有很多涉及double-checked locking (DCL)的讨论，有兴趣者可以进一步研究。

一般认为第一种形式要更加安全些；但是后者可以用在类初始化时需要参数输入的情况下。

在Jive的ForumFactory中采取了后者lazy initialization形式，这是为了能够动态配置指定ForumFactory的具体子类。

在getInstance中，从配置文件中获得当前工厂的具体实现，如果需要启动XmlForumFactory，就不必修改ForumFactory代码，直接在配置文件中指定className的名字为XmlForumFactory。

这样通过下列动态装载机制生成ForumFactory具体对象：
Class c = Class.forName(className);
factory = (ForumFactory)c.newInstance();
这是利用Java的反射机制，可以通过动态指定className的数值而达到生成对象的方式。

使用单态模式的目标是为了控制对象的创建，单态模式经常使用在控制资源的访问上。

例如数据库连接或Socket连接等。

单态模式可以控制在某个时刻只有一个线程访问资源。

由于Java中没有全局变量的概念，因此使用单态模式有时可以起到这种作用，当然需要注意是在一个JVM中。

2.4 访问控制与代理模式
仔细研究会发现，在ForumFactory的getInstance方法中最后的返回值有些奇怪。

按照单态模式的概念应该直接返回factory这个对象实例，但是却返回了
ForumFactoryProxy的一个实例，这实际上改变了单态模式的初衷。

这样客户端每次通过调用ForumFactory的getInstance返回的就不是ForumFactory的惟一实例，而是新的对象。

之所以这样做是为了访问权限的控制，姑且不论这样做的优劣，先看看什么是代理模式。

代理模式是属于设计模式结构型模式中一种，它是实际访问对象的代理对象，或者影子对象，主要达到控制实际对象的访问。

这种控制的目的很多，例如提高性能等。

即远程代理模式，这种模式将在以后章节讨论。

其中一个主要的控制目的是控制客户端对实际对象的访问权限。

在Jive系统中，因为有角色权限的分别，对于Forum、ForumThread和FroumMessage的访问操作必须经过权限机制验证后才能进行。

以ForumFactoryProxy中的createForum方法为例，其实ForumFactoryProxy
也是FroumFactory的一种工厂实现，它的createForum具体实现如下：
public Forum createForum(String name, String description)
throws UnauthorizedException, ForumAlreadyExistsException
{
if (permissions.get(ForumPermissions.SYSTEM_ADMIN)) {
Forum newForum = factory.createForum(name, description);
return new ForumProxy(newForum, authorization, permissions);
}
else {
throw new UnauthorizedException();
}
}
在这个方法中进行了权限验证，判断是否属于系统管理员。

如果是，将直接从DbForumFactory对象factory的方法createForum中获得一个新的Forum对象，然后再返回Forum的子类代理对象ForumProxy。

因为在Forum中也还有很多属性和操作方法，这些也需要进行权限验证。

ForumProxy和ForumFactoryProxy 起到类似的作用。

Jive中有下列几个代理类：
•ForumFactoryProxy：客户端和DbForumFactory之间的代理。

客户端访问DbForumFactory的任何方法都要先经过ForumFactoryProxy相应方法代理一次。

以下意思相同。

•ForumProxy：客户端和DbForum之间的代理，研究Forum对象的每个方法，必须先看ForumProxy对象的方法。

•ForumMessageProxy：客户端和DbForumMessage之间的代理。

•ForumThreadProxy：客户端和DbForumThread之间的代理。

User和Group也有相应的代理类。

由以上分析看出，每个数据对象都有一个代理。

如果系统中数据对象非常多，依据这种一对一的代理关系，会有很多代理类，将使系统变得不是非常干净，因此可以使用动态代理来代替这所有的代理类，具体实现将在以后章节讨论。

2.5 批量分页查询与迭代模式
迭代（Iterator）模式是提供一种顺序访问某个集合各个元素的方法，确保不暴露该集合的内部表现。

迭代模式应用于对大量数据的访问，Java Collection API 中Iterator就是迭代模式的一种实现。

在前面章节已经讨论过，用户查询大量数据，从数据库不应该直接返回ResultSet，应该是Collection。

但是有一个问题，如果这个数据很大，需要分页面显示。

如果一下子将所有页面要显示的数据都查询出来放在Collection，会影响性能。

而使用迭代模式则不必将全部集合都展现出来，只有遍历到某个元素时才会查询数据库获得这个元素的数据。

以论坛中显示帖子主题为例，在一个页面中不可能显示所有主题，只有分页面显示，如图3-5所示。

图3-5中一共分15页来显示所有论坛帖子，可以从显示Forum.jsp中发现下列语句可以完成上述结果：
ResultFilter filter = new ResultFilter(); //设置结果过滤器
filter.setStartIndex(start); //设置开始点
filter.setNumResults(range); //设置范围
ForumThreadIterator threads = forum.threads(filter); //获得迭代器
while(threads.hasNext){
//逐个显示threads中帖子主题，输出图3-5中的每一行
}
图3-5 分页显示所有帖子
上述代码中主要是从Forum的threads方法获得迭代器ForumThreadIterator 的实例，依据前面代理模式中分析、研究Forum对象的方法，首先是看ForumProxy 中对应方法，然后再看DbForum中对应方法的具体实现。

在ForumProxy中，threads方法如下：
public ForumThreadIterator threads(ResultFilter resultFilter) {
ForumThreadIterator iterator = forum.threads(resultFilter);
return new ForumThreadIteratorProxy(iterator, authorization, permissions);
}
首先是调用了DbForum中具体的threads方法，再追踪到DbForum中看看，它的threads方法代码如下：
public ForumThreadIterator threads(ResultFilter resultFilter) {
//按resultFilter设置范围要求获得SQL查询语句
String query = getThreadListSQL(resultFilter, false);
//获得resultFilter设置范围内的所有ThreadID集合
long [] threadBlock = getThreadBlock(query.toString(), resultFilter.getStartIndex());
//以下是计算查询区域的开始点和终点
int startIndex = resultFilter.getStartIndex();
int endIndex;
// If number of results is set to inifinite, set endIndex to the total
// number of threads in the forum.
if (resultFilter.getNumResults() == ResultFilter.NULL_INT) {
endIndex = (int)getThreadCount(resultFilter);
}else {
endIndex = resultFilter.getNumResults() + startIndex;
}
return new ForumThreadBlockIterator(threadBlock, query.toString(),
startIndex, endIndex, this.id, factory);
}
ResultFilter是一个查询结果类，可以对论坛主题Thread和帖子内容Message 进行过滤或排序，这样就可以根据用户要求定制特殊的查询范围。

如查询某个用户去年在这个论坛发表的所有帖子，那只要创建一个ResultFilter对象就可以代表这个查询要求。

在上面threads方法代码中，第一步是先定制出相应的动态SQL查询语句，然后使用这个查询语句查询数据库，获得查询范围内所有的ForumThread的ID集合，然后在这个ID集合中获得当前页面的ID子集合，这是非常关键的一步。

在这关键的一步中，有两个重要的方法getThreadListSQL和getThreadBlock：
•GetThreadListSQL：获得SQL查询语句query的值，这个方法Jive实现起来显得非常地琐碎。

•GetThreadBlock：获得当前页面的ID子集合，那么如何确定ID子集合的开始位置呢？查看getThreadBlock方法代码，可以发现，它是使用最普遍的ResultSet next()方法来逐个跳跃到开始位置。

上面代码的Threads方法中最后返回的是ForumThreadBlockIterator，它是抽象类ForumThreadIterator的子类，而ForumThreadIterator继承了Collection 的Iterator，以此声明自己是一个迭代器，ForumMessageBlockIterator实现的具体方法如下：
public boolean hasNext(); //判断是否有下一个元素
public boolean hasPrevious() //判断是否有前一个元素
public Object next() throws java.util.NoSuchElementException //获得下一个元素实例
ForumThreadBlockIterator中的Block是“页”的意思，它的一个主要类变量threadBlock包含的是一个页面中所有ForumThread的ID，next()方法实际是对threadBlock中ForumThread进行遍历，如果这个页面全部遍历完成，将再获取下一页（Block）数据。

在ForumThreadBlockIterator重要方法getElement中实现了两个功能：
•如果当前遍历指针超过当前页面，将使用getThreadBlock获得下一个页面的ID子集合；
•如果当前遍历指针在当前页面之内，根据ID获得完整的数据对象，实现输出；
ForumThreadBlockIterator的getElement方法代码如下：
private Object getElement(int index) {
if (index < 0) { return null; }
// 检查所要获得的 element 是否在本查询范围内（当前页面内）
if (index < blockStart ||
index >= blockStart + DbForum.THREAD_BLOCK_SIZE) {
try {
//从缓冲中获得Forum实例
DbForum forum =
factory.cacheManager.forumCache.get(forumID);
//获得下一页的内容
this.threadBlock = forum.getThreadBlock(query, index);
this.blockID = index / DbForum.THREAD_BLOCK_SIZE;
this.blockStart = blockID * DbForum.THREAD_BLOCK_SIZE;
} catch (ForumNotFoundException fnfe) {
return null;
}
}
Object element = null;
// 计算这个元素在当前查询范围内的相对位置
int relativeIndex = index % DbForum.THREAD_BLOCK_SIZE;
// Make sure index isn't too large
if (relativeIndex < threadBlock.length) {
try {
// 从缓冲中获得实际thread 对象
element = factory.cacheManager.threadCache.get(
threadBlock[relativeIndex]);
} catch (ForumThreadNotFoundException tnfe) { }
}
return element;
}
ForumThreadBlockIterator是真正实现分页查询的核心功能，ForumThreadBlockIterator对象返回到客户端的过程中，遭遇ForumThreadIteratorProxy的截获，可以回头看看ForumProxy中的threads方法，它最终返回给调用客户端Forum.jsp的是ForumThreadIteratorProxy实例。

ForumThreadIteratorProxy也是迭代器ForumThreadIterator的一个子类，它的一个具体方法中：
public Object next() {
return new ForumThreadProxy((ForumThread)iterator.next(), authorization,
permissions);
}
这一句是返回一个ForumThreadProxy实例，返回就是一个ForumThread实例的代理。

这里，Jive使用代理模式实现访问控制实现得不是很巧妙，似乎有代理到处“飞”的感觉，这是可以对之进行改造的。

从以上可以看出，Jive在输出如图3-5所示的多页查询结果时，采取了下列步骤：
（1）先查询出符合查询条件的所有对象元素的ID集合，注意不是所有对象元素，只是其ID的集合，这样节约了大量内存。

（2）每个页面视为一个Block，每当进入下一页时，获得下一个页面的所有对象的ID集合。

（3）输出当前页面的所有对象时，首先从缓冲中获取，如果缓冲中没有，再根据ID从数据库中获取完整的对象数据。

上述实现方法完全基于即查即显，相比于一般批量查询做法：一次性获得所有数据，然后遍历数据结果集ResultSet，Jive这种批量查询方式是一种比较理想的选择。

以上是ForumThread的批量显示，有关帖子内容ForumMessage也是采取类似做法。

在每个ForumThread中可能有很多帖子内容（ForumMessage对象集合），也不能在一个页面中全部显示，所以也是使用迭代模式来实现的。

显示一个Forum主题下所有帖子内容的功能由ForumThread的messages()方法完成，检查它的代理类FroumThreadProxy如何具体完成：
public Iterator messages(ResultFilter resultFilter) {
Iterator iterator = thread.messages(resultFilter);
return new IteratorProxy(JiveGlobals.MESSAGE, iterator, authorization, permissions);
}
实现的原理基本相同，返回的都是一个Iterator代理类，在这些代理类中都是进行用户权限检验的。

Jive中也有关于一次性获得所有数据，然后遍历ResultSet的做法。

这种做法主要适合一次性查询数据库的所有数据，例如查询当前所有论坛Forum，首先实现SQL语句：
SELECT forumID FROM jiveForum。