数据库连接池会在启动时就建立所需的若干连接，并一直保持连接状态，
但是当数据库服务停止后，这些连接就被外部因素给中断了
网上优化了的配置信息：
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> 
<property name="driverClassName" value="${db.driverClassName}"/> 
<property name="url" value="${db.url}"/> 
<property name="username" value="${db.username}"/> 
<property name="password" value="${db.password}"/> 
<!--initialSize: 初始化连接--> 
<property name="initialSize" value="5"/> 
<!--maxIdle: 最大空闲连接--> 
<property name="maxIdle" value="10"/> 
<!--minIdle: 最小空闲连接--> 
<property name="minIdle" value="5"/> 
<!--maxActive: 最大连接数量--> 
<property name="maxActive" value="15"/> 
<!--removeAbandoned: 是否自动回收超时连接--> 
<property name="removeAbandoned" value="true"/> 
<!--removeAbandonedTimeout: 超时时间(以秒数为单位)--> 
<property name="removeAbandonedTimeout" value="180"/> 
<!--maxWait: 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒--> 
<property name="maxWait" value="3000"/> 
<property name="validationQuery"> 
<value>SELECT 1</value> 
</property> 
<property name="testOnBorrow"> 
<value>true</value> 
</property> 
</bean>  

dbcp配置中文版本，自apache 官方文档
原文请见http://commons.apache.org/dbcp/configuration.html。

参数  描述
username  传递给JDBC驱动的用于建立连接的用户名
password  传递给JDBC驱动的用于建立连接的密码
url  传递给JDBC驱动的用于建立连接的URL
driverClassName  使用的JDBC驱动的完整有效的java 类名
connectionProperties  当建立新连接时被发送给JDBC驱动的连接参数，
格式必须是 [propertyName=property;]*
注意 ：参数user/password将被明确传递，所以不需要包括在这里。

参数  默认值  描述
defaultAutoCommit  true  连接池创建的连接的默认的auto-commit状态
defaultReadOnly  driver default  连接池创建的连接的默认的read-only状态.
如果没有设置则setReadOnly方法将不会被调用. (某些驱动不支持只读模式,比如:Informix)
defaultTransactionIsolation  driver default  连接池创建的连接的默认的TransactionIsolation状态.
下面列表当中的某一个: (参考javadoc)

    * NONE
    * READ_COMMITTED
    * READ_UNCOMMITTED
    * REPEATABLE_READ
    * SERIALIZABLE

defaultCatalog   连接池创建的连接的默认的catalog

参数  默认值  描述
initialSize  0  初始化连接:连接池启动时创建的初始化连接数量,1.2版本后支持
maxActive  8  最大活动连接:连接池在同一时间能够分配的最大活动连接的数量,
如果设置为非正数则表示不限制
maxIdle  8  最大空闲连接:连接池中容许保持空闲状态的最大连接数量,超过的空闲连接将被释放,
如果设置为负数表示不限制
minIdle  0  最小空闲连接:连接池中容许保持空闲状态的最小连接数量,低于这个数量将创建新的连接,
如果设置为0则不创建
maxWait  无限  最大等待时间:当没有可用连接时,连接池等待连接被归还的最大时间(以毫秒计数),
超过时间则抛出异常,如果设置为-1表示无限等待

参数  默认值  描述
validationQuery   SQL查询,用来验证从连接池取出的连接,在将连接返回给调用者之前.如果指定,
则查询必须是一个SQL SELECT并且必须返回至少一行记录
testOnBorrow  true  指明是否在从池中取出连接前进行检验,如果检验失败,
则从池中去除连接并尝试取出另一个.
注意: 设置为true后如果要生效,validationQuery参数必须设置为非空字符串
testOnReturn  false  指明是否在归还到池中前进行检验
注意: 设置为true后如果要生效,validationQuery参数必须设置为非空字符串
testWhileIdle  false  指明连接是否被空闲连接回收器(如果有)进行检验.如果检测失败,
则连接将被从池中去除.
注意: 设置为true后如果要生效,validationQuery参数必须设置为非空字符串
timeBetweenEvictionRunsMillis  -1  在空闲连接回收器线程运行期间休眠的时间值,以毫秒为单位.
 如果设置为非正数,则不运行空闲连接回收器线程
numTestsPerEvictionRun  3  在每次空闲连接回收器线程(如果有)运行时检查的连接数量
minEvictableIdleTimeMillis  1000 * 60 * 30  连接在池中保持空闲而不被空闲连接回收器线程
(如果有)回收的最小时间值，单位毫秒

参数  默认值  描述
poolPreparedStatements  false  开启池的prepared statement 池功能
maxOpenPreparedStatements  不限制  statement池能够同时分配的打开的statements的最大数量,
如果设置为0表示不限制

这里可以开启PreparedStatements池. 当开启时, 将为每个连接创建一个statement池,
并且被下面方法创建的PreparedStatements将被缓存起来:
    * public PreparedStatement prepareStatement(String sql)
    * public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
注意: 确认连接还有剩余资源可以留给其他statement
参数  默认值  描述
accessToUnderlyingConnectionAllowed  false  控制PoolGuard是否容许获取底层连接

如果容许则可以使用下面的方式来获取底层连接:
    Connection conn = ds.getConnection();
    Connection dconn = ((DelegatingConnection) conn).getInnermostDelegate();
    ...
    conn.close();

默认false不开启, 这是一个有潜在危险的功能, 不适当的编码会造成伤害.
(关闭底层连接或者在守护连接已经关闭的情况下继续使用它).请谨慎使用,
并且仅当需要直接访问驱动的特定功能时使用.
注意: 不要关闭底层连接, 只能关闭前面的那个.
参数  默认值  描述
removeAbandoned  false  标记是否删除泄露的连接,如果他们超过了removeAbandonedTimout的限制.
如果设置为true, 连接被认为是被泄露并且可以被删除,如果空闲时间超过removeAbandonedTimeout.
设置为true可以为写法糟糕的没有关闭连接的程序修复数据库连接.
removeAbandonedTimeout  300  泄露的连接可以被删除的超时值, 单位秒
logAbandoned  false  标记当Statement或连接被泄露时是否打印程序的stack traces日志。
被泄露的Statements和连接的日志添加在每个连接打开或者生成新的Statement,
因为需要生成stack trace。

如果开启"removeAbandoned",那么连接在被认为泄露时可能被池回收. 这个机制在(getNumIdle() < 2)
 and (getNumActive() > getMaxActive() - 3)时被触发.
举例当maxActive=20, 活动连接为18,空闲连接为1时可以触发"removeAbandoned".
但是活动连接只有在没有被使用的时间超过"removeAbandonedTimeout"时才被删除,默认300秒.
在resultset中游历不被计算为被使用.

　　1.使用Java.util.Properties类的load()方法

　　示例：

　　2.使用java.util.ResourceBundle类的getBundle()方法

　　3.使用java.util.PropertyResourceBundle类的构造函数

　　4.使用class变量的getResourceAsStream()方法

　　5.使用class.getClassLoader()所得到的java.lang.ClassLoader的getResourceAsStream()方法

　　6.使用java.lang.ClassLoader类的getSystemResourceAsStream()静态方法

　　补充

　　Servlet中可以使用javax.servlet.ServletContext的getResourceAsStream()方法

  spring中有集成了javamail，在使用框架的时候用spring来发送mail也是很方便的。下面是一个spring mail的小例子。

  在这个例子中，除了需要struts和spring的框架外，还需要mail.jar,activation.jar.

  web.xml的代码：

  <?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
 xmlns="http://java.sun.com/xml/ns/j2ee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
 http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath*:spring/*.xml</param-value>
 </context-param>

 <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>
    <!-- Spring refresh Introspector to prevent from out of memory  -->
 <listener>
  <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
 </listener>
 <!-- Support session scope, Spring bean -->
 <listener>                                                       
      <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
 </listener>
 <!-- Struts2 Action Mapping-->
 <filter>
        <filter-name>struts2</filter-name>
        <filter-class>
            org.apache.struts2.dispatcher.FilterDispatcher
        </filter-class>
    </filter>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
   <!-- session time out -->
 <session-config>
  <session-timeout>30</session-timeout>
 </session-config>
 <!-- default index -->
 <welcome-file-list>
  <welcome-file>send.jsp</welcome-file>
 </welcome-file-list>
</web-app>
Java类MailAction.java:

package action;

import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSenderImpl;

import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionSupport;
public class MailAction extends ActionSupport{
 private JavaMailSenderImpl mailSender;
 private SimpleMailMessage mailMessage;
  public String sendMail(){
  SimpleMailMessage msg = new SimpleMailMessage(mailMessage);
        msg.setText("Spring Mail Simple!");
        mailSender.send(msg);
        return Action.SUCCESS;
 }
  public void setMailMessage(SimpleMailMessage mailMessage) {
  this.mailMessage = mailMessage;
 }

 public void setMailSender(JavaMailSenderImpl mailSender) {
  this.mailSender = mailSender;
 }

}
spring配置文件applicationContext.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd"
    default-autowire="byName" default-lazy-init="true">

 <bean id="mailAction" class="action.MailAction">
  <property name="mailSender" ref="mailSender"/>
  <property name="mailMessage" ref="mailMessage"/>
 </bean>
 
 <bean id="mailSender"
          class="org.springframework.mail.javamail.JavaMailSenderImpl">
        <property name="host" value="smtp.163.com"/>
            <!-- mail  account   -->
        <property name="username" value="shwwwx"/>
        <property name="password" value="wwx1226"/>
        <property name="javaMailProperties">
            <props>
                <prop key="mail.smtp.auth">true</prop>
            </props>
        </property>
    </bean>
      <!-- mail template -->
    <bean id="mailMessage" class="org.springframework.mail.SimpleMailMessage">
        <property name="to" value="shwwwx@163.com,nabelun@163.com"/>
        <property name="from" value="shwwwx@163.com"/>
        <property name="subject" value="Mail Simple"/>
    </bean>
</beans>

struts2的配置文件struts.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <constant name="struts.objectFactory" value="spring" />
    <constant name="struts.devMode" value="false" />
    <constant name="struts.i18n.encoding" value="utf-8" />
    <package name="springtimer"   extends="struts-default">
       <action name="mailsend" class="mailAction" method="sendMail">
        <result>sendok.jsp</result>
        <interceptor-ref name="defaultStack"/>
       </action>
    </package>
</struts>
页面send.jsp:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<html>
  <head>
    <title>My JSP 'send.jsp' starting page</title>
  </head>
  <body>
 <form action="mailsend.action" method="post">
  <input type="submit" value="邮件发送">
 </form>
  </body>
</html>

页面sendok.jsp:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>My JSP 'sendok.jsp' starting page</title>
  </head>
  <body>
    Send Mail Success! <br>
  </body>
</html>
运行send.jsp发送邮件，成功的话会跳转到sendok.jsp页面。

Passport 一方面意味着用一个帐号可以在不同服务里登录，另一方面就是在一个服务里面登录后可以无障碍的漫游到其他服务里面去。坦白说，目前 sohu passport 在这一点实现的很烂（不过俺的工作就是要把它做好啦，hehe）

搜狐的 SSO 需求比较麻烦，因为它旗下有好多域名：sohu.com、chinaren.com、sogou.com、focus.cn、17173.com、go2map.com，登录用户漫游的主要障碍也来自于此。

以前亿邮的邮件系统在和别的系统整合的时候是提供一个 URL，用户从第三方系统里面点击这个链接就可以生成访问邮件界面所需的 cookie，然后进入邮件。这个方式的确很有效，但问题是：
1. 每个外部链接都必须用特殊的 URL 跳转，维护很麻烦
2. 两个系统集成已经很麻烦了，若是集成的系统有好几个，彼此都需要跳转而缺乏一个中心机制就成了噩梦
3. 根本无法处理用户直接在地址栏输入地址进行访问的情况

即使是跨域，上述的解决方法相对来说还是容易的。
A. 首先是所有登录必须首先通过一个中央服务器进行认证，然后在它那里给浏览器种下 cookie（下面称之为 sso cookie）
B. 当用户访问另外的域名 app 的时候，浏览器是无法直接发送 sso cookie 给服务器认证的。此时应该利用 javascript，动态创建一个隐藏的 iframe，让其访问 sso
C. 这个 iframe 的请求是可以把 sso cookie 送给 sso server 的。sso server 验证 cookie 后，返回一个重定向页面到 app 的某个 URL，由该 URL 设置 app cookie
D. 此时浏览器上可看见的页面容器实际上也是可以和重定向回来的内容交互的。比如可以用 js 控制发现重定向页面成功返回后，就刷新整个页面，让它看起来和用户登录后访问没有什么区别。

下面是真正的技巧：怎样才能在 IE 里面跨域去设置 cookie
上述技术看起来是不是很好？但它的前提是所有的登录都 post 到 sso server 上，认证成功后再返回 app 页面。可我接受到的需求之一就是要支持页面无刷新登录。

哈！就是说本来在 chinaren.com 上提交登录表单的 action 应该是 passport.sohu.com 这个 sso server。可是在 AJAX 大潮下，chinaren 计划采用 XMLHTTPRequest 提交，这个就麻烦了，因为是不能跨域来提交的。

那么解决方法就是跨域产生 cookie，即 js 发现口令校验成功后，再在 passport.sohu.com 上种上合法的 cookie.

套用上面的跨域读 cookie 的方案似乎很简单去推论：就是创建一个隐含的 iframe，让那个 iframe 去调用 passport.sohu.com 的 URL 来产生 cookie。很遗憾，此方法在 Fx 下工作的很好，但是不能在 IE 上应用。（在 IE 状态栏上显示 cookie 隐私警告，红色圆底白横杠）

我试了很多很多方法，包括创建 、 node，包括用 js 设置，但都一次次被 IE 无情的挡在了浏览器外。google 之，也没有任何真正可用的答案，中文网页要么介绍的方法是错的，要么说无解。

最后还是在 chinaren 一哥们的帮助下，翻出了他们所使用的，以和 alumni.sohu.com 交互的方法（不知道是哪位牛人发现的），只需要设置 P3P HTTP Header，在隐含 iframe 里面跨域设置 cookie 就可以成功。他们所用的内容是：

P3P: CP="CURa ADMa DEVa PSAo PSDo OUR BUS UNI PUR INT DEM STA PRE COM NAV OTC NOI DSP COR"

最后是我做的一个小小的演示：cookie 怎么在 vmx.cn 和 dup2.net 之间交互

1. http://qiuyingbo.test.vmx.cn/cookie.php

2. 随便输入什么，点 reset cookie，就可以看到 vmx.cn 的 cookie 已经被设上了

3. 在该页面点连接到 http://www.dup2.net/vmx/cookie.html

4. 点"get corss-domain cookie" .. （此时 js 会去创建一个iframe，请求 qiuyingbo.test.vmx.cn ，返回页面把 cookie 值作为 GET 参数重定向回 dup2.net 的另外一个URL。）

5. 点 "display corss-domain cookie" .. 就可以看到 vmx.cn 的 cookie 了

6. 在该页面的输入框中输入其它的值，然后点 "set cross-domain cookie"，该行为将主动设置 vmx.cn 的 cookie

7. 点链接回到 http://qiuyingbo.test.vmx.cn/cookie.php ，就可以看到新的值了

网上看了别人介绍的一片文章，说使用P3P可以完成跨域COOKIE操作，感觉很COOL，不过没有提供源代码，我胡乱写了一下，大家看看。

实际工作中，类似这样的要求很多，比如说，我们有两个域名，我们想实现在一个域名登录后，能自动完成另一个域名的登录，也就是PASSPORT的功能。

我只写一个大概，为了测试的方便，先编辑hosts文件，加入测试域名（C:\WINDOWS\system32\drivers\etc\hosts）

127.0.0.1       www.a.com
127.0.0.1       www.b.com

首先：创建 a_setcookie.php 文件，内容如下：

<?php 
//header('P3P: CP="CURa ADMa DEVa PSAo PSDo OUR BUS UNI PUR INT DEM STA PRE COM NAV OTC NOI DSP COR"'); 

setcookie("test", $_GET['id'], time()+3600, "/", ".a.com"); 
?>

然后：创建 a_getcookie.php 文件，内容如下：

<?php 
var_dump($_COOKIE); 
?> 

最后：创建 b_setcookie.php 文件，内容如下：

<script src="http://www.a.com/a_setcookie.php?id=www.b.com"></script>

－－－－－－－－－－－－－－－－－－－－－－－－－－－－

三个文件创建完毕后，我们通过浏览器依次访问：

http://www.b.com/b_setcookie.php
http://www.a.com/a_getcookie.php

我们会发现，在访问b.com域的时候，我们并没有在a.com域设置上cookie值。

然后我们修改一下a_setcookie.php文件，去掉注释符号，a_setcookie.php即为：

<?php  
header('P3P: CP="CURa ADMa DEVa PSAo PSDo OUR BUS UNI PUR INT DEM STA PRE COM NAV OTC NOI DSP COR"');  

setcookie("test", $_GET['id'], time()+3600, "/", ".a.com");  
?> 

再次通过浏览器依次访问：

http://www.b.com/b_setcookie.php
http://www.a.com/a_getcookie.php

这次，你会发现在访问b.com域的时候，我们设置了a.com域的cookie值。

末了补充一句，似乎只有IE对跨域访问COOKIE限制比较严格，上述代码在FIREFOX下测试，即使不发送P3P头信息，也能成功。不过IE是老大啊。

参考文档：http://www.w3.org/P3P/

1、采用RequestDispatcher的方式进行

            jsp页面中添加如下代码：
           <%
      response.setContentType("application/x-download");//设置为下载application/x-download
      String filedownload = "/要下载的文件名";//即将下载的文件的相对路径
      String filedisplay = "最终要显示给用户的保存文件名";//下载文件时显示的文件保存名称
      filenamedisplay = URLEncoder.encode(filedisplay,"UTF-8");
      response.addHeader("Content-Disposition","attachment;filename=" + filedisplay);
    
      try
      {
          RequestDispatcher dis = application.getRequestDispatcher(filedownload);
          if(dis!= null)
          {
              dis.forward(request,response);
          }
          response.flushBuffer();
      }
      catch(Exception e)
      {
          e.printStackTrace();
      }
      finally
      {
    
      }
%>

2、采用文件流输出的方式下载

         <%@page language="java" contentType="application/x-msdownload"    pageEncoding="gb2312"%><%
      //关于文件下载时采用文件流输出的方式处理：
      //加上response.reset()，并且所有的％>后面不要换行，包括最后一个；

      response.reset();//可以加也可以不加
      response.setContentType("application/x-download");
      String filedownload = "想办法找到要提供下载的文件的物理路径＋文件名";
      String filedisplay = "给用户提供的下载文件名";
      filedisplay = URLEncoder.encode(filedisplay,"UTF-8");
      response.addHeader("Content-Disposition","attachment;filename=" + filedisplay);

      OutputStream outp = null;
      FileInputStream in = null;
      try
      {
          outp = response.getOutputStream();
          in = new FileInputStream(filenamedownload);

          byte[] b = new byte[1024];
          int i = 0;

          while((i = in.read(b)) > 0)
          {
              outp.write(b, 0, i);
          }
          outp.flush();
      }
      catch(Exception e)
      {
          System.out.println("Error!");
          e.printStackTrace();
      }
      finally
      {
          if(in != null)
          {
              in.close();
              in = null;
          }
          if(outp != null)
          {
              outp.close();
              outp = null;
          }
      }
%>

在wsad里面写JSP文件下载,总是出现这个异常,getOutputStream() has already been called for this response,输出流已经被调用了.

      上网查半天终于明白一点,JSP早下载文件的时候用到了OutputStream,而在Application Server在处理编译jsp时对于％>和<％之间的内容一般是原样输出，而且默认是PrintWriter.

我们不可能列举所有可能的顽固，我们会针对几种最常见的问题进行处理。当然了，正如前面说到的，如果我们自己使用 java.net.HttpURLConnection来搞定这些问题是很恐怖的事情，因此在开始之前我们先要介绍一下一个开放源码的项目，这个项目就是 Apache开源组织中的httpclient，它隶属于Jakarta的commons项目，目前的版本是2.0RC2。commons下本来已经有一个net的子项目，但是又把httpclient单独提出来，可见http服务器的访问绝非易事。

Commons-httpclient项目就是专门设计来简化HTTP客户端与服务器进行各种通讯编程。通过它可以让原来很头疼的事情现在轻松的解决，例如你不再管是HTTP或者HTTPS的通讯方式，告诉它你想使用HTTPS方式，剩下的事情交给httpclient替你完成。本文会针对我们在编写HTTP客户端程序时经常碰到的几个问题进行分别介绍如何使用httpclient来解决它们，为了让读者更快的熟悉这个项目我们最开始先给出一个简单的例子来读取一个网页的内容，然后循序渐进解决掉前进中的所有问题。

1． 读取网页(HTTP/HTTPS)内容

下面是我们给出的一个简单的例子用来访问某个页面

/*

 * Created on 2003-12-14 by Liudong

 */

package http.demo;

import java.io.IOException;

import org.apache.commons.httpclient.*;

import org.apache.commons.httpclient.methods.*;

/**

 * 最简单的HTTP客户端,用来演示通过GET或者POST方式访问某个页面

 * @author Liudong

 */

public class SimpleClient {

    public static void main(String[] args) throws IOException

    {

        HttpClient client = new HttpClient();   

        //设置代理服务器地址和端口    

        //client.getHostConfiguration().setProxy("proxy_host_addr",proxy_port);

        //使用GET方法，如果服务器需要通过HTTPS连接，那只需要将下面URL中的http换成https

        HttpMethod method = new GetMethod("http://java.sun.com");

        //使用POST方法

        //HttpMethod method = new PostMethod("http://java.sun.com");

        client.executeMethod(method);

        //打印服务器返回的状态

        System.out.println(method.getStatusLine());

        //打印返回的信息

        System.out.println(method.getResponseBodyAsString());

        //释放连接

        method.releaseConnection();

    }
}

在这个例子中首先创建一个HTTP客户端(HttpClient)的实例，然后选择提交的方法是GET或者POST，最后在HttpClient实例上执行提交的方法，最后从所选择的提交方法中读取服务器反馈回来的结果。这就是使用HttpClient的基本流程。其实用一行代码也就可以搞定整个请求的过程，非常的简单！

从作用域范围来说,Servlet的作用域有ServletContext,HttpSession,ServletRequest.

Context范围:
    
ServletContextListener:
对一个应用进行全局监听.随应用启动而启动,随应用消失而消失主要有两个方法:
contextDestroyed(ServletContextEvent event) 
 在应用关闭的时候调用
contextInitialized(ServletContextEvent event) 
在应用启动的时候调用

这个监听器主要用于一些随着应用启动而要完成的工作,也就是很多人说的我想在容器
启动的时候干..........
一般来说对"全局变量"初始化,如
public void contextInitialized(ServletContextEvent event){
    ServletContex sc = event.getServletContext();
    sc.setAttribute(name,value);
}
以后你就可以在任何servlet中getServletContext().getAttribute(name);
我最喜欢用它来做守护性工作,就是在contextInitialized(ServletContextEvent event) 
方法中实现一个Timer,然后就让应用在每次启动的时候让这个Timer工作:
public void contextInitialized(ServletContextEvent event){
    timer = new Timer();
    timer.schedule(new TimerTask(){
        public void run(){
            //do any things
        }
    },0,时间间隔);
}

    有人说Timer只能规定从现在开始的多长时间后,每隔多久做一次事或在什么时间做
一次事,那我想在每月1号或每天12点做一项工作如何做呢?
你只要设一个间隔,然后每次判断一下当时是不是那个时间段就行了啊,比如每月一号做,那你
时间间隔设为天,即24小时一个循环,然后在run方法中判断当时日期new Date().getDate()==1
就行了啊.如果是每天的12点,那你时间间隔设为小时,然后在run中判断new Date().getHour()
==12,再做某事就行了.

ServletContextAttributeListener:

这个监听器主要监听ServletContex对象在setAttribute()和removeAttribute()的事件,注意
也就是一个"全局变量"在被Add(第一次set),replace(对已有的变量重新赋值)和remove的时候.
分别调用下面三个方法:
public void attributeAdded(ServletContextAttributeEvent scab)这个方法不仅可以知道
哪些全局变量被加进来,而且可获取容器在启动时自动设置了哪些context变量:

public void attributeAdded(ServletContextAttributeEvent scab){
    System.out.println(scab.getName());
}
  public void attributeRemoved(ServletContextAttributeEvent scab) 

  public void attributeReplaced(ServletContextAttributeEvent scab) 
  
  








Session范围:
HttpSessionListener:
这个监听器主要监听一个Session对象被生成和销毁时发生的事件.对应有两个方法:
  public void sessionCreated(HttpSessionEvent se) 

  public void sessionDestroyed(HttpSessionEvent se)

  一般来说,一个session对象被create时,可以说明有一个新客端进入.可以用来粗略统计在线人
数,注意这不是精确的,因为这个客户端可能立即就关闭了,但sessionDestroyed方法却会按一定
的策略很久以后才会发生.

HttpSessionAttributeListener:
和ServletContextAttributeListener一样,它监听一个session对象的Attribut被Add(一个特定
名称的Attribute每一次被设置),replace(已有名称的Attribute的值被重设)和remove时的事件.
对就的有三个方法.
  public void attributeAdded(HttpSessionBindingEvent se) 

  public void attributeRemoved(HttpSessionBindingEvent se) 

  public void attributeReplaced(HttpSessionBindingEvent se) 

  上面的几个监听器的方法,都是在监听应用逻辑中servlet逻辑中发生了什么事,一般的来说.
我们只要完成逻辑功能,比如session.setAttribute("aaa","111");我只要把一个名为aaa的变量
放在session中以便以后我能获取它,我并不关心当session.setAttribute("aaa","111");发生时
我还要干什么.(当然有些时候要利用的),但对于下面这个监听器,你应该好好发解一下:

HttpSessionBindingListener:
上面的监听器都是作为一个独立的Listener在容器中控制事件的.而HttpSessionBindingListener
对在一对象中监听该对象的状态,实现了该接口的对象如果被作为value被add到一个session中或从
session中remove,它就会知道自己已经作为一个session对象或已经从session删除,这对于一些非
纯JAVA对象,生命周期长于session的对象,以及其它需要释放资源或改变状态的对象非常重要.
比如:
session.setAttribute("abcd","1111");
以后session.removeAttribute("abcd");因为abcd是一个字符中,你从session中remove后,它就会
自动被垃圾回收器回收,而如果是一个connection:(只是举例,你千万不要加connection往session
中加入)
session.setAttribute("abcd",conn);
以后session.removeAttribute("abcd");这时这个conn被从session中remove了,你已经无法获取它
的句柄,所以你根本没法关闭它.而在没有remove之前你根本不知道什么时候要被remove,你又无法
close(),那么这个connection对象就死了.另外还有一些对象可以在被加入一个session时要锁定
还要被remove时要解锁,应因你在程序中无法判断什么时候被remove(),add还好操作,我可以先加锁
再add,但remove就后你就找不到它的句柄了,根本没法解锁,所以这些操作只能在对象自身中实现.
也就是在对象被add时或remove时通知对象自己回调相应的方法:

MyConn extends Connection implements HttpSessionBindingListener{
  public void valueBound(HttpSessionBindingEvent se){
    this.initXXX();
  }
  public void valueUnbound(HttpSessionBindingEvent se){

    this.close();
  }
}

session.setAttribute("aaa",new MyConn());
这时如果调用session.removeAttribute("aaa"),则触发valueUnbound方法,就会自动关闭自己.
而其它的需要改变状态的对象了是一样.

另外还有一个HttpSessionActivationListener监听器是实现分布式应用中session同步的.不作
多介绍,如果有要实现该功能的朋友可以和我联系.




在servlet2.4中,对于request范围已经实现对应的监听器:
ServletRequestListener，ServletRequestAttributeListener
但没有找到好的容器的支持所以没有做过多的测试.虽然从API可以掌握99%,但没有经过真正的
测试我是不会仅把API抄出来的.以后我会补齐这方面的内容

原作者:Axman

垃圾收集器(Garbage Collector，GC)对Java程序员来说，基本 上是透明的，但是一个优秀的Java程序员必须了解GC的工作原理、如何优化GC的性能、如何与GC进行有限的交互，因为有一些应用程序对性能要求较高，例如嵌入式系统、实时系统等，只有全面提升内存的管理效率 ,才能提高整个应用程序的性能。本篇文章首先简单介绍GC的工作原理之后，然后再对GC的几个关键问题进行深入探讨，最后提出一些Java程序设计建议，从GC角度提高Java程序的性能。

一GC的基本原理

Java的内存管理实际上就是对象的管理，其中包括对象的分配和释放。

对于程序员来说，分配对象使用new关键字；释放对象时，只要将对象所有引用赋值为null，让程序不能够再访问到这个对象，我们称该对象为"不可达的"。GC将负责回收所有"不可达"对象的内存空间。

对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象(详见参考资料1 )。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。但是，为了保证GC能够在不同平台实现的问题，Java规范对GC的很多行为都没有进行严格的规定。例如，对于采用什么类型的回收算法、什么时候进行回收等重要问题都没有明确的规定。因此，不同的JVM的实现者往往有不同的实现算法。这也给Java程序员的开发带来行多不确定性。本文研究了几个与GC工作相关的问题，努力减少这种不确定性给Java程序带来的负面影响。

二 增量式GC( Incremental GC )

GC在JVM中通常是由一个或一组进程来实现的，它本身也和用户程序一样占用heap空间，运行时也占用CPU。当GC进程运行时，应用程序停止运行。因此，当GC运行时间较长时，用户能够感到Java程序的停顿，另外一方面，如果GC运行时间太短，则可能对象回收率太低，这意味着还有很多应该回收的对象没有被回收，仍然占用大量内存。因此，在设计GC的时候，就必须在停顿时间和回收率之间进行权衡。一个好的GC实现允许用户定义自己所需要的设置，例如有些内存有限有设备，对内存的使用量非常敏感，希望GC能够准确的回收内存，它并不在意程序速度的放慢。另外一些实时网络游戏，就不能够允许程序有长时间的中断。增量式GC就是通过一定的回收算法，把一个长时间的中断，划分为很多个小的中断，通过这种方式减少GC对用户程序的影响。虽然，增量式GC在整体性能上可能不如普通GC的效率高，但是它能够减少程序的最长停顿时间。

下图就表示了，增量式GC和普通GC的比较。其中灰色部分表示线程占用CPU的时间。

Sun JDK提供的HotSpot JVM就能支持增量式GC。HotSpot JVM缺省GC方式为不使用增量GC，为了启动增量GC，我们必须在运行Java程序时增加-Xincgc的参数。HotSpot JVM增量式GC的实现是采用Train GC算法。它的基本想法就是，将堆中的所有对象按照创建和使用情况进行分组(分层)，将使用频繁高和具有相关性的对象放在一队中，随着程序的运行，不断对组进行调整。当GC运行时，它总是先回收最老的(最近很少访问的)的对象，如果整组都为可回收对象，GC将整组回收。这样，每次GC运行只回收一定比例的不可达对象，保证程序的顺畅运行。Train GC算法是一个非常好的算法，具体算法见参考资料4。

三 详解finalize函数

finalize是位于Object类的一个方法，该方法的访问修饰符为protected，由于所有类为Object的子类，因此用户类很容易访问到这个方法。由于，finalize函数没有自动实现链式调用，我们必须手动的实现，因此finalize函数的最后一个语句通常是super.finalize()。通过这种方式，我们可以实现从下到上实现finalize的调用，即先释放自己的资源，然后再释放父类的资源。

根据Java语言规范，JVM保证调用finalize函数之前，这个对象是不可达的，但是JVM不保证这个函数一定会被调用。另外，规范还保证finalize函数最多运行一次。

很多Java初学者会认为这个方法类似与C++中的析构函数，将很多对象、资源的释放都放在这一函数里面。其实，这不是一种很好的方式。原因有三，其一，GC为了能够支持finalize函数，要对覆盖这个函数的对象作很多附加的工作。其二，在finalize运行完成之后，该对象可能变成可达的，GC还要再检查一次该对象是否是可达的。因此，使用finalize会降低GC的运行性能。其三，由于GC调用finalize的时间是不确定的，因此通过这种方式释放资源也是不确定的。

通常，finalize用于一些不容易控制、并且非常重要资源的释放，例如一些I/O的操作，数据的连接。这些资源的释放对整个应用程序是非常关键的。在这种情况下，程序员应该以通过程序本身管理(包括释放)这些资源为主，以finalize函数释放资源方式为辅，形成一种双保险的管理机制，而不应该仅仅依靠finalize来释放资源。

下面给出一个例子说明，finalize函数被调用以后，仍然可能是可达的，同时也可说明一个对象的finalize只可能运行一次。

class MyObject{
    Test main; //记录Test对象，在finalize中时用于恢复可达性
    public MyObject(Test t)
    {	 
	main=t; //保存Test 对象
    }
    protected void finalize()
    {
	main.ref=this;// 恢复本对象，让本对象可达
	System.out.println("This is finalize");//用于测试finalize只运行一次
    }
}

class Test {
	MyObject ref;
 	public static void main(String[] args) {
 		Test test=new Test();
 		test.ref=new MyObject(test);
 		test.ref=null; //MyObject对象为不可达对象，finalize将被调用
 		System.gc(); 
 		if (test.ref!=null) System.out.println("My Object还活着");	
	}
}

运行结果：
This is finalize
MyObject还活着

此例子中，需要注意的是虽然MyObject对象在finalize中变成可达对象，但是下次回收时候，finalize却不再被调用，因为finalize函数最多只调用一次。

四 程序如何与GC进行交互

Java2增强了内存管理功能， 增加了一个java.lang.ref包，其中定义了三种引用类。这三种引用类分别为SoftReference、WeakReference和PhantomReference。通过使用这些引用类，程序员可以在一定程度与GC进行交互，以便改善GC的工作效率。这些引用类的引用强度介于可达对象和不可达对象之间。它们的引用强度如下图所示：

创建一个引用对象也非常容易，例如如果你需要创建一个Soft Reference对象，那么首先创建一个对象，并采用普通引用方式(可达对象)；然后再创建一个SoftReference引用该对象；最后将普通引用设置为null。通过这种方式，这个对象就只有一个Soft Reference引用。同时，我们称这个对象为Soft Reference 对象。

Soft Reference的主要特点是据有较强的引用功能。只有当内存不够的时候，才进行回收这类内存，因此在内存足够的时候，它们通常不被回收。另外，这些引用对象还能保证在Java抛出OutOfMemory 异常之前，被设置为null。它可以用于实现一些常用图片的缓存，实现Cache的功能，保证最大限度的使用内存而不引起OutOfMemory。以下给出这种引用类型的使用伪代码；

//申请一个图像对象
Image image=new Image();//创建Image对象
…
//使用 image
…
//使用完了image，将它设置为soft 引用类型，并且释放强引用；
SoftReference sr=new SoftReference(image);
image=null;
	…
	//下次使用时
	if (sr!=null) image=sr.get();
	else{
	//由于GC由于低内存，已释放image，因此需要重新装载；
	image=new Image();
sr=new SoftReference(image);
}

Weak引用对象与Soft引用对象的最大不同就在于：GC在进行回收时，需要通过算法检查是否回收Soft引用对象，而对于Weak引用对象，GC总是进行回收。Weak引用对象更容易、更快被GC回收。虽然，GC在运行时一定回收Weak对象，但是复杂关系的Weak对象群常常需要好几次GC的运行才能完成。Weak引用对象常常用于Map结构中，引用数据量较大的对象，一旦该对象的强引用为null时，GC能够快速地回收该对象空间。该例子见参考资料4;

Phantom引用的用途较少，主要用于辅助finalize函数的使用。Phantom对象指一些对象，它们执行完了finalize函数，并为不可达对象，但是它们还没有被GC回收。这种对象可以辅助finalize进行一些后期的回收工作，我们通过覆盖Reference的clear()方法，增强资源回收机制的灵活性。

五一些Java编码的建议

根据GC的工作原理，我们可以通过一些技巧和方式，让GC运行更加有效率，更加符合应用程序的要求。以下就是一些程序设计的几点建议。

1. 最基本的建议就是尽早释放无用对象的引用。大多数程序员在使用临时变量的时候，都是让引用变量在退出活动域(scope)后，自动设置为null。我们在使用这种方式时候，必须特别注意一些复杂的对象图，例如数组，队列，树，图等，这些对象之间有相互引用关系较为复杂。对于这类对象，GC回收它们一般效率较低。如果程序允许，尽早将不用的引用对象赋为null。这样可以加速GC的工作。
2. 尽量少用finalize函数。finalize函数是Java提供给程序员一个释放对象或资源的机会。但是，它会加大GC的工作量，因此尽量少采用finalize方式回收资源。
3. 如果需要使用经常使用的图片，可以使用soft应用类型。它可以尽可能将图片保存在内存中，供程序调用，而不引起OutOfMemory。
4. 注意集合数据类型，包括数组，树，图，链表等数据结构，这些数据结构对GC来说，回收更为复杂。另外，注意一些全局的变量，以及一些静态变量。这些变量往往容易引起悬挂对象(dangling reference)，造成内存浪费。
5. 当程序有一定的等待时间，程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。使用增量式GC可以缩短Java程序的暂停时间。

参考资料

文章

1. 欧阳辰，周欣 "Java与内存泄漏" http://www-900.ibm.com/developerWorks/cn/java/l-JavaMemoryLeak/index.shtml
2. Y. Srinivas Ramakrishna "Atuomatic Memory Management in the Java HotSpot Virtual Machine"，此文章JavaOne2002的演讲材料, http://java.sun.com/javaone
3. Monica Pawlan "Reference Objects and Garbage Collector" 此文章为JDC的文章，可在http://developer.java.sun.com/上找到
4. Bill Venners Chapter 9 of "Inside the Java 2 Virtual Machine" http://www.artima.com/insidejvm/ed2/ch09GarbageCollectionPrint.html
5. Sun Microsystems, "Java Language Specification, Second Version"

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=281108

Spring整合C3P0的配置

#<!-- 初始化连接 -->
dataSource.initialSize=10

#<!-- 最大空闲连接 -->
dataSource.maxIdle=20

#<!-- 最小空闲连接 -->
dataSource.minIdle=5

#最大连接数量
dataSource.maxActive=50

#是否在自动回收超时连接的时候打印连接的超时错误
dataSource.logAbandoned=true

#是否自动回收超时连接
dataSource.removeAbandoned=true

#超时时间(以秒数为单位)
#设置超时时间有一个要注意的地方，超时时间=现在的时间-程序中创建Connection的时间，如果maxActive比较大，比如超过100，那么removeAbandonedTimeout可以设置长一点比如180，也就是三分钟无响应的连接进行回收，当然应用的不同设置长度也不同。
dataSource.removeAbandonedTimeout=180

#<!-- 超时等待时间以毫秒为单位 -->
#maxWait代表当Connection用尽了，多久之后进行回收丢失连接
dataSource.maxWait=1000

　　以下是我在连接控制中调用的方法：

        Properties  dbProps=null;
　　//下面的读取配置文件可以根据实际的不同修改
        dbProps = ConfigProperties.getInstance().getProperties("jdbc.properties");
        try {
         String driveClassName = dbProps.getProperty("jdbc.driverClassName");
         String url = dbProps.getProperty("jdbc.url");
         String username = dbProps.getProperty("jdbc.username");
         String password = dbProps.getProperty("jdbc.password");
         
         String initialSize = dbProps.getProperty("dataSource.initialSize");
         String minIdle = dbProps.getProperty("dataSource.minIdle");
         String maxIdle = dbProps.getProperty("dataSource.maxIdle");
         String maxWait = dbProps.getProperty("dataSource.maxWait");
         String maxActive = dbProps.getProperty("dataSource.maxActive");
           //是否在自动回收超时连接的时候打印连接的超时错误
          boolean logAbandoned = (Boolean.valueOf(dbProps.getProperty("dataSource.logAbandoned","false"))).booleanValue();

          //是否自动回收超时连接
          boolean removeAbandoned = (Boolean.valueOf(dbProps.getProperty("dataSource.removeAbandoned","false"))).booleanValue();

          //超时时间(以秒数为单位)
          int removeAbandonedTimeout = Integer.parseInt(dbProps.getProperty("dataSource.removeAbandonedTimeout","300"));
        
         dataSource = new BasicDataSource();
         dataSource.setDriverClassName(driveClassName);
         dataSource.setUrl(url);
         dataSource.setUsername(username);
         dataSource.setPassword(password);

         //初始化连接数
         if(initialSize!=null)
          dataSource.setInitialSize(Integer.parseInt(initialSize));
         
         //最小空闲连接
         if(minIdle!=null)
          dataSource.setMinIdle(Integer.parseInt(minIdle));

         //最大空闲连接
         if(maxIdle!=null)
          dataSource.setMaxIdle(Integer.parseInt(maxIdle));
         
         //超时回收时间(以毫秒为单位)
         if(maxWait!=null)
          dataSource.setMaxWait(Long.parseLong(maxWait));
         
         //最大连接数
         if(maxActive!=null){
          if(!maxActive.trim().equals("0"))
           dataSource.setMaxActive(Integer.parseInt(maxActive));
         }

         System.out.println("logAbandoned="+logAbandoned);
            dataSource.setLogAbandoned(logAbandoned);
         dataSource.setRemoveAbandoned(removeAbandoned);
         dataSource.setRemoveAbandonedTimeout(removeAbandonedTimeout);
         
         Connection conn = dataSource.getConnection();
         if(conn==null){
          log.error("创建连接池时,无法取得连接!检查设置!!!");
         }else{
          conn.close();
         }
         log.error("连接池创建成功!!!");
        }
        catch (Exception e) {
              log.error("创建连接池失败!请检查设置!!!");
        }

有误的地方欢迎指正!      by yy。。。。。。

Hibernate支持DBCP包进行数据库连接池的配置。简要说明配置过程：
(仅仅是个人摸索，如有问题，欢迎指点)
需要的包：
Commons-Pool （下载地址：http://jakarta.apache.org/commons/pool/） ：提供一个一般对象池的接口，而且包含实现了通常池工具箱。
Commons-DBCP（下载地址：http://jakarta.apache.org/commons/dbcp/） ：提供数据库连接池服务。DBCP很聪明，把Commons-Pool和JDBC的driver封装起来，使达到连接池的目的。

Hibernate属性文件的配置参数
#连接池的最大活动个数
hibernate.dbcp.maxActive 100
#当连接池中的连接已经被耗尽的时候，DBCP将怎样处理( 0 = 失败, 1 = 等待, 2= 增长)
hibernate.dbcp.whenExhaustedAction 1
#最大等待时间
hibernate.dbcp.maxWait 120000
#没有人用连接的时候，最大闲置的连接个数。
hibernate.dbcp.maxIdle 10
##以下是对prepared statement的处理，同上。
hibernate.dbcp.ps.maxActive 100
hibernate.dbcp.ps.whenExhaustedAction 1
hibernate.dbcp.ps.maxWait 120000
hibernate.dbcp.ps.maxIdle 10

## 可选，是否对池化的连接进行验证
#给出一条简单的sql语句进行验证
#hibernate.dbcp.validationQuery select 1 from dual
#在取出连接时进行有效验证
#hibernate.dbcp.testOnBorrow true
#在放回连接时进行有效验证
#hibernate.dbcp.testOnReturn false

#Hibernate已经实现了DBCP Provider实现，别忘了在下面的键值去掉＃字符
hibernate.connection.provider_class net.sf.hibernate.connection.DBCPConnectionProvider

1. <property name="connection.pool.size">2</property>  
2. <property name="statement_cache.size">25</property>  
3. <property name="jdbc.fetch_size">50</property>  
4. <property name="jdbc.batch_size">30</property>  
5.   
6. <property name="show_sql">true</property>  
7. <property name="connection.provider_class">net.sf.hibernate.connection.DBCPConnectionProvider</property>  
8. <property name="dbcp.maxActive">100</property>  
9. <property name="dbcp.whenExhaustedAction">1</property>  
10. <property name="dbcp.maxWait">120000</property>  
11. <property name="dbcp.maxIdle">10</property>  
12. <property name="dbcp.ps.maxActive">100</property>  
13. <property name="dbcp.ps.whenExhaustedAction">1</property>  
14. <property name="dbcp.ps.maxWait">120000</property>  
15. <property name="dbcp.ps.maxIdle">100</property>  

打开网站开始寻找我的目标,发现这个东西居然有好多版本.比如

<%@ page contentType="text/html; charset=GBK" %>
<html>
<head>
<title>
JSON示例
</title>
<script type="text/javascript" src="zxml.src.js"></script>
<script type="text/javascript" src="json.js"></script>
<script type="text/javascript">
 var xmlHttp;
       
        //创建对象
        function createXMLHttpRequest(){
         xmlHttp = zXmlHttp.createRequest();
        }
       
        function doJSON(){
           //得到Car对象
         var car = getCarObject();
               
                //用JSON字符串化car对象
                var carAsJSON = car.toJSONString();
                alert("汽车对象JSON化为:\n" + carAsJSON);
               
                var url = "JSONExample?timeStamp=" + new Date().getTime();
               
                //创建对象
                createXMLHttpRequest();
                xmlHttp.open("POST",url,true);
                xmlHttp.onreadystatechange = handleStateChange;
                xmlHttp.setRequestHeader("Content-Type","application/x-www-form.urlencoded");
                xmlHttp.send(carAsJSON);
        }
       
        //回调方法
        function handleStateChange(){
         if (xmlHttp.readyState == 4){
                 if (xmlHttp.status == 200){
                         parseResults();
                        }
                }
        }
       
        //解析结果
        function parseResults(){
         var responseDiv = document.getElementById("serverResponse");
                if (responseDiv.hasChildNodes()){
                 responseDiv.removeChild(responseDiv.childNode[0]);
                }
               
                var responseText = document.createTextNode(xmlHttp.responseText);
                responseDiv.appendChild(responseText);
        }
       
        //得到Car对象
        function getCarObject(){
         return new Car("Dodge","Coronet R/T",1968,"yellow");
        }
       
       
        //Car构造函数
        function Car(make,model,year,color){
         this.make = make;
                this.model = model;
                this.year = year;
                this.color = color;
        }
</script>
</head>
<body>
<br /><br />
<form action="#">
  <input type="button" value="发送JSON数据" onclick="doJSON();"/>
</form>
<h2>
  服务器响应：
</h2>
<div id="serverResponse">
</div>
</body>
</html>

    服务器：JSONExample.java

package ajaxbook.chap4;

import java.io.*;
import java.net.*;
import java.text.ParseException;
import javax.servlet.*;
import javax.servlet.http.*;
import org.json.JSONObject;

public class JSONExample
    extends HttpServlet {
  //处理Post方法
  protected void doPost(HttpServletRequest request,
                        HttpServletResponse response) throws ServletException,
      IOException {
    String json = readJSONStringFromRequestBody(request);

    //使用JSON绑字Ajax对象
    JSONObject jsonObject = null;
    try {
      jsonObject = new JSONObject(json);
    }
    catch (ParseException pe) {
      System.out.println("ParseException: " + pe.toString());
    }

    //返回输出结果
    String responseText = "You have a " + jsonObject.getInt("year") + " "
        + jsonObject.getString("make") + " " + jsonObject.getString("model")
        + " " + " that is " + jsonObject.getString("color") + " in color.";

    response.setContentType("text/xml");
    response.getWriter().print(responseText);
  }

  //得到参数
  private String readJSONStringFromRequestBody(HttpServletRequest request) {
    StringBuffer json = new StringBuffer();
    String line = null;
    try {
      BufferedReader reader = request.getReader();
      while ( (line = reader.readLine()) != null) {
        json.append(line);
      }
    }
    catch (Exception e) {
      System.out.println("Error reading JSON string: " + e.toString());
    }
    return json.toString();
  }
}

注意：要引入json.js和json的源文件，使用json.jar不行，源文件参见书籍源代码第三章

参考：Ajax基础教程  作笔记吧 

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=975204

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class Test {
 public static void main(String[] args) {
  final String dayNames[] = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五",
    "星期六" };

  String s = "2006-01-12 16:30";
  SimpleDateFormat sdfInput = new SimpleDateFormat("yyyy-MM-dd HH:mm");

  Calendar calendar = Calendar.getInstance();
  Date date = new Date();

  try {
   date = sdfInput.parse(s);
  } catch (ParseException e) {
   e.printStackTrace();
  }

  calendar.setTime(date);
  int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK)-1;
  if(dayOfWeek<0)dayOfWeek=0;
 System.out.println(dayNames[dayOfWeek]);
 }
}

function GradientShow() //实现淡入的函数
{
    ie5menu.filters.alpha.opacity+=intInterval
    if (ie5menu.filters.alpha.opacity<100) setTimeout("GradientShow()",intDelay)
}
   
function GradientClose() //实现淡出的函数
    {
    ie5menu.filters.alpha.opacity-=intInterval
    if (ie5menu.filters.alpha.opacity>0) {
     setTimeout("GradientClose()",intDelay)
     }
    else {
     ie5menu.style.visibility="hidden"
     }
}

function ChangeBG() //改变菜单项的背景颜色，这里的两种颜色值可以改为你需要的
{
    oEl=event.srcElement
    if (oEl.style.background!="navy") {
        oEl.style.background="navy"
    }
    else {
        oEl.style.background="#cccccc"
    }
}
// -->
</SCRIPT>

<STYLE type=text/CSS>
.cMenu {
    FILTER: alpha(opacity=0);BACKGROUND-COLOR: #D6D3CE;BORDER-BOTTOM: #666666 2px solid; BORDER-LEFT: #E4E4E4 2px solid; BORDER-RIGHT: #666666 2px solid; BORDER-TOP: #E4E4E4 2px solid; COLOR: #000000; CURSOR: default; FONT-SIZE: 9pt; color:#000000;FONT-WEIGHT: normal; LINE-HEIGHT: 20px; POSITION: absolute; VISIBILITY: hidden; WIDTH: 110px
}
.menuitems {
    font-size:9pt;
    MARGIN: 2px;
    PADDING-BOTTOM: 0px;
PADDING-LEFT: 15px;
PADDING-RIGHT: 3px;
PADDING-TOP: 0px;
}
</STYLE>

<META content="Microsoft FrontPage 4.0" name=GENERATOR>
</HEAD>
<BODY>
<OBJECT classid=CLSID:8856F961-340A-11D0-A96B-00C04FD705A2 height=0 id=WebBrowser width=0>
</OBJECT>
<RIGHTCLICK><!--[if IE]>
<DIV class=cMenu id=ie5menu onclick=jumptoie5() onmouseout=lowlightie5()
onmouseover=highlightie5()>

<DIV class=menuitems url="javascript:click_obj(0)">后退</DIV>
<DIV class=menuitems url="javascript:click_obj(1)">前进</DIV>
<DIV class=menuhr><hr style="width:100%"></DIV>
<DIV class=menuitems url="javascript:click_obj(2)">刷新</DIV>
<DIV class=menuitems url="javascript:click_obj(3)">加入收藏夹</DIV>
<DIV class=menuitems url="javascript:click_obj(4)">查看源文件</DIV>
<DIV class=menuhr><hr style="width:100%"></DIV>
<DIV class=menuitems url="javascript:click_obj(5)">属性</DIV>

</DIV>
<![endif]-->

<SCRIPT language=JavaScript>
<!--
function click_obj(id){
    switch(id){
        case 0:   
            history.back()
            break
        case 1:
            history.forward()
            break
        case 2:
            window.location.reload()
            break
        case 3:
            window.external.AddFavorite(location.href, document.title)
            break
        case 4:
            window.location = "view-source:" + window.location.href
            break
        case 5:
            document.all.WebBrowser.ExecWB(10,1)
            break
    }
}

if (document.all&&window.print){
    ie5menu.className="cMenu"
    document.oncontextmenu=showmenuie5
    document.body.onclick=hidemenuie5
}
//-->
</SCRIPT>
</RIGHTCLICK>
</BODY></HTML>