psy-operation.tld

Xml代码
<?xml version="1.0" encoding="UTF-8" ?> 
<taglib xmlns="http://java.sun.com/xml/ns/j2ee" 
    xmlns:xsi="http://www.blog.com.cn/http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://www.blog.com.cn/http://java.sun.com/xml/ns/j2eehttp://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd" 
    version="http://www.blog.com.cn/2.0"> 
  <description> 
 psychcn 标记库 1.0  
  </description> 
  <tlib-version>1.0</tlib-version> 
  <short-name>psydict</short-name> 
  <uri>http://www.psychcn.com/taglibs</uri> 
    <tag> 
    <name>op</name> 
    <description>权限标签</description> 
    <tag-class>com.psychcn.web.tags.OperationTag</tag-class> 
 <body-content>scriptless</body-content> 
      
    <attribute> 
       <name>code</name> 
       <required>true</required> 
       <rtexprvalue>true</rtexprvalue> 
    </attribute> 
    <attribute> 
       <name>opset</name> 
       <required>false</required> 
       <rtexprvalue>true</rtexprvalue> 
    </attribute>      
  </tag> 
</taglib> 

<?xml version="1.0" encoding="UTF-8" ?>
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.blog.com.cn/http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.blog.com.cn/http://java.sun.com/xml/ns/j2eehttp://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
    version="http://www.blog.com.cn/2.0">
  <description>
 psychcn 标记库 1.0
  </description>
  <tlib-version>1.0</tlib-version>
  <short-name>psydict</short-name>
  <uri>http://www.psychcn.com/taglibs</uri>
    <tag>
    <name>op</name>
    <description>权限标签</description>
    <tag-class>com.psychcn.web.tags.OperationTag</tag-class>
 <body-content>scriptless</body-content>
   
    <attribute>
       <name>code</name>
       <required>true</required>
       <rtexprvalue>true</rtexprvalue>
    </attribute>
    <attribute>
       <name>opset</name>
       <required>false</required>
       <rtexprvalue>true</rtexprvalue>
    </attribute>   
  </tag>
</taglib>

OperationTag.java

Java代码
import javax.servlet.jsp.JspException;  
import javax.servlet.jsp.tagext.SimpleTagSupport;  
 
import java.io.IOException;  
import java.util.*;  
 
public class OperationTag extends SimpleTagSupport {  
 private Set operation_set;  
 private String default_operation_set_name = "ops";  
 private String code;  
   
 public void setCode(String code) {  
  this.code = code;  
 }  
 public void setOpset(Set operation_set) {  
  this.operation_set = operation_set;  
 }  
 public void setOpsetName(String name) {  
  this.default_operation_set_name= name;  
 }  
   
 public void doTag() throws JspException, IOException{  
  //session中没有设置权限HashSet,给默认值  
  if (operation_set==null) {  
   Object o = this.getJspContext().findAttribute(default_operation_set_name);  
   if (o instanceof Set)  
    operation_set = (Set)o;  
  }  
    
  if (code == null || operation_set == null)  
   throw new JspException("标签属性无效,无法执行!");  
    
  //这里支持多个code,用','分割,有一个符合条件就输出,全部不满足则不输出(注意不能有空格,区分大小写)  
  String[] codes = code.split(",");  
  for (String s : codes) {  
   if (operation_set.contains(s)) {  
    this.getJspBody().invoke(this.getJspContext().getOut());  
    return;  
   }  
  }  
 }  
} 

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;

import java.io.IOException;
import java.util.*;

public class OperationTag extends SimpleTagSupport {
 private Set operation_set;
 private String default_operation_set_name = "ops";
 private String code;
 
 public void setCode(String code) {
  this.code = code;
 }
 public void setOpset(Set operation_set) {
  this.operation_set = operation_set;
 }
 public void setOpsetName(String name) {
  this.default_operation_set_name= name;
 }
 
 public void doTag() throws JspException, IOException{
  //session中没有设置权限HashSet,给默认值
  if (operation_set==null) {
   Object o = this.getJspContext().findAttribute(default_operation_set_name);
   if (o instanceof Set)
    operation_set = (Set)o;
  }
 
  if (code == null || operation_set == null)
   throw new JspException("标签属性无效,无法执行!");
 
  //这里支持多个code,用','分割,有一个符合条件就输出,全部不满足则不输出(注意不能有空格,区分大小写)
  String[] codes = code.split(",");
  for (String s : codes) {
   if (operation_set.contains(s)) {
    this.getJspBody().invoke(this.getJspContext().getOut());
    return;
   }
  }
 }
}
 

底层查找权限接口：

OperationService.java

Java代码
public java.util.HashSet<String> findByUserId(String userId) throws Exception;  
实现接口类：(//通过USERID找到对应的operation的code)  
 
OperationServiceImpImp.java  
 
 public java.util.HashSet<String> findByUserId(String userId) throws Exception{  
  Session s = getSession();  
  Transaction tx = s.beginTransaction();  
    
  String sql = "select DISTINCT o.code from users u " +  
      "inner join groupmember gm on u.userId=gm.user_Id " +   
      "inner join groupacl ga on gm.group_id=ga.group_id " +  
      "inner join operation o on ga.op_id = o.id " +  
      "where u.userId=?";  
  Query q = s.createSQLQuery(sql).setString(0,userId);  
  List<Object> ls = q.list();  
  HashSet ops = new HashSet();  
  for(Object object : ls){  
   ops.add(object);  
  }  
  tx.commit();  
  releaseSession(s);  
    
  return ops;  
 } 

public java.util.HashSet<String> findByUserId(String userId) throws Exception;
实现接口类：(//通过USERID找到对应的operation的code)

OperationServiceImpImp.java

 public java.util.HashSet<String> findByUserId(String userId) throws Exception{
  Session s = getSession();
  Transaction tx = s.beginTransaction();
 
  String sql = "select DISTINCT o.code from users u " +
      "inner join groupmember gm on u.userId=gm.user_Id " +
      "inner join groupacl ga on gm.group_id=ga.group_id " +
      "inner join operation o on ga.op_id = o.id " +
      "where u.userId=?";
  Query q = s.createSQLQuery(sql).setString(0,userId);
  List<Object> ls = q.list();
  HashSet ops = new HashSet();
  for(Object object : ls){
   ops.add(object);
  }
  tx.commit();
  releaseSession(s);
 
  return ops;
 }

这样，在用户登录时，可以把该用户的权限HashSet装载到Session中

//把当前用户的权限添加到HashSet
  

Java代码
HashSet ops = AppResource.operationService.findByUserId(user.getUserId());  
session.setAttribute("ops",ops); 

HashSet ops = AppResource.operationService.findByUserId(user.getUserId());
session.setAttribute("ops",ops);

最后，在JSP中就可以简单的使用标签来判断有没有某个权限，没有则不显示

Xml代码
<%@ taglib prefix="psy" uri="http://www.psychcn.com/taglibs" %>   
<psy:op code="Finance_Payment">看你有没有权限让我显示</psy:op> 

<%@ taglib prefix="psy" uri="http://www.psychcn.com/taglibs" %>
<psy:op code="Finance_Payment">看你有没有权限让我显示</psy:op>

OK！可以根据需要修改。

Spring架构上的好处

在我们进入细节之前，让我们来看看Spring能够给工程带来的种种好处：

Spring能有效地组织你的中间层对象，不管你是否选择使用了EJB。如果你仅仅使用了Struts或其他为J2EE的 API特制的framework，Spring致力于解决剩下的问题。

Spring能消除在许多工程中常见的对Singleton的过多使用。根据我的经验，这是一个很大的问题，它降低了系统的可测试性和面向对象的程度。

通过一种在不同应用程序和项目间一致的方法来处理配置文件，Spring能消除各种各样自定义格式的属性文件的需要。曾经对某个类要寻找的是哪个 魔法般的属性项或系统属性感到不解，为此不得不去读Javadoc甚至源编码？有了Spring，你仅仅需要看看类的JavaBean属性。 Inversion of Control的使用（在下面讨论）帮助完成了这种简化。

通过把对接口编程而不是对类编程的代价几乎减少到没有，Spring能够促进养成好的编程习惯。

Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。

使用Spring构建的应用程序易于单元测试。

Spring能使EJB的使用成为一个实现选择,而不是应用架构的必然选择。你能选择用POJOs或local EJBs来实现业务接口，却不会影响调用代码。

Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适用于许多web应用。例如，Spring能使用AOP提供声明性事务管理而不通过EJB容器，如果你仅仅需要与单个数据库打交道，甚至不需要一个JTA实现。

Spring为数据存取提供了一个一致的框架,不论是使用的是JDBC还是O/R mapping产品（如Hibernate）。

package anni;
public class EncodingFilter implements Filter {
    public void init(FilterConfig config) throws ServletException {}
    public void destroy() {}
    public void doFilter(ServletRequest request,
            ServletResponse response,
            FilterChain chain)
            throws IOException, ServletException {
        request.setCharacterEncoding("gb2312");
        chain.doFilter(request, response);
    }
}

web.xml中
<filter>
    <filter-name>EncodingFilter</filter-name>
    <filter-class>anni.EncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>EncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

filter标签部分定义使用的过滤器，filter-mapping标签告诉服务器把哪些请求交给过滤器处理。这里的/*表示所有请求，/表示根路径，*（星号）代表所有请求，加在一起就变成了根路径下的所有请求。这样，所有的请求都会先被EncodingFilter拦截，并在请求里设置上指定的gb2312编码。

================================
用filter控制用户访问权限

我们要保护的页面是admin/index.jsp，为此我们在web.xml进行如下配置。
<filter>
    <filter-name>SecurityFilter</filter-name>
    <filter-class>anni.SecurityFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>SecurityFilter</filter-name>
    <url-pattern>/admin/*</url-pattern>
</filter-mapping>

SecurityFilter过滤器:
public void doFilter(ServletRequest request,
        ServletResponse response,
        FilterChain chain)
        throws IOException, ServletException {
    HttpServletRequest req = (HttpServletRequest) request;
    HttpServletResponse res = (HttpServletResponse) response;
   HttpSession session = req.getSession();
    if (session.getAttribute("username") != null) {
        chain.doFilter(request, response);
    } else {
        res.sendRedirect("../failure.jsp");
    }
}

首先要将ServletRequest和ServletResponse转换成HttpServletRequest和HttpServletResponse，因为Filter本来设计成为多种协议服务，http协议仅仅是其中一部分。不过我们接触到的也只有http，而且也只有转换成对应HttpServletRequest和HttpServletResponse才能进行下面的session操作和页面重定向。
得到了http请求之后，可以获得请求对应的session，判断session中的username变量是否为null，如果不为null，说明用户已经登录，就可以调用doFilter继续请求访问的资源。如果为null，说明用户还没有登录，禁止用户访问，并使用页面重定向跳转到failure.jsp页面显示提示信息。

==================================
filter所谓的特性

请求映射
filter-mapping和servlet-mapping都是将对应的filter或servlet映射到某个url-pattern上，当客户发起某一请求时，服务器先将此请求与web.xml中定义的所有url-pattern进行匹配，然后执行匹配通过的filter和servlet。

你可以使用三种方式定义url-pattern。
1.直接映射一个请求。
<servlet-mapping>
    <servlet-name>ContactServlet</servlet-name>
    <url-pattern>/contact.do</url-pattern>
</servlet-mapping>
                   
2.映射一个路径下的所有请求。
<servlet-mapping>
    <servlet-name>EncodingFilter</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

3.映射结尾相同的一类请求。
<servlet-mapping>
    <servlet-name>ControllerServlet</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

想要获得所有以user开头.do结尾的请求吗？user*.do在url-pattern是无法识别的，只能配置成*.do，再去servlet中对请求进行筛选。
想要让一个servlet负责多个请求吗？/user/*,/admin/*,*.do写在一起url-pattern也不认识，只能配成多个servlet-mapping。
<servlet-mapping>
    <servlet-name>ControllerServlet</servlet-name>
    <url-pattern>/user/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>ControllerServlet</servlet-name>
    <url-pattern>/admin/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>ControllerServlet</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

过滤链

服务器会按照web.xml中过滤器定义的先后循序组装成一条链，然后一次执行其中的doFilter()方法。执行的顺序就如上图所示，执行第一个过滤器的chain.doFilter()之前的代码，第二个过滤器的chain.doFilter()之前的代码，请求的资源，第二个过滤器的chain.doFilter()之后的代码，第一个过滤器的chain.doFilter()之后的代码，最后返回响应。
过滤链的好处是，执行过程中任何时候都可以打断，只要不执行chain.doFilter()就不会再执行后面的过滤器和请求的内容。而在实际使用时，就要特别注意过滤链的执行顺序问题，像EncodingFilter就一定要放在所有Filter之前，这样才能确保在使用请求中的数据前设置正确的编码。

filter的详细配置

在servlet-2.3中，Filter会过滤一切请求，包括服务器内部使用forward转发请求和<%@ include file="/index.jsp"%>的情况。
到了servlet-2.4中Filter默认下只拦截外部提交的请求，forward和include这些内部转发都不会被过滤，但是有时候我们需要forward的时候也用到Filter，这样就需要如下配置。
<filter>
    <filter-name>TestFilter</filtername>
    <filter-class>anni.TestFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>TestFilter</filtername>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
    <dispatcher>FORWARD</dispatcher>
    <dispatcher>INCLUDE</dispatcher>
    <dispatcher>EXCEPTION</dispatcher>
</filter-mapping>
       
这样TestFilter就会过滤所有状态下的请求。如果我们没有进行设置，默认使用的就是REQUEST。而EXCEPTION是在isErrorPage="true"的情况下出现的，这个用处不多，看一下即可。
这里FORWARD是解决request.getDispatcher("index.jsp").forward(request, response);无法触发Filter的关键，配置上这个以后再进行forward的时候就可以触发过滤器了。

Filter还有一个有趣的用法，在filter-mapping中我们可以直接指定servlet-mapping，让过滤器只处理一个定义在web.xml中的servlet。
<filter-mapping>
    <filter-name>TestFilter</filter-name>
    <servlet-name>TestServlet</servlet-name>
</filter-mapping>
<servlet>
    <servlet-name>TestServlet</servlet-name>
    <servlet-class>anni.TestServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>TestServlet</servlet-name>
    <url-pattern>/TestServlet</url-pattern>
</servlet-mapping>
      
直接指定servlet-name，TestFilter便会引用TestServlet配置的url-pattern，在某些filter与servlet绑定的情况下不失为一个好办法。

==================================================

关于用户超时的例子：

public class OnlineUserListener implements HttpSessionListener {
    public void sessionCreated(HttpSessionEvent event) {
    }
    public void sessionDestroyed(HttpSessionEvent event) {
        HttpSession session = event.getSession();
        ServletContext application = session.getServletContext();
        // 取得登录的用户名
        String username = (String) session.getAttribute("username");
        // 从在线列表中删除用户名
        List onlineUserList = (List) application.getAttribute("onlineUserList");
        onlineUserList.remove(username);
        System.out.println(username + "超时退出。");
    }
}

以下两种情况下就会发生sessionDestoryed（会话销毁）事件：

1.执行session.invalidate()方法时。例如：request.getSession().invalidate();

2.如果用户长时间没有访问服务器，超过了会话最大超时时间，服务器就会自动销毁超时的session。会话超时时间可以在web.xml中进行设置。

========================================

使用HttpSessionBindingListener

HttpSessionBindingListener虽然叫做监听器，但使用方法与HttpSessionListener完全不同。我们实际看一下它是如何使用的。

我们的OnlineUserBindingListener实现了HttpSessionBindingListener接口，接口中共定义了两个方法：valueBound()和valueUnbound()，分别对应数据绑定，和取消绑定两个事件。

所谓对session进行数据绑定，就是调用session.setAttribute()把HttpSessionBindingListener保存进session中。我们在LoginServlet.java中进行这一步。

// 把用户名放入在线列表
session.setAttribute("onlineUserBindingListener", new OnlineUserBindingListener(username));
       
这就是HttpSessionBindingListener和HttpSessionListener之间的最大区别：HttpSessionListener只需要设置到web.xml中就可以监听整个应用中的所有session。HttpSessionBindingListener必须实例化后放入某一个session中，才可以进行监听。

从监听范围上比较，HttpSessionListener设置一次就可以监听所有session，HttpSessionBindingListener通常都是一对一的。

正是这种区别成就了HttpSessionBindingListener的优势，我们可以让每个listener对应一个username，这样就不需要每次再去session中读取username，进一步可以将所有操作在线列表的代码都移入listener，更容易维护。

valueBound()方法的代码如下：

public void valueBound(HttpSessionBindingEvent event) {
    HttpSession session = event.getSession();
    ServletContext application = session.getServletContext();

    // 把用户名放入在线列表
    List onlineUserList = (List) application.getAttribute("onlineUserList");
    // 第一次使用前，需要初始化
    if (onlineUserList == null) {
        onlineUserList = new ArrayList();
        application.setAttribute("onlineUserList", onlineUserList);
    }
    onlineUserList.add(this.username);
}
       
username已经通过构造方法传递给listener，在数据绑定时，可以直接把它放入用户列表。

与之对应的valueUnbound()方法，代码如下：

public void valueUnbound(HttpSessionBindingEvent event) {
    HttpSession session = event.getSession();
    ServletContext application = session.getServletContext();

    // 从在线列表中删除用户名
    List onlineUserList = (List) application.getAttribute("onlineUserList");
    onlineUserList.remove(this.username);

    System.out.println(this.username + "退出。");
}
       
这里可以直接使用listener的username操作在线列表，不必再去担心session中是否存在username。

valueUnbound的触发条件是以下三种情况：

1.执行session.invalidate()时。

2.session超时，自动销毁时。

3.执行session.setAttribute("onlineUserListener", "其他对象");或session.removeAttribute("onlineUserListener");将listener从session中删除时。

因此，只要不将listener从session中删除，就可以监听到session的销毁。

import javax.servlet.http.HttpServletRequest;

import com.mdcl.mocha.fe.developer.template.util.TemplateUtil;

public class ParamUtil {

 /**
  * 把request取到的参数放到一个Map中
  * @param request
  * @return
  */
 public static Map parseRequest(HttpServletRequest request){
  Map map = new HashMap();
  String key = null;
  String value = null;
        for(Enumeration enumeration = request.getParameterNames(); enumeration.hasMoreElements(); map.put(key, value))
        {
            key = (String)enumeration.nextElement();
            String as[] = request.getParameterValues(key);
            value = as[0];
            for(int i = 1; i < as.length; i++)
             value = value + "," +as[i];

        }
  return map;
 }
}

Date created = new Date(session.getCreationTime());
//得到session对象创建的时间
Date accessed = new Date(session.getLastAccessedTime());
//得到最后访问该session对象的时间
out.println("<br>"+"ID " + session.getId()+" ");
//得到该session的id，并打印
out.println("<br>"+"Created: " + created+" ");
//打印session创建时间
out.println("<br>"+"Last Accessed: " + accessed+" ");
//打印最后访问时间

session.setAttribute("Name","Tom");
//在session中添加变量Name=Tom
session.setAttribute("UID","12345678");
//在session中添加变量UID=12345678

Enumeration e = session.getAttributeNames();
//得到session中变量名的枚举对象
while (e.hasMoreElements()) { //遍历每一个变量
String name = (String)e.nextElement(); //首先得到名字
String value = session.getAttribute(name).toString();
//由名字从session中得到值
out.println("<br>"+name + " = " + value+" "); //打印
}

%>
</body>
</html>

 if((pNO != null) && (!pNO.equals(""))){

  pageNo=Integer.parseInt(pNO);
 }

 if (countall > pageSize) {
  if ((countall / pageSize) * pageSize < countall) {
   pageCount = (countall / pageSize) + 1;
  }
  else{
   pageCount = (countall / pageSize);
  }
 }
 
 else if (countall / pageSize == 1) {
  pageCount = 1;
 }
 else {
  pageCount = 1;
 }

 if (pageNo >= pageCount) {
  pageNo = pageCount;
 }
 else if (pageNo < 1) {
  pageNo = 1;
 }
    
    
 mixNum = (pageNo-1) * pageSize;
 maxNum = pageNo*pageSize;
 
 if((mixNum + pageSize) > countall){
  maxNum = countall;
 }
 else{
  maxNum = mixNum+pageSize;
 }
%>
---------------------------------------------------------------------------------------------
<html>
<head>
<script language="JavaScript" type="text/JavaScript">
function check(){
 if(Jtrim(document.forms.meslistForm.textfield.value)==""){
  alert("请输入页数");
 }
 else if(checkNum(document.forms.meslistForm.textfield.value)){
  window.location.href="?pageNo="+document.forms.meslistForm.textfield.value;
 }else{
  alert("请输入数字。");
 }
 document.forms.meslistForm.textfield.value = "";
 document.forms.meslistForm.textfield.select();
}
function checkNum(str){
return str.match(/\D/)==null;
}

function Jtrim(str)
{

        var i = 0;
        var len = str.length;
        if ( str == "" ) return( str );
        j = len -1;
        flagbegin = true;
        flagend = true;
        while ( flagbegin == true && i< len)
        {
           if ( str.charAt(i) == " " )
                {
                  i=i+1;
                  flagbegin=true;
                }
                else
                {
                        flagbegin=false;
                }
        }

        while  (flagend== true && j>=0)
        {
            if (str.charAt(j)==" ")
                {
                        j=j-1;
                        flagend=true;
                }
                else
                {
                        flagend=false;
                }
        }

        if ( i > j ) return ("")

        trimstr = str.substring(i,j+1);
        return trimstr;
}</script>
</head>

<body>
<%
 for(int i=mixNum;i<maxNum;i++){
 //此处用list循环下标用i
 }         
%>

 <table align="center" width="100%" border="0" cellspacing="0" cellpadding="0">
   <tr>
    <td width="4%" height="27" align="center" valign="middle"
     class="word">&nbsp;</td>
    <td width="56%" align="center" valign="middle" class="word"><img
     src="<%=path%>/images/pagination/list_home.gif" width="13"
     height="13">&nbsp; <%
      if (pageNo > 1) {
     %> <a href="?pageNo=1">&nbsp;首页</a>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
    <%
                     }else{
                    %> &nbsp;首页&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <%
                     }
                    %> <img src="<%=path%>/images/pagination/list_pre.gif"
     width="13" height="13"> <%
      if (pageNo > 1) {
     %> <a href="?pageNo=<%=(pageNo-1)%>">&nbsp;前一页</a>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
    <%
                     }else{
                    %> &nbsp;前一页&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <%
                     }
                    %> <img
     src="<%=path%>/images/pagination/list_next.gif" width="13"
     height="13"> <%
      if (pageCount>pageNo) {
     %> <a href="?pageNo=<%=(pageNo+1)%>">&nbsp;&nbsp;后一页</a>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
    <%
                     }else{
                    %> &nbsp;&nbsp;后一页&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <%
                     } 
                    %> <img src="<%=path%>/images/pagination/list_end.gif"
     width="13" height="13"> <%
      if (pageCount>pageNo) {
     %> <a href="?pageNo=<%=(pageCount)%>">&nbsp;&nbsp;尾页</a> <%
                     }else{
                    %> &nbsp;&nbsp;尾页 <%
                     } 
                    %>
    <td width="26%" align="center" valign="middle" class="word">共<%=pageCount%>页&nbsp;第<%=pageNo%>页&nbsp;
    跳转</td>
    <td width="4%" align="center" valign="middle" class="word"><input
     name="textfield" type="text" class="input" size="1"></td>
    <td width="6%" align="center" valign="middle" class="word"><a
     href="javascript:check()"><img
     src="<%=path%>/images/pagination/go.gif" border="0" width="18"
     height="18"></a></td>

    <td width="4%" align="left" valign="middle" class="word">&nbsp;</td>
   </tr>
  </table></body>  
</html>