BlogJava-java fans-文章分类-jsp学习

HTML相对路径--上级目录及下级目录的写法(转)

fly — Thu, 01 Nov 2012 02:55:00 GMT

如何表示上级目录

../表示源文件所在目录的上一级目录，../../表示源文件所在目录的上上级目录，以此类推。

假设info.html路径是：c:/Inetpub/wwwroot/sites/blabla/info.html
假设index.html路径是：c:/Inetpub/wwwroot/sites/index.html
在info.html加入index.html超链接的代码应该这样写：

index.html

假设info.html路径是：c:/Inetpub/wwwroot/sites/blabla/info.html
假设index.html路径是：c:/Inetpub/wwwroot/index.html
在info.html加入index.html超链接的代码应该这样写：

index.html

假设info.html路径是：c:/Inetpub/wwwroot/sites/blabla/info.html
假设index.html路径是：c:/Inetpub/wwwroot/sites/wowstory/index.html
在info.html加入index.html超链接的代码应该这样写：

index.html

如何表示下级目录

引用下级目录的文件，直接写下级目录文件的路径即可。

假设info.html路径是：c:/Inetpub/wwwroot/sites/blabla/info.html
假设index.html路径是：c:/Inetpub/wwwroot/sites/blabla/html/index.html
在info.html加入index.html超链接的代码应该这样写：

index.html

假设info.html路径是：c:/Inetpub/wwwroot/sites/blabla/info.html
假设index.html路径是：c:/Inetpub/wwwroot/sites/blabla/html/tutorials/index.html
在info.html加入index.html超链接的代码应该这样写：

index.html

fly 2012-11-01 10:55 发表评论

大话Session (转)

fly — Thu, 10 Jun 2010 07:10:00 GMT

摘要: 引言在web开发中，session是个非常重要的概念。在许多动态网站的开发者看来，session就是一个变量，而且其表现像个黑洞，他只需要将东西在合适的时机放进这个洞里，等需要的时候再把东西取出来。这是开发者对session最直观的感受，但是黑洞里的景象或者说session内部到底是怎么工作的呢？当笔者向身边的一些同事或朋友问及相关的更进一步的细节时，很多... 阅读全文

fly 2010-06-10 15:10 发表评论

如何限制同一客户端登录的用户数量以及禁止同一用户同时在不同客户端登录？ (转)

fly — Thu, 10 Jun 2010 02:27:00 GMT

在web应用系统中，出于安全性考虑，经常需要对同一客户端登录的用户数量和一个客户同时在多个客户端登陆进行限制。具体一点就是：

1、在同一台电脑上一次只允许有一个用户登录系统，2、一个用户在同一时间只允许在一个客户端登录。

我最近做的一个系统就遇到了这样的问题，本来系统已经开发完成了，但是安全测评没有通过，就是因为没有做这两个限制。怎么来做这样的限制呢？我在网上找了很久，发现问这个问题的人很多，但是没有找到特别清楚的答案。后来自己摸索着，看了一些书，终于找到解决办法了。

要解决这个问题实际上不难，对于高手来说可能都懒得去说了，但是对于不熟悉web编程的人来说可能会困扰很久。下面我把我的解决办法说出来，供大家参考！

先介绍一下我那个系统的背景：j2ee，tomcat，没有用cookie。

首先确定解决这两个问题的基本思路：

1、要解决同一台电脑上只允许有一个用户登录系统，只有一个办法。监视每一个连接的来源，如果发现有一个新的连接与某个已经存在的连接来自同一台电脑，则终止其中的一个（当然，也可以提醒用户，让他自己决定终止哪一个）。

2、要禁止一个用户账号同时在不同的客户端登录，只有监视每一个连接的用户账号，如果发现一个新连接的用户账号跟某个已经存在的连接的用户账号相同，则自动将前一个终止（同样，也可以让用户自己决定终止哪一个）。

确定了基本思路以后，就要找具体办法了。我最初的想法是在数据库建立一张表，存放已登录用户的用户名、物理地址、Session id等信息。当用户登录时，与这张表里面的数据进行匹配，如果发现物理地址与表中的某条记录相同，则表示是同一台客户端上有多个用户再登录，如果发现正在登录的用户的用户名与表中已有记录相同而主机名不同，则表示是一个账号同时在不同的客户端使用。

相信很多一开始遇到这个问题的人都会考虑这种解决办法。但是这种办法有很多问题，最主要的问题有两个：第一是效率，每一次都要从数据库里面取数据进行匹配。第二是用户退出时需要删除表中的记录，而当用户非正常退出时，很难及时监测（后来发现其实有办法监测）。

后来在网上的某个帖子里面看到一位大侠提到用监听器，只是那位大侠说的太含糊，照他说的办法根本无法解决。虽然无法解决，但是提供了一个思路。于是我找了一本书，仔细看了其中关于监听器的部分。解决办法就在其中了！！！

监听器的详细介绍见我的下一篇博文，这里先把解决办法告诉大家：

监听器可以监听Session及其所包含的属性，即Attribute。

所以我们要做的就是：

1、建立一个监听器，实现HttpSessionAttributeListener接口，监听每一个Attribute的增加、编辑、删除事件。监听器中还要建立一个map，将所有的session放入这个map中。

2、在用户登录时将用户名、物理地址、Session id存到Session中去（可以建立一个用户登录地址数据传输对象，我建立了一个UserSessionAdd类，里面包含username，macAdd，sessionId三个属性，用户登录时将这个数据对象初始化，并存入到session中）。

3、每个新会话开启时，在监听器中对Session包含的属性进行判断，如果新增的属性与map中已有session的用户登录地址数据相同，则表示新会话与我们要做的两个限制相冲突。将与之冲突的会话提取出来，销毁掉！

这么说，还是不够清楚，下面看代码：

Web.xml文件：

监听器类的路径，如：com.web.MyListener

用户登录地址数据传输对象：

public class UserSessionAdd {

private String add;

private String sessid;

private String username

public String getUsername(){

return username

}

Public void setUsername(String username){

this.username=username;

}

public String getIp() {

return add;

}

public void setAdd(String add) {

this.add = add;

}

public String getSessid() {

return sessid;

}

public void setSessid(String sessid) {

this.sessid = sessid;

}

用户登录的代码：

···

String userHost = request.getRemoteHost();

String sessionId = request.getSession().getId();

UserSessionAdd usa = new UserSessionAdd();

usa.setUsername(username);

usa.setSessid(sessionId);

usa.setAdd(userHost);

request.getSession().setAttribute(“usa”,usa);

监听器代码：

public class MyListener implements HttpSessionAttributeListener{

Map map = new HashMap();

public void attributeAdded(HttpSessionBindingEvent event) {

String name = event.getName();

if(name.equals("usa")){

UserSessionAdd usa = (UserSessionAdd)event.getValue();

if(map.get(usa.getAdd())!=null){

HttpSession sess = map.get(usa.getAdd());

UserSessionAdd usa1 = (UserSessionAdd)sess.getAttribute("usa");

sess.removeAttribute("usa");

sess.invalidate();

}

map.put(usa.getAdd(), event.getSession());

}

public void attributeRemoved(HttpSessionBindingEvent event) {

String name = event.getName();

if(name.equals("usa")){

UserSessionAdd usa = (UserSessionAdd)event.getValue();

map.remove(usa.getAdd());

}

public void attributeReplaced(HttpSessionBindingEvent event) {

// TODO Auto-generated method stub

````

}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/yutan_313/archive/2010/03/22/5405934.aspx

fly 2010-06-10 10:27 发表评论

防止出现乱码，J2EE项目统一使用UTF-8编码设置方法(转)

fly — Thu, 03 Jun 2010 14:33:00 GMT

1.数据库建立为UTF-8格式
2.项目右键属性为UTF-8格式
3.所有页面申明为UTF-8
4.JDBC URL设为：UTF-8
jdbc:mysql://localhost:3306/company?useUnicode=true&characterEncoding=utf-8
5.数据库Driver选择UTF-8格式
6.Tomcat编码改成UTF-8
在server.xml里面增加URIEncoding="UTF-8"

Xml代码

<Connector port="8080" maxHttpHeaderSize="8192" maxThreads="150" minSpareThreads="25" maxSpareThreads="75" enableLookups="false" redirectPort="8443" acceptCount="100" connectionTimeout="20000" disableUploadTimeout="true" URIEncoding="UTF-8" />

7.加编码过滤器SetCharacterEncodingFilter.java
注意：根据所在包名确定具体使用哪个包

Java代码

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class SetCharacterEncodingFilter implements Filter {
protected String encoding = null;
protected FilterConfig filterConfig = null;
protected boolean ignore = true;
public void init(FilterConfig filterConfig) throws ServletException {
this.filterConfig = filterConfig;
this.encoding = filterConfig.getInitParameter("encoding");
String value = filterConfig.getInitParameter("ignore");
if (value == null)
this.ignore = true;
else if (value.equalsIgnoreCase("true"))
this.ignore = true;
else if (value.equalsIgnoreCase("yes"))
this.ignore = true;
else
this.ignore = false;
}
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
// TODO 自动生成方法存根
if (ignore || (request.getCharacterEncoding() == null)) {
String encoding = selectEncoding(request);
if (encoding != null)
request.setCharacterEncoding(encoding);
}
chain.doFilter(request, response);
}
public void destroy() {
// TODO 自动生成方法存根
this.encoding = null;
this.filterConfig = null;
}
protected String selectEncoding(ServletRequest request) {
return (this.encoding);
}
}

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class SetCharacterEncodingFilter implements Filter {
protected String encoding = null;
protected FilterConfig filterConfig = null;
protected boolean ignore = true;
public void init(FilterConfig filterConfig) throws ServletException {
this.filterConfig = filterConfig;
this.encoding = filterConfig.getInitParameter("encoding");
String value = filterConfig.getInitParameter("ignore");
if (value == null)
this.ignore = true;
else if (value.equalsIgnoreCase("true"))
this.ignore = true;
else if (value.equalsIgnoreCase("yes"))
this.ignore = true;
else
this.ignore = false;
}
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
// TODO 自动生成方法存根
if (ignore || (request.getCharacterEncoding() == null)) {
String encoding = selectEncoding(request);
if (encoding != null)
request.setCharacterEncoding(encoding);
}
chain.doFilter(request, response);
}
public void destroy() {
// TODO 自动生成方法存根
this.encoding = null;
this.filterConfig = null;
}
protected String selectEncoding(ServletRequest request) {
return (this.encoding);
}
}

在web.xml里面映射配置

Xml代码

<filter>
<filter-name>Set Character Encodingfilter-name>
<filter-class>com.yourcompany.util.SetCharacterEncodingFilterfilter-class>
<init-param>
<param-name>encodingparam-name>
<param-value>UTF-8param-value>
init-param>
filter>
<filter-mapping>
<filter-name>Set Character Encodingfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>

fly 2010-06-03 22:33 发表评论

weblogic.xml,web.xml配置文件模板（转）

fly — Sun, 31 Jan 2010 14:42:00 GMT

----------------------------------7.0sp2 weblogic.xml------------------------------------------------------------------

http://www.bea.com/servers/wls700/dtd/weblogic700-web-jar.dtd">


      compileFlags
      -g


      keepgenerated
      true


      encoding
      GBK


      workingDir
      /home/webdev/barcelona/WEB-INF/workingdir/



      /*
      GBK


----------------------------------8.1sp2 weblogic.xml------------------------------------------------------------------

http://www.bea.com/servers/wls810/dtd/weblogic810-web-jar.dtd">


      compileFlags
      -g


      keepgenerated
      true


      encoding
      GBK


      workingDir
      /home/webdev/html/guanli/WEB-INF/workingdir/



      /*
      GBK


guanli

----------------------------------------------web.xml--------------------------------------------------------------

http://java.sun.com/dtd/web-app_2_3.dtd">

bbs_fcb

    bbs.jsp
    index.htm
    index.jsp

http://java.sun.com/dtd/web-app_2_3.dtd">

bbs_huati

    bbs.jsp
    index.htm
    index.jsp

    404
    /404.html

    500
    /500.html

Trackback: http://tb.donews.net/TrackBack.aspx?PostId=882456

fly 2010-01-31 22:42 发表评论

HttpServletRequest getQueryString()（转）

fly — Sun, 31 Jan 2010 06:08:00 GMT

api第一句：Returns the query string that is contained in the request URL after the path，这就说明它只对get方法抛的数据有效。post方法传的参数getQueryString将什么都得不到。

我的总结：

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Enumeration;

import javax.servlet.http.HttpServletRequest;

public class QueryString {
    private StringBuffer query = new StringBuffer();

    public QueryString(String name, String value) {
        encode(name, value);
    }

    public synchronized void add(String name, String value) {
        query.append('&');
        encode(name, value);
    }

    private synchronized void encode(String name, String value) {
        try {
            query.append(URLEncoder.encode(name, "UTF-8"));
            query.append('=');
            value = value.replaceAll(" ", "%20");
            query.append(value);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    public String getQuery() {
        return query.toString();
    }

    public String toString() {
        return getQuery();
    }


    /**
     * 直接接受request
     * 注：request中提供的getQueryString方法只对Get方法才能生效，
     * 在我们不知道方法的情况下最好重写getQueryString
     * @param request
     * @return
     */
    public static String getQueryString(HttpServletRequest request) {
        boolean first = true;
        StringBuffer strbuf = new StringBuffer("");
        Enumeration emParams = request.getParameterNames();
        //do-while
        do {
            if (!emParams.hasMoreElements()) {
                break;
            }

            String sParam = (String) emParams.nextElement();
            String[] sValues = request.getParameterValues(sParam);

            String sValue = "";
            for (int i = 0; i < sValues.length; i++) {
                sValue = sValues[i];
                if (sValue != null && sValue.trim().length() != 0 && first == true) {
                    //第一个参数
                    first = false;
                    strbuf.append(sParam).append("=").append(sValue);
                } else if (sValue != null && sValue.trim().length() != 0 && first == false) {
                    strbuf.append("&").append(sParam).append("=").append(sValue);
                }
            }
        } while (true);

        return strbuf.toString();
    }

    public static void main(String args[]) {
        QueryString qs = new QueryString("parms1", "1");
        qs.add("parms", "2");
        qs.add("parms", "3");

        System.out.println(qs.toString());    //parms1=1&parms=2&parms=3
    }
}

fly 2010-01-31 14:08 发表评论

过滤器过滤特殊符号

fly — Sun, 31 Jan 2010 05:37:00 GMT

首先，列出我用到的参考资料吧：

资料一来自：http://magicgod.javaeye.com/blog/146537

资料二来自：http://blog.sina.com.cn/s/blog_56000153010005iq.html

我就是根据上面的两个资料，写了一个FILTER和一个JAVA 类，具体如下：

FILTER: SpecialCharacterFilter

view plaincopy to clipboardprint?

import java.io.IOException;

import java.util.Enumeration;

import java.util.HashMap;

import javax.servlet.Filter;

import javax.servlet.FilterChain;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

public class SpecialCharacterFilter extends HttpServlet implements Filter {

    protected FilterConfig config;

    public void destroy() {

    }

    public void doFilter(ServletRequest req, ServletResponse res,

            FilterChain chain) throws IOException, ServletException {

        System.out.println("[SpecialCharacterFilter] : doFilter *************");

        HttpServletRequest request = (HttpServletRequest)req;

        HashMap m = new HashMap(request.getParameterMap());

        HashMap mm = new HashMap();

        Enumeration enu = request.getParameterNames();

        if(m.size() > 0 && processParameters(m, enu, mm)) {

            ParameterRequestWrapper wrapRequest = new ParameterRequestWrapper(request, mm);

            chain.doFilter(wrapRequest, res);

        } else {

            chain.doFilter(req, res);

        }

    }

    public void init(FilterConfig arg0) throws ServletException {

        this.config = arg0;

    }

    public boolean processParameters(HashMap m, Enumeration enu, HashMap mm) {

        System.out.println("[SpecialCharacterFilter] : processParameters *************");

        if (m != null && enu != null) {

            while (enu.hasMoreElements()) {

                String key = (String)enu.nextElement();

                String [] values = (String [])m.get(key);

                for(int i = 0; i < values.length; i ++) {

                    if (values[i] != null) {

                        values[i] = values[i].trim();

                        values[i] = values[i].replaceAll("&", "&");

                        values[i] = values[i].replaceAll("<", "<");

                        values[i] = values[i].replaceAll(">", ">");

                        values[i] = values[i].replaceAll("\t", "    ");

                        values[i] = values[i].replaceAll("\r\n", "\n");

                        values[i] = values[i].replaceAll("\n", "
");

                        values[i] = values[i].replaceAll(" ", " ");

                        values[i] = values[i].replaceAll("'", "'");

                        values[i] = values[i].replaceAll("\\\\", "\");

                    }

                }

                mm.put(key, values);

            }

        }

        return true;

    }

}

import java.io.IOException;

import java.util.Enumeration;

import java.util.HashMap;

import javax.servlet.Filter;

import javax.servlet.FilterChain;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

public class SpecialCharacterFilter extends HttpServlet implements Filter {

protected FilterConfig config;

public void destroy() {

}

public void doFilter(ServletRequest req, ServletResponse res,

FilterChain chain) throws IOException, ServletException {

System.out.println("[SpecialCharacterFilter] : doFilter *************");

HttpServletRequest request = (HttpServletRequest)req;

HashMap m = new HashMap(request.getParameterMap());

HashMap mm = new HashMap();

Enumeration enu = request.getParameterNames();

if(m.size() > 0 && processParameters(m, enu, mm)) {

ParameterRequestWrapper wrapRequest = new ParameterRequestWrapper(request, mm);

chain.doFilter(wrapRequest, res);

} else {

chain.doFilter(req, res);

}

public void init(FilterConfig arg0) throws ServletException {

this.config = arg0;

}

public boolean processParameters(HashMap m, Enumeration enu, HashMap mm) {

System.out.println("[SpecialCharacterFilter] : processParameters *************");

if (m != null && enu != null) {

while (enu.hasMoreElements()) {

String key = (String)enu.nextElement();

String [] values = (String [])m.get(key);

for(int i = 0; i < values.length; i ++) {

if (values[i] != null) {

values[i] = values[i].trim();

values[i] = values[i].replaceAll("&", "&");

values[i] = values[i].replaceAll("<", "<");

values[i] = values[i].replaceAll(">", ">");

values[i] = values[i].replaceAll("\t", " ");

values[i] = values[i].replaceAll("\r\n", "\n");

values[i] = values[i].replaceAll("\n", "
");

values[i] = values[i].replaceAll(" ", " ");

values[i] = values[i].replaceAll("'", "'");

values[i] = values[i].replaceAll("\\\\", "\");

}

mm.put(key, values);

}

return true;

}

}
view plaincopy to clipboardprint?
JAVA 类：ParameterRequestWrapper

JAVA 类：ParameterRequestWrapper view plaincopy to clipboardprint?

import java.util.Enumeration;   

  

import java.util.Map;   

  

import java.util.Vector;   

  

  

  

import javax.servlet.http.HttpServletRequest;   

  

import javax.servlet.http.HttpServletRequestWrapper;   

  

  

  

public class ParameterRequestWrapper extends HttpServletRequestWrapper {   

  

  

  

    private Map params;   

  

  

  

    public ParameterRequestWrapper(HttpServletRequest request, Map newParams) {   

  

        super(request);   

  

        this.params = newParams;   

  

    }   

  

  

  

    public Map getParameterMap() {   

  

        return params;   

  

    }   

  

  

  

    public Enumeration getParameterNames() {   

  

        Vector l = new Vector(params.keySet());   

  

        return l.elements();   

  

    }   

  

  

  

    public String[] getParameterValues(String name) {   

  

        Object v = params.get(name);   

  

        if (v == null) {   

  

            return null;   

  

        } else if (v instanceof String[]) {   

  

            return (String[]) v;   

  

        } else if (v instanceof String) {   

  

            return new String[] { (String) v };   

  

        } else {   

  

            return new String[] { v.toString() };   

  

        }   

  

    }   

  

  

  

    public String getParameter(String name) {   

  

        Object v = params.get(name);   

  

        if (v == null) {   

  

            return null;   

  

        } else if (v instanceof String[]) {   

  

            String[] strArr = (String[]) v;   

  

            if (strArr.length > 0) {   

  

                return strArr[0];   

  

            } else {   

  

                return null;   

  

            }   

  

        } else if (v instanceof String) {   

  

            return (String) v;   

  

        } else {   

  

            return v.toString();   

  

        }   

  

    }   

  

}

最后，还是写一下WEB.XML的配置吧：

    

  

        specialCharacterFilter   

  

           

  

            com.fhn.vismp.common.SpecialCharacterFilter   

  

           

  

       

  

  

  

       

  

        specialCharacterFilter   

  

        *.do   

  

       

  

       

  

        specialCharacterFilter   

  

        *.jsp

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/wanchengpeng/archive/2008/07/09/2628926.aspx

fly 2010-01-31 13:37 发表评论

Java过滤器-Filter过滤器的使用

fly — Wed, 13 Jan 2010 15:18:00 GMT

过滤是SERVLET2。3规范新有的功能，目前TOMCAT4，WEBLOGIC7都已支持。它能实现很多以前使用不便或很难实现的功能，在产品体系中，我们可以很好地使用SERVLET过滤，使得各个部件可以在保持系统统一权限控制的前提下，来实现各个独自的个性权限系统。

下面先看下SERVLET过滤是如何工作的，如下图

优点

和传统架构相比，SERVLET过滤的优点如下：

在传统架构中：

每次接受到请求，挂钩式方法就被调用，不论它们是否执行（有时甚至是空的）。
方法的作用域及并发关系（每个方法可能在不同的线程上被调用）不允许在处理相同的请求时简单、高效地共享不同挂钩式方法调用间的变量和信息。

在SERVLET过滤中：

嵌套的方法调用通过一系列过滤器实现，它仅有应用于当前请求的过滤器组成；基于挂钩式调用的传统执行方式需要在处理短句中调用挂钩式例程，即使一个特定短句的处理逻辑不起任何作用。
局部变量在实际的过滤方法返回之前都作保留，并且可用（因为上游过滤器的调用总在堆栈上，等待后续调用的返回）。

过滤的实现

调用链
所有过滤器都服从调用的过滤器链，并通过定义明确的接口得到执行。一个执行过滤器的 Java 类必须执行这一 javax.servlet.Filter 接口。这一接口含有三个过滤器必须执行的方法：

doFilter(ServletRequest, ServletResponse, FilterChain)：这是一个完成过滤行为的方法。这同样是上游过滤器调用的方法。引入的FilterChain对象提供了后续过滤器所要调用的信息。
init(FilterConfig)：这是一个容器所调用的初始化方法。它保证了在第一次doFilter()调用前由容器调用。您能获取在 web.xml 文件中指定的初始化参数。
destroy()：容器在破坏过滤器实例前，doFilter()中的所有活动都被该实例终止后，调用该方法。

嵌套调用在 doFilter() 方法执行中发生。除非您建立一个过滤器明确阻止所有后续处理（通过其它过滤器及资源处理器），否则过滤器一定会在 doFilter 方法中作以下的调用：

FilterChain.doFilter(request, response);

安装过滤器：定义与映射
容器通过 Web 应用程序中

的配置描述符 web.xml 文件了解过滤器。有两个新的标记与过滤器相关：和。应该指定它们为 web.xml 文件内标记的子标记。

过滤器定义的元素
标记是一个过滤器定义，它必定有一个和子元素。子元素给出了一个与过滤器实例相关的、基于文本的名字。指定了由容器载入的实际类。您能随意地包含一个子元素为过滤器实例提供初始化参数。例如，下面的过滤器定义指定了一个叫做 IE Filter 的过滤器：

一、使浏览器不缓存页面的过滤器
import javax.servlet.*;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
* 用于的使 Browser 不缓存页面的过滤器
*/
public class ForceNoCacheFilter implements Filter {

public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException
{
    ((HttpServletResponse) response).setHeader("Cache-Control","no-cache");
    ((HttpServletResponse) response).setHeader("Pragma","no-cache");
    ((HttpServletResponse) response).setDateHeader ("Expires", -1);
    filterChain.doFilter(request, response);
}

public void destroy()
{
}
      public void init(FilterConfig filterConfig) throws ServletException
{
}
}
二、检测用户是否登陆的过滤器
1.写个过滤器
import javax.servlet.Filter;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.FilterChain;

import java.io.IOException;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpSession;

import javax.servlet.http.HttpServletResponse;

public class RightFilter

implements Filter {

public void init(FilterConfig filterConfig) throws ServletException {

}

public void doFilter(ServletRequest request, ServletResponse response,

FilterChain chain) throws IOException, ServletException {

HttpServletRequest req = (HttpServletRequest) request;

HttpServletResponse res = (HttpServletResponse) response;

HttpSession session = req.getSession(true);

//从session里取的用户名信息

String username = (String) session.getAttribute("username");

//判断如果没有取到用户信息,就跳转到登陆页面

if (username == null || "".equals(username)) {

//跳转到登陆页面

res.sendRedirect("http://"+req.getHeader("Host")+"/login.jsp");

}

else {

//已经登陆,继续此次请求

chain.doFilter(request,response);

}

public void destroy() {

}

2.然后在web.xml里配置需要登陆权限验证的JSP文件:
a.如果是某个具体的JSP文件(如a.jsp)需要登陆验证

<web-app>

  <filter>
    <filter-name>rightfilter-name>
    <filter-class>com.taihuatalk.taihua.common.RightFilterfilter-class>
  filter>

  <filter-mapping>
    <filter-name>rightfilter-name>
    <url-pattern>/a.jspurl-pattern>
  filter-mapping>

web-app>

b.如果是某一个目录(如a/目录)整个目录下的文件都需要登陆验证:

三、字符编码的过滤器
import javax.servlet.*;
import java.io.IOException;

/**
* 用于设置 HTTP 请求字符编码的过滤器，通过过滤器参数encoding指明使用何种字符编码,用于处理Html Form请求参数的中文问题
*/
public class CharacterEncodingFilter
implements Filter
{
protected FilterConfig filterConfig = null;
protected String encoding = "";

public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException
{
          if(encoding != null)
           servletRequest.setCharacterEncoding(encoding);
          filterChain.doFilter(servletRequest, servletResponse);
}

public void destroy()
{
    filterConfig = null;
    encoding = null;
}

      public void init(FilterConfig filterConfig) throws ServletException
{
           this.filterConfig = filterConfig;
          this.encoding = filterConfig.getInitParameter("encoding");

}
}

2、在web.xml中做一些设置

     code
     CharacterEncodingFilter

     encoding
     GBK


     code
     /*

fly 2010-01-13 23:18 发表评论

在TOMCAT下配置工程的默认访问(转)

fly — Wed, 02 Dec 2009 14:56:00 GMT

对工程的部署一般是将工程的压缩文件放在tomcat安装目录的webapps下，访问时通过键入：http://localhost:8080/xx(假定为本机访问，xx是部署时的应用工程的访问名字）。而如果直接键入：http://localhost:8080出来的将是tomcat自带的欢迎页面，如何让键入http://localhost:8080出来的是自己的应用工程的页面呢？在这里希望和大家一起探讨一下。

在Tomcat默认安装后，tomcat的主目录是webapps/root目录，所以如果想改变tomcat的主目录的话可以如下所做，所以第一种方法是：
打开C:/Tomcat/conf/server.xml，在之间加入代码：
这样重新启动tomcat，我们的主目录就被设置为dolphin这个项目了。

第二种方法是：
将tomcat安装目录下的ROOT下的所有文件全部删除，然后将工程的解压后的文件全部拷进去。

第三种方法是：
Tomcat5.0以下版本在C:/Tomcat/conf/Catalina/localhost目录下会自动生成了一个ROOT.Xml，但是5.0以上版本不再生成此文件，所以可以新建个ROOT.xml,在里面加入如下代码：

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/zhangguo117/archive/2008/04/14/2290515.aspx

fly 2009-12-02 22:56 发表评论

浅谈JSP页面跳转与请求转发(转)

fly — Sun, 09 Aug 2009 14:39:00 GMT

request之请求转发
a0.jsp
<%@ page contentType="text/html; charset=GBK" %>
<html>
<head>
<title>
请求参数输入页面
title>
head>
<body bgcolor="#ffffff">
<h1>
请求参数输入页面
h1>
<form action="a1.jsp" method="POST">
  <table border="1">
    <tr>
      <td>用户名:td>
      <td><input  type="text" name="name"/>td>
    tr>
    <tr>
      <td>性别:td>
      <td>
        <input  type="radio" name="sex" value="男"/>男
        <input  type="radio" name="sex" value="女"/>女
      td>
    tr>
    <tr>
      <td>兴趣爱好:td>
      <td>
        <input  type="checkbox" name="interest" value="上网"/>上网
        <input  type="checkbox" name="interest" value="旅游"/>旅游
        <input  type="checkbox" name="interest" value="阅读"/>阅读
      td>
    tr>
  table>
  <input  type="submit" name="submit" value="提交"/>
form>
body>
html>
a1.jsp的code如下：

<%@ page contentType="text/html; charset=GBK"%>
<html>
<head>
<title>接收请求参数title>
head>
<body bgcolor="#ffffff">
<h1>接收客户端请求数据h1>
<%
    request.setCharacterEncoding("GBK");
    String name = request.getParameter("name");
    String sex = request.getParameter("sex");
    String[] interest = request.getParameterValues("interest");
%>
<table border="1">
    <tr>
        <td>用户名:td>
        <td><%=name%>td>
    tr>
    <tr>
        <td>性别:td>
        <td><%=sex%>td>
    tr>
    <tr>
        <td>兴趣爱好:td>
        <td>
        <%
                for (int i = 0; i < interest.length; i++) {
                out.print(interest[i]);
                out.print(",");
            }
        %>
        td>
    tr>
table>
<%
    RequestDispatcher rd=request.getRequestDispatcher("ra3.jsp");
    rd.forward(request,response);
%>
body>
html>

a2.jsp的code如下：

<%@ page contentType="text/html; charset=GBK" %>
<html>
<head>
<title>
dispatcher转发结果显示页面
title>
head>
<body bgcolor="#ffffff">
<h1>
dispatcher转发结果显示页面
h1>
name参数的值是:<%=request.getParameter("name")%>
body>
html>

JSP页面跳转与请求转发收藏

1、response.sendRedirect(url)

是指请求重定向，原来页面的参数在这里是得不到的，即用request.getParameter("param")返回的是null

2、forward请求转发，指将原页面的request,response对象传入新的页面，因此这新旧页面拥有相同的 request,response对象。这样request.getParameter("param")就可以得到相应的值

3、区分ServletContext.getRequestDispatcher与 ServletRequest.getRequestDispatcher

ServletContext.getRequestDispatcher 路径必须是相对上下文的绝对路径

ServletRequest.getRequestDispatcher 可以是相对也可以是绝对

4、注意的一点是：使用forward转发后在浏览器上看到的地址栏显示的是转发前的还不是转发后的。如由test.jsp向good.jsp转发了，那么地址栏显示的是test.jsp.这是因为forward是在服务器端进行的，浏览器根本不知道，而重定向是在客户端进行的，所以使用response.sentRedirect("red.jsp")会直接定向到red.jsp。由此想到index.jsp如果请求的是servlet那么在servlet中进行forawrd转发到另一个red.jsp页面，但当查看结果时，在地址栏显示的将只是servlet的名称而不是red.jsp，如果你想知道最终看到的页面的名称那只有查代码了。

reference it:

服务器端进行转向的4种方法：

1. ServletContext的getRequestDispatcher()

2. ServletContext的getNamedDispatcher()

3. ServletRequest的getRequestDispatcher()

4. ServletResponse的sendRedirect()进行转向。

1.2.3 => forward() 4. sendRedirect()

使用forward方法，因为这些这样比较高效。只有在forward方法不能使用时（比如要转向到一个非本web应用），再使用ServletResponse的sendRedirect()方法。

与 sendRedirect 方法的比较

虽然与 sendRedirect 方法，都可以将浏览器浏览的网页，重导至另一个网页，但是两者在原理上是不太相同。

a. : 动作是利用伺服端，将资料输出至缓冲区的机制，在前一个网页尚未输出到客户端前，取消资料的输出，然后输出另一个网页的资料，达到重导浏览器的效果。

优点: 两网页间可以分享 request 对象内的变量。

b. sendRedirect : 动作是透过 HTTP 协议的 Header ，对浏览器下达重导指令，因此，不牵涉到服务器端缓冲区的问题。

不过由于 sendRedirect 方法作用于客户端，所以重导前后网页无法分享存在于 request 对象内的变量。
Solution: response.sendRedirect(“sendRedirect.htm?name=sparkwu&E-Mail=spark.wu@cobra-tech.com”)

fly 2009-08-09 22:39 发表评论

weblogic: TokenStreamIOException的解决方法(转)

fly — Fri, 27 Mar 2009 02:14:00 GMT

在weblogic有时会有TokenStreamIOException（unix或linux系统）异常出现：

Root cause of ServletException.

weblogic.utils.ParsingException: nested TokenStreamException: antlr.TokenStreamIOException

at weblogic.servlet.jsp.JspLexer.parse(JspLexer.java(Compiled Code))

at weblogic.servlet.jsp.JspParser.doit(JspParser.java:106)

at weblogic.servlet.jsp.JspParser.parse(JspParser.java:234)

at weblogic.servlet.jsp.Jsp2Java.outputs(Jsp2Java.java:125)

at weblogic.utils.compiler.CodeGenerator.generate(CodeGenerator.java:258)

at weblogic.servlet.jsp.JspStub.compilePage(JspStub.java:388)

at weblogic.servlet.jsp.JspStub.prepareServlet(JspStub.java:238)

at weblogic.servlet.jsp.JspStub.prepareServlet(JspStub.java:188)

at weblogic.servlet.internal.ServletStubImpl.getServlet(ServletStubImpl.java(Compiled Code))

at weblogic.servlet.internal.ServletStubImpl.invokeServlet(ServletStubImpl.java(Compiled Code))

at weblogic.servlet.internal.RequestDispatcherImpl.forward(RequestDispatcherImpl.java:322)

at edu.yale.its.tp.cas.servlet.Login.doGet(Login.java:188)

at javax.servlet.http.HttpServlet.service(HttpServlet.java:740)

at javax.servlet.http.HttpServlet.service(HttpServlet.java(Compiled Code))

at weblogic.servlet.internal.ServletStubImpl$ServletInvocationAction.run(ServletStubImpl.java(Inlined Compiled Code))

at weblogic.servlet.internal.ServletStubImpl.invokeServlet(ServletStubImpl.java(Compiled Code))

at weblogic.servlet.internal.ServletStubImpl.invokeServlet(ServletStubImpl.java(Inlined Compiled Code))

at weblogic.servlet.internal.WebAppServletContext$ServletInvocationAction.run(WebAppServletContext.java(Compiled Code))

at weblogic.security.acl.internal.AuthenticatedSubject.doAs(AuthenticatedSubject.java(Compiled Code))

at weblogic.security.service.SecurityManager.runAs(SecurityManager.java(Inlined Compiled Code))

at weblogic.servlet.internal.WebAppServletContext.invokeServlet(WebAppServletContext.java(Compiled Code))

at weblogic.servlet.internal.ServletRequestImpl.execute(ServletRequestImpl.java(Compiled Code))

at weblogic.kernel.ExecuteThread.execute(ExecuteThread.java(Compiled Code))

at weblogic.kernel.ExecuteThread.run(ExecuteThread.java:178)

原因：中文编码问题

解决：在web.xml里加上过滤:

<filter-name>Set Character Encodingfilter-name>

<filter-class>edu.yale.its.tp.cas.SetCharacterEncodingFilterfilter-class>

<init-param>

<param-name>encodingparam-name>

<param-value>GB2312param-value>

init-param>

filter>

<filter-mapping>

<filter-name>Set Character Encodingfilter-name>

<url-pattern>/*url-pattern>

filter-mapping>

--------------//SetCharacterEncodingFilter类是中文过滤类

package edu.yale.its.tp.cas;

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

/**
* Example filter that sets the character encoding to be used in parsing the

* incoming request, either unconditionally or only if the client did not

* specify a character encoding.

* 如果原来没有设置request的编码，就设置；否则保持不变

public class SetCharacterEncodingFilter
implements Filter {

protected String encoding = null;

protected FilterConfig filterConfig = null;

protected boolean ignore = true;

/**
* Take this filter out of service.

public void destroy() {

this.encoding = null;

this.filterConfig = null;

}

/**
* Select and set (if specified) the character encoding to be used to

* interpret request parameters for this request.

public void doFilter(ServletRequest request, ServletResponse response,

FilterChain chain)

throws IOException, ServletException {

// Conditionally select and set the character encoding to be used

if (ignore || (request.getCharacterEncoding() == null)) {

String encoding = selectEncoding(request);

if (encoding != null) {

request.setCharacterEncoding(encoding); //设置request编码的地方

}else
{

request.setCharacterEncoding("gb2312"); //强制设置编码
}

}

// Pass control on to the next filter

// 传递控制到下一个过滤器

chain.doFilter(request, response);

}

/**
* Place this filter into service.

* 从web-app的web.xml文件中读取初始参数的值

public void init(FilterConfig filterConfig) throws ServletException {

this.filterConfig = filterConfig;

this.encoding = filterConfig.getInitParameter("encoding");

String value = filterConfig.getInitParameter("ignore");

if (value == null) {

this.ignore = true;
}

else if (value.equalsIgnoreCase("true")) {

this.ignore = true;
}

else if (value.equalsIgnoreCase("yes")) {

this.ignore = true;
}

else {

this.ignore = false;
}

}

/**
* Select an appropriate character encoding to be used, based on the

* characteristics of the current request and/or filter initialization

* parameters. If no character encoding should be set, return

* null.

* 选择request原来的编码

protected String selectEncoding(ServletRequest request) {

return (this.encoding);

}

fly 2009-03-27 10:14 发表评论

JDBC对数据库的事务操作- -(转)

fly — Mon, 22 Sep 2008 04:07:00 GMT

JDBC对数据库的事务操作- -

1．概述：

在jdbc的数据库操作中，一项事务是由一条或是多条表达式所组成的一个不可分割的工作单元。我们通过提交commit()或是回滚rollback（）来结束事务的操作。关于事务操作的方法都位于接口java.sql.Connection中。

2．特点：
★ 在jdbc中，事务操作缺省是自动提交。也就是说，一条对数据库的更新表达式代表一项事务操作，操作成功后，系统将自动调用commit()来提交，否则将调用rollback()来回滚。
★ 在jdbc 中，可以通过调用setAutoCommit(false)来禁止自动提交。之后就可以把多个数据库操作的表达式作为一个事务，在操作完成后调用 commit()来进行整体提交，倘若其中一个表达式操作失败，都不会执行到commit()，并且将产生响应的异常；此时就可以在异常捕获时调用 rollback()进行回滚。这样做可以保持多次更新操作后，相关数据的一致性，示例如下：

try {

conn =

DriverManager.getConnection

("jdbc:oracle:thin:@host:1521:SID","username","userpwd";

conn.setAutoCommit(false);//禁止自动提交，设置回滚点

stmt = conn.createStatement();

stmt.executeUpdate(“alter table …”); //数据库更新操作1

stmt.executeUpdate(“insert into table …”); //数据库更新操作2

conn.commit(); //事务提交

}catch(Exception ex) {

ex.printStackTrace();

try {

conn.rollback(); //操作不成功则回滚

}catch(Exception e) {

e.printStackTrace();

}

★ jdbc API支持事务对数据库的加锁，并且提供了5种操作支持，2种加锁密度。

５种支持：

static int TRANSACTION_NONE = 0;

→禁止事务操作和加锁。

static int TRANSACTION_READ_UNCOMMITTED = 1;

→允许脏数据读写(dirty reads)、重复读写(repeatable reads)和影象读写（phntom

reads）

static int TRANSACTION_READ_COMMITTED = 2;

→禁止脏数据读写(dirty reads)，允许重复读写(repeatable reads)和影象读写（phntom reads）

static int TRANSACTION_REPEATABLE_READ = 4;

→禁止脏数据读写(dirty reads)和重复读写(repeatable reads)，允许影象读写（phntom reads）

static int TRANSACTION_SERIALIZABLE = 8;

→禁止脏数据读写(dirty reads)、重复读写(repeatable reads)和允许影象读写(phntom reads)

2种密度：

最后一项为表加锁，其余3～4项为行加锁。

脏数据读写(dirty reads):当一个事务修改了某一数据行的值而未提交时，另一事务读取了此行值。倘若前一事务发生了回滚，则后一事务将得到一个无效的值（脏数据）。

重复读写(repeatable reads):当一个事务在读取某一数据行时，另一事务同时在修改此数据行。则前一事务在重复读取此行时将得到一个不一致的值。

影象读写(phantomreads):当一个事务在某一表中进行数据查询时，另一事务恰好插入了满足了查询条件的数据行。则前一事务在重复读取满足条件的值时，将得到一个额外的“影象“值。

Jdbc根据数据库提供的缺省值来设置事务支持及其加锁，当然，也可以手工设置：

setTransactionIsolation（TRANSACTION_READ_UNCOMMITTED）;

可以查看数据库的当前设置：

getTransactionIsolation()

需要注意的是，在进行受动设置时，数据库及其驱动程序必须得支持相应的事务操作操作才行。

上述设置随着值的增加，其事务的独立性增加，更能有效的防止事务操作之间的冲突；同时也增加了加锁的开销，降低了用户之间访问数据库的并发性，程序的运行效率也回随之降低。因此得平衡程序运行效率和数据一致性之间的冲突。一般来说，对于只涉及到数据库的查询操作时，可以采用TRANSACTION_READ_UNCOMMITTED 方式；对于数据查询远多于更新的操作，可以采用TRANSACTION_READ_COMMITTED方式；对于更新操作较多的，可以采用 TRANSACTION_REPEATABLE_READ；在数据一致性要求更高的场合再考虑最后一项，由于涉及到表加锁，因此会对程序运行效率产生较大的影响。

另外，在oracle中数据库驱动对事务处理的缺省值是TRANSACTION_NONE，即不支持事务操作，所以需要在程序中手动进行设置。

3．小结

jdbc提供的对数据库事务操作的支持是比较完整的，通过事务操作可以提高程序的运行效率，保持数据的一致性。

提示4：正确地使用事务

在创建可靠的系统时，正确地使用事务是非常关键的：如果登记一项销售额涉及到改变三个独立的表，那么数据库应该在这三个表中反映出这些变化或者所有表中都不反映。在Oracle中，通过执行一系列SQL 语句来处理事务，然后把它们“提交”到数据库，或者“回滚”到事务开始。高效的事务设计通常是系统成功部署的关键。

核心的JDBC包支持4种“transaction isolation modes（事务隔离模式）”，允许程序指定它们希望的事务行为。Oracle支持它们中的两种：默认的 “read committed(读提交数据)” 和更安全的“serializable(可串行化)”模式。“read committed” 模式支持不可重复读（non-repeatable read），在这种情况下，一个事务所做的修改对查询中的另一个事务是可见的；还支持错误读取（phantom read），这种情况下，被其他事务所做的修改对于运行的查询是可见的。依赖于在多个操作中数据库的完全一致视图的应用程序应该选择损失一定的性能,使用更严格的“serializable(可串行化)”设置。

JDBC连接在默认的情况下也在“auto-commit”（自动提交）模式下运行，这意味着每个语句一执行完就立即提交给数据库后。这种模式有一些优点，开发人员不需要在每次更新或插入操作之后调用commit() 方法。它还可以确保最新的数据库视图。另一方面，关闭自动提交将可以稍微提高一点性能，并且将允许多语句事务。

在servlet环境中使用JDBC事务时，与使用连接共享时应用了许多相同的规则。在代码的结尾处或者回滚或者提交事务是非常重要的。确保这一点的最好方法是使用try...catch...finally 块。不完整的事务可能产生不可预见的后果，包括从不完整或不一致的数据库视图到当事务一个接一个排队等候访问被锁定的资源时使整个应用程序被锁定的种种情况。

下面的例子说明如何使用JDBC事务:

Connection con = null;

try {

ds = (DataSource)myContext.lookup("jdbc/oracleServer");

pooledCon = ds.getConnection("scott", "tiger");

pooledCon.setAutoCommit(false);

pooledCon.setTransactionIsolation(

Connection.TRANSACTION_SERIALIZABLE);

// ..

pooledCon.commit();

} catch (Exception ignored) {

try { pooledCon.rollback(); } catch (SQLException ig) {}

} finally {

if(pooledCon != null) {

pooledCon.setAutoCommit(true);

pooledCon.close();

}

连接池中得到的每一个连接是极为重要的。

尽管常规事务很有吸引力，但无论你使用哪种连接管理模型，都绝不应该将它们推广应用到对服务器的多个请求（一个或更多servlet的多个调用）。用户决不应该在一个事务没有完成时就发出第二个请求。需要跨多个对象或多个请求中分布事务的应用程序应该考虑其他可选的体系结构。举例来说，同Java事务处理API (JTA)一起的JDBC 2.0可选包，使与完善的事务处理服务器的集成成为可能。

如果你正在运行Oracle9i第2版，你将可以获取JDBC 3.0中引入的一些新的事务特性。这些特性中最重要的是事务存储点（Transaction Savepoint），它允许你将事务回滚到某一特定点,而不是要么全部回滚、要么全不回滚。

public void createA(Connection conn,A a){
int flag=0;
if(conn==null){
flag=1;
conn = getConnection();
}
try{
{do update}
if(flag==1){
conn.commit();
}
} catch(Exception e){
if(flag==1){
conn.rollback();
}
throw e;
} finally{
if(flag==1){
conn.close();
}
}
}

public void createB(B b){
Connection conn = getConnection();
{create b}
try{
createA(conn,a);
conn.commit();
} catch(Exception e){
conn.rollback();
}

fly 2008-09-22 12:07 发表评论

Web应用中重复提交的问题的三种解决方案

fly — Mon, 07 Jul 2008 06:13:00 GMT

前两种是利用javascript,后面一种是在使用Struts的情况下的参考实现

1 javascript ，设置一个变量，只允许提交一次。


    var checkSubmitFlg = false;
    function checkSubmit() {
        if (checkSubmitFlg == true) {
        return false;
        }
        checkSubmitFlg = true;
        return true;
        }
        document.ondblclick = function docondblclick()
        {
        window.event.returnValue = false;
        }
        document.onclick = function doconclick() {
        if (checkSubmitFlg) {
        window.event.returnValue = false;
        }
    }

2 还是javascript，将提交按钮或者image置为disable

           onsubmit="getElById('submitInput').disabled = true; return true;">


3 利用struts的同步令牌机制

利用同步令牌（Token）机制来解决Web应用中重复提交的问题，Struts也给出了一个参考实现。

基本原理：

服务器端在处理到达的请求之前，会将请求中包含的令牌值与保存在当前用户会话中的令牌值进行比较，
看是否匹配。在处理完该请求后，且在答复发送给客户端之前，将会产生一个新的令牌，该令牌除传给
客户端以外，也会将用户会话中保存的旧的令牌进行替换。这样如果用户回退到刚才的提交页面并再次
提交的话，客户端传过来的令牌就和服务器端的令牌不一致，从而有效地防止了重复提交的发生。

    if (isTokenValid(request, true))
    {    // your code here
        return mapping.findForward("success");
    } else
    {
        saveToken(request);    return mapping.findForward("submitagain");
    }

Struts根据用户会话ID和当前系统时间来生成一个唯一（对于每个会话）令牌的，具体实现可以参考
TokenProcessor类中的generateToken()方法。

1. //验证事务控制令牌,会自动根据session中标识生成一个隐含input代表令牌，防止两次提交
2. 在action中：

       //       if (!isTokenValid(request))           errors.add(ActionErrors.GLOBAL_ERROR,                      new ActionError("error.transaction.token"));       resetToken(request); //删除session中的令牌

3. action有这样的一个方法生成令牌

   protected String generateToken(HttpServletRequest request)
    {       HttpSession session = request.getSession();
    try {
        byte id[] = session.getId().getBytes();
        byte now[] =new Long(System.currentTimeMillis()).toString().getBytes();                   MessageDigest md = MessageDigest.getInstance("MD5");
        md.update(id);
        md.update(now);
        return (toHex(md.digest()));
        } catch (IllegalStateException e)
        {
               return (null);
        } catch (NoSuchAlgorithmException e)
        {
           return (null);
        }
        }
转自网友

fly 2008-07-07 14:13 发表评论

关于Tomcat 5.5.XX数据源配置出现连接问题的解决- -

fly — Fri, 04 Jul 2008 06:31:00 GMT

关于Tomcat 5.5.XX数据源配置出现连接问题的解决
错误信息：Cannot create JDBC driver of class '' for connect URL 'null'

当我们用Tomcat5.0.XX时，以Oracle为例，一般我们的配置如下，但直接移到5.5.XX时就会发生错误


      factory
      org.apache.commons.dbcp.BasicDataSourceFactory


      password
      password


      url
      jdbc:oracle:thin:@localhost:1521:SID


      driverClassName
      oracle.jdbc.driver.OracleDriver


      username
      username

当要移植到Tomcat5.5.XX时，配置应当修改一下，如下所示：
    name="jdbc/XXX"
    type="javax.sql.DataSource"
    password="password"
    driverClassName="oracle.jdbc.driver.OracleDriver"
    maxIdle="2"
    maxWait="5000"
    username="username"
    url="jdbc:oracle:thin:@localhost:1521:SID"
    maxActive="4"/>

相应的参数请进行相应的改动，以上只是解决的示例。
转自网友。

fly 2008-07-04 14:31 发表评论

有关乱码的处理(转)

fly — Mon, 13 Aug 2007 11:16:00 GMT

　　为什么说乱码是中国程序员无法避免的话题呢？这个首先要从编码机制上说起，大家都是中文和英文的编码格式不是一样，解码也是不一样的！如果中国的程序员不会遇到乱码，那么只有使用汉语编程。汉语编程是怎么回事我也不大清楚，应该是前年吧，我一朋友给我介绍汉语编程，怎么不错不错？当时因为学习忙没去关注这个，等我闲了，那个朋友不弄这个，问他他也不说不大清楚，最后自己对这个学习也不了了之了。

今天我写这个不是讲解中英文之间的差距，解码等，我是将我在这几年工作遇到各种各样的乱码的解决方法，总结一样，也希望大家能把自己晕倒解决乱码的方法都说出来，咱们弄一个解决乱码的“葵花宝典”。

　　对于Java由于默认的编码方式是 UNICODE,所以用中文也易出问题,常见的解决是
String s2 = new String(s1.getBytes(“ISO-8859-1”),”GBK”);

　　1、utf8解决JSP中文乱码问题

　　一般说来在每个页面的开始处，加入：

＜%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%＞

＜%
request.setCharacterEncoding("UTF-8");
%＞

　　charset=UTF-8 的作用是指定JSP向客户端输出的编码方式为“UTF-8”

　　pageEncoding="UTF-8" 为了让JSP引擎能正确地解码含有中文字符的JSP页面，这在LINUX中很有效

　　request.setCharacterEncoding("UTF-8"); 是对请求进行了中文编码

　　有时，这样仍不能解决问题，还需要这样处理一下：

String msg = request.getParameter("message");
String str=new String(msg.getBytes("ISO-8859-1"),"UTF-8");
out.println(st);

　　2、Tomcat 5.5 中文乱码

　　只要把%TOMCAT安装目录%/ webapps\servlets-examples\WEB-INF\classes\filters\SetCharacterEncodingFilter.class文件拷到你的webapp目录/filters下，如果没有filters目录，就创建一个。

　 2)在你的web.xml里加入如下几行：

＜filter＞
＜filter-name＞Set Character Encoding＜/filter-name＞
＜filter-class＞filters.SetCharacterEncodingFilter＜/filter-class＞
＜init-param＞
＜param-name＞encoding＜/param-name＞
＜param-value＞GBK＜/param-value＞
＜/init-param＞
＜/filter＞
＜filter-mapping＞
＜filter-name＞Set Character Encoding＜/filter-name＞
＜url-pattern＞/*＜/url-pattern＞
＜/filter-mapping＞

　 3)完成.

　 2 get方式的解决办法

　 1) 打开tomcat的server.xml文件，找到区块，加入如下一行：

URIEncoding=”GBK”

　完整的应如下：
　
＜Connector
port="80" maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
debug="0" connectionTimeout="20000"
disableUploadTimeout="true"
URIEncoding="GBK"
/＞

　2)重启tomcat,一切OK。

　　3、xmlHttpRequest中文问题

　　页面jsp用的GBK编码

＜%@ page contentType="text/html; charset=GBK"%＞

　　javascript部分

function addFracasReport() {
var url="controler?actionId=0_06_03_01&actionFlag=0010";
var urlmsg="&reportId="+fracasReport1.textReportId.value; //故障报告表编号

var xmlHttp=Common.createXMLHttpRequest();
xmlHttp.onreadystatechange = Common.getReadyStateHandler(xmlHttp, eval("turnAnalyPage"));
xmlHttp.open("POST",url,true);
xmlHttp.setRequestHeader( " Content-Type " , " application/x-www-form-urlencoded);
xmlHttp.send(urlmsg);

}

　　后台java中获得的reportId是乱码，不知道该怎么转，主要是不知道xmlHttp.send(urlmsg); 以后是什么编码？在后面用java来转，试了几种，都没有成功，其中有：

public static String UTF_8ToGBK(String str) {
try {
return new String(str.getBytes("UTF-8"), "GBK");
} catch (Exception ex) {
return null;
}
}

public static String UTF8ToGBK(String str) {
try {
return new String(str.getBytes("UTF-16BE"), "GBK");
} catch (Exception ex) {
return null;
}
}

public static String GBK(String str) {
try {
return new String(str.getBytes("GBK"),"GBK");
} catch (Exception ex) {
return null;
}
}
public static String getStr(String str) {
try {
String temp_p = str;
String temp = new String(temp_p.getBytes("ISO8859_1"), "GBK");
temp = sqlStrchop(temp);
return temp;
} catch (Exception e) {
return null;
}
}

　　4、JDBC ODBC Bridge的Bug及其解决方法

　　在编写一数据库管理程序时，发现JDBC-ODBC Bridge存在不易发现的Bug。在向数据表插入数据时，如果为英文字符，存储内容完全正确，如果存入中文字符，部分数据库只能存储前七八个中文字符，其他内容被截去，导致存储内容的不完整（有些数据库不存在这个问题，如Sybase SQL Anywhere 5.0。JDBC-ODBC Bridge还存在无法建表的Bug）。

　　对于广大需要存储中文信息的Java程序员来说，这可是一个不好的消息。要么改用其他语言编程，要么选择其他价格昂贵的数据库产品。“一次编写，到处运行”的目标，也大打折扣。能不能采用变通的方法，将中文信息进行处理后再存储来解决这个问题呢？答案是肯定的。

　　解决问题的具体思路、方法

　　Java采用Unicode码编码方式，中英文字符均采用16bit存储。既然存储英文信息是正确的，根据一定规则，将中文信息转换成英文信息后存储，自然不会出现截尾现象。读取信息时再进行逆向操作，将英文信息还原成中文信息即可。由GB2312编码规则可知，汉字一般为二个高位为1的ASCII码，在转换时将一个汉字的二个高位1去掉，还原时再将二个高位1加上。为了处理含有英文字符的中文字串，对英文字符则需要加上一个Byte 0标记。以下提供的两个公用静态方法，可加入任何一个类中使用。

　　将中英文字串转换成纯英文字串

　　public static String toTureAsciiStr(String str){

　　StringBuffer sb = new StringBuffer();

　　byte[] bt = str.getBytes();

　　for(int i =0 ; i〈bt.length; i++){

　　if(bt[i]〈0){

　　//是汉字去高位1

　　sb.append((char)(bt[i]&&0x7f));

　　 }else{//是英文字符补0作记录

　　sb.append((char)0);

　　sb.append((char)bt[i]);

　　 }

　　 }

　　return sb.toString();

　　}

　　将经转换的字串还原

　　public static String unToTrueAsciiStr(String str){

　　 byte[] bt = str.getBytes();

　　 int i,l=0,length = bt.length,j=0;

　　 for(i = 0; i〈length; i++){

　　 if(bt[i] == 0){

　　 l++;

　　 }

　　 }

　　 byte []bt2 = new byte[length-l];

　　 for(i =0 ; i〈length; i++){

　　 if(bt[i] == 0){

　　 i++;

　　 bt2[j] = bt[i];

　　 }else{

　　 bt2[j] = (byte)(bt[i]|0x80);

　　 }

　　 j++;

　　 }

　　String tt = new String(bt2);

　　return tt;

　　}

　　上例在实际编程中效果很好，只是存储的中文信息需要经过同样处理，才能被其他系统使用。而且如果中文字串出现英文字符，实际上增加了额外的存储空间。

　　5、Solaris下Servlet编程的中文问题及解决办法

　　在使用Java开发Internet上的一个应用系统时，发现在Windows下调试完全正常的Servlet，上传到Solaris 服务器上，运行却出现故障——返回的网页不能显示中文，应为中文的信息全为乱码；用中文信息做关键字，不能正确检索数据库。后来采用加入检查代码等方法探知故障原因如下：

　　显示乱码主要是因为通过类 HttpServletResponse提供的方法setContentType 无法改变返回给客户的数据的编码方式，正确的编码方式应为GB2312或者GBK，而事实上为缺省的ISO8859-1。无法检索中文信息则是因为，客户提交的中文信息经浏览器编码到达服务器后，Servlet无法将其正确解码。

　　举例说明显示乱码解决方法

　　Servlet 一般通常做法如下：

　　public class ZldTestServlet extends HttpServlet {

　　public void doGet (HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException{

　　//在使用 Writer向浏览器返回数据前，设置 content-type header ，在这里设置相应的字符集gb2312

　　response.setContentType("text/html; charset=gb2312");

　　PrintWriter out = response.getWriter(); //*

　　// 正式返回数据

　　out.println("〈html〉〈head〉〈title〉Servlet test〈/title〉〈/head〉" );

　　out.println("这是一个测试页！");

　　out.println("〈/body〉〈/html〉");

　　out.close();

　　}

　　 ...

　　}

　　解决页面显示乱码问题，需将*处代码换成如下内容：

　　PrintWriter out = new PrintWriter(new OutputStreamWriter(response.getOutputStream(),"gb2312"));

　　Solaris中文信息检索问题的解决
　　浏览器利用表单向服务器提交信息时，一般采用x-www-form-urlencoded 的MIME格式对数据进行编码。如果使用get方法，参数名称和参数值经编码后附加在URL后，在Java中称作查询串（query string）。

　　在Servlet程序中，如果采用ServletRequest的方法getParameter取得参数值，在Solaris环境下，对汉字却不能正确解码。因而无法正确检索数据库。

　　在Java 1.2的包——java.net中提供了URLEncode和URLDecode类。类URLEncode提供了按x-www-form-urlencoded格式对给定串进行转换的方法。类URLEncode则提供了逆方法。

　　6、Common Mail乱码问题

　　common mail是一个小而方便的mail包，他实现了对Java Mail的封装，使用起来十分的方便，但是我在使用他的时候发现，使用纯文本的内容发送，结果是乱码，代码如下：

public class TestCommonMail {
public static void main(String[] args) throws EmailException, MessagingException {
SimpleEmail email = new SimpleEmail();
email.setCharset("GB2312");
email.setHostName("smtp.163.com");
email.setSubject("test");
email.addTo("test@163.com");
email.setFrom("test@163.com");
email.setMsg("我的测试");
email.setAuthentication("test", "test");
email.send();
}
}

分析了一下commons mail的源码找到了原因。源码如下:

public class SimpleEmail extends Email
{
public Email setMsg(String msg) throws EmailException, MessagingException
{
if (EmailUtils.isEmpty(msg))
{
throw new EmailException("Invalid message supplied");
}

setContent(msg, TEXT_PLAIN);
return this;
}
}

Email代码片段

public void setContent(Object aObject, String aContentType)
{
this.content = aObject;
if (EmailUtils.isEmpty(aContentType))
{
this.contentType = null;
}
else
{
// set the content type
this.contentType = aContentType;

// set the charset if the input was properly formed
String strMarker = "; charset=";
int charsetPos = aContentType.toLowerCase().indexOf(strMarker);
if (charsetPos != -1)
{
// find the next space (after the marker)
charsetPos += strMarker.length();
int intCharsetEnd =
aContentType.toLowerCase().indexOf(" ", charsetPos);

if (intCharsetEnd != -1)
{
this.charset =
aContentType.substring(charsetPos, intCharsetEnd);
}
else
{
this.charset = aContentType.substring(charsetPos);
}
}
}
}

email.send(); 的send方法将调用
public void buildMimeMessage() throws EmailException
{
try
{
this.getMailSession();
this.message = new MimeMessage(this.session);

if (EmailUtils.isNotEmpty(this.subject))
{
if (EmailUtils.isNotEmpty(this.charset))
{
this.message.setSubject(this.subject, this.charset);
}
else
{
this.message.setSubject(this.subject);
}
}

// ========================================================
// Start of replacement code
if (this.content != null)
{
this.message.setContent(this.content, this.contentType);
}
// end of replacement code
// ========================================================
else if (this.emailBody != null)
{
this.message.setContent(this.emailBody);
}
else
{
this.message.setContent("", Email.TEXT_PLAIN);
}

if (this.fromAddress != null)
{
this.message.setFrom(this.fromAddress);
}
else
{
throw new EmailException("Sender address required");
}

if (this.toList.size() + this.ccList.size() + this.bccList.size() == 0)
{
throw new EmailException(
"At least one receiver address required");
}

if (this.toList.size() ＞ 0)
{
this.message.setRecipients(
Message.RecipientType.TO,
this.toInternetAddressArray(this.toList));
}

if (this.ccList.size() ＞ 0)
{
this.message.setRecipients(
Message.RecipientType.CC,
this.toInternetAddressArray(this.ccList));
}

if (this.bccList.size() ＞ 0)
{
this.message.setRecipients(
Message.RecipientType.BCC,
this.toInternetAddressArray(this.bccList));
}

if (this.replyList.size() ＞ 0)
{
this.message.setReplyTo(
this.toInternetAddressArray(this.replyList));
}

if (this.headers.size() ＞ 0)
{
Iterator iterHeaderKeys = this.headers.keySet().iterator();
while (iterHeaderKeys.hasNext())
{
String name = (String) iterHeaderKeys.next();
String value = (String) headers.get(name);
this.message.addHeader(name, value);
}
}

if (this.message.getSentDate() == null)
{
this.message.setSentDate(getSentDate());
}

if (this.popBeforeSmtp)
{
Store store = session.getStore("pop3");
store.connect(this.popHost, this.popUsername, this.popPassword);
}
}
catch (MessagingException me)
{
throw new EmailException(me);
}
}
由代码可以知道纯文本方式最终调用了Java Mail的
message.setContent(this.content, this.contentType);
content是内容
contentType是类型，如text/plain,
(我们可以试试直接用Java mail发邮件，设置文本内容不使用setText方法，也使用setContent("测试", "text/plain")方式，你可以看到内容也是乱码)

　　关键就在于text/plain，我们改成text/plain; charset=gb2312，ok乱码解决了。在commons mail我们看SimpleEmail 类中setMsg方法调用的就是 setContent(msg, TEXT_PLAIN); 我们只需要将Email类中的常量TEXT_PLAIN修改一下加入 charset=你的字符集，重新打包jar，这样就可以了

　　7、toad的字符集的设置与oracle的安装

　　oracle数据库服务器的安装一般是中文字符集，有时安装在不同的平台下，设置为ISO编码，toad是oracle开发的最好工具，不是我说的，可是中文环境下安装的toad，打开英文字符的oracle时，中文全是乱码。必须进行设置

环境变量---〉系统变量
加
NLS_lANG=SIMPLIFIED CHINESE_CHINA.ZHS16GBK
或
NLS_lANG=AMERICAN_AMERICA.WE8ISO8859P1

AMERICAN_AMERICA.WE8MSWIN1252

或者

打开注册表，点击HKEY_LOCAL_MATHINE
再点击Software,再点击ORACLE
在点击HOME（ORACLE所在目录）
在注册表的右半面有NLS_LANG,
双击它，将你想要的覆盖掉原来的就可以了
最好记下旧的，以便可以改回来。

connect sys/chang_on_install
update props$
set value$='ZHS16CGB231280'
where name='NLS_CHARACTERSET';
commit;
这样就OK了

　　8、如何解決GWT(google web toolkit)中文的問題

　　GWT 中文乱码解决方法

1.把你要显示的中文“测试字符串”输入到一个文件，如:1.txt
2.进入命令行,进入1.txt所在的目录,敲入以下命令:native2ascii.exe 1.txt 2.txt 回车。这样就生成了另外一个文件2.txt。
3.2.txt的内容如下:\u6d4b\u8bd5\u5b57\u7b26\u4e32
4.然后用上面的编码，在gwt中使用，就可以了.

　　9、xmlHttp得到的网页怎么是乱码？

　　(1)在服务器端使用WebRequest而不是xmlHttp
　　(2) 将

StreamReader sr = new StreamReader(stream);

　　对于简体中文改成：

StreamReader sr = new StreamReader(stream , Encoding.Default );

　　对于utf-8改成：

StreamReader sr = new StreamReader(stream , Encoding.UTF8 );

　　当然，Encoding枚举还有很多其他的成员，对于不同的编码content-type可以有选择的应用

　　(3)后来我发现无论是content-type是gb2312还是utf-8,用

StreamReader sr = new StreamReader(stream , Encoding.Default );

　　都可以返回正常的汉字，所以统一的改成Encoding.Default

--------------------------------------------------------------------------------

最后，在服务器端从一个url获得网页的源代码的代码如下：

/// ＜summary＞
/// post一个指定的url，获得网页的源代码(用WebRequest实现)
/// ＜/summary＞
/// ＜param name="url"＞＜/param＞
/// ＜returns＞
/// 如果请求失败，返回null
/// 如果请求成功，返回网页的源代码
/// ＜/returns＞
public static string GetContentFromUrl2( string url )
{
//变量定义
string respstr;

WebRequest myWebRequest=WebRequest.Create(url);
// myWebRequest.PreAuthenticate=true;
// NetworkCredential networkCredential=new NetworkCredential( username , password , domain );
// myWebRequest.Credentials=networkCredential;

// Assign the response object of 'WebRequest' to a 'WebResponse' variable.
WebResponse myWebResponse=myWebRequest.GetResponse();
System.IO.Stream stream = myWebResponse.GetResponseStream();
StreamReader sr = new StreamReader(stream , Encoding.Default );
//以字符串形式读取数据流
respstr = sr.ReadToEnd();
sr.Close();

return respstr;

}

http://java.csdn.net/page/fc252fc4-2554-49d4-be0e-b6c6ab88d6ac

fly 2007-08-13 19:16 发表评论

Tomcat的目录配置(转)

fly — Sat, 31 Mar 2007 09:50:00 GMT

本章介绍如何在Tomcat上创建和发布Web应用。这里首先讲解Tomcat的目录结构以及Web应用的目录结构，接着介绍如何将HTML、 Servlet、JSP和Tag Library部署到Web应用中，然后介绍把整个Web应用打包并发布的方法，最后介绍如何在Tomcat上配置虚拟主机。

本章侧重于讨论Web应用的结构和发布方法，所以没有对本章的Servlet和JSP的例子进行详细解释，关于Servlet和JSP的技术可以分别参考其它章节的内容。

2.1 Tomcat的目录结构

在Tomcat上发布Web应用之前，首先要了解Tomcat的目录结构。Tomcat的目录结构参见表2-1，这些目录都是的子目录。

表2-1 Tomcat的目录结构

目录	描述
/bin	存放在Windows平台以及Linux平台上启动和关闭Tomcat的脚本文件
/conf	存放Tomcat服务器的各种配置文件，其中最重要的配置文件是server.xml
/server	包含3个子目录: classes、lib和webapps
/server/lib	存放Tomcat服务器所需的各种JAR文件
/server/webapps	存放Tomcat自带的两个Web应用: admin应用和manager应用
/common/lib	存放Tomcat服务器以及所有 Web应用都可以访问的JAR文件
/shared/lib	存放所有Web应用都可以访问的JAR文件
/logs	存放Tomcat的日志文件
/webapps	当发布Web应用时，默认情况下把Web应用文件放于此目录下
/work	Tomcat把由JSP生成的 Servlet放于此目录下

从表2-1可以看出，在/server/lib目录、/common/lib和/shared/lib目录下都可以放JAR文件，它们的区别在于：

在/server/lib目录下的JAR文件只可被Tomcat服务器访问

在/shared/lib目录下的JAR文件可以被所有的Web应用访问，但不能被Tomcat服务器访问

在/common/lib目录下的JAR文件可以被Tomcat服务器和所有Web应用访问

此外，对于下面将要介绍的Java Web应用，在它的WEB-INF目录下，也可以建立lib子目录，在lib子目录下可以放各种JAR文件，这些JAR文件只能被当前Web应用访问。

在以上提到的lib目录下都只接受JAR文件，如果类压缩文件为ZIP文件，应该将它展开，重新打包为JAR文件再拷贝到lib目录中。如果直接将ZIP文件拷贝到lib目录，则会发现Tomcat服务器仍然找不到相关的类。打包命令参见2.2.8节。

2.2 创建和发布Web应用

Java Web应用由一组静态HTML页、Servlet、JSP和其他相关的class组成。每种组件在Web应用中都有固定的存放目录。Web应用的配置信息存放在web.xml文件中。在发布某些组件（如Servlet）时，必须在web.xml文件中添加相应的配置信息。

2.2.1 Web应用的目录结构

Web应用具有固定的目录结构，这里假定开发一个名为helloapp的Web应用。首先，应该在/webapps目录下创建这个Web应用的目录结构，参见表2-2。

表2-2 Web应用的目录结构

目录	描述
/helloapp	Web应用的根目录，所有的JSP和HTML文件都存放于此目录下
/helloapp/WEB-INF	存放Web应用的发布描述文件web.xml
/helloapp/WEB-INF/classes	存放各种class文件， Servlet类文件也放于此目录下
/helloapp/WEB-INF/lib	存放Web应用所需的各种JAR文件

例如，在这个目录下，可以存放JDBC驱动程序的JAR文件

从表2-2中，我们看到在classes以及lib子目录下，都可以存放Java类文件。在运行过程中，Tomcat的类装载器先装载classes目录下的类，再装载lib目录下的类。因此，如果两个目录下存在同名的类，classes目录下的类具有优先权。

本章介绍的helloapp应用的目录结构如图2-1所示，helloapp应用在Windows资源管理器中的展开如图2-2所示。

在helloapp应用中创建了如下组件：

HTML组件：index.htm

JSP组件：login.jsp和hello.jsp

Servlet组件：DispatcherServlet

这些组件之间的链接关系为：

index.htm→login.jsp→DispatcherServlet→hello.jsp 图2-1 helloapp应用的目录结构图2-2 helloapp应用在Windows资源管理器中的展开图

2.2.2 web.xml文件

Java Web应用通过一个基于XML的发布描述符文件来配置其发布信息，这个文件名为web.xml，它存放于WEB-INF子目录下。在附录B中将详细介绍web.xml的配置方法，在附录C中将介绍XML的基本知识。在web.xml文件中可包含如下配置信息：

Servlet的定义

Servlet的初始化参数

Servlet以及JSP的映射

安全域配置参数

welcome文件清单

资源引用

环境变量的定义

现在，创建一个默认的web.xml文件，并把这个文件放到WEB-INF目录中。



  '-//Sun Microsystems,
  Inc.//DTD Web Application 2.3
  //EN'
  'http://java.sun.com/
  j2ee/dtds/web-app_2_3.dtd'>

以上web.xml文件的第一行指定了XML的版本和字符编码，第二行DOCTYPE指定文档类型，接下来声明了一个元素，所有关于Web应用的配置元素都将加入到这个元素中。

2.2.3 在server.xml中加入元素

元素是/conf/server.xml中使用最频繁的元素，它代表了运行在上的单个Web应用。一个中可以有多个元素。每个Web应用必须有惟一的URL路径，这个URL路径在元素的path属性中设定。例如，在名为"localhost"的元素中加入如下元素：


unpackWARs="true" autoDeploy="true">
……
……
docBase="helloapp" debug="0"
reloadable="true"/>

Context元素的各个属性的说明参见表2-3。

表2-3 Context元素的属性

属性	描述
path	指定访问该Web应用的URL入口
docBase	指定Web应用的文件路径，可以给定绝对路径，也可以给定相对于Host的appBase属性的相对路径（关于Host的appBase属性参见2.3节）。如果Web应用采用开放目录结构，则指定Web应用的根目录；如果Web应用是个WAR文件，则指定WAR文件的路径
reloadable	如果这个属性设为true， Tomcat服务器在运行状态下会监视在WEB-INF/classes 和WEB-INF/lib目录下class文件的改动。如果监测到有class文件被更新，服务器会自动重新加载Web应用

在开发阶段，将reloadable属性设为true，有助于调试Servlet和其他的class文件。但是由于这一功能会加重服务器的运行负荷，因此建议在Web应用的产品发布阶段，将这个属性设为false。

自:
http://qingfengxiyu.spaces.live.com/blog/cns!e5f7a3aef9b09ed!149.entry

fly 2007-03-31 17:50 发表评论

新手入门－JSP（完结篇）

fly — Wed, 11 Oct 2006 09:16:00 GMT

摘要: 1. 什么是 JSP ： JSP 简单来说就是在一个网页中利用 <%%> 来嵌套 JAVA 程序片。例如： ... 阅读全文

fly 2006-10-11 17:16 发表评论

一个简单的servlet例子

fly — Sat, 12 Aug 2006 02:32:00 GMT

以下是一个简单的servlet程序,首先见立一个目录,在D:\Tomcat\webapps\下建立servletdemo,并添加一个子目录
WEB-INF文件夹
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWorld extends HttpServlet {
public void doGet(HttpServletRequest req, HttpServletResponse res)
                               throws ServletException, IOException {
    res.setContentType("text/html");
    PrintWriter out = res.getWriter();
    out.println("");
    out.println("Hello World");
    out.println("");
    out.println("Hello World");
    out.println("");
}
public void doPost(HttpServletRequest req, HttpServletResponse res)
                              throws ServletException, IOException {
                         doGet(req, res);
}
}
在写一个部署的文件web.xml

PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"
"http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">

            HelloWorld


            HelloWorld





            HelloWorld


            /HelloWorld





            HelloWorld


            /HelloWorld.do





            HelloWorld


           *.hello





            HelloWorld


          /hello/*



这样你就可以在浏览器中用以下url打开
http://localhost:8080/servletdemo/HelloWorld
/servletdemo/HelloWorld
/hello.html
/well.hello
/fancy/meeting/you/here.hello
/hello/to/you

fly 2006-08-12 10:32 发表评论

jsp中乱码的问题解决

fly — Fri, 11 Aug 2006 09:01:00 GMT

public static String UnicodeToChinese(String s) {
try {
if (s == null || s.equals(""))
return "";
String newstring = null;
newstring = new String(s.getBytes("ISO8859_1"), "gb2312");
return newstring;
} catch (UnsupportedEncodingException e) {
return s;
}
}

public static String ChineseToUnicode(String s) {
try {
if (s == null || s.equals(""))
return "";
String newstring = null;
newstring = new String(s.getBytes("gb2312"), "ISO8859_1");
return newstring;
} catch (UnsupportedEncodingException e) {
return s;
}
}
写进数据库时用ChineseToUnicode()方法进行编码,读出来的时候用UnicodeToChinese()方法进行解码既可

fly 2006-08-11 17:01 发表评论

JSP中tomcat的SQL Server2000数据库连接池的配置

fly — Fri, 11 Aug 2006 08:55:00 GMT

JSP中tomcat的SQL Server2000数据库连接池的配置
环境：
1. 数据库：Microsoft SQL Server 2000
2. 数据库驱动程序：com.microsoft.jdbc.sqlserver.SQLServerDriverr
JNDI（Java Naming and Directory Interface）概述：
Tomcat4（5）提供了一个与Java Enterprise Edition应用服务相兼容的JNDI--InitialContext实现实例。它的初始数据设置在$CATALINA_HOME/conf/server.xml文件里，并可能在网页应用环境描述（/WEB-INF/web.xml）里被下列元素引用：
1) --环境入口，设置应用程序如何操作。
2) --资源参数，一般是数据库驱动程序、JavaMail Session、自定义类工厂等。
3) --在Servlet 2.4里用来简化设置不需认证信息的资源资源如环境参数、resource-ref变量。
InitialContext在网页应用程序初始化时被设置，用来支持网页应用程序组件。所有的入口和资源都放在JNDI命名空间里的java:comp/env段里。点击下列网址以获取更多信息：
1) Java命名和目录接口（Java Naming and Directory Interface）
2) J2EE平台说明（J2EE Platform Specification）
设置JNDI资源
设置JNDI资源要在$CATALINA_HOME/conf/server.xml文件里使用下列标志符：
1) --设置域个可变的JNDI InitialContext入口的名字和值（同上面说的等价）。
2) --设置应用程序可用的资源的名字和类型（同上面说的等价）。
3) --设置Java资源类工厂的名称或将用的JavaBean属性。
4) --给全局JNDI环境（JNDI Context）添加一个链接。
上述这些标志符必须放在和之间（针对专门的网页应用程序）或和之间。
此外，设在网页应用环境描述（Web Application Descriptor）（/WEB-INF/web.xml）里的名字和值也在初始环境（Initial Context）里被设置，当被元素值允许时将被重设初始值。
全局变量能在子元素的里设置。
数据库连接池概述：
数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。
数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。
数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。数据库连接池的最小连接数和最大连接数的设置要考虑到下列几个因素：
1) 最小连接数是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费；
2) 最大连接数是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之后的数据库操作。
3) 如果最小连接数与最大连接数相差太大，那么最先的连接请求将会获利，之后超过最小连接数量的连接请求等价于建立一个新的数据库连接。不过，这些大于最小连接数的数据库连接在使用完不会马上被释放，它将被放到连接池中等待重复使用或是空闲超时后被释放。
配置Tomcat数据库连接池的前提：
1. 必须装有Java运行环境；
2. 必须有SQL Server2000数据库服务器（可以不在本地）；
3. 必须有jtds.jar，并将它放在$CATALINA_HOME/common/lib目录下（只能是这里）。使用它是因为Microsoft公司的Java SQL Server驱动程序不支持二次查询，可到网上搜到。目前使用的是jtds-0.6.jar。
在$CATALINA_HOME/conf/server.xml里设置数据库连接池：
下面是配置的代码，必须放在和之间。

maxActive

100

maxIdle

30

maxWait

10000

removeAbandoned

true

removeAbandonedTimeout

60

logAbandoned

false

factory

org.apache.commons.dbcp.BasicDataSourceFactory

username

Iorishinier

password

mypasswd

driverClassName

com.microsoft.jdbc.sqlserver.SQLServerDriverr

url

jdbc:jtds:sqlserver://127.127.127.127:1433/Northwind

下面是一些参数的说明：

其中：
1) path 指定路径，这里设定的是$CATALINA_HOME/webapps下的quality目录；
2) docBase 文件根目录。
3) reloader 当网页被更新时是否重新编译。
4) maxActive 连接池的最大数据库连接数。设为0表示无限制。
5) maxIdle 数据库连接的最大空闲时间。超过此空闲时间，数据库连接将被标记为不可用，然后被释放。设为0表示无限制。
6) maxWait 最大建立连接等待时间。如果超过此时间将接到异常。设为－1表示无限制。
7) removeAbandoned 回收被遗弃的（一般是忘了释放的）数据库连接到连接池中。
8) removeAbandonedTimeout 数据库连接过多长时间不用将被视为被遗弃而收回连接池中。
9) logAbandoned 将被遗弃的数据库连接的回收记入日志。
10) driverClassName JDBC驱动程序。
11) url 数据库连接字符串
在$CATALINA_HOME/webapps/quality/WEB-INF/web.xml里设置被引用的资源：
下面是配置代码，必须放在和里。

connectDB test
jdbc/connectDB
javax.sql.DataSource
Container

下面是一下参数的必要说明：
1) description 对被引用的资源的描述。
2) res-ref-name 资源名称。见上面的
3) res-type 资源类型。见上面的
在JSP中使用资源：
这是在$CATALINA_HOME/webapps/quality下的某级子目录里的jsp网页文件部分代码：
<%@ page contentType="text/html;charset=GBK"%>
<%@ page errorPage="error.jsp"%>
<%@ page import="javax.naming.*"%>
<%@ page import="javax.sql.*"%>
<%@ page import="java.sql.*"%>

<%

………………
………………

// 数据库操作
Context ctx=null;
Connection cnn=null;
Statement stmt=null;
ResultSet rs=null;
try
{
ctx=new InitialContext();
if(ctx==null)
throw new Exception("没有匹配的环境");
DataSource ds=(DataSource)ctx.lookup("java:comp/env/jdbc/connectDB");
if(ds==null)
throw new Exception("没有匹配数据库");

cnn=ds.getConnection();
stmt=cnn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);
rs=stmt.executeQuery("select * from table1");

………………
………………

}
finally
{
if(rs!=null)
rs.close();
if(stmt!=null)
stmt.close();
if(cnn!=null)
cnn.close();
if(ctx!=null)
ctx.close();
}
%>

代码说明：
DataSource ds=(DataSource)ctx.lookup("java:comp/env/jdbc/connectDB");
上面这句应用了刚才设的资源。
资源使用完要释放，尤其是Context资源，见try-catch-finally部分的finally代码段，这是一种好的习惯。资源释放时如果释放了上级资源，下级资源将先被释放。如：释放了ctx，那么资源释放顺序将是rs，stmt，cnn，ctx。换句话说，如果释放了ctx，那么rs，stmt和cnn都将不可用了。
这里的释放资源只是将数据库连接返回连接池中，并不是把资源真正释放掉，见数据库连接池概述。

fly 2006-08-11 16:55 发表评论

JSP连接数据库大全

fly — Fri, 11 Aug 2006 08:50:00 GMT

一、jsp连接Oracle8/8i/9i数据库（用thin模式）

testoracle.jsp如下：
< %@ page contentType="text/html;charset=gb2312"% >
< %@ page import="java.sql.*"% >
< html >
< body >
< %Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
String url="jdbc:oracle:thin:@localhost:1521:orcl";
//orcl为你的数据库的SID
String user="scott";
String password="tiger";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {% >
您的第一个字段内容为：< %=rs.getString(1)% >
您的第二个字段内容为：< %=rs.getString(2)% >
< %}% >
< %out.print("数据库操作成功，恭喜你");% >
< %rs.close();
stmt.close();
conn.close();
% >
< /body >
< /html >

二、jsp连接Sql Server7.0/2000数据库

testsqlserver.jsp如下：
< %@ page contentType="text/html;charset=gb2312"% >
< %@ page import="java.sql.*"% >
< html >
< body >
< %Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=pubs";
//pubs为你的数据库的
String user="sa";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {% >
您的第一个字段内容为：< %=rs.getString(1)% >
您的第二个字段内容为：< %=rs.getString(2)% >
< %}% >
< %out.print("数据库操作成功，恭喜你");% >
< %rs.close();
stmt.close();
conn.close();
% >
< /body >
< /html >

三、jsp连接DB2数据库

testdb2.jsp如下：
< %@ page contentType="text/html;charset=gb2312"% >
< %@ page import="java.sql.*"% >
< html >
< body >
< %Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance();
String url="jdbc:db2://localhost:5000/sample";
//sample为你的数据库名
String user="admin";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {% >
您的第一个字段内容为：< %=rs.getString(1)% >
您的第二个字段内容为：< %=rs.getString(2)% >
< %}% >
< %out.print("数据库操作成功，恭喜你");% >
< %rs.close();
stmt.close();
conn.close();
% >
< /body >
< /html >

四、jsp连接Informix数据库

testinformix.jsp如下：
< %@ page contentType="text/html;charset=gb2312"% >
< %@ page import="java.sql.*"% >
< html >
< body >
< %Class.forName("com.informix.jdbc.IfxDriver").newInstance();
String url =
"jdbc:informix-sqli://123.45.67.89:1533/testDB:INFORMIXSERVER=myserver;
user=testuser;password=testpassword";
//testDB为你的数据库名

fly 2006-08-11 16:50 发表评论

一个Servlet教程

fly — Wed, 09 Aug 2006 02:59:00 GMT

一、Servlet的基本结构。

//Servlet de 基本结构

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class SomeServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {

// 用 "request" 可以读取输入的值 (e.g. cookies)
// 和表单提交的数据
// 用 "response" 返回输出的内容

PrintWriter out = response.getWriter();

// 用 "out" 向浏览器写内容。

}
}

Servlet都是有HttpServlet继承下来的。基本结构如上面的代码所示：
下面就举几个Servlet的小例子。

//生成一般文本的例子下载本例

package test;
//用这条语句编译 javac -encoding iso8859_1 filename.java

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class HelloServlet extends HttpServlet {
public void doGet( HttpServletRequest requset,
HttpServletResponse response)
throws IOException, ServletException {
PrintWriter out = response.getWriter();
out.println("Hello,world!");
out.println("你好，万维网");
}
}

//生成HTML内容的例子。下载本程序

package test;
//javac -encoding iso8859_1 HelloWWW.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class HelloWWW extends HttpServlet {
public void doGet( HttpServletRequest requset,
HttpServletResponse response)
throws IOException, ServletException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println(""+
""+
""+
""+"Hello WWW by LoveJSP.site"+""+
""+
"

Hello WWW

"+
"

你好，万维网

"+
"

welcom to LoveJSP.site

"+
""+
"");
}
}
处理表单提交的数据 Pely Gan

在Web程序设计中，处理表单提交的数据是获取Web数据的主要方法，今天，我们来看一看Servlet中是怎样处理来自表单的数据的。

表单数据的提交方法有两种Post方法和Get方法，当使用Post方法时，数据由标准的输入设备读入，当使用Get方法时，数据由CGI变量QUERY_STRING传递给表单数据处理程序。

Servlet会自动将以上两种方法得到的数据进行处理，从而使用户只要简单的调用HttpServletRequest的getParameter方法，给出变量名称即可取得该变量的值。需要注意的是，变量的名称是大小写敏感的。对于Post方法或Get方法提交的数据，Servlet的处理方法是一样的。当请求的变量不存在时，将会返回一个空字符串。如果变量有多个值，你应该调用getParameterValues，这个方法将会返回一个字符串数组。使用getParameterNames可以取得所有变量的名称，该方法返回一个Emumeration方法。

下面让我们来看一个简单的例子，下面这个Servlet读取表单中指定名称的五个字段的值。下载这个例子

//Html file----> postdata.htm 下载本文件

getFormData Servlet Example form LoveJSP.com

Demo Page

//Servlet File getFormData.java 下载本文件

package lovejsp;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

/** Servlet getParameter Ex from Lovejsp.site(http://www.lovejsp.com)
*/

public class getFormData extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "读取表单数据";
out.println(LovejspTools.headTitle(title) + //a tools method to show the html code with title
"\n" +
"

" + title + "

\n" +
"

username: "
+ request.getParameter("username") + "\n" +
"
password: "
+ request.getParameter("password") + "\n" +
"
Email: "
+ request.getParameter("Email") + "\n" +
"
Homepage: "
+ request.getParameter("Homepage") + "\n" +
"

\n" +
"");
}
}

这个程序的运行结果如下图所示：

大家可能注意到了，上面的结果中Email的值是null，这是因为在表单中没有这个字段，表单的email的名称是email。

下面这个程序是getParameterNames的示例，也是调试程序的很好的工具，它的功能是显示所有的表单数据。

//Servlet File ShowAllFormData.java 下载本文件

package lovejsp;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;

public class ShowAllFormData extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "显示所有的Form变量的值";
out.println(""+title+""+
"\n" +
"

" + title + "

\n" +
"\n" +
"\n" +
"

变量名称	变量值"); Enumeration paramNames = request.getParameterNames(); while(paramNames.hasMoreElements()) { String paramName = (String)paramNames.nextElement(); out.println("
" + paramName + "\n	"); String[] paramValues = request.getParameterValues(paramName); if (paramValues.length == 1) { String paramValue = paramValues[0]; if (paramValue.length() == 0) out.print("No Value"); else out.print(paramValue); } else { out.println(" "); for(int i=0; iout.println(" " + paramValues[i]); } out.println(" "); } } out.println("

\n");
}

public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}

运行结果：

好了，that's all for today,thank you all. see you next time
在Servlet中使用请求头(Request Header) LoveJSP.site

Request Header简介
当一个客户端(通常是浏览器)向Web服务器发送一个请求是，它要发送一个请求的命令行，一般是GET或POST命令，当发送POST命令时，它还必须向服务器发送一个叫"Content-Length”的请求头(Request Header) 用以指明请求数据的长度，除了Content-Length之外，它还可以向服务器发送其它一些Headers，如：

Accept 浏览器可接受的MIME类型
Accept-Charset 浏览器支持的字符编码
Accept-Encoding 浏览器知道如何解码的数据编码类型(如 gzip)。Servlets 可以预先检查浏览器是否支持gzip并可以对支持gzip的浏览器返回gzipped的HTML页面，并设置Content-Encoding回应头(response header)来指出发送的内容是已经gzipped的。在大多数情况下，这样做可以加快网页下载的速度。
Accept-Language 浏览器指定的语言，当Server支持多语种时起作用。
Authorization 认证信息，一般是对服务器发出的WWW-Authenticate头的回应。
Connection 是否使用持续连接。如果servlet发现这个字段的值是Keep-Alive，或者由发出请求的命令行发现浏览器支持 HTTP 1.1 (持续连接是它的默认选项)，使用持续连接可以使保护很多小文件的页面的下载时间减少。
Content-Length (使用POST方法提交时，传递数据的字节数)
Cookie (很重要的一个Header，用来进行和Cookie有关的操作，详细的信息将在后面的教程中介绍)
Host (主机和端口)
If-Modified-Since (只返回比指定日期新的文档，如果没有，将会反回304 "Not Modified")
Referer (URL)
User-Agent (客户端的类型，一般用来区分不同的浏览器)
如果你想更多的了解Request Header的内容，你可以访问W3C的网站。

在Servlet中读取Request Header的内容

在Servlet中读取Request Header的值是很简单的，只要调用HttpServletRequest的getHeader方法就可以了，当你指定要返回的Header的名称，该方法就会返回String类型的Header的内容，如果指定的Header不存在，就返回null。调用getHeaderNames可以返回包含所有Header名字的Enumeration.

读取所有Request Header值的Servlet程序

下面是Tomcat中所带的Servlet例子中关于Request Header的例子，下载该程序。

import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class RequestHeaderExample extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException
{
response.setContentType("text/html");
PrintWriter out = response.getWriter();
Enumeration e = request.getHeaderNames();
while (e.hasMoreElements()) {
String name = (String)e.nextElement();
String value = request.getHeader(name);
out.println(name + " = " + value);
}
}
}
访问标准CGI变量
LoveJSP.site
1. CGI变量简介
如果你在以前使用过传统的CGI，你应该对"CGI变量”的概念很熟悉。由这些变量可以取得一些和请求（Request）有关的信息。其中一些来自于 HTTP 请求命令行（request line）和headers （例如：在URI中问号后面的部分或者Content-Length header），一些来自于 Socket本身（例如：被请求主机的IP和名称），还有一些来自于服务器的配置信息（例如：被映射为URL目录的实际路径）。

2. Servlet和标准CGI变量之间的对应关系
下面的表格中给出了Servlet和标准CGI变量之间的对应关系，对以前使用CGI变量进行编程的朋友会有很大的帮助。在下表中我们假设request是HttpServletRequest类型的对象。
CGI变量含义在 doGet 或 doPost 访问的办法
AUTH_TYPE 如果在请求中有 Authorization header ，则这个变量将会被赋值 (basic 或 digest) request.getAuthType()
CONTENT_LENGTH 只有当请求的方法是 POST 时这个变量才会有意义，它表示传送的数据的字节数。 String.valueOf(request.getContentLength()) （返回String）或者 request.getContentLength()，返回一个整数（int）。
CONTENT_TYPE 如果被赋值，就表示数据的MIME类型。 request.getContentType()
DOCUMENT_ROOT 和网站根目录对应的实际路径 getServletContext().getRealPath("/") 注意：在以前的Servlet标准中，这条语句是这样写的request.getRealPath("/") 。
HTTP_XXX_YYY 访问任意的HTTP headers request.getHeader("Xxx-Yyy")
PATH_INFO URL 指向的路径的信息。由于Servlet可以和服务器直接通讯，所以这个变量对Servlet没什么作用。 request.getPathInfo()
PATH_TRANSLATED 在Server上被映射为web目录的目录的真实路径的信息。和上一个变量一样，对Servlet用处不大。 request.getPathTranslated()
QUERY_STRING 如果用 GET 方法发出请求（requests），这个变量中将会存放请求的数据，其形式为经过URL编码的一个大字符串。在servlet中，你很少会用到这个原始的字符串。而是用 request.getParameter 方法来访问某个特定的请求数据。 request.getQueryString()
REMOTE_ADDR 客户端的IP地址，是String类型的。其形式类似于 "192.9.48.9"。 request.getRemoteAddr()
REMOTE_HOST 发出请求的客户端的域名(例如. "java.sun.com") 如果不能检测到域名，就用客户端的IP地址代替。 request.getRemoteHost()
REMOTE_USER 如果 Authorization header 被赋值，则这个变量中放有用户名。 request.getRemoteUser()
REQUEST_METHOD 请求的类型。通常为 GET 或 POST，但也可能是 HEAD， PUT， DELETE， OPTIONS，或者 TRACE。 request.getMethod()
SCRIPT_NAME srvlet的路径 request.getServletPath()
SERVER_NAME 服务器的名称 request.getServerName()
SERVER_PORT 服务器的端口 String.valueOf(request.getServerPort())（返回String类型） request.getServerPort()（返回int类型）
SERVER_PROTOCOL 在请求命令行中用的协议的版本号。(例如. HTTP/1.0 或 HTTP/1.1)。 request.getProtocol()
SERVER_SOFTWARE 所用 Web Server 软件的名称 getServletContext().getServerInfo()

3. 例子：读取CGI变量。
下面是一个显示除去 HTTP_XXX_YYY 外所有CGI变量的的servlet。他显示了在上面的表格中列出的所有CGI变量的值。
3.1 ShowCGIVariables.java
Download Here

//! ####### Start ShowCGIVariables.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;

public class ShowCGIVariables extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String[][] variables =
{ { "AUTH_TYPE", request.getAuthType() },
{ "CONTENT_LENGTH", String.valueOf(request.getContentLength()) },
{ "CONTENT_TYPE", request.getContentType() },
{ "DOCUMENT_ROOT", getServletContext().getRealPath("/") },
{ "PATH_INFO", request.getPathInfo() },
{ "PATH_TRANSLATED", request.getPathTranslated() },
{ "QUERY_STRING", request.getQueryString() },
{ "REMOTE_ADDR", request.getRemoteAddr() },
{ "REMOTE_HOST", request.getRemoteHost() },
{ "REMOTE_USER", request.getRemoteUser() },
{ "REQUEST_METHOD", request.getMethod() },
{ "SCRIPT_NAME", request.getServletPath() },
{ "SERVER_NAME", request.getServerName() },
{ "SERVER_PORT", String.valueOf(request.getServerPort()) },
{ "SERVER_PROTOCOL", request.getProtocol() },
{ "SERVER_SOFTWARE", getServletContext().getServerInfo() }
};
String title = "Servlet Example: 显示CGI变量";
out.println(""+title +""+
"\n" +
"

" + title + "

\n" +
"\n" +
"\n" +
"

CGI Variable Name	Value"); for(int i=0; iString varName = variables[i][0]; String varValue = variables[i][1]; if (varValue == null) varValue = "没有被赋值"; out.println("
" + varName + "	" + varValue); } out.println("

");
}

public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}

//! ####### End ShowCGIVariables.java

fly 2006-08-09 10:59 发表评论

禁止Tomcat目录列表

fly — Sat, 08 Jul 2006 01:32:00 GMT

禁止Tomcat目录列表
记事本打开E:\Apache Group\Tomcat 5.0\conf\web.xml
查找listings在下面
true改为false

fly 2006-07-08 09:32 发表评论

JSP内置对象

fly — Sat, 08 Jul 2006 01:31:00 GMT

JSP内置对象
　　
内置对象是不需要声明，直接可以在JSP中使用的对象，JSP有以下几种内置对象：
　　
request request表示HttpServletRequest对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie, header, 和session数据的有用的方法。
　　
　response response表示HttpServletResponse对象，并提供了几个用于设置送回浏览器的响应的方法（如cookies,头信息等）
　　
　out out 对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。
　　
　pageContext pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的API，并且包装了通用的servlet相关功能的方法。
　　
　session session表示一个请求的javax.servlet.http.HttpSession对象。Session可以存贮用户的状态信息
　　
　application applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息
　　
　config config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。
　　
　page page表示从该页面产生的一个servlet实例。

--------------------------------------------------------------------------------

fly 2006-07-08 09:31 发表评论

getFormData Servlet Demo Page
username:
password:
Email:
Homepage: