在看这篇文章前，我推荐你看一下Eclipse 快捷键手册，你也可以到这儿：下载PDF文件我的eclipse版本是4.2 Juno。

0.三点特别提醒：

• 不要使用System.out.println作为调试工具
• 启用所有组件的详细的日志记录级别
• 使用一个日志分析器来阅读日志

[

（System.out.println()对开发人员来说，有时候也许可以是一种调试手段，但是项目一旦完成他就没有什么用途了，就变成垃圾了，得必须注释或删除掉，这样会比较麻烦。启用所有组件的详细日志记录级别，运用日志分析器来记录详细系统运行状态,这对后期网站的优化和维护会有很多作用。）这仅仅是个人理解，仅供参考！

]

1.条件断点

想象一下我们平时如何添加断点，通常的做法是双击行号的左边。在debug视图中，BreakPoint View将所有断点都列出来，但是我们可以添加一个boolean类型的条件来决定断点是否被跳过。如果条件为真，在断点处程序将停止，否则断点被跳过，程序继续执行。

2.异常断点

在断点view中有一个看起来像J！的按钮，我们可以使用它添加一个基于异常的断点，例如我们希望当NullPointerException抛出的时候程序暂停，我们可以这样:

3.观察点

这是一个很好的功能，他允许当一个选定的属性被访问或者被更改的时候程序执行暂停，并进行debug。最简单的办法是在类中声明成员变量的语句行号左边双击，就可以加入一个观察点。

4.查看变量

在选中的变量上使用Ctrl+Shift+d 或者 Ctrl+Shift+i可以查看变量值，另外我们还可以在Expressions View中添加监视。

5.更改变量的值

我们可以在Debug的时候改变其中变量的值。在Variables View中可以按下图所示操作。

6.在主方法停止

在Run/Debug设置中，我们可以按如下图所示的启用这个特性。程序将会在main方法的第一行停住

7.环境变量

我们可以很方便的在Edit Conriguration对话框中添加环境变量

8.跳出函数到选定层

这个功能非常酷，是我第二个非常喜欢的功能，Drop to frame就是说，可以重新跳到当前方法的开始处重新执行，并且所有上下文变量的值也回到那个时候。不一定是当前方法，可以点击当前调用栈中的任何一个frame跳到那里（除了最开始的那个frame）。主要用途是所有变量状态快速恢复到方法开始时候的样子重新执行一遍，即可以一遍又一遍地在那个你关注的上下文中进行多次调试（结合改变变量值等其它功能），而不用重来一遍调试到哪里了。当然，原来执行过程中产生的副作用是不可逆的（比如你往数据库中插入了一条记录）。

9.分步过滤

当我们在调试的时候摁F5将进入方法的内部，但这有个缺点有的时候可能会进入到一些库的内部（例如JDK），可能并不是我们想要的，我们可以在Preferences中添加一个过滤器，排除指定的包。

10.跳入，跳过和返回

    文档地址 : https://visualvm.dev.java.net/docindex.html

    入门文档 : https://visualvm.dev.java.net/zh_CN/gettingstarted.html

    

               permission java.security.AllPermission;

          };
            
          执行命令jstatd -J-Djava.security.policy=jstatd.all.policy -J-Djava.rmi.server.hostname=192.168.1.8 &(192.168.1.8  为你服务器的ip地址,&表示用守护线程的方式运行)
          jstatd命令详解 :http://hzl7652.iteye.com/blog/1183182 
         
          打开jvisualvm, 右键Remort,选择 "Add Remort Host..."，在弹出框中输入你的远端IP,比如192.168.1.8. 连接成功.
    
    2. 配置JMX管理tomcat
        打开Tomcat的bin/catalina.bat，如果为linux或unix系统，则为catalina.sh文件 。 
           无限制访问 
           

Java Excel 是一开放源码项目，通过它 Java 开发人员可以读取 Excel 文件的内容、创建新的 Excel 文件、更新已经存在的 Excel 文件。使用该 API 非 Windows 操作系统也可以通过纯 Java 应用来处理 Excel 数据表。因为是使用 Java 编写的，所以我们在 Web 应用中可以通过 JSP、Servlet 来调用 API 实现对 Excel 数据表的访问。

现在发布的稳定版本是 V2.0，提供以下功能：

• 从 Excel 95、97、2000 等格式的文件中读取数据；
• 读取 Excel 公式（可以读取 Excel 97 以后的公式）；
• 生成 Excel 数据表（格式为 Excel 97）；
• 支持字体、数字、日期的格式化；
• 支持单元格的阴影操作，以及颜色操作；
• 修改已经存在的数据表；

现在还不支持以下功能，但不久就会提供了：

1. 不能够读取图表信息；
2. 可以读，但是不能生成公式，任何类型公式最后的计算值都可以读出；

回页首

应用示例

1 从 Excel 文件读取数据表

Java Excel API 既可以从本地文件系统的一个文件 (.xls)，也可以从输入流中读取 Excel 数据表。读取 Excel 数据表的第一步是创建 Workbook( 术语：工作薄 )，下面的代码片段举例说明了应该如何操作：( 完整代码见 ExcelReading.java)

 import java.io.*; import jxl.*; … … … … try { // 构建 Workbook 对象 , 只读 Workbook 对象 // 直接从本地文件创建 Workbook // 从输入流创建 Workbook InputStream is = new FileInputStream(sourcefile); jxl.Workbook rwb = Workbook.getWorkbook(is); } catch (Exception e) { e.printStackTrace(); } 

一旦创建了 Workbook，我们就可以通过它来访问 Excel Sheet( 术语：工作表 )。参考下面的代码片段：

 // 获取第一张 Sheet 表 Sheet rs = rwb.getSheet(0); 

我们既可能通过 Sheet 的名称来访问它，也可以通过下标来访问它。如果通过下标来访问的话，要注意的一点是下标从 0 开始，就像数组一样。

一旦得到了 Sheet，我们就可以通过它来访问 Excel Cell( 术语：单元格 )。参考下面的代码片段：

 // 获取第一行，第一列的值 Cell c00 = rs.getCell(0, 0); String strc00 = c00.getContents(); // 获取第一行，第二列的值 Cell c10 = rs.getCell(1, 0); String strc10 = c10.getContents(); // 获取第二行，第二列的值 Cell c11 = rs.getCell(1, 1); String strc11 = c11.getContents(); System.out.println("Cell(0, 0)" + " value : " + strc00 + "; type : " + c00.getType()); System.out.println("Cell(1, 0)" + " value : " + strc10 + "; type : " + c10.getType()); System.out.println("Cell(1, 1)" + " value : " + strc11 + "; type : " + c11.getType()); 

如果仅仅是取得 Cell 的值，我们可以方便地通过 getContents() 方法，它可以将任何类型的 Cell 值都作为一个字符串返回。示例代码中 Cell(0, 0) 是文本型，Cell(1, 0) 是数字型，Cell(1,1) 是日期型，通过 getContents()，三种类型的返回值都是字符型。

如果有需要知道 Cell 内容的确切类型，API 也提供了一系列的方法。参考下面的代码片段：

 String strc00 = null; double strc10 = 0.00; Date strc11 = null; Cell c00 = rs.getCell(0, 0); Cell c10 = rs.getCell(1, 0); Cell c11 = rs.getCell(1, 1); if(c00.getType() == CellType.LABEL) { LabelCell labelc00 = (LabelCell)c00; strc00 = labelc00.getString(); } if(c10.getType() == CellType.NUMBER) { NmberCell numc10 = (NumberCell)c10; strc10 = numc10.getValue(); } if(c11.getType() == CellType.DATE) { DateCell datec11 = (DateCell)c11; strc11 = datec11.getDate(); } System.out.println("Cell(0, 0)" + " value : " + strc00 + "; type : " + c00.getType()); System.out.println("Cell(1, 0)" + " value : " + strc10 + "; type : " + c10.getType()); System.out.println("Cell(1, 1)" + " value : " + strc11 + "; type : " + c11.getType()); 

在得到 Cell 对象后，通过 getType() 方法可以获得该单元格的类型，然后与 API 提供的基本类型相匹配，强制转换成相应的类型，最后调用相应的取值方法 getXXX()，就可以得到确定类型的值。API 提供了以下基本类型，与 Excel 的数据格式相对应，如下图所示：

每种类型的具体意义，请参见 Java Excel API Document。

当你完成对 Excel 电子表格数据的处理后，一定要使用 close() 方法来关闭先前创建的对象，以释放读取数据表的过程中所占用的内存空间，在读取大量数据时显得尤为重要。参考如下代码片段：

 // 操作完成时，关闭对象，释放占用的内存空间 rwb.close(); 

Java Excel API 提供了许多访问 Excel 数据表的方法，在这里我只简要地介绍几个常用的方法，其它的方法请参考附录中的 Java Excel API Document。

Workbook 类提供的方法

1. int getNumberOfSheets() 
获得工作薄（Workbook）中工作表（Sheet）的个数，示例：

 jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); int sheets = rwb.getNumberOfSheets(); 

2. Sheet[] getSheets() 
返回工作薄（Workbook）中工作表（Sheet）对象数组，示例：

 jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); Sheet[] sheets = rwb.getSheets(); 

3. String getVersion() 
返回正在使用的 API 的版本号，好像是没什么太大的作用。

 jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); String apiVersion = rwb.getVersion(); 

Sheet 接口提供的方法

1) String getName() 
获取 Sheet 的名称，示例：

 jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); jxl.Sheet rs = rwb.getSheet(0); String sheetName = rs.getName(); 

2) int getColumns() 
获取 Sheet 表中所包含的总列数，示例：

 jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); jxl.Sheet rs = rwb.getSheet(0); int rsColumns = rs.getColumns(); 

3) Cell[] getColumn(int column) 
获取某一列的所有单元格，返回的是单元格对象数组，示例：

 jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); jxl.Sheet rs = rwb.getSheet(0); Cell[] cell = rs.getColumn(0); 

4) int getRows() 
获取 Sheet 表中所包含的总行数，示例：

 jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); jxl.Sheet rs = rwb.getSheet(0); int rsRows = rs.getRows(); 

5) Cell[] getRow(int row) 
获取某一行的所有单元格，返回的是单元格对象数组，示例子：

 jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); jxl.Sheet rs = rwb.getSheet(0); Cell[] cell = rs.getRow(0); 

6) Cell getCell(int column, int row) 
获取指定单元格的对象引用，需要注意的是它的两个参数，第一个是列数，第二个是行数，这与通常的行、列组合有些不同。

 jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile)); jxl.Sheet rs = rwb.getSheet(0); Cell cell = rs.getCell(0, 0); 

2 生成新的 Excel 工作薄

下面的代码主要是向大家介绍如何生成简单的 Excel 工作表，在这里单元格的内容是不带任何修饰的 ( 如：字体，颜色等等 )，所有的内容都作为字符串写入。( 完整代码见 ExcelWriting.java)

与读取 Excel 工作表相似，首先要使用 Workbook 类的工厂方法创建一个可写入的工作薄 (Workbook) 对象，这里要注意的是，只能通过 API 提供的工厂方法来创建 Workbook，而不能使用 WritableWorkbook 的构造函数，因为类 WritableWorkbook 的构造函数为 protected 类型。示例代码片段如下：

 import java.io.*; import jxl.*; import jxl.write.*; … … … … try { // 构建 Workbook 对象 , 只读 Workbook 对象 //Method 1：创建可写入的 Excel 工作薄 jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(new File(targetfile)); //Method 2：将 WritableWorkbook 直接写入到输出流 /* OutputStream os = new FileOutputStream(targetfile); jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(os); */ } catch (Exception e) { e.printStackTrace(); } 

API 提供了两种方式来处理可写入的输出流，一种是直接生成本地文件，如果文件名不带全路径的话，缺省的文件会定位在当前目录，如果文件名带有全路径的话，则生成的 Excel 文件则会定位在相应的目录；另外一种是将 Excel 对象直接写入到输出流，例如：用户通过浏览器来访问 Web 服务器，如果 HTTP 头设置正确的话，浏览器自动调用客户端的 Excel 应用程序，来显示动态生成的 Excel 电子表格。

接下来就是要创建工作表，创建工作表的方法与创建工作薄的方法几乎一样，同样是通过工厂模式方法获得相应的对象，该方法需要两个参数，一个是工作表的名称，另一个是工作表在工作薄中的位置，参考下面的代码片段：

 // 创建 Excel 工作表 jxl.write.WritableSheet ws = wwb.createSheet("Test Sheet 1", 0); 

"这锅也支好了，材料也准备齐全了，可以开始下锅了！"，现在要做的只是实例化 API 所提供的 Excel 基本数据类型，并将它们添加到工作表中就可以了，参考下面的代码片段：

 //1. 添加 Label 对象 jxl.write.Label labelC = new jxl.write.Label(0, 0, "This is a Label cell"); ws.addCell(labelC); // 添加带有字型 Formatting 的对象 jxl.write.WritableFont wf = new jxl.write.WritableFont(WritableFont.TIMES, 18, WritableFont.BOLD, true); jxl.write.WritableCellFormat wcfF = new jxl.write.WritableCellFormat(wf); jxl.write.Label labelCF = new jxl.write.Label(1, 0, "This is a Label Cell", wcfF); ws.addCell(labelCF); // 添加带有字体颜色 Formatting 的对象 jxl.write.WritableFont wfc = new jxl.write.WritableFont(WritableFont.ARIAL, 10, WritableFont.NO_BOLD, false, UnderlineStyle.NO_UNDERLINE, jxl.format.Colour.RED); jxl.write.WritableCellFormat wcfFC = new jxl.write.WritableCellFormat(wfc); jxl.write.Label labelCFC = new jxl.write.Label(1, 0, "This is a Label Cell", wcfFC); ws.addCell(labelCF); //2. 添加 Number 对象 jxl.write.Number labelN = new jxl.write.Number(0, 1, 3.1415926); ws.addCell(labelN); // 添加带有 formatting 的 Number 对象 jxl.write.NumberFormat nf = new jxl.write.NumberFormat("#.##"); jxl.write.WritableCellFormat wcfN = new jxl.write.WritableCellFormat(nf); jxl.write.Number labelNF = new jxl.write.Number(1, 1, 3.1415926, wcfN); ws.addCell(labelNF); //3. 添加 Boolean 对象 jxl.write.Boolean labelB = new jxl.write.Boolean(0, 2, false); ws.addCell(labelB); //4. 添加 DateTime 对象 jxl.write.DateTime labelDT = new jxl.write.DateTime(0, 3, new java.util.Date()); ws.addCell(labelDT); // 添加带有 formatting 的 DateFormat 对象 jxl.write.DateFormat df = new jxl.write.DateFormat("dd MM yyyy hh:mm:ss"); jxl.write.WritableCellFormat wcfDF = new jxl.write.WritableCellFormat(df); jxl.write.DateTime labelDTF = new jxl.write.DateTime(1, 3, new java.util.Date(), wcfDF); ws.addCell(labelDTF); 

这里有两点大家要引起大家的注意。第一点，在构造单元格时，单元格在工作表中的位置就已经确定了。一旦创建后，单元格的位置是不能够变更的，尽管单元格的内容是可以改变的。第二点，单元格的定位是按照下面这样的规律 (column, row)，而且下标都是从 0 开始，例如，A1 被存储在 (0, 0)，B1 被存储在 (1, 0)。

最后，不要忘记关闭打开的 Excel 工作薄对象，以释放占用的内存，参见下面的代码片段：

 // 写入 Exel 工作表 wwb.write(); // 关闭 Excel 工作薄对象 wwb.close(); 

这可能与读取 Excel 文件的操作有少少不同，在关闭 Excel 对象之前，你必须要先调用 write() 方法，因为先前的操作都是存储在缓存中的，所以要通过该方法将操作的内容保存在文件中。如果你先关闭了 Excel 对象，那么只能得到一张空的工作薄了。

3 拷贝、更新 Excel 工作薄

接下来简要介绍一下如何更新一个已经存在的工作薄，主要是下面二步操作，第一步是构造只读的 Excel 工作薄，第二步是利用已经创建的 Excel 工作薄创建新的可写入的 Excel 工作薄，参考下面的代码片段：( 完整代码见 ExcelModifying.java)

 // 创建只读的 Excel 工作薄的对象 jxl.Workbook rw = jxl.Workbook.getWorkbook(new File(sourcefile)); // 创建可写入的 Excel 工作薄对象 jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(new File(targetfile), rw); // 读取第一张工作表 jxl.write.WritableSheet ws = wwb.getSheet(0); // 获得第一个单元格对象 jxl.write.WritableCell wc = ws.getWritableCell(0, 0); // 判断单元格的类型 , 做出相应的转化 if(wc.getType() == CellType.LABEL) { Label l = (Label)wc; l.setString("The value has been modified."); } // 写入 Excel 对象 wwb.write(); // 关闭可写入的 Excel 对象 wwb.close(); // 关闭只读的 Excel 对象 rw.close(); 

之所以使用这种方式构建 Excel 对象，完全是因为效率的原因，因为上面的示例才是 API 的主要应用。为了提高性能，在读取工作表时，与数据相关的一些输出信息，所有的格式信息，如：字体、颜色等等，是不被处理的，因为我们的目的是获得行数据的值，既使没有了修饰，也不会对行数据的值产生什么影响。唯一的不利之处就是，在内存中会同时保存两个同样的工作表，这样当工作表体积比较大时，会占用相当大的内存，但现在好像内存的大小并不是什么关键因素了。

一旦获得了可写入的工作表对象，我们就可以对单元格对象进行更新的操作了，在这里我们不必调用 API 提供的 add() 方法，因为单元格已经于工作表当中，所以我们只需要调用相应的 setXXX() 方法，就可以完成更新的操作了。

尽单元格原有的格式化修饰是不能去掉的，我们还是可以将新的单元格修饰加上去，以使单元格的内容以不同的形式表现。

新生成的工作表对象是可写入的，我们除了更新原有的单元格外，还可以添加新的单元格到工作表中，这与示例 2 的操作是完全一样的。

最后，不要忘记调用 write() 方法，将更新的内容写入到文件中，然后关闭工作薄对象，这里有两个工作薄对象要关闭，一个是只读的，另外一个是可写入的。

回页首

小结

本文只是对 Java Excel API 中常用的方法作了介绍，要想更详尽地了解 API，请大家参考 API 文档，或源代码。Java Excel API 是一个开放源码项目，请大家关注它的最新进展，有兴趣的朋友也可以申请加入这个项目，或者是提出宝贵的意见。

Java代码

1. <filter>   
2.         <filter-name>JAMonFilter</filter-name>   
3.         <filter-class>com.easywebwork.filter.EasyPageMonFilter</filter-class>   
4.     </filter>   
5.     <filter-mapping>   
6.         <filter-name>JAMonFilter</filter-name>   
7.         <url-pattern>/*</url-pattern>   
8.     </filter-mapping>  

<filter>
<filter-name>JAMonFilter</filter-name>
<filter-class>com.easywebwork.filter.EasyPageMonFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>JAMonFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

Java代码

1. /**  
2.  * @author 张荣华（ahuaxuan）  
3.  *  
4.  * @since 2007-8-13  
5.  */  
6. public class PageMonFilter extends JAMonFilter{   
7.   
8.     private static final long serialVersionUID = 5746197114960908454L;   
9.   
10.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {   
11.          Monitor allPages = MonitorFactory.start(new MonKeyImp("org.easywebwork.allPages",getURI(request),"ms."));   
12.          //这里就是我们要监视的所有的页面的配置   
13.          Monitor monitor = MonitorFactory.start(getURI(request));   
14.          //这里就是我们要监视的某个页面的配置   
15.          try {   
16.           filterChain.doFilter(request, response);   
17.          } finally {   
18.           monitor.stop();   
19.           allPages.stop();   
20.          }   
21.        }   
22.   
23.        protected String getURI(ServletRequest request) {   
24.          if (request instanceof HttpServletRequest) {   
25.            return ((HttpServletRequest) request).getRequestURI();   
26.          }  else {   
27.            return "Not an HttpServletRequest";   
28.          }   
29.        }   
30.   
31.        private FilterConfig filterConfig = null;   
32.           
33. }}  

/**
* @author 张荣华（ahuaxuan）
*
* @since 2007-8-13
*/
public class PageMonFilter extends JAMonFilter{
private static final long serialVersionUID = 5746197114960908454L;
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
Monitor allPages = MonitorFactory.start(new MonKeyImp("org.easywebwork.allPages",getURI(request),"ms."));
//这里就是我们要监视的所有的页面的配置
Monitor monitor = MonitorFactory.start(getURI(request));
//这里就是我们要监视的某个页面的配置
try {
filterChain.doFilter(request, response);
} finally {
monitor.stop();
allPages.stop();
}
}
protected String getURI(ServletRequest request) {
if (request instanceof HttpServletRequest) {
return ((HttpServletRequest) request).getRequestURI();
} 	else {
return "Not an HttpServletRequest";
}
}
private FilterConfig filterConfig = null;
}}

Java代码

1. <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">   
2.         <property name="beanNames">   
3.             <list>   
4.                 <value>userService</value>                 
5.             </list>   
6.         </property>   
7.         <property name="interceptorNames">   
8.             <list>   
9.                 <value>jamonInterceptor</value>   
10.             </list>   
11.         </property>   
12.     </bean>   
13.        
14.     <bean id="jamonInterceptor" class="org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor">   
15. </bean>  

<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<list>
<value>userService</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>jamonInterceptor</value>
</list>
</property>
</bean>
<bean id="jamonInterceptor" class="org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor">
</bean>

Java代码

1. log4j.logger.org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor = TRACE  

log4j.logger.org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor = TRACE

Java代码

1. /**  
2.    * <p>Attempts to establish a connection with the data source that  
3.    * this <code>DataSource</code> object represents.  
4.    *  
5.    * @return  a connection to the data source  
6.    * @exception SQLException if a database access error occurs  
7.    */  
8.   Connection getConnection() throws SQLException;   
9.          
10.   /**  
11.    * <p>Attempts to establish a connection with the data source that  
12.    * this <code>DataSource</code> object represents.  
13.    *  
14.    * @param username the database user on whose behalf the connection is   
15.    *  being made  
16.    * @param password the user's password  
17.    * @return  a connection to the data source  
18.    * @exception SQLException if a database access error occurs  
19.    * @since 1.4  
20.    */  
21.   Connection getConnection(String username, String password)    
22.     throws SQLException;  

/**
* <p>Attempts to establish a connection with the data source that
* this <code>DataSource</code> object represents.
*
* @return  a connection to the data source
* @exception SQLException if a database access error occurs
*/
Connection getConnection() throws SQLException;
/**
* <p>Attempts to establish a connection with the data source that
* this <code>DataSource</code> object represents.
*
* @param username the database user on whose behalf the connection is
*  being made
* @param password the user's password
* @return  a connection to the data source
* @exception SQLException if a database access error occurs
* @since 1.4
*/
Connection getConnection(String username, String password)
throws SQLException;

Java代码

1. /**  
2.  * @author ahuaxuan(aaron zhang)  
3.  * @since 2008-2-25  
4.  * @version $Id$  
5.  */  
6. public class MonitorDataSource implements DataSource {   
7.     public DataSource realDataSource;   
8.   
9.     public void setRealDataSource(DataSource realDataSource) {   
10.         this.realDataSource = realDataSource;   
11.     }   
12.   
13.     public DataSource getRealDataSource() {   
14.         return realDataSource;   
15.     }   
16.     public Connection getConnection() throws SQLException {   
17. //表示由jamon来代理realDataSource返回的Connection   
18.         return MonProxyFactory.monitor(realDataSource.getConnection());   
19.     }   
20.   
21.     public Connection getConnection(String username, String password)   
22.             throws SQLException {   
23. //表示由jamon来代理realDataSource返回的Connection   
24.   
25.         return MonProxyFactory.monitor(realDataSource.getConnection(username,   
26.                 password));   
27.     }   
28. }  

/**
* @author ahuaxuan(aaron zhang)
* @since 2008-2-25
* @version $Id$
*/
public class MonitorDataSource implements DataSource {
public DataSource realDataSource;
public void setRealDataSource(DataSource realDataSource) {
this.realDataSource = realDataSource;
}
public DataSource getRealDataSource() {
return realDataSource;
}
public Connection getConnection() throws SQLException {
//表示由jamon来代理realDataSource返回的Connection
return MonProxyFactory.monitor(realDataSource.getConnection());
}
public Connection getConnection(String username, String password)
throws SQLException {
//表示由jamon来代理realDataSource返回的Connection
return MonProxyFactory.monitor(realDataSource.getConnection(username,
password));
}
}

Java代码

1. <bean id="writeMonitorDataSource" class="org.ahuaxuan.MonitorDataSource" destroy-method="close">   
2.         <property name="realDataSource" ref="writeDataSource"/>   
3.     </bean>  

<bean id="writeMonitorDataSource" class="org.ahuaxuan.MonitorDataSource" destroy-method="close">
<property name="realDataSource" ref="writeDataSource"/>
</bean>

Java代码

1. <bean id="writeDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">   
2.         <property name="driverClassName">   
3.             <value>${jdbc.driverClassName}</value>   
4.         </property>   
5.         <property name="url">   
6.             <value>${jdbc.url}</value>   
7.         </property>   
8.         <property name="username">   
9.             <value>${jdbc.username}</value>   
10.         </property>   
11.         <property name="password">   
12.             <value>${jdbc.password}</value>   
13.         </property>   
14.         <property name="maxActive">   
15.             <value>${jdbc.maxActive}</value>   
16.         </property>   
17.         <property name="maxIdle">   
18.             <value>${jdbc.maxIdle}</value>   
19.         </property>   
20.         <property name="maxWait">   
21.             <value>${jdbc.maxWait}</value>   
22.         </property>   
23. </bean>  

<bean id="writeDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName">
<value>${jdbc.driverClassName}</value>
</property>
<property name="url">
<value>${jdbc.url}</value>
</property>
<property name="username">
<value>${jdbc.username}</value>
</property>
<property name="password">
<value>${jdbc.password}</value>
</property>
<property name="maxActive">
<value>${jdbc.maxActive}</value>
</property>
<property name="maxIdle">
<value>${jdbc.maxIdle}</value>
</property>
<property name="maxWait">
<value>${jdbc.maxWait}</value>
</property>
</bean>

最近的一个项目在Hibernate使用C3P0的连接池，数据库为Mysql。开发测试没有问题，在运行中每个一段长的空闲时间就出现异常:

1. org.hibernate.exception.JDBCConnectionException: could not execute query
2. at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:74)
3. at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:43)
4. .......
5. Caused by: com.mysql.jdbc.exceptions.MySQLNonTransientConnectionException: No operations allowed after connection closed.Connection was implicitly closed due to underlying exception/error:
8. ** BEGIN NESTED EXCEPTION **
10. com.mysql.jdbc.CommunicationsException
11. MESSAGE: Communications link failure due to underlying exception:
13. ** BEGIN NESTED EXCEPTION **
15. java.net.SocketException
16. MESSAGE: Broken pipe
18. STACKTRACE:
20. java.net.SocketException: Broken pipe
21. at java.net.SocketOutputStream.socketWrite0(Native Method)
22. ......
23. ** END NESTED EXCEPTION **

查看了Mysql的文档，以及Connector/J的文档以及在线说明发现，出现这种异常的原因是：

Mysql服务器默认的“wait_timeout”是8小时，也就是说一个connection空闲超过8个小时，Mysql将自动断开该connection。这就是问题的所在，在C3P0 pools中的connections如果空闲超过8小时，Mysql将其断开，而C3P0并不知道该connection已经失效，如果这时有Client请求connection，C3P0将该失效的Connection提供给Client，将会造成上面的异常。

解决的方法有3种：

1. 增加wait_timeout的时间。
2. 减少Connection pools中connection的lifetime。
3. 测试Connection pools中connection的有效性。

当然最好的办法是同时综合使用上述3种方法，下面就DBCP和C3P0分别做一说明，假设wait_timeout为默认的8小时

DBCP增加以下配置信息:

//set to 'SELECT 1'

validationQuery = "SELECT 1"

//set to 'true'

testWhileIdle = "true"

//some positive integer

timeBetweenEvictionRunsMillis = 3600000

//set to something smaller than 'wait_timeout'

minEvictableIdleTimeMillis = 18000000

//if you don't mind a hit for every getConnection(), set to "true"

testOnBorrow = "true"

C3P0增加以下配置信息:
 

//获取connnection时测试是否有效

testConnectionOnCheckin = true

//自动测试的table名称

automaticTestTable=C3P0TestTable

//set to something much less than wait_timeout, prevents connections from going stale

idleConnectionTestPeriod = 18000

//set to something slightly less than wait_timeout, preventing 'stale' connections from being handed out

maxIdleTime = 25000

//if you can take the performance 'hit', set to "true"

testConnectionOnCheckout = true

 

 

 

在配置文件中要写成  <property name="minPoolSize"><value>1</value></property> 格式

不能写成 这样<property name="properties">
   <props>
    <prop key="c3p0.initialPoolSize">1</prop>

   </props>

</property>

c3p0不能完全识别!!

不高兴 2009-08-11 17:27 发表评论

]]>

一、        邮件传输协议简介
1.        邮件传输概念
邮件服务是Internet上最常用的服务之一，它提供了与操作系统平台无关的通信服务，使用邮件服务，用户可通过电子邮件在网络之间交换数据信息。邮件传输包括将邮件从发送者客户端发往邮件服务器，以及接收者从邮件服务器将邮件取回到接收者客户端。
2.        SMTP和POP3
在TCP/IP协议簇中，一般使用SMTP协议发送邮件，POP3协议接收邮件。
SMTP，全称Simple Message Transfer Protocol，中文名为简单邮件传输协议，工作在TCP/IP层次的应用层。SMTP采用Client/Server工作模式，默认使用TCP 25端口，提供可靠的邮件发送服务。
POP3，全称Post Office Protocol 3，中文名为第三版邮局协议，工作在TCP/IP层次的应用层。POP3采用Client/Server工作模式，默认使用TCP 110端口，提供可靠的邮件接收服务。
3.        SMTP和POP3的工作原理
发送和接收邮件都需要以下两个组件：用户代理（UA，常用的是Foxmail或Outlook）和SMTP/POP3服务器。
SMTP工作原理：
1)        客户端使用TCP协议连接SMTP服务器的25端口；
2)        客户端发送HELO报文将自己的域地址告诉给SMTP服务器；
3)        SMTP服务器接受连接请求，向客户端发送请求账号密码的报文；
4)        客户端向SMTP服务器传送账号和密码，如果验证成功，向客户端发送一个OK命令，表示可以开始报文传输；
5)        客户端使用MAIL命令将邮件发送者的名称发送给SMTP服务器；
6)        SMTP服务器发送OK命令做出响应；
7)        客户端使用RCPT命令发送邮件接收者地址，如果SMTP服务器能识别这个地址，就向客户端发送OK命令，否则拒绝这个请求；
8)        收到SMTP服务器的OK命令后，客户端使用DATA命令发送邮件的数据。
9)        客户端发送QUIT命令终止连接。
POP3工作原理：
1)        客户端使用TCP协议连接邮件服务器的110端口；
2)        客户端使用USER命令将邮箱的账号传给POP3服务器；
3)        客户端使用PASS命令将邮箱的账号传给POP3服务器；
4)        完成用户认证后，客户端使用STAT命令请求服务器返回邮箱的统计资料；
5)        客户端使用LIST命令列出服务器里邮件数量；
6)        客户端使用RETR命令接收邮件，接收一封后便使用DELE命令将邮件服务器中的邮件置为删除状态；
7)        客户端发送QUIT命令，邮件服务器将将置为删除标志的邮件删除，连接结束。
（注：客户端UA可以设定将邮件在邮件服务器上保留备份，而不将其删除。）

二、        跟踪分析Email电子邮件通讯过程
1.        分析Email的具体流程
1)        发送邮件
我们使用科来网络分析系统5.0捕获并分析一个使用SMTP协议的发送邮件过程，客户端主机名为“wangym”，客户端用户代理使用Foxmail 5.0 beta2，邮件发送者test1@colasoft.com，邮件接收者test2@colasoft.com。
在客户端主机上打开科来网络分析系统5.0。为避免数据干扰，设定一个过滤器，只捕获本机的数据通讯。
打开客户端主机上的Foxmail 5.0 beta2，新建两个邮件账户，test1@colasoft.com和test2@colasoft.com，设置好账户的SMTP/POP3服务器地址、用户名、密码等信息并测试成功。
在科来网络分析系统5.0中开始数据捕获，在Foxmail中使用test1@colasoft.com向test2@colasoft.com发送一封邮件，邮件原始信息如图1所示。发送完成后即可在科来网络分析系统5.0对刚才的邮件发送操作进行分析（为避免数据包干扰，分析时可停止捕获。）。
注意：此文里提到的发送邮件均指使用TCP 25端口的标准SMTP通信，对于非25端口的邮件发送，用户可在“工程->高级分析模块->邮件分析模块->SMTP设置->SMTP端口”处进行更改，系统默认为25，当SMTP服务器有多个端口时，多个端口之间用分号分隔，如25;125。

科来网络分析系统5.0对上面发送邮件操作的报文跟踪，详细信息如下：
A.        第1、2、3个数据包是TCP连接的三次握手数据包，连接的双方是本机与域名ns1.colasoft.com对应的IP地址；
B.        从第4个数据包开始，客户端开始通过TCP协议连接SMTP服务器，并与SMTP服务器进行命令的交互，及邮件的发送，具体的交互过程详见图3以及对图3的分析。
[attach]604[/attach]    

科来网络分析系统5.0对上面发送邮件操作的TCP原始数据流重组信息。具体分析数据流重组信息，可以得到上面发送邮件操作的详细过程如下：
A.        客户端使用EHLO（或HELO）命令向SMTP服务器发送HELO报文，启动邮件传输过程，并同时将客户端地址发送SMTP服务器端，此处为wangym；
B.        SMTP服务器接受了客户端的连接请求，并请求输入账号和密码进行认证；
C.        客户端向服务器端传送账号和密码；
D.        SMTP服务器通过验证，客户端使用MAIL命令将邮件发送者的名称传送给SMTP服务器；
E.        客户端使用RCPT命令将邮件接收者的名称传送给SMTP服务器；
F.        客户端使用DATA命令传送邮件数据给SMTP服务器；
G.        数据传送完毕后，客户端发送QUIT命令关闭连接。
注意：
        SMTP传输使用的是base64编码，图4中AUTH LOGIN下的“dGVzdDFAY29sYXNvZnQuY29t”是当前使用账号对应的base64编码；
        图3所示的SMTP数据流中，客户端向SMTP服务器传送了两次发件人名称和收件人名称，可能的原因有两种：
a.        网络的延迟较大，客户端在规定时间内未收到SMTP服务器的响应，认为传送发件人名称和收件人名称的数据包丢失而进行的重传；
b.        客户端主机上的防病毒软件在邮件发送前对邮件进行的检测，如Norton Antivirus就会进行这种检测，禁用此检测功能即可避免此种情况的发生。

2)        接收邮件
我们再使用科来网络分析系统5.0捕获并分析一个使用POP3协议的接收邮件过程，客户端主机名为“wangym”，客户端用户代理使用Foxmail 5.0 beta2，邮件接收者test2@colasoft.com。
在客户端主机上打开科来网络分析系统5.0。与上面相同，设定一个过滤器，只捕获本机的数据通讯，选择高级分析模块，在邮件分析模块的常规设置中，将保存邮件选择为“是”，并选择好邮件的保存位置，如图1所示。
在科来网络分析系统5.0中开始数据捕获，同时在Foxmail中选中test2@colasoft.com，并收取邮件。接收完成后即可在科来网络分析系统5.0对刚才的邮件接收操作进行分析（为避免数据包干扰，分析时可停止捕获。）。
注意：此文里提到的接收邮件均指使用TCP 110端口的标准POP3通信，对于非110端口的邮件发送，用户可在“工程->高级分析模块->邮件分析模块->SMTP设置->POP3端口”处进行更改，系统默认为110，当SMTP服务器有多个端口时，多个端口之间用分号分隔，如110;1110。

科来网络分析系统5.0对上面接收邮件操作的报文跟踪。　
A.        1、2、3数据包是TCP连接的三次握手数据包，连接的双方是本机与域名ns1.colasoft.com对应的IP地址；
B.        从第4个数据包开始，客户端开始通过TCP协议连接POP3服务器，并与POP3服务器进行命令的交互，及邮件的接收，具体的交互过程详见图4以及对图4的分析。

科来网络分析系统5.0对上面接收邮件操作的TCP原始数据流重组信息。具体分析其数据流重组信息，可以得到上面接收邮件操作的详细过程：
A.        客户端使用USER命令向POP3服务器传送用户账号test2@colasoft.com；
B.        客户端使用PASS命令向POP3服务器传送用户密码1234567890；
C.        POP3服务器通过验证，向客户端发送一个OK报文；
D.        客户端使用STAT命令请求POP3服务器返回邮箱的统计资料信息，POP3服务器返回当前有一封邮件；
E.        客户端使用LIST命令列出POP3服务器里的邮件数量，当前为1封邮件；
F.        客户端使用RETR命令接收邮件，接收后使用DELE命令将邮件POP3服务器中的邮件置为删除状态；
G.        客户端发送QUIT命令，邮件服务器将将置为删除标志的邮件删除，连接结束。
注意：
        POP3直接使用明文传输；
        直接重组出了接收到的邮件内容，此信息不经过任何编码或加密处理，直接为明文方式，与图1所示的邮件原始信息一致。

3)        SMTP/POP3命令码
通过SMTP/POP3协议进行邮件收发操作时，均通过不同的命令码进行不同的操作，现将其命令码总结如下：
SMTP命令如表1所示：
命令        作用
HELO        客户端发送此命令与SMTP服务器建立连接，将发送者邮件地址发送给SMTP服务器
MAIL        客户端将邮件发送者的名称传送给SMTP服务器
RCPT        客户端将邮件接收者的名称传送给SMTP服务器
DATA        客户端将邮件报文内容传送给SMTP服务器
SEND        用于向指定用户传送邮件
SAML/SOML        用于发送邮件
RSET        取消客户端与SMTP服务器间的当前事务，释放与当前事务相关的内存
EXPN        标识邮件接收者列表
QUIT        终止客户端与SMTP服务器间的连接

POP3命令如表2所示：
命令        作用
USER        客户端向POP3服务器传送账号
PASS        客户端向POP3服务器传送密码
STAT        客户端请求POP3服务器返回邮箱的统计信息
UIDL        客户端请求POP3服务器返回邮件的唯一标识符
LIST        客户端请求POP3服务器返回邮件数量和每封邮件的大小
RETR        客户端请求POP3服务器返回由参数标识的邮件的全部文本
DELE        POP3服务器将由参数标识的邮件标记为删除
RSET        POP3服务器重置所有标记为删除的邮件，用于撤消DELE命令
NOOP        POP3服务器返回一个肯定的响应
QUIT        终止客户端POP3服务器间的连接

三、        总结
以上简单介绍了SMTP和POP3协议，并使用科来网络分析分析系统5.0跟踪分析了一个基于SMTP/POP3协议的邮件收发操作。据此，用户在遇到不能正常收发邮件（使用SMTP/POP3协议）的问题时，即可结合上述的SMTP/POP3相关知识，使用网络检测分析软件（这儿是科来网络分析系统5.0）对邮件接收和邮件发送的报文进行跟踪分析，以完成对此类故障的快速排查。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/hyde82/archive/2007/06/13/1650581.aspx

1.直接的方式
取得cookie：
httpurlconnection huc= (httpurlconnection) url.openconnection();
inputstream is = huc.getinputstream();
// 取得sessionid.
string cookieval = hc.getheaderfield("set-cookie");
string sessionid;
if(cookieval != null)
{
sessionid = cookieval.substring(0, cookieval.indexof(";"));
}

发送设置cookie：
httpurlconnection huc= (httpurlconnection) url.openconnection();
if(sessionid != null)
{
huc.setrequestproperty("cookie", sessionid);
}
inputstream is = huc.getinputstream();

2.利用的jcookie包(http://jcookie.sourceforge.net/ )
获取cookie:
url url = new url("http://www.site.com/");
httpurlconnection huc = (httpurlconnection) url.openconnection();
huc.connect();
inputstream is = huc.getinputstream();
client client = new client();
cookiejar cj = client.getcookies(huc);

新的请求,利用上面获取的cookie:

url = new url("http://www.site.com/");
huc = (httpurlconnection) url.openconnection();
client.setcookies(huc, cj);

3.post方式的模拟
url url = new url("www.xyz.com");
httpurlconnection huc = (httpurlconnection) url.openconnection();
//设置允许output
huc.setdooutput(true);
//设置为post方式
huc.setrequestmethod("post");
huc.setrequestproperty("user-agent","mozilla/4.7 [en] (win98; i)");
stringbuffer sb = new stringbuffer();
sb.append("username="+usernme);
sb.append("&password="+password);

//post信息
outputstream os = huc.getoutputstream();
os.write(sb.tostring().getbytes("gbk"));
os.close();

bufferedreader br = new bufferedreader(new inputstreamreader(huc.getinputstream()))

huc.connect();

string line = br.readline();

while(line != null){

l

system.out.printli(line);

line = br.readline();

}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/hyde82/archive/2007/06/06/1640817.aspx