1. 基于标准，纯正java，实现了http1.0和1.1。
   
2. 在一个可扩展的OO框架内，实现了HTTP的全部方法(GET, POST,
   PUT, DELETE, HEAD, OPTIONS, and TRACE)
   
3. 支持HTTPS(ssl上的HTTP)的加密操作
   
4. 透明地穿过HTTP代理建立连接
   
5. 通过CONNECT方法，利用通过建立穿过HTTP代理的HTTPS连接
   
6. 利用本地Java socket，透明地穿过SOCKS(版本5和4）代理建立连接
   
7. 支持利用Basic、Digest和NTLM加密的认证
   
8. 支持用于上传大文件的Multi-Part表单POST方法
   
9. 插件式安全socket实现，易于使用第三方的解决方案
   
10. 连接管理，支持多线程应用，支持设定单个主机总连接和最高连接数量,自动检测和关闭失效连接
    
11. 直接将请求信息流送到服务器的端口
    
12. 直接读取从服务器的端口送出的应答信息
    
13. 支持HTTP/1.0中用KeepAlive和HTTP/1.1中用persistance设置的持久连接
    
14. 直接访问由服务器送出的应答代码和头部信息
    
15. 可设置连接超时时间
16. 
    
17. HttpMethods 实现Command Pattern，以允许并行请求或高效连接复用
    
18. 遵循the Apache Software License协议，源码免费可得
    

2、预备工作

3、取得源码

4、使用HttpClient编程的基本步聚

1. 创建 HttpClient 的一个实例.
   
2. 创建某个方法（DeleteMethod，EntityEnclosingMethod，ExpectContinueMethod，GetMethod，HeadMethod，MultipartPostMethod，OptionsMethod，PostMethod，PutMethod，TraceMethod）的一个实例，一般可用要目标URL为参数。
   
3. 让 HttpClient 执行这个方法.
   
4. 读取应答信息.
   
5. 释放连接.
   
6. 处理应答.
   

5、认证

1. 从HttpClientAPI的角度来看，NTLM与其它认证方式一样的工作，差别是需要提供'NTCredentials'实例而不是'UsernamePasswordCredentials'(其实，前者只是扩展了后者)
   
2. 对NTLM认证，访问空间是连接到的机器的域名，这对多域名主机会有一些麻烦.只有HttpClient连接中指定的域名才是认证用的域名。建议将realm设为null以使用默认的设置。
   
3. NTLM只是认证了一个连接而不是一请求，所以每当一个新的连接建立就要进行一次认证，且在认证的过程中保持连接是非常重要的。 因此，NTLM不能同时用于代理认证和服务器认证，也不能用于http1.0连接或服务器不支持持久连接的情况。

6、重定向

1. 301 永久移动. HttpStatus.SC_MOVED_PERMANENTLY
   
2. 302 临时移动. HttpStatus.SC_MOVED_TEMPORARILY
   
3. 303 See Other. HttpStatus.SC_SEE_OTHER
   
4. 307 临时重定向. HttpStatus.SC_TEMPORARY_REDIRECT

1. 300 多重选择. HttpStatus.SC_MULTIPLE_CHOICES
   
2. 304 没有改动. HttpStatus.SC_NO T_MODIFIED
   
3. 305 使用代理. HttpStatus.SC_USE_PROXY
   

7、字符编码(character encoding)

8、Cookies

1. Netscape cookie草案，是最早的cookie规范，基于rfc2109。尽管这个规范与rc2109有较大的差别，这样做可以与一些服务器兼容。
   
2. rfc2109，是w3c发布的第一个官方cookie规范。理论上讲，所有的服务器在处理cookie(版本1)时，都要遵循此规范，正因如此，HttpClient将其设为默认的规范。遗憾的是，这个规范太严格了，以致很多服务器不正确的实施了该规范或仍在作用Netscape规范。在这种情况下，应使用兼容规范。
   
3. 兼容性规范，设计用来兼容尽可能多的服务器，即使它们并没有遵循标准规范。当解析cookie出现问题时，应考虑采用兼容性规范。

1. HttpClient client = new HttpClient();
   client.getState().setCookiePolicy(CookiePolicy.COMPATIBILITY);
   这种方法设置的规范只对当前的HttpState有效，参数可取值CookiePolicy.COMPATIBILITY，CookiePolicy.NETSCAPE_DRAFT或CookiePolicy.RFC2109。
   
2. System.setProperty("apache.commons.httpclient.cookiespec", "COMPATIBILITY");
   此法指的规范，对以后每个新建立的HttpState对象都有效，参数可取值"COMPATIBILITY","NETSCAPE_DRAFT"或"RFC2109"。
   　　常有不能解析cookie的问题，但更换到兼容规范大都能解决。
   

9、使用HttpClient遇到问题怎么办?

1. 用一个浏览器访问服务器，以确认服务器应答正常
   
2. 如果在使代理，关掉代理试试
   
3. 另找一个服务器来试试（如果运行着不同的服务器软件更好）
   
4. 检查代码是否按教程中讲的思路编写
   
5. 设置log级别为debug，找出问题出现的原因
   
6. 打开wiretrace，来追踪客户端与服务器的通信，以确实问题出现在什么地方
   
7. 用telnet或netcat手工将信息发送到服务器，适合于猜测已经找到了原因而进行试验时
   
8. 将netcat以监听方式运行，用作服务器以检查httpclient如何处理应答的。
   
9. 利用最新的httpclient试试，bug可能在最新的版本中修复了
   
10. 向邮件列表求帮助
    
11. 向bugzilla报告bug.

10、SSL

1. 提供了一个实现了org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory接口的socket factory。这个 socket factory负责打一个到服务器的端口，使用标准的或第三方的SSL函数库，并进行象连接握手等初始化操作。通常情况下，这个初始化操作在端口被创建时自动进行的。
   
2. 实例化一个org.apache.commons.httpclient.protocol.Protocol对象。创建这个实例时，需要一个合法的协议类型(如https)，一个定制的socket factory，和一个默认的端中号(如https的443端口).
   Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443);
   然后，这个实例可被设置为协议的处理器。
   HttpClient httpclient = new HttpClient();
   httpclient.getHostConfiguration().setHost("www.whatever.com", 443, myhttps);
   GetMethod httpget = new GetMethod("/");
   httpclient.executeMethod(httpget);
   
   
3. 通过调用Protocol.registerProtocol方法，将此定制的实例，注册为某一特定协议的默认的处理器。由此，可以很方便地定制自己的协议类型(如myhttps)。
   Protocol.registerProtocol("myhttps",
   new Protocol("https", new MySSLSocketFactory(), 9443));
   ...
   HttpClient httpclient = new HttpClient();
   GetMethod httpget = new GetMethod("myhttps://www.whatever.com/");
   httpclient.executeMethod(httpget);
   如果想用自己定制的处理器取代https默认的处理器，只需要将其注册为"https"即可。
   Protocol.registerProtocol("https",
   new Protocol("https", new MySSLSocketFactory(), 443));
   HttpClient httpclient = new HttpClient();
   GetMethod httpget = new GetMethod("https://www.whatever.com/");
   httpclient.executeMethod(httpget);

1. 持续的SSL连接在Sun的低于1.4JVM上不能工作，这是由于JVM的bug造成。
   
2. 通过代理访问服务器时，非抢先认证（ Non-preemptive authentication）会失败，这是由于HttpClient的设计缺陷造成的，以后的版本中会修改。

11、httpclient的多线程处理

12、HTTP方法

1. 对已有的资源做评注
   
2. 将信息发布到BBS、新闻组、邮件列表，或类似的文章组中
   
3. 将一块数据，提交给数据处理进程
   
4. 通过追加操作，来扩展一个数据库

import java.util.Collection;

import org.apache.commons.chain.Command;
import org.apache.commons.chain.Context;

public class ForeachCommand implements Command {
    private String collectionProperty;
    private String instanceProperty;
    private Command command;
   
    @SuppressWarnings("unchecked")
    public boolean execute(Context context) throws Exception {
        Collection<? extends Object> collection = (Collection<? extends Object>) context.get(collectionProperty);
        if (collection != null) {
            for(Object object : collection) {
                context.put(instanceProperty, object);
                if (PROCESSING_COMPLETE == command.execute(context)) {
                    return PROCESSING_COMPLETE;
                } // else continue
            }
        }
        return CONTINUE_PROCESSING;
    }

    public String getCollectionProperty() {
        return collectionProperty;
    }

    public void setCollectionProperty(String collectionProperty) {
        this.collectionProperty = collectionProperty;
    }

    public String getInstanceProperty() {
        return instanceProperty;
    }

    public void setInstanceProperty(String instanceProperty) {
        this.instanceProperty = instanceProperty;
    }

    public Command getCommand() {
        return command;
    }

    public void setCommand(Command command) {
        this.command = command;
    }

}

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;

public class FileUtil {

 public static void moveFile(File source, String path) throws IOException {
  if(!source.renameTo(new File(path, source.getName()))){
   throw new IOException(
     "Can't move file "
     + source.getName()
     + " to "
     + path);
  }
 }
 
 public static File moveFile(File source, File path) throws IOException {
  File newFile = new File(path, source.getName());
  if(!source.renameTo(newFile)){
   throw new IOException(
     "Can't move file "
     + source.getName()
     + " to "
     + path);
  }
  return newFile;
 }
 
 public static void moveFile(File source, File path, boolean uniqueFileName) throws IOException {
  String fileName = source.getName();
  File file = new File(path, fileName);
  int count = 1;
  while(true) {
   if(file.exists()) {
    String newFileName = null;
    int idx = fileName.lastIndexOf(".");
    if(idx > 0) {
     newFileName = fileName.substring(0, idx) + "." + count + fileName.substring(idx); 
    } else {
     newFileName = fileName + "." + count;
    }
    file = new File(path, newFileName);
    count++;
   } else {
    break;
   }
  }
  if(!source.renameTo(file)){
   //try {
   // copyFile(source, file);
   // deleteFile(source);
   //}
   //catch (IOException e)
   //{
    throw new IOException(
      "Can't move file "
      + source.getName() //+ " (" + source.getAbsolutePath() + ")"
      + " to "
      + path);
     //+"("+e.getMessage()+")");
     // + " (" + file.getAbsolutePath() + ")");
   //}
  }
 }
 
 public static void moveFiles(File sourceDir, File destDir) throws IOException {
  java.io.File[] list=sourceDir.listFiles();
  for (int i = 0; i < list.length; i++) {
   if (!list[i].isDirectory()) {
    if(!list[i].renameTo(new File(destDir, list[i].getName()))) {
     throw new IOException(
       "Can't move file "
       + list[i].getName()
       + " to "
       + destDir.getAbsolutePath());
    }
   }
  }
 }
 
 /**
  * Copy a File (source) to a File (destination)
  * @param source
  * @param dest
  * @throws IOException
  */
 public static void copyFile(File source, File dest) throws IOException {
      FileChannel in = null, out = null;
      try {         
           in = new FileInputStream(source).getChannel();
           out = new FileOutputStream(dest).getChannel();

           long size = in.size();
           MappedByteBuffer buf = in.map(FileChannel.MapMode.READ_ONLY, 0, size);
           out.write(buf);

      } finally {
           if (in != null)     
            in.close();
           if (out != null)    
            out.close();
      }
 }
 
 /**
  * Write an input stream to a file.
  * @param source
  * @param dest
  * @param size
  * @throws IOException
  */
 public static int writeFile(InputStream source, File dest, long buffer) throws IOException {
  int bytesWrote = 0;
  FileChannel out = null;
  ReadableByteChannel in = null;
  ByteBuffer data = ByteBuffer.allocate((int) buffer);
  try {
   in = Channels.newChannel(source);
   out = new FileOutputStream(dest).getChannel();
   
   int read = in.read(data);
   while(read > 0) {
    bytesWrote += read;
    data.flip();
    out.write(data);
    data.clear();
    read = in.read(data);
   }

  } finally {
   if(out != null)
    out.close();
   if(in != null)
    in.close();
  }
  return bytesWrote;
 }
 
 public static void delete(java.io.File path) throws IOException {
  if (path.isDirectory()) {
   deleteDirectory(path);
  } else {
   deleteFile(path);
  }
 }
 
 protected static void deleteDirectory(java.io.File path) throws IOException {
  java.io.File[] list = path.listFiles();
  for (int i = 0; i < list.length; i++) {
   if (list[i].isDirectory()) {
    deleteDirectory(list[i]);
    if (!list[i].delete()) {
     throw new IOException("Can't delete directory '"+list[i]+"'.");
    }
   } else {
    deleteFile(list[i]);
   }
  }
 }
 
 protected static void deleteFile(java.io.File path) throws IOException {
  if (!path.delete()) {
   throw new IOException("Can't delete file '"+path+"'.");
  }
 }
 
 // TODO optimize ... read and write with buffers?!
 //@SuppressWarnings("unchecked")
 public static Collection splitFile(File file, int splitlen, File tmpDir) throws IOException
 {
  long leng = 0;
  int count = 1, read = 0;
  byte [] buffer = new byte[8196];
  
  String fileName  = file.getName();
  Collection files = new ArrayList();  
  RandomAccessFile infile = new RandomAccessFile(file, "r");
  read = infile.read(buffer);
  while(read != -1)
  {
   file = new File(tmpDir, fileName + ".lms.sp" + count);
   RandomAccessFile outfile = new RandomAccessFile(file, "rw");
   while( read != -1 && leng < splitlen)
   {
    outfile.write(buffer, 0, read);
    leng += read;
    read = infile.read(buffer);
   }
   leng = 0;
   outfile.close();
   file.deleteOnExit();
   files.add(file);
   count++;
  }
  return files;
 }
 
 public static File joinFile(String fileName, File tmpDir) throws IOException
 {
  int count = 1, read = 0;
  byte [] buffer = new byte[8196];
  
  File destFile = new File(tmpDir, fileName);
  RandomAccessFile outfile = new RandomAccessFile(destFile, "rw");
  while(true)
  {
   File readFile = new File(tmpDir, fileName + ".lms.sp" + count);
   if (readFile.exists())
   {
    RandomAccessFile infile = new RandomAccessFile(readFile, "r");
    read = infile.read(buffer);
    while(read != -1)
    {
     outfile.write(buffer, 0, read);
     read = infile.read(buffer);
    }
    infile.close();
    readFile.delete();
    count++;
   }
   else
   {
    break;
   }
  }
  outfile.close();
  return destFile;
 }
 
 public static boolean isComplete(String fileName, File dir, int parts) {
  int counter = 1;
  int matched = 0;
  File[] list = dir.listFiles();
  for (int i = 0; i < list.length; i++) {
   if (!list[i].isDirectory()) {
    String f = list[i].getName();
    String f2 = fileName + ".lms.sp";
    if(f.startsWith(f2)) {
     matched++;
    }
    counter++;
   }
  }
  if(matched == parts) {
   return true;
  } else {
   return false;
  }
  
 }
 
 public static File zipFile(File file, File dir) throws IOException {
  WritableByteChannel out = null;
  ReadableByteChannel in = null;
  FileInputStream source = new FileInputStream(file);
  File dest = new File(dir, file.getName() + ".zip");
  ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(dest));
  dest.deleteOnExit();
  int buffer = 4096;
  ByteBuffer data = ByteBuffer.allocate(buffer);
  try {
   zos.putNextEntry(new ZipEntry(file.getName()));

   in = Channels.newChannel(source);
   out = Channels.newChannel(zos);
   
   int read = in.read(data);
   while(read > 0) {
    data.flip();
    out.write(data);
    data.clear();
    read = in.read(data);
   }
   
   zos.closeEntry();
  } finally {
   if(zos != null) {
    zos.finish();
   }
   if(out != null)
    out.close();
   if(in != null)
    in.close();
  }
  return dest;
 }
 
 public static File unzipFile(File file, File dir) throws IOException {
  WritableByteChannel out = null;
  ReadableByteChannel in = null;
  ZipEntry entry = null;
  ZipFile zipFile = null;
  int buffer = 4096;
  ByteBuffer data = ByteBuffer.allocate(buffer);
  File unzippedFile = null;
  try {
   zipFile = new ZipFile(file, ZipFile.OPEN_READ);
   Enumeration zipFileEntries = zipFile.entries();
      
   // Process each entry
   if (zipFileEntries.hasMoreElements()) {
    // grab a zip file entry
    entry = (ZipEntry) zipFileEntries.nextElement();
    String currentEntry = entry.getName();
    InputStream input = zipFile.getInputStream(entry);
    unzippedFile = new File(dir, currentEntry);
    FileOutputStream output = new FileOutputStream(unzippedFile);
    
    in = Channels.newChannel(input);
    out = Channels.newChannel(output);

    int read = in.read(data);
    while(read > 0) {
     data.flip();
     out.write(data);
     data.clear();
     read = in.read(data);
    }
   }
  } finally {
   if(file != null)
    file.delete();
   if(zipFile != null)
    zipFile.close();
   if(out != null)
    out.close();
   if(in != null)
    in.close();
  }
  return unzippedFile;
 }
}


不过最好使用Apache Common 的IO组件。
里面有个FileUtils，提供了很多很好的方法。
可以参考：
 

http://commons.apache.org/io/apidocs/index.html

public void test1() throws IOException{
        File f=new File("d:"+File.separator+"1.txt");

        BufferedInputStream br=new BufferedInputStream(new FileInputStream(f));
        StringBuffer whole=new StringBuffer();
        int line;
        for (line=br.read(); line!=-1; line=br.read()) {
            whole.append(line);
           
        }
        System.out.println(whole.toString());
    }

One reason you might want to do this is if a thread determines that it is in a state where the best thing it can do is nothing. This may be an alternative to ending the thread by using the Abort method, or simply exiting the thread’s method. Once a thread ends, there is no way to restart it. However, if a thread calls the Sleep method and passes in Infinite for the timeout value, it is possible to exit that state at a later time. This concept is similar to calling Join.

When Join is called and no parameter is passed in, the current thread will wait indefinitely for the thread to end. When Join is called with a timeout value, the Join method will block for at most that period of time and then return a value indicating if the thread of interest ended. A key difference is that Join is called on a different thread while Sleep is called on the current thread. Join also causes the current thread to pause for a period of time, but with the idea that it is waiting for some other thread to terminate. At the point the thread being joined terminates, the Join method returns.

• You can define your own fields, methods, and constructors for the enumerated type.

• If you define one or more constructors, you can invoke a constructor for each enumerated value by following the value name with constructor arguments in parentheses.

• Although an enum may not extend anything, it may implement one or more interfaces.

• Most esoterically, individual enumerated values can have their own class bodies that override methods defined by the type.

Rather than formally specifying the syntax for each of these advanced enum declarations, we'll demonstrate the syntax in the examples that follow.

for example:

public enum Prefix {
// These are the values of this enumerated type.
// Each one is followed by constructor arguments in parentheses.
// The values are separated from each other by commas, and the
// list of values is terminated with a semicolon to separate it from
// the class body that follows.
MILLI("m",    .001),
CENTI("c",    .01),
DECI("d",     .1),
DECA("D",   10.0),
HECTA("h", 100.0),
KILO("k", 1000.0);  // Note semicolon
// This is the constructor invoked for each value above.
Prefix(String abbrev, double multiplier) {
this.abbrev = abbrev;
this.multiplier = multiplier;
}
// These are the private fields set by the constructor
private String abbrev;
private double multiplier;
// These are accessor methods for the fields.  They are instance methods
// of each value of the enumerated type.
public String abbrev() { return abbrev; }
public double multiplier() { return multiplier; }
}

Telnet to port 25 of a SMTP server, and you will see the server respond with a numeric code (220). SMTPReply.isPositiveCompletion( ) returns true if the response code of the previously executed command is between 200 and 299; the value of the initial response code, 220, is equal to the public static variable SMTPReply.SERVICE_READY. The following example uses getReplyCode( ) and SMTPReply.isPositiveCompletion() to test the connection to the SMTP server:

import org.apache.commons.net.smtp.SMTP;
import org.apache.commons.net.smtp.SMTPClient;
import org.apache.commons.net.smtp.SMTPReply;
SMTPClient client = new SMTPClient( );
client.connect("www.discursive.com");
int response = client.getReplyCode( );
if( SMTPReply.isPositiveCompletion( response ) ) {
// Set the sender and the recipients
client.setSender( "tobrien@discursive.com" );
client.addRecipient( "president@whitehouse.gov" );
client.addRecipient( "vicepresident@whitehouse.gov" );
// Supply the message via a Writer
Writer message = client.sendMessageData( );
message.write( "Spend more money on energy research.  Thanks." );
message.close( );
// Send the message and print a confirmation
boolean success = client.completePendingCommand( );
if( success ) {
System.out.println( "Message sent" );
}
} else {
System.out.println( "Error communicating with SMTP server" );
}
client.disconnect( );

Instead of sendSimpleMessage( ), the previous example sets a sender address and two recipient addresses using setSender( ) and addRecipient(). The message body is then written to a Writer returned by sendMessageData(). When the Writer is closed, the message is sent by calling completePendingCommand(). completePendingCommand( ) returns true if the message has been queued for delivery.

Use Commons Net POP3Client to check a POP3 mailbox for incoming mail. The following example connects to the POP3 server www.discursive.com, logs in as tobrien@discursive.com, and prints each message in the mailbox:

import org.apache.commons.io.CopyUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.net.pop3.POP3Client;
import org.apache.commons.net.pop3.POP3MessageInfo;
POP3Client client = new POP3Client( );
client.connect("www.discursive.com");
client.login("tobrien@discursive.com", "secretpassword");
POP3MessageInfo[] messages = client.listMessages( );
for (int i = 0; i < messages.length; i++) {
int messageNum = messages[i].number;
System.out.println( "************* Message number: " + messageNum );
Reader reader = client.retrieveMessage( messageNum );
System.out.println( "Message:\n" + IOUtils.toString( reader ) );
IOUtils.closeQuietly( reader );
}
client.logout( );
client.disconnect( );

bitsCN_com

DL.bitsCN.com网管软件下载

BBS.bitsCN.com国内最早的网管论坛

The results can be puzzling. If the input file is an image it may be mangled or not display at all. Binary or text data may be incomplete. This is because Read Doesn't Do What You Think It Does. A quick glance at the Java API for java.io.InputStream gives us the following information:


public int read(byte[] b) throws IOException


Reads some number of bytes from the input stream and stores them
into the buffer array b. The number of bytes actually read is returned as an integer. . .

The documentation states that read reads "some number" of bytes. It is not guaranteed to fill the byte array. The number of bytes read is returned by the read method. One should use this return value to make sure that he is receiving the data which he expects. A correct usage of read() would be to read chunks of a file and collect them in a buffer like so:


ByteArrayOutputStream buffer = new ByteArrayOutputStream();
File aFile = new File("input.data");
InputStream is = new FileInputStream(aFile);
byte[] temp = new byte[1024];
int read;

while((read = is.read(temp)) > 0){
   buffer.write(temp, 0, read);
}
           
byte[] data = buffer.toByteArray();
// process the data array . . .


DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();

You can now read a document from a file:

File f = . . .
Document doc = builder.parse(f);

Alternatively, you can use a URL:

URL u = . . .
Document doc = builder.parse(u);

You can even specify an arbitrary input stream:

InputStream in = . . .
Document doc = builder.parse(in);

NodeList children = root.getChildNodes();
for (int i = 0; i < children.getLength(); i++)
{
Node child = children.item(i);
. . .
}

If you expect only subelements, then you can ignore the whitespace:

for (int i = 0; i < children.getLength(); i++)
{
Node child = children.item(i);
if (child instanceof Element)
{
Element childElement = (Element) child;
. . .
}
}

通用分页实现及其OO设计探讨

本来是打算拿到it168投稿的！！那边的速度太慢了！先贴出来先！！

分页是一种常用的页面数据显示技术，分页能够通过减少页面数据处理量从而提高了系统的性能。分页应该是做WEB开发必须掌握的一个小技术。而分页却是复杂的，倒不是它的技术有多复杂；而是有太多的重复代码，这些代码都难以重用。能不能实现一个通用的分页框架？每次只需要去覆写一两个方法，通过少量的代码就能实现分页的功能？

一般分页应该要具有的功能有
1. 灵活的设置分页大小。可以动态的设置分页大小，而不是写死到代码中。
2. 自动计算总页数。根据分页大小和总记录数自动计算总页数。
3. 获得当前页的页号。
4. 获得当前页的总记录数。一般是最后一页的时候可能会小于分页大小。
5. 判断当前页是否为第一页。
6. 判断当前页是否为最后一页。
7. 判断当前页是否有上一页。
8. 判断当前页是否有下一页。
9. 获得当前页的数据列表。
10. 获得当前页的第一条记录的索引号
11. 获得当前页的最后一条记录的索引号。
二、常用的分页技术
目前常用的分页技术有两种：
1. 第一次访问是读取所有记录，放入session中，然后每次从session对象中读取当前页的数据
2. 每次都访问数据库，从数据库中读取当前页的记录。
这两种方法都各有优缺点，当数据量比较少时，第一种方法无疑是要快一些，因为减少与数据库的连接访问。而当数据量比较大时，比如查询结果可能会是上万条，那么内存的开销是十分大的，放到session中还有一个问题是能不能及时的清除无用的对象。而且这么大数据量在网络中传输也会使系统变得很慢。
第二种方法就是专门解决这个问题的，它每次访问数据库，只读取当前页所需的记录，大大的减少网络传输量；它不会把页数据放到session中，大大提高服务器的性能。
所以第二种方式要优于第一种方法。Session不要乱用，要用也仅仅是存放一些公共变量，相对于占用空间比较少的对象。不适合存放大量的数据，否则在很多个用户同时访问时那么系统会很慢，因为服务器内存被销耗的很厉害

三、通用分页框架需要解决的问题
作为一个通用分页框架，
1． 应该不依赖于任何其它框架
2． 应该支持多种数据库
3． 应该可以应用于任何web框架中，如：struts,spring等。
4． 应该把数据访问的具体实现留给用户去实现。
5． 应该实现关键的算法和过程，如：计算总页数，所需的实始化动作。
6． 应该减化Contrller控制器的代码，以往的分页技术在Contrller中存在太多的if…else代码。十分难懂，应该由一个辅助类来实现。
7． 应该减化jsp页面的代码，页面应该没有任何与分页相关的计算。应该由分页对象来实现。
8． 应该支持两种分页方式，采用session或不采用session由用户控制。

四、具体实现
1.通用分页接口。定义接口可以有更多不同的实现，接口只声明了分页应该具有的公共行为。
ViewPage.java
/**
* 分页接口
* @author ex_yuanguangdong
*
*/
public interface ViewPage {



/**
* 获取总页数
* @return 总页数
*/
public int getPageCount();


/**
* 获得页面大小
* @return 页面大小
*/
public int getPageSize();


/**
* 设置页面大小
* @param size
*/
public void setPageSize(int size);
/**
* 获得当前页数据
* @return 数据列表
*/
public List getPageData();


/**
* 获得当前页索引号
* @return 当前页索引号
*/
public int getPageIndex();

/**
* 获得当前页记录总数
* @return 当前页记录总数
*/
public int getPageRows();

/**
* 是否有下一页
* @return
*/
public boolean getHashNextPage();


/**
* 是否有上一页
* @return
*/
public boolean getHashPreviousPage();

/**
* 转到尾页
*
*/
public void gotoLastPage();
/**
* 转到首页
*
*/
public void gotoFirstPage();

/**
* 是否首页
* @return
*/
public boolean isFirstPage();

/**
* 是否尾页
* @return
*/
public boolean isLastPage();

/**
* 转到上一页
*
*/
public void gotoPreviousPage();

/**
* 转到下一页
*
*/
public void gotoNextPage();

/**
* 转到指定页面,pageIndex小于1时，转到第一页;pageIndex大于总页数时，转到最尾页
* @param pageIndex 指定的页号
*/
public void gotoPage(int pageIndex);

/**
* 获取当前页第一条记录的记录号
* @return int 当前页第一条记录的记录号
*/
public int getPageFirstRecord();

/**
* 获取当前页最后一条记录的记录号
* @return int 当前页最后一条记录的记录号
*/
public int getPageLastRecord();

}

2． 分页抽像实现类，实现关键的算法
AbstractViewPage.java
/**
* 分页默认抽象实现
* 初始时，分页类有下列默认值：
* 分页大小为-1,为不分页;
* 总页数为1页
* 当前页为第一页
* 总记录数为0条
* 当前页数据列表为没有任何记录的列表
* @author ex_yuanguangdong
*
*/
public abstract class AbstractViewPage implements ViewPage {

//-----------------------------------------
//私有静态常量
//-----------------------------------------

private static final int DEFAULT_PAGE_INDEX = 1;

private static final int DEFALT_PAGE_COUNT = 1;

private static final int DEFAULT_PAGE_SIZE = -1;

private static final int DEFAULT_ROWS = 0;

//-----------------------------------------
//私有成员变量
//-----------------------------------------

/**当前页索引号**/
private int pageIndex = DEFAULT_PAGE_INDEX;
/**总页数**/
private int pageCount =DEFALT_PAGE_COUNT;

/**分页大小**/
private int pageSize = DEFAULT_PAGE_SIZE ;

/**数据总记录数**/
private int rows = DEFAULT_ROWS;


//------------------------------------------
//本地成员变量getter,setter方法
//------------------------------------------


/**
* 设置新页号，只有大于等于1而且小于等于总页数并且不为当前页时，才允许设置
* @param pageIndex The pageIndex to set.
*/
private void setPageIndex(int newPageIndex) {

if( newPageIndex >= this.DEFAULT_PAGE_INDEX && newPageIndex <= this.getPageCount() && newPageIndex != this.pageIndex) {
this.pageIndex = newPageIndex;
}

}

/**
* @return Returns the rows.
*/
private int getRows() {
return rows;
}

/**
* @param rows The rows to set.
*/
private void setRows(int rows) {
this.rows = rows;
}
/**
* @param pageCount The pageCount to set.
*/
private void setPageCount(int pageCount) {
this.pageCount = pageCount;
}



//--------------------------------------
//实现Page接口方法
//--------------------------------------


/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#getPageData()
*/
public List getPageData() {
List pageList =null;

//获得当前页数据
pageList = this.pageList(this.getPageFirstRecord(), this.getPageRows());
//保证不返回null
if(pageList == null) {
pageList =new ArrayList();
}
return pageList;

}

/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#getPageIndex()
*/
public int getPageIndex() {
return this.pageIndex;
}
/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#isFirstPage()
*/
public boolean isFirstPage() {

return this.DEFAULT_PAGE_INDEX ==this.pageIndex;
}
/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#isLastPage()
*/
public boolean isLastPage() {
//当前页索引为总页数时为最后一页
return this.pageIndex == this.pageCount;
}

/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#getHashNextPage()
*/
public boolean getHashNextPage() {
//当前页索引号小于总页数
return this.pageIndex < this.pageCount ;
}

/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#getHashPreviousPage()
*/
public boolean getHashPreviousPage() {
//当前页索引号大于默认的初始页号,这里为1
return this.pageIndex > this.DEFAULT_PAGE_INDEX ;
}



/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#getPageCount()
*/
public int getPageCount() {

return this.pageCount;
}



/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#getPageSize()
*/
public int getPageSize() {

return this.pageSize;
}

/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#getPageRows()
*/
public int getPageRows() {
//当页面大小为-1 时,返回总记录数
if(this.DEFAULT_PAGE_SIZE == this.pageSize ) {
return this.rows;
}

//不为最后一页时，返回pageSize
if(!this.isLastPage()) {
return this.pageSize;
}
//最后一页时
return this.rows - (this.pageSize * (this.pageCount -1));
}



/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#getPageFirstRecord()
*/
public int getPageFirstRecord() {

//页大小为-1 时
if(this.DEFAULT_PAGE_SIZE== this.pageSize ) {
return 0;
}
return (this.pageIndex -1)* this.pageSize;
}

/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#getPageLastRecord()
*/
public int getPageLastRecord() {
//页大小为-1时,返回总记录数
if(this.DEFAULT_PAGE_SIZE == this.pageSize) {
return this.rows;
}
return this.getPageFirstRecord() + this.getPageRows() ;
}
/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#gotoFirstPage()
*/
public void gotoFirstPage() {
this.gotoPage(this.DEFAULT_PAGE_INDEX);

}

/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#gotoLastPage()
*/
public void gotoLastPage() {
this.gotoPage(this.getPageCount());

}

/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#gotoPreviousPage()
*/
public void gotoPreviousPage() {
this.gotoPage(this.getPageIndex() -1);

}

/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#gotoNextPage()
*/
public void gotoNextPage() {
this.gotoPage(this.getPageIndex() + 1);

}

/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#gotoPage(int)
*/
public void gotoPage(int newPageIndex) {
if( newPageIndex >= this.DEFAULT_PAGE_INDEX && newPageIndex <= this.getPageCount() ) {
this.setPageIndex(newPageIndex);
}

}
/**
* @see com.palic.elis.pos.junit.counter.web.mvc.ViewPage#setPageSize(int)
*/
public void setPageSize(int size) {
if(size < 1) {
size = 1;
}

this.pageSize = size;

//进行初始化
this.doInit();
}

//-----------------------------------
//辅助方法
//-----------------------------------


/**
* 分页初始化方法,为了保证总是能正确的初始化，所以声明为final ,为了让子类可以调用声明为protected
*
*/
protected final void doInit() {
int rows = 0;

//获得总记录数
rows= totalRows();

//设置总记录数
this.setRows(rows);
//设置新的总页数

//计算并设置总页数
int pages = calculatePageCount();
this.setPageCount(pages);

//转到第一页
this.gotoPage(this.DEFAULT_PAGE_INDEX);

onInit();
}
/**
* 记算总页数
* @return 总页数
*/
private int calculatePageCount() {

//总记录数为0条，则返回的总页数为1
if(this.getRows() == 0) {
return this.DEFALT_PAGE_COUNT;
}

//如果页面大小为-1,则返回的总页数为1
if(this.DEFAULT_PAGE_SIZE == this.getPageSize() ) {
return this.DEFALT_PAGE_COUNT;
}

return this.getRows() / this.getPageSize() + ( this.getRows() % this.getPageSize() ==0 ? 0 :1);
}


/**
* 获得总记录数，调用queryTotalRows(),将异常封装为non-checked 异常
* @return 总记录数
* @throws ApplicationRuntimeException
*/
private int totalRows() throws ApplicationRuntimeException{
try{
return queryTotalRows();
}
catch(Exception ex){
throw new ApplicationRuntimeException(ex);
}
}
/**
* 获得当前页数据，调用queryPageList()方法，将异常封装为non-checked异常
* @param startRow 开始记录号
* @param rowCount 记录总数
* @return 当前页数据
* @throws ApplicationRuntimeException
*/
private List pageList(int startRow, int rowCount) throws ApplicationRuntimeException{
try{
return queryPageList(startRow, rowCount);
}catch(Exception ex){
throw new ApplicationRuntimeException(ex);
}
}


//-----------------------------------------
//子类实现的方法
//-----------------------------------------

/**
* 初始化附加方法，由子类扩展
*/
protected void onInit() {

}


/**
* 查询获得总记录数，由子类具体实现
* @return 总记录数
* @throws Exception
*/
protected abstract int queryTotalRows() throws Exception;

/**
* 查询当前页数据,从startRow 开始的rowCount条记录
* @param startRow 开始记录号
* @param rowCount 记录总数
* @return 当前页数据
* @throws Exception
*/
protected abstract List queryPageList(int startRow, int rowCount) throws Exception;

}

3． 分页辅助类
ViewPageHelper.java/**
* 分页辅助类,用于减化Controller中的代码
* @author yuanguangdong
* date: Oct 22, 2006
*/
public class ViewPageHelper {
private static final int FIRST_PAGE_VALUE = 1;

private static final int PREVIOUS_PAGE_VALUE = 2;

private static final int NEXT_PAGE_VALUE = 3;

private static final int LAST_PAGE_VALUE = 4;

private static final int SPECIAL_PAGE_VALUE = 5;

public static final String FIRST_PAGE = "FIRST_PAGE";

public static final String PREVIOUS_PAGE = "PREVIOUS_PAGE";

public static final String NEXT_PAGE = "NEXT_PAGE";

public static final String LAST_PAGE = "LAST_PAGE";

public static final String SPECIAL_PAGE = "SPECIAL_PAGE";

/**分页动作参数名**/
public static final String PAGE_ACTION = "page_action";

/**分页对象属性名**/
public static final String SESSION_PAGE = "session_page";

/**页号参数名**/
public static final String PAGE_NO = "page_no";

private static Map actionMap = new HashMap();
static {
actionMap.put(FIRST_PAGE, new Integer(FIRST_PAGE_VALUE));
actionMap.put(PREVIOUS_PAGE, new Integer(PREVIOUS_PAGE_VALUE));
actionMap.put(NEXT_PAGE, new Integer(NEXT_PAGE_VALUE));
actionMap.put(LAST_PAGE, new Integer(LAST_PAGE_VALUE));
actionMap.put(SPECIAL_PAGE, new Integer(SPECIAL_PAGE_VALUE));
}
/**
* 执行分页动作
* @param page 分页对象
* @param action 分页动作参数
* @param pageIndex 页号
*/
public static void doAction(ViewPage page, String action, int pageIndex) {
int actionIndex = 0;
if (page == null) {
throw new NullPointerException("Page对象null");
}
if (action == null || "".equals(action)) {
throw new IllegalArgumentException("无效的分页动作参数null");
}
action = action.toUpperCase();
if (!actionMap.containsKey(action)) {
throw new UnsupportedOperationException("不支持的分页动作参数:" + action);
}
Integer index = (Integer) actionMap.get(action);
actionIndex = index.intValue();
switch (actionIndex) {
case FIRST_PAGE_VALUE:
page.gotoFirstPage();
break;
case PREVIOUS_PAGE_VALUE:
page.gotoPreviousPage();
break;
case NEXT_PAGE_VALUE:
page.gotoNextPage();
break;
case LAST_PAGE_VALUE:
page.gotoLastPage();
break;
case SPECIAL_PAGE_VALUE:
page.gotoPage(pageIndex);
}
}

public static void doAction(ViewPage page, String action){
doAction(page, action, 1);
}
}

五、应用通用分页框架
1．继承AbstractViewPage类，实现queryPageList(int startRow, int endRow)和
queryTotalRows()方法。

protected int queryTotalRows() throws Exception
获得查询条件的总记录数

protected List queryPageList(int startRow, int rowCount)
用于查询指定范围的数据。startRow为开始记录号, rowCount为查询的记录数

queryPageList(0,20)为查询从第一条开始的20条记录。

使用Ibatis可以由queryPageList调用queryForList()方法。

/**
* 用户信息分页内部类
* @author yuanguangdong
* date: Oct 22, 2006
*/
class UserInfoPage extends AbstractViewPage{

//------------------------------------------------
//实现AbstractViewPage抽象类的抽象方法
//------------------------------------------------

/**
* @see com.prs.application.ehld.web.mvc.AbstractViewPage#getPageDate(int, int)
*/
protected List queryPageList(int startRow, int endRow) throws Exception {
return sampleAction.getUserInfoList(startRow, endRow);
}

/**
* @see com.prs.application.ehld.web.mvc.AbstractViewPage#getRows()
*/
protected int queryTotalRows() throws Exception {
return sampleAction.getUserCount();
}

}



3. 在Contrller中的实现
public ModelAndView listUser(HttpServletRequest request,
HttpServletResponse response) throws Exception {
String pageAction =
RequestUtils.getStringParameter(request,ViewPageHelper.PAGE_ACTION);
Integer pageIndex =
RequestUtils.getIntParameter(request,ViewPageHelper.PAGE_NO);
//声明分页对象
ViewPage userPage =
(ViewPage) request.getSession().getAttribute(ViewPageHelper.SESSION_PAGE);
//第一次请求
if(pageAction == null || userPage == null){
//构建一个新的分页对象
userPage = new UserInfoPage();
//设置分页大小
userPage.setPageSize(2);
}else{

if(ViewPageHelper.SPECIAL_PAGE.equals(pageAction)){
//如果页数为空，则默认为1
if (pageIndex == null)
pageIndex = new Integer(1);
ViewPageHelper.doAction(userPage,pageAction,pageIndex.intValue());
}else{
ViewPageHelper.doAction(userPage,pageAction);
}
}

//从分页对象中获得当前页数据
List userInfoList = userPage.getPageData();

ModelAndView mav = new ModelAndView(userInfoListView);
mav.addObject(this.userInfoListKey,userInfoList);
request.getSession().setAttribute(ViewPageHelper.SESSION_PAGE,userPage);
return mav;
}

4. jsp页面实现

<%@ page contentType="text/html;charset=utf-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt" %>
<%@ taglib prefix="tiles" uri="http://jakarta.apache.org/struts/tags-tiles" %>
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags" %>
<html>
<head>
<title>显示所有员工</title>

<SCRIPT language="javaScript">
function pageNoChange(pageNo){
location.href= "ehld.sample.getuserinfolist.do?page_action=SPECIAL_PAGE&page_no="+pageNo.value;

}
</SCRIPT>
</head>

<body>
<table width="80%" border="0">
<tr>
<td bgcolor="#F0FEFF"><div align="left">  用户列表</div></td>
</tr>
</table>
<br>
<input name="adduser" type="submit" id="adduser" value="新增用户" onclick="location.href='ehld.sample.edituserinfo.do'">
<table width="80%" border="0">
<tr bgcolor="#58ED64">
<th width="25%">id</th>
<th width="34%">姓名</th>
<th colspan="2">操作</th>
</tr>
<c:forEach items="${userInfoList}" var="userInfoDTO">
<tr bgcolor="#D6EBF8">
<td><c:out value="${userInfoDTO.userID}"/></td>
<td><c:out value="${userInfoDTO.userName}"/></td>
<td width="21%"><a href="ehld.sample.edituserinfo.do?id=<c:out value='${userInfoDTO.userID}'/>">编辑</a></td>
<td width="20%"><a href="#">删除</a></td>
</tr>
</c:forEach>
</table>
<c:if test="${session_page.firstPage}">
首页
</c:if>
<c:if test="${! session_page.firstPage}">
<a href="ehld.sample.getuserinfolist.do?page_action=FIRST_PAGE">首页</a>
</c:if>
<c:if test="${! session_page.hashPreviousPage}">
上一页
</c:if>
<c:if test="${session_page.hashPreviousPage}">
<a href="ehld.sample.getuserinfolist.do?page_action=PREVIOUS_PAGE">上一页</a>
</c:if>

<c:if test="${!session_page.hashNextPage}">
下一页
</c:if>

<c:if test="${session_page.hashNextPage}">
<a href="ehld.sample.getuserinfolist.do?page_action=NEXT_PAGE">下一页</a>
</c:if>

<c:if test="${session_page.lastPage}">
尾页
</c:if>

<c:if test="${!session_page.lastPage}">
<a href="ehld.sample.getuserinfolist.do?page_action=LAST_PAGE">尾页</a>
</c:if>

共有<c:out value="${session_page.pageCount}" />页,第

<select name = "pageNo" onChange = "java script:pageNoChange(this);">
<c:forEach begin="1" end = "${session_page.pageCount}" var = "pageIndex">
<option value="<c:out value='${pageIndex}'/>" <c:if test = "${pageIndex ==session_page.pageIndex }">selected</c:if>>
<c:out value="${pageIndex}"/>
</option>
</c:forEach>
</select>
页
</body>
</html>

六、设计探讨
1．通过提供queryTotalRows() 和queryPageList(int startRow, int rowCount)方法，交由用户具体的去实现，所以能够支持任何数据库。
对于Ibatis用户可以使用queryForList()方法,对于用jdbc实现也可以有多种方法来支持各种数据库。
Ms sql 可以使用top 关键字，来获得指定范围的数据
ORACEL可以使用rowid 伪列来获得指定范围的数据
具体怎么去读取数据，完全交由用户控制
2.分页对象与具体的业务对象分离。分页对象如果不能与具体的业务对象分离那么就不可能实现分页对象的重用，不可以实现代码的最大的重用。这不符合oo的按职责来设计对象的原则。
3. ViewPageHelper帮助类的使用有两个好处，统一为分页代码所需的字符参数进行定义，便于contrller和jsp页面代码的维护。第二便于代码重用，减少在contrller中的if分支句语。如果不使用帮助类，则在每个controller中都会产生大量相同的代码。
4. final关键字的使用，protected final void doInit()用于分页对象的实始化，它读取并设置总记录数，计算总页数，默认为第一页等。为什么不在构造函数中来做它呢？如果在构造函数来做它，子类就不可以扩展了。像这样的初始化方法的位置应该由扩展类来灵活控制。声明为protected是不让它由外部对象来进行访问，但是子类又可以进行调用。声明为final是为了子类不能重写它，如果子类重写不当就会造成分页对象的执行逻辑错误。但是如果子类又想扩展它怎么办？子类重写protected void onInit()方法就可以了。这样就能保证父类的逻辑，又能够让子类进行扩展。
5.异常处理的思考，queryTotalRows()和queryPageList方法都是要求由子类实现的抽象类，这两个类的特点都是可能会调用业务对象去实现相应的功能，业务对象可能会访问业务数据库等，可能会抛出任何Exception，但是分页对象类去调用queryTotalRows()和queryPageList的方法是不应该对这些Exception进行任何处理的，如果进行try…catch那么就会隐藏了异常的细节，这是十分可怕的。如果这些方法抛出异常，分页对象应该是不能处理的，不能处理的异常应该封装为运行时异常，所以就有了下面的实现
private List pageList(int startRow, int rowCount) throws ApplicationRuntimeException{
try{
return queryPageList(startRow, rowCount);
}catch(Exception ex){
throw new ApplicationRuntimeException(ex);
}
}

private int totalRows() throws ApplicationRuntimeException{
try{
return queryTotalRows();
}
catch(Exception ex){
throw new ApplicationRuntimeException(ex);
}
}

分页对象内部调用pageList和totalRows方法，这样就很好的解决了异常的问题，把异常交由外部调用者去决定是否处理，而不是强制调用者去处理。

5. 模板方法模式的使用，这是一个典型的模板方法模式的运用。在父类实现关键的算法代码，实现分页对象的处理逻辑，而把某些会发生改变的方法交由子类去实现，使得子类完全不用去关心父类的实现细节，子类只需要重写两个简单的方法就可以实现父类的功能。这就是模板方法带来的最大好处。模板方法模式在各种开源框架中有着广泛的运用，看看spring的源码就知道。子类只需要去实现自己最关心的细节，而父类实现那些不变的逻辑或算法。
6. 针对接口编程，而不是针对类编程。接口可以实现多重继承，而类却不能。接口有比类获得更多的好处，更利于扩展。比如说分页接口，它可以让用户有更多不同的实现，完全不依赖于任何类。只需要为它定制了共同的行为就可以了。在使用委托的时候接口比抽像类更好用。比如在装饰模式的使用中，可能需要实现一个接口，而其中还要有一个本接口的引用。 如果是抽象类，则不可以实现。
7. 通用框架应该具有灵活性，不应该依懒于任何具体的框架。如果通用框架依懒于某一技术细节，某一框架，那么它就有一定的局限性。所以通用分页不应该依懒于ibatis或hibernate 或spring的某一特点。更不应该依懒于sql或oralce某种数据库。

/*
 * @(#)FilterInputStream.java 1.28 03/12/19
 *
 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package java.io;

/**
 * A <code>FilterInputStream</code> contains
 * some other input stream, which it uses as
 * its  basic source of data, possibly transforming
 * the data along the way or providing  additional
 * functionality. The class <code>FilterInputStream</code>
 * itself simply overrides all  methods of
 * <code>InputStream</code> with versions that
 * pass all requests to the contained  input
 * stream. Subclasses of <code>FilterInputStream</code>
 * may further override some of  these methods
 * and may also provide additional methods
 * and fields.
 *
 * @author  Jonathan Payne
 * @version 1.28, 12/19/03
 * @since   JDK1.0
 */
public
class FilterInputStream extends InputStream {
    /**
     * The input stream to be filtered.
     */
    protected volatile InputStream in;   
/**
     * Creates a <code>FilterInputStream</code>
     * by assigning the  argument <code>in</code>
     * to the field <code>this.in</code> so as
     * to remember it for later use.
     *
     * @param   in   the underlying input stream, or <code>null</code> if
     *          this instance is to be created without an underlying stream.
     */
    protected FilterInputStream(InputStream in) {
 this.in = in;
    }

    /**
     * Reads the next byte of data from this input stream. The value
     * byte is returned as an <code>int</code> in the range
     * <code>0</code> to <code>255</code>. If no byte is available
     * because the end of the stream has been reached, the value
     * <code>-1</code> is returned. This method blocks until input data
     * is available, the end of the stream is detected, or an exception
     * is thrown.
     * <p>
     * This method
     * simply performs <code>in.read()</code> and returns the result.
     *
     * @return     the next byte of data, or <code>-1</code> if the end of the
     *             stream is reached.
     * @exception  IOException  if an I/O error occurs.
     * @see        java.io.FilterInputStream#in
     */
    public int read() throws IOException {
 return in.read();
    }

    /**
     * Reads up to <code>byte.length</code> bytes of data from this
     * input stream into an array of bytes. This method blocks until some
     * input is available.
     * <p>
     * This method simply performs the call
     * <code>read(b, 0, b.length)</code> and returns
     * the  result. It is important that it does
     * <i>not</i> do <code>in.read(b)</code> instead;
     * certain subclasses of  <code>FilterInputStream</code>
     * depend on the implementation strategy actually
     * used.
     *
     * @param      b   the buffer into which the data is read.
     * @return     the total number of bytes read into the buffer, or
     *             <code>-1</code> if there is no more data because the end of
     *             the stream has been reached.
     * @exception  IOException  if an I/O error occurs.
     * @see        java.io.FilterInputStream#read(byte[], int, int)
     */
    public int read(byte b[]) throws IOException {
 return read(b, 0, b.length);
    }

    /**
     * Reads up to <code>len</code> bytes of data from this input stream
     * into an array of bytes. This method blocks until some input is
     * available.
     * <p>
     * This method simply performs <code>in.read(b, off, len)</code>
     * and returns the result.
     *
     * @param      b     the buffer into which the data is read.
     * @param      off   the start offset of the data.
     * @param      len   the maximum number of bytes read.
     * @return     the total number of bytes read into the buffer, or
     *             <code>-1</code> if there is no more data because the end of
     *             the stream has been reached.
     * @exception  IOException  if an I/O error occurs.
     * @see        java.io.FilterInputStream#in
     */
    public int read(byte b[], int off, int len) throws IOException {
 return in.read(b, off, len);
    }

    /**
     * Skips over and discards <code>n</code> bytes of data from the
     * input stream. The <code>skip</code> method may, for a variety of
     * reasons, end up skipping over some smaller number of bytes,
     * possibly <code>0</code>. The actual number of bytes skipped is
     * returned.
     * <p>
     * This method
     * simply performs <code>in.skip(n)</code>.
     *
     * @param      n   the number of bytes to be skipped.
     * @return     the actual number of bytes skipped.
     * @exception  IOException  if an I/O error occurs.
     */
    public long skip(long n) throws IOException {
 return in.skip(n);
    }

    /**
     * Returns the number of bytes that can be read from this input
     * stream without blocking.
     * <p>
     * This method
     * simply performs <code>in.available()</code> and
     * returns the result.
     *
     * @return     the number of bytes that can be read from the input stream
     *             without blocking.
     * @exception  IOException  if an I/O error occurs.
     * @see        java.io.FilterInputStream#in
     */
    public int available() throws IOException {
 return in.available();
    }

    /**
     * Closes this input stream and releases any system resources
     * associated with the stream.
     * This
     * method simply performs <code>in.close()</code>.
     *
     * @exception  IOException  if an I/O error occurs.
     * @see        java.io.FilterInputStream#in
     */
    public void close() throws IOException {
 in.close();
    }

    /**
     * Marks the current position in this input stream. A subsequent
     * call to the <code>reset</code> method repositions this stream at
     * the last marked position so that subsequent reads re-read the same bytes.
     * <p>
     * The <code>readlimit</code> argument tells this input stream to
     * allow that many bytes to be read before the mark position gets
     * invalidated.
     * <p>
     * This method simply performs <code>in.mark(readlimit)</code>.
     *
     * @param   readlimit   the maximum limit of bytes that can be read before
     *                      the mark position becomes invalid.
     * @see     java.io.FilterInputStream#in
     * @see     java.io.FilterInputStream#reset()
     */
    public synchronized void mark(int readlimit) {
 in.mark(readlimit);
    }

    /**
     * Repositions this stream to the position at the time the
     * <code>mark</code> method was last called on this input stream.
     * <p>
     * This method
     * simply performs <code>in.reset()</code>.
     * <p>
     * Stream marks are intended to be used in
     * situations where you need to read ahead a little to see what's in
     * the stream. Often this is most easily done by invoking some
     * general parser. If the stream is of the type handled by the
     * parse, it just chugs along happily. If the stream is not of
     * that type, the parser should toss an exception when it fails.
     * If this happens within readlimit bytes, it allows the outer
     * code to reset the stream and try another parser.
     *
     * @exception  IOException  if the stream has not been marked or if the
     *               mark has been invalidated.
     * @see        java.io.FilterInputStream#in
     * @see        java.io.FilterInputStream#mark(int)
     */
    public synchronized void reset() throws IOException {
 in.reset();
    }

    /**
     * Tests if this input stream supports the <code>mark</code>
     * and <code>reset</code> methods.
     * This method
     * simply performs <code>in.markSupported()</code>.
     *
     * @return  <code>true</code> if this stream type supports the
     *          <code>mark</code> and <code>reset</code> method;
     *          <code>false</code> otherwise.
     * @see     java.io.FilterInputStream#in
     * @see     java.io.InputStream#mark(int)
     * @see     java.io.InputStream#reset()
     */
    public boolean markSupported() {
 return in.markSupported();
    }
}

JNDI: The Java Naming and Directory Interface

The Java Naming and Directory Interface是访问不同名字和目录服务的统一API接口。

不同的服务使用不同的名字格式。

Java程序需要以相同的格式访问数据库，文件，目录，对象和网络。

JNID有两部分接口：应用程序接口和提供服务的接口。在应用程序中使用API来访问名字或目录服务，在一个新的服务中使用SPI来提供服务。

名字服务（Naming Services）

名字服务提供一种方法，映射标识符到实体或对象。

你需要知道的几条基本条款：

绑定：绑定是将一个不可分割的名字（"原子"名字）与一个对象联系起来。像DNS，我们用名字www.yahoo.com与IP地址216.32.74.53联系起来，一个文件对象用文件名afile.txt联系起来。

名字空间；名字空间包含一组名字，但名字空间内每个名字是唯一的。一个文件目录就是一个简单的名字空间，如目录C:\temp，在这个目录下，不能有两个相同名字的文件，但是，不同目录下的两个文件可能有相同的名字。

复合名字：复合名字是用名字空间构成的唯一名字，有一个或多个"原子"名字构成，取决于所在的名字空间。文件路径就是一个复合名字，比如我们用C:\temp\myfile.txt，我们可以看到，这个名字由根目录名（C:\），临时目录名（temp）和一个文件名（myfile.txt）构成，这3个名字复合起来表示一个唯一的名字。

组合名字：组合名字能跨越多个名字空间。一个URL就是一个组合名字，如果你看见http://www.npu.edu/index.htm，你使用http服务连接到服务器，然后使用另一个名字空间/index.htm来访问一个文件。

目录服务

目录服务提供一组分成等级的目录对象，具有可搜索的能力。

在目录服务中存储的对象可以是任何能用一组属性描述的对象，每个对象都可通过一组属性来描述该对象的能力。例如，一个Person对象可能有height，hair color，age，sex等属性。目录服务还可提供根据要求来搜索的能力，如我们可以使用Person的age属性，搜索20-25岁间的Person对象，目录服务将返回符合条件的Persion对象。这通常被称作基于内容的搜索。

在客户端使用JNDI：

u       创建一个java.util.Hashtable或者java.util.Properties的实例。

u       添加变量到Hashtable或Properties对象：

由naming server提供的JNDI class类名。

包含aming server位置的URL。

安全信任书。

u       通过Hashtable或Properites或jndi属性文件创建一个InitialContext对象。

以上所有方法都可能抛出NamingException。

}

1.       所有的额外新添加的方法要放到InvocationHandler的实现类中

2.       Proxy类都与InvocationHandler相联系的，也就是说Proxy类的中的方法调用都会被重新分配到实例的InvoctionHandler中的invoke方法中，传递了reflect中的method类

3.       创建Java动态代理类的步骤：

a)       实现InvocationHandler接口

b)      通过Proxy.newProxyInstance得到一个Proxy类的实例

一般的写法如下：

public class XXXHandler implements InvocationHandler {

private Object originalObject;

public Object bind(Object obj) {

this.originalObject = obj;

return Proxy.newProxyInstance(

obj.getClass().getClassLoader(),

obj.getClass().getInterfaces(),

this)

}

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

method.invoke(originalObject, args);

}

4.       这样调用XXXHandler：代理目标的接口类= XXXHandler的实例.bind(代理目标的实现类)

posted @ 2007-07-07 15:46 topquan 阅读(80) | 评论 (0) | 编辑 收藏