BlogJava-心无痕的博客-随笔分类-JAVAhttp://www.blogjava.net/xinwuhen/category/29825.htmlzh-cnWed, 07 Apr 2010 09:42:15 GMTWed, 07 Apr 2010 09:42:15 GMT60用连接池配置BIRT报表的数据库连接。。。。http://www.blogjava.net/xinwuhen/archive/2009/04/07/264241.html心无痕心无痕Tue, 07 Apr 2009 05:32:00 GMThttp://www.blogjava.net/xinwuhen/archive/2009/04/07/264241.htmlhttp://www.blogjava.net/xinwuhen/comments/264241.htmlhttp://www.blogjava.net/xinwuhen/archive/2009/04/07/264241.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/264241.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/264241.html现阶段我们在开发报表的时候，是使用jdbc链接数据库的，为提高报表的运行效率和稳定性，使用连接池进行管理。比较简便和低耦合的解决办法，使用jndi连接池。

 

jdbc和jndi的区别

JDBC -最基本的连接数据库的方式， 每次对数据库打交道的时候 ，连接数据库是需要实例下你实现连接数据库的方法或者类。
JNDI DataSource 英文全称是:Java Naming and Directory Interface java 命明接口，当服务启动时 事先把连接数据库的已经连好多条，具体多少条你可以设置，存放在tomcat容器里，用的时候可以直接使用， 不用再实例化得到连接， 相对与jdbc效率要快点

 

 

在eclipse设计报表的时候，我们使用jdbc链接数据库做测试，当到了tomcat运行环境中切换到jndi连接池，这是比较方便的开发方法。

实现步骤：

1.tomcat配置jndi连接池

在 {tomcat目录}\webapps\{项目名}\META-INF 中新增context.xml文件，配置代码如下

<?xml version="1.0" encoding="UTF-8"?>
<Context>
 <Resource
      auth="Container"
      name="jdbc/travel_agency"
      type="javax.sql.DataSource"
      maxIdle="5"
      maxWait="-1"
   driverClassName="com.mysql.jdbc.Driver"
      username="itravel"
   password="709394"
      url="jdbc:mysql://192.168.1.100/travel_agency?useUnicode=true&amp;characterEncoding=UTF-8"
      maxActive="10"/>
</Context>

2.在web.xml中加入配置

 

<resource-ref>
    <description>Database Source</description>
    <res-ref-name>jdbc/travel_agency</res-ref-name>
    <res-type>javax.sql.DataSource</res-type>
    <res-auth>Container</res-auth>
</resource-ref>


3.实例报表中数据源代码

 

1 <data-sources>
2        <oda-data-source extensionID="org.eclipse.birt.report.data.oda.jdbc" name="数据源" id="227">
3            <property name="odaDriverClass">com.mysql.jdbc.Driver</property> 
4            <property name="odaURL">jdbc:mysql://192.168.1.100/travel_agency</property> 
5            <property name="odaUser">itravel</property>
6            <encrypted-property name="odaPassword" encryptionID="base64">NzA5Mzk0</encrypted-property>
7            <property name="odaJndiName">java:comp/env/jdbc/travel_agency</property>
8        </oda-data-source>
9    </data-sources>

 

 

除了第7行 <property name="odaJndiName">java:comp/env/jdbc/travel_agency</property>，其余是我们的之前的配置。用了第7行的代码，表示该报表支持jndi数据源，birt在运行报表的时候，会先用jndi去连接，如果失败了再用jdbc链接，这样做的好处就是，我们在开发报表的时候，没有放到web环境中，可以使用jdbc，当放到tomcat中，因为有了第7行的配置。默认采用jdni连接。

4.步骤3中第6行密码的生成程序（JAVA程序）
package com.hollycrm.birt.security;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import sun.misc.BASE64Encoder;

public class CreateBirtBase64Password {

public static void main(String[] args) {

InputStreamReader inStreamReader = new InputStreamReader(System.in);

BufferedReader buffReader = new BufferedReader(inStreamReader);

System.out.println("请输入需要通过Base64加密的字符串：");

String strSrcPassword = null;

try {

strSrcPassword = buffReader.readLine();

if (strSrcPassword != null) {

// 通过用户输入的密码信息生成Base64的加密密码

String strBase64Password = new BASE64Encoder().encode(strSrcPassword.trim().getBytes());

System.out.println("您输入的原始密码为：" + strSrcPassword + "\r对应生成的Base64密码值为：" + strBase64Password);

}

} catch (IOException e) {

e.printStackTrace();

}

}

}



心无痕 2009-04-07 13:32 发表评论
]]>关于用javascript动态生成表格的注意点...http://www.blogjava.net/xinwuhen/archive/2009/03/18/260606.html心无痕心无痕Wed, 18 Mar 2009 15:11:00 GMThttp://www.blogjava.net/xinwuhen/archive/2009/03/18/260606.htmlhttp://www.blogjava.net/xinwuhen/comments/260606.htmlhttp://www.blogjava.net/xinwuhen/archive/2009/03/18/260606.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/260606.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/260606.html有时为了动态生成页面内容, 我们会用到javascript来这么处理, 但有时用javascript动态生成页面信息时,会有错误却查不到信息,现以用javascript动态生成表格为例, 说明如下(以下代码可以直接拷贝下来,存为html格式的文件执行):

<html>
<head>
 <script language='javascript'>
  function addNode() {
   
   // 第一部分代码
   
   var vDiv = document.getElementById('1'); // 注意:此处是取的不包含在<table>内的<div>标签
   var vTable = document.createElement('table');
   var tbody = document.createElement("tbody");
   var vTr = document.createElement('tr');
   var vTd = document.createElement('td');
   var vText = document.createTextNode('这是第一部分代码');
   vTd.appendChild(vText); // 或: vTd.innerText='这是第一部分代码';
   vTr.appendChild(vTd);
   tbody.appendChild(vTr);
   vTable.appendChild(tbody);
   vDiv.appendChild(vTable);
   
   
   
   // 第二部分代码
   /*
   var vDiv = document.getElementById('2'); // 注意:此处是取的<table>标签
   //var obj = document.createElement("table");
      var tbody = document.createElement("tbody");
   var tr = document.createElement("tr");
   var td = document.createElement("td");
   td.innerText = "这是第二部分代码";
   tr.appendChild(td);
   tbody.appendChild(tr);
   //obj.appendChild(tbody);
   vDiv.appendChild(tbody); // 注意: 此处vDiv即为<table>标签, 故只需要在这个标签上添加<tbody>标签
          //   同样，如果本段代码取<tbody>标签，
          // 即：var vDiv = document.getElementById('4');
          // 那么，我们只需用vDiv.appendChild(tr);即可实现同样的效果。
   */
   
   /*
   // 第三部分代码
   var vDiv = document.getElementById('8'); // 注意:此处是取的包含在<tbody>标签(id为6)内的<div>标签
   //var obj = document.createElement("table");
      //var tbody = document.createElement("tbody");
   var tr = document.createElement("tr");
   var td = document.createElement("td");
   td.innerText="这是第三部分代码";
   tr.appendChild(td);
   //tbody.appendChild(tr);
   //obj.appendChild(tbody);
   vDiv.appendChild(tr); // 通过此处，向id为8的<div>添加标签<tr>是错误的；因为，<div>与<tr>不是父子关系
   
   // 这是错误的代码： vDiv.innerHtml="<table><tr><td>test</td></tr></table>";
   */

  }
 </script>
</head>
<body>

 <!-- 总结: 动态生成页面表格 -->
 <!--    1: 在页面中本身就没有<table>标签时, 必须创建<table>、<tbody>、<tr>、<td>这四个标签,并且缺一不可; -->
 <!--   参见：“第一部分代码” -->
 <!--    2: 在页面中本身存在<table>标签时, 依据上边四个标签必须有的原则：在页面中有的标签我们直接取 -->
 <!--   最内层的标签, 然后把缺的标签补上即可;参见：“第二部分代码” -->
 <!--    3: 对于没有父子关系的标签，如ID为8的标签（即：div标签）与tr标签就没有父子关系。-->
 <!--   此时，就不能直接添加tbody标签到div标签内部. 参见：“第三部分代码”。-->

 <!-- 此处仅有div标签 -->
 <div id='1'>
    
 </div>

 <!-- 此处仅有table标签 -->
 <table id='2'>
  
 </table>

 <!-- 此处有table、tbody二种标签 -->
 <table id='3'>
  <tbody id='4'>

  </tbody>
 </table>

 <table id='5'>
  <tbody id='6'>
   <tr id=7>
    
   </tr>
   <div id='8'>
    
   </div>
  </tbody>
 </table>
</body>
<html>

<script language='javascript'>
 addNode();
</script>



心无痕 2009-03-18 23:11 发表评论
]]>深入Struts 1.1----转自IBM DeveloperWorkshttp://www.blogjava.net/xinwuhen/archive/2008/07/01/212013.html心无痕心无痕Tue, 01 Jul 2008 14:10:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/07/01/212013.htmlhttp://www.blogjava.net/xinwuhen/comments/212013.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/07/01/212013.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/212013.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/212013.html2003 年 8 月 02 日

作为基于MVC模式的Web应用最经典框架，Struts已经正式推出了1.1版本，该版本在以往版本的基础上，提供了许多激动人心的新功能。本文就将带你走进Struts 1.1去深入地了解这些功能。

本文内容包括：
Model 2
Struts 1.1 和Model 2
模块
ActionServlet
ActionForm
Action
宣称式异常处理
taglib
Commons Logging 接口
关于作者
对本文的评价

说明：希望本文的读者能有一定的Struts使用基础。

Model 2

Struts是基于Model 2之上的，而Model 2是经典的MVC（模型－视图－控制器）模型的Web应用变体，这个改变主要是由于网络应用的特性--HTTP协议的无状态性引起的。Model 2的目的和MVC一样，也是利用控制器来分离模型和视图，达到一种层间松散耦合的效果，提高系统灵活性、复用性和可维护性。在多数情况下，你可以将Model 2与MVC等同起来。

下图表示一个基于Java技术的典型网络应用，从中可以看出Model 2中的各个部分是如何对应于Java中各种现有技术的。



在利用Model 2之前，我们是把所有的表示逻辑和业务逻辑都集中在一起（比如大杂烩似的JSP），有时也称这种应用模式为Model 1，Model 1的主要缺点就是紧耦合，复用性差以及维护成本高。


回页首


Struts 1.1 和Model 2

既然Struts 1.1是基于Model 2之上，那它的底层机制也就是MVC，下面是Struts 1.1中的MVC实现示意图：



图解说明：其中不同颜色代表MVC的不同部分：红色（控制器）、紫色（模型）和绿色（视图）

首先，控制器（ActionServlet）进行初始化工作，读取配置文件（struts-config.xml），为不同的Struts模块初始化相应的ModuleConfig对象。比如配置文件中的Action映射定义都保存在ActionConfig集合中。相应地有ControlConfig集合、FormBeanConfig集合、ForwardConfig集合和MessageResourcesConfig集合等。

提示：模块是在Struts 1.1中新提出的概念，在稍后的内容中我们将详细介绍，你现在可以简单地把模块看作是一个子系统，它们共同组成整个应用，同时又各自独立。Struts 1.1中所有的处理都是在特定模块环境中进行的。模块的提出主要是为了解决Struts 1.0中单配置文件的问题。

控制器接收HTTP请求，并从ActionConfig中找出对应于该请求的Action子类，如果没有对应的Action，控制器直接将请求转发给JSP或者静态页面。否则控制器将请求分发至具体Action类进行处理。

在控制器调用具体Action的execute方法之前，ActionForm对象将利用HTTP请求中的参数来填充自己（可选步骤，需要在配置文件中指定）。具体的ActionForm对象应该是ActionForm的子类对象，它其实就是一个JavaBean。此外，还可以在ActionForm类中调用validate方法来检查请求参数的合法性，并且可以返回一个包含所有错误信息的ActionErrors对象。如果执行成功，ActionForm自动将这些参数信息以JavaBean（一般称之为form bean）的方式保存在Servlet Context中，这样它们就可以被其它Action对象或者JSP调用。

Struts将这些ActionForm的配置信息都放在FormBeanConfig集合中，通过它们Struts能够知道针对某个客户请求是否需要创建相应的ActionForm实例。

Action很简单，一般只包含一个execute方法，它负责执行相应的业务逻辑，如果需要，它也进行相应的数据检查。执行完成之后，返回一个ActionForward对象，控制器通过该ActionForward对象来进行转发工作。我们主张将获取数据和执行业务逻辑的功能放到具体的JavaBean当中，而Action只负责完成与控制有关的功能。遵循该原则，所以在上图中我将Action对象归为控制器部分。

提示：其实在Struts 1.1中，ActionMapping的作用完全可以由ActionConfig来替代，只不过由于它是公共API的一部分以及兼容性的问题得以保留。ActionMapping通过继承ActionConfig来获得与其一致的功能，你可以等同地看待它们。同理，其它例如ActionForward与ForwardConfig的关系也是如此。

下图给出了客户端从发出请求到获得响应整个过程的图解说明。



下面我们就来详细地讨论一下其中的每个部分，在这之前，先来了解一下模块的概念。


回页首


模块

我们知道，在Struts 1.0中，我们只能在web.xml中为ActionServlet指定一个配置文件，这对于我们这些网上的教学例子来说当然没什么问题，但是在实际的应用开发过程中，可能会有些麻烦。因为许多开发人员都可能同时需要修改配置文件，但是配置文件只能同时被一个人修改，这样肯定会造成一定程度上的资源争夺，势必会影响开发效率和引起开发人员的抱怨。

在Struts 1.1中，为了解决这个并行开发的问题，提出了两种解决方案：

  1. 多个配置文件的支持
  2. 模块的支持

 

支持多个配置文件，是指你能够为ActionServlet同时指定多个xml配置文件，文件之间以逗号分隔，比如Struts提供的MailReader演示例子中就采用该种方法。

  <!-- Action Servlet Configuration -->
            <servlet>
            <servlet-name>action</servlet-name>
            <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
            <init-param>
            <param-name>config</param-name>
            <param-value>/WEB-INF/struts-config.xml, /WEB-INF/struts-config-registration.xml</param-value>
            </init-param>
            <load-on-startup>1</load-on-startup>
            </servlet>

这种方法可以很好地解决修改冲突的问题，不同的开发人员可以在不同的配置文件中设置自己的Action、ActionForm等等（当然不是说每个开发人员都需要自己的配置文件，可以按照系统的功能模块进行划分）。但是，这里还是存在一个潜在的问题，就是可能不同的配置文件之间会产生冲突，因为在ActionServlet初始化的时候这几个文件最终还是需要合并到一起的。比如，在struts-config.xml中配置了一个名为success的<forward>，而在struts-config-registration.xml中也配置了一个同样的<forward>，那么执行起来就会产生冲突。

为了彻底解决这种冲突，Struts 1.1中引进了模块（Module）的概念。一个模块就是一个独立的子系统，你可以在其中进行任意所需的配置，同时又不必担心和其它的配置文件产生冲突。因为前面我们讲过，ActionServlet是将不同的模块信息保存在不同的ModuleConfig对象中的。要使用模块的功能，需要进行以下的准备工作：

1、为每个模块准备一个配置文件

2、配置web.xml文件，通知控制器

决定采用多个模块以后，你需要将这些信息告诉控制器，这需要在web.xml文件进行配置。下面是一个典型的多模块配置：

<init-param>
            <param-name>config</param-name>
            <param-value>/WEB-INF/struts-config.xml</param-value>
            </init-param>
            <init-param>
            <param-name>config/customer</param-name>
            <param-value>/WEB-INF/struts-config-customer.xml</param-value>
            </init-param>
            <init-param>
            <param-name>config/order</param-name>
            <param-value>/WEB-INF/struts-config-order.xml</param-value>
            </init-param>

要配置多个模块，你需要在原有的一个<init-param>（在Struts 1.1中将其对应的模块称为缺省模块）的基础之上，增加模块对应的<init-param>。其中<param-name>表示为config/XXX的形式，其中XXX为对应的模块名，<param-value>中还是指定模块对应的配置文件。上面这个例子说明该应用有三个模块，分别是缺省模块、customer和order，它们分别对应不同的配置文件。

3、准备各个模块所需的ActionForm、Action和JSP等资源

但是要注意的是，模块的出现也同时带来了一个问题，即如何在不同模块间进行转发？有两种方法可以实现模块间的转发，一种就是在<forward>（全局或者本地）中定义，另外一种就是利用org.apache.struts.actions.SwitchAction。

下面就是一个全局的例子：

    ...
            <struts-config>
            ...
            <global-forwards>
            <forward name="toModuleB"
            contextRelative="true"
            path="/moduleB/index.do"
            redirect="true"/>
            ...
            </global-forwards>
            ...
            </struts-config>

可以看出，只需要在原有的path属性前加上模块名，同时将contextRelative属性置为true即可。此外，你也可以在<action>中定义一个类似的本地<forward>。

  <action-mappings>
            <!-- Action mapping for profile form -->
            <action path="/login"
            type="com.ncu.test.LoginAction"
            name="loginForm"
            scope="request"
            input="tile.userLogin"
            validate="true">
            <forward name="success" contextRelative="true" path="/moduleA/login.do"/>
            </action>
            </action-mappings>

如果你已经处在其他模块，需要转回到缺省模块，那应该类似下面这样定义，即模块名为空。

<forward name="success" contextRelative="true" path="/login.do"/>

此外，你也可以使用org.apache.struts.actions.SwitchAction，例如：

    ...
            <action-mappings>
            <action path="/toModule"
            type="org.apache.struts.actions.SwitchAction"/>
            ...
            </action-mappings>
            ...





回页首


ActionServlet

我们首先来了解MVC中的控制器。在Struts 1.1中缺省采用ActionServlet类来充当控制器。当然如果ActionServlet不能满足你的需求，你也可以通过继承它来实现自己的类。这可以在/WEB-INF/web.xml中来具体指定。

要掌握ActionServlet，就必须了解它所扮演的角色。首先，ActionServlet表示MVC结构中的控制器部分，它需要完成控制器所需的前端控制及转发请求等职责。其次，ActionServlet被实现为一个专门处理HTTP请求的Servlet，它同时具有servlet的特点。在Struts 1.1中它主要完成以下功能：

  • 接收客户端请求
  • 根据客户端的URI将请求映射到一个相应的Action类
  • 从请求中获取数据填充Form Bean（如果需要）
  • 调用Action类的execute()方法获取数据或者执行业务逻辑
  • 选择正确的视图响应客户

 

此外，ActionServlet还负责初始化和清除应用配置信息的任务。ActionServlet的初始化工作在init方法中完成，它可以分为两个部分：初始化ActionServlet自身的一些信息以及每个模块的配置信息。前者主要通过initInternal、initOther和initServlet三个方法来完成。

我们可以在/WEB-INF/web.xml中指定具体的控制器以及初始参数，由于版本的变化以及Struts 1.1中模块概念的引进，一些初始参数被废弃或者移入到/WEB-INF/struts-config.xml中定义。下面列出所有被废弃的参数，相应地在web.xml文件中也不鼓励再使用。

  • application
  • bufferSize
  • content
  • debug
  • factory
  • formBean
  • forward
  • locale
  • mapping
  • maxFileSize
  • multipartClass
  • nocache
  • null
  • tempDir

ActionServlet根据不同的模块来初始化ModuleConfig类，并在其中以XXXconfig集合的方式保存该模块的各种配置信息，比如ActionConfig，FormBeanConfig等。

初始化工作完成之后，ActionServlet准备接收客户请求。针对每个请求，方法process(HttpServletRequest request, HttpServletResponse response)将被调用。该方法指定具体的模块，然后调用该模块的RequestProcessor的process方法。

protected void process(HttpServletRequest request,
            HttpServletResponse response)
            throws IOException, ServletException {
            RequestUtils.selectModule(request, getServletContext());
            getRequestProcessor(getModuleConfig(request)).process(request, response);
            }

RequestProcessor包含了Struts控制器的所有处理逻辑，它调用不同的processXXX方法来完成不同的处理。下表列出其中几个主要的方法：

方法 功能
processPath 获取客户端的请求路径
processMapping 利用路径来获得相应的ActionMapping
processActionForm 初始化ActionForm（如果需要）并存入正确的scope中
processActionCreate 初始化Action
processActionPerform 调用Action的execute方法
processForwardConfig 处理Action返回的ActionForward





回页首


ActionForm

对于ActionForm你可以从以下几个方面来理解它：

  1. ActionForm表示HTTP窗体中的数据，可以将其看作是模型和视图的中介，它负责保存视图中的数据供模型或者视图使用。Struts 1.1文档中把它比作HTTP和Action之间的防火墙，这体现了ActionForm具有的过滤保护的作用，只有通过ActionForm验证的数据才能够发送到Action处理。
  2. ActionForm是与一个或多个ActionConfig关联的JavaBean，在相应的action的execute方法被调用之前，ActionForm会自动利用请求参数来填充自己（初始化属性）。
  3. ActionForm是一个抽象类，你必须通过继承来实现自己的类。

 

ActionForm首先利用属性的getter和setter方法来实现初始化，初始化完毕后，ActionForm的validate方法被调用，你可以在其中来检查请求参数的正确性和有效性，并且可以将错误信息以ActionErrors的形式返回到输入窗体。否则，ActionForm将被作为参数传给action的execute方法以供使用。

ActionForm bean的生命周期可以设置为session（缺省）和request，当设置为session时，记得在reset方法中将所有的属性重新设置为初始值。

由于ActionForm对应于HTTP窗体，所以随着页面的增多，你的ActionForm将会急速增加。而且可能同一类型页面字段将会在不同的ActionForm中出现，并且在每个ActionForm中都存在相同的验证代码。为了解决这个问题，你可以为整个应用实现一个ActionForm或者至少一个模块对应于一个ActionForm。

但是，聚合的代价就是复用性很差，而且难维护。针对这个问题，在Struts 1.1中提出了DynaActionForm的概念。

DynaActionForm类

DynaActionForm的目的就是减少ActionForm的数目，利用它你不必创建一个个具体的ActionForm类，而是在配置文件中配置出所需的虚拟ActionForm。例如，在下表中通过指定<form-bean>的type为"org.apache.struts.action.DynaActionForm"来创建一个动态的ActionForm--loginForm。

<form-beans>
            <form-bean name="loginForm" type="org.apache.struts.action.DynaActionForm">
            <form-property name="actionClass" type="java.lang.String"/>
            <form-property name="username" type="java.lang.String"/>
            <form-property name="password" type="java.lang.String"/>
            </form-bean>
            </form-beans>

动态的ActionForm的使用方法跟普通的ActionForm相同，但是要注意一点。普通的ActionForm对象需要为每个属性提供getter和setter方法，以上面的例子而言，我们需要提供getUsername() 和 setUsername()方法取得和设置username属性，同样地有一对方法用于取得和设置password属性和actionClass属性。

如果使用DynaActionForm，它将属性保存在一个HashMap类对象中，同时提供相应的get(name) 和 set(name)方法，其中参数name是要访问的属性名。例如要访问DynaActionForm中username的值，可以采用类似的代码：

String username = (String)form.get("username")；

由于值存放于一个HashMap对象，所以要记得对get()方法返回的Object对象做强制性类型转换。正是由于这点区别，如果你在Action中非常频繁地使用ActionForm对象，建议还是使用普通的ActionForm对象。

在Struts 1.1中，除了DynaActionForm以外，还提供了表单输入自动验证的功能，在包org.apache.struts.validator中提供了许多有用的类，其中最常见的就是DynaValidatorForm类。

DynaValidatorForm类

DynaValidatorForm是DynaActionForm的子类，它能够提供动态ActionForm和自动表单输入验证的功能。和使用DynaActionForm类似，你必须首先在配置文件中进行配置：

<form-beans>
            <form-bean name="loginForm" type="org.apache.struts.validator.DynaValidatorForm">
            <form-property name="actionClass" type="java.lang.String"/>
            <form-property name="username" type="java.lang.String"/>
            <form-property name="password" type="java.lang.String"/>
            </form-bean>
            </form-beans>

同时要定义验证的插件：

  <plug-in className="org.apache.struts.validator.ValidatorPlugIn">
            <set-property property="pathnames"
            value="/WEB-INF/validator-rules.xml,
            /WEB-INF/validation.xml"/>
            </plug-in>

其中的validator.xml和validator-rules.xml分别表示验证定义和验证规则的内容（可以合并在一起），比如针对上例中的DynaValidatorForm，我们有如下验证定义（validator.xml）：

<?xml version="1.0" encoding="ISO-8859-1" ?>
            <!DOCTYPE form-validation PUBLIC
            "-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.0//EN"
            "http://jakarta.apache.org/commons/dtds/validator_1_0.dtd">
            <!--    Validation Rules    $Id: validation.xml-->
            <form-validation>
            <!-- ========== Default Language Form Definitions ===================== -->
            <formset>
            <form name="loginForm">
            <field property="username" depends="required, minlength,maxlength">
            <arg0   key="prompt.username"/>
            <arg1   key="${var:minlength}" name="minlength" resource="false"/>
            <arg2   key="${var:maxlength}" name="maxlength" resource="false"/>
            <var>
            <var-name>maxlength</var-name>
            <var-value>16</var-value>
            </var>
            <var>
            <var-name>minlength</var-name>
            <var-value>3</var-value>
            </var>
            </field>
            <field property="password" depends="required, minlength,maxlength" bundle="alternate">
            <arg0   key="prompt.password"/>
            <arg1   key="${var:minlength}" name="minlength" resource="false"/>
            <arg2   key="${var:maxlength}" name="maxlength" resource="false"/>
            <var>
            <var-name>maxlength</var-name>
            <var-value>16</var-value>
            </var>
            <var>
            <var-name>minlength</var-name>
            <var-value>3</var-value>
            </var>
            </field>
            </form>
            </formset>
            </form-validation>

从上述定义中，我们可以看到对于字段username有三项验证：required, minlength, maxlength，意思是该字段不能为空，而且长度在3和16之间。而validator-rules.xml文件则可以采用Struts提供的缺省文件。注意在<form-bean>中定义的form是如何与validation.xml中的form关联起来的。最后，要启动自动验证功能，还需要将Action配置的validate属性设置为true。

<action path="/login"
            type="com.ncu.test.LoginAction"
            name="loginForm"
            scope="request"
            input="tile.userLogin"validate="true">

此时，Struts将根据xml配置文件中的定义来检验表单输入，并将不符合要求的错误信息输出到页面。但是你可能会想：这个功能虽然好，可是什么检验都跑到服务器端执行，效率方面和用户易用性方面是不是有些问题？你可能会怀念起那简单的JavaScript客户端验证。

不用担心，在Struts 1.1中也支持JavaScript客户端验证。如果你选择了客户端验证，当某个表单被提交以后，Struts 1.1启动客户端验证，如果浏览器不支持JavaScript验证，则服务器端验证被启动，这种双重验证机制能够最大限度地满足各种开发者的需要。JavaScript验证代码也是在validator-rules.xml文件中定义的。要启动客户端验证，你必须在相应的JSP文件中做如下设置：

  1. 为<html:form>增加onsubmit属性
  2. 设置Javascript支持

 

下表中列出了一JSP文件的示例代码，红字部分为Javascript验证所需代码。

<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
            <table bgcolor="#9AFF9A" cellspacing="0" cellpadding="10" border="1" width="100%">
            <tr>
            <td>
            <table cellspacing="0" cellpadding="0" border="0" width="100%">
            <tr bgcolor="#696969">
            <td align="center">
            <font color="#FFFFFF">Panel 3: Profile</font>
            </td>
            </tr>
            <tr>
            <td><br>
            <html:errors/>
            <html:form action="/login.do" focus="username"  onsubmit="return validateLoginForm(this);">
            <html:hidden property="actionClass"/>
            <center>
            <table>
            <tr>
            <td>UserName:</td>
            <td><html:text property="username" size="20"/></td>
            </tr>
            <tr>
            <td>Password:</td>
            <td><html:password property="password" size="20"/></td>
            </tr>
            <tr>
            <td colspan=2><html:submit property="submitProperty" value="Submit"/></td>
            </table>
            </center>
            </html:form>
            <html:javascript formName="loginForm" dynamicJavascript="true" staticJavascript="false"/>
            <script language="Javascript1.1" src="staticJavascript.jsp"></script>
            </td>
            </tr>
            </table>
            </td>
            </tr>
            </table>

其中onsubmit的值为"return validateLoginForm(this);"，它的语法为：

return validate + struts-config.xml中定义的form-bean名称 + (this);

staticJavascript.jsp的内容为：

<%@ page language="java" %>
            <%-- set document type to Javascript (addresses a bug in Netscape according to a web resource --%>
            <%@ page contentType="application/x-javascript" %>
            <%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
            <html:javascript dynamicJavascript="false" staticJavascript="true"/>

如果validator-rules.xml中定义的基本验证功能不能满足你的需求，你可以自己添加所需的验证类型。


回页首


Action

我们通过继承Action类来实现具体的执行类。具体Action类的功能一般都在execute（以前是perform方法）方法中完成，其中主要涉及到以下几个方面：

  1. 辅助ActionForm进行一些表单数据的检查。
  2. 执行必要的业务逻辑，比如存取数据库，调用实体bean等。
  3. 更新服务器端的bean数据，后续对象中可能会用到这些数据，比如在JSP中利用bean:write来获得这些数据。
  4. 根据处理结果决定程序的去处，并以ActionForward对象的形式返回给ActionServlet。

 

提示：由于在Action和ActionForm中都可以实现验证方法，那么如何来安排它们之间的分工呢？一般来说，我们秉着MVC分离的原则，也就是视图级的验证工作放在ActionForm来完成，比如输入不能为空，email格式是否正确，利用ValidatorForm可以很轻松地完成这些工作。而与具体业务相关的验证则放入Action中，这样就可以获得最大ActionForm重用性的可能。

前面我们提到过，我们主张将业务逻辑执行分离到单独的JavaBean中，而Action只负责错误处理和流程控制。而且考虑到重用性的原因，在执行业务逻辑的JavaBean中不要引用任何与Web应用相关的对象，比如HttpServletRequest，HttpServletResponse等对象，而应该将其转化为普通的Java对象。关于这一点，可以参考Petstore中WAF框架的实现思路。

此外，你可能还注意到execute与perform的一个区别：execute方法简单地掷出Exception异常，而perform方法则掷出ServletException和IOException异常。这不是说Struts 1.1在异常处理功能方面弱化了，而是为了配合Struts 1.1中一个很好的功能--宣称式异常处理机制。


回页首


宣称式异常处理

和EJB中的宣称式事务处理概念类似，宣称式异常处理其实就是可配置的异常处理，你可以在配置文件中指定由谁来处理Action类中掷出的某种异常。你可以按照以下步骤来完成该功能：

  1. 实现org.apache.struts.action.ExceptionHandler的子类，覆盖execute方法，在该方法中处理异常并且返回一个ActionForward对象
  2. 在配置文件中配置异常处理对象，你可以配置一个全局的处理类或者单独为每个Action配置处理类

 

下表就定义了一个全局的处理类CustomizedExceptionHandler，它被用来处理所有的异常。

<global-exceptions>
            <exception
            handler="com.yourcorp.CustomizedExceptionHandler"
            key="global.error.message"
            path="/error.jsp"
            scope="request"
            type="java.lang.Exception"/>
            </global-exceptions>

其中具体的参数含义，可以参考ExceptionHandler.java源文件。


回页首


taglib

讲完了模型和控制器，接下来我们要涉及的是视图。视图的角色主要是由JSP来完成，从JSP的规范中可以看出，在视图层可以"折腾"的技术不是很多，主要的就是自定义标记库的应用。Struts 1.1在原有的四个标记库的基础上新增了两个标记库--Tiles和Nested。

其中Tiles除了替代Template的基本模板功能外，还增加了布局定义、虚拟页面定义和动态页面生成等功能。Tiles强大的模板功能能够使页面获得最大的重用性和灵活性，此外可以结合Tiles配置文件中的页面定义和Action的转发逻辑，即你可以将一个Action转发到一个在Tiles配置文件中定义的虚拟页面，从而减少页面的数量。比如，下表中的Action定义了一个转发路径，它的终点是tile.userMain，而后者是你在Tiles配置文件中定义的一个页面。

<!-- ========== Action Mapping Definitions ============================== -->
            <action-mappings>
            <!-- Action mapping for profile form -->
            <action path="/login"
            type="com.ncu.test.LoginAction"
            name="loginForm"
            scope="request"
            input="tile.userLogin"
            validate="true">
            <forward name="success" path="tile.userMain"/>
            </action>
            </action-mappings>

Tiles配置文件：tiles-defs.xml

<!DOCTYPE tiles-definitions PUBLIC
            "-//Apache Software Foundation//DTD Tiles Configuration//EN"       "http://jakarta.apache.org/struts/dtds/tiles-config.dtd">
            <tiles-definitions>
            <!-- =======================================================  -->
            <!-- Master definitions                                       -->
            <!-- =======================================================  -->
            <!-- Page layout used as root for all pages. -->
            <definition name="rootLayout" path="/tiles-layouts/rootLayout.jsp">
            <put name="titleString" value="CHANGE-ME"/>
            <put name="topMenu" value="/tiles-components/topMenu.jsp"/>
            <put name="leftMenu" value="/tiles-components/panel1.jsp"/>
            <put name="body" value="CHANGE-ME"/>
            <put name="footer" value="/tiles-components/footer.jsp"/>
            </definition>
            <!-- =======================================================  -->
            <!-- Page definitions 					-->
            <!-- =======================================================  -->
            <!-- User Login page -->
            <definition name="tile.userLogin" extends="rootLayout">
            <put name="titleString" value="User Login"/>
            <put name="body" value="/src/userLogin.jsp"/>
            </definition>
            <!-- User Main page -->
            <definition name="tile.userMain" extends="rootLayout">
            <put name="titleString" value="User Main"/>
            <put name="body" value="/src/userMain.jsp"/>
            </definition>
            </tiles-definitions>

而Nested标记库的作用是让以上这些基本标记库能够嵌套使用，发挥更大的作用。


回页首


Commons Logging 接口

所谓的Commons Logging接口，是指将日志功能的使用与日志具体实现分开，通过配置文件来指定具体使用的日志实现。这样你就可以在Struts 1.1中通过统一的接口来使用日志功能，而不去管具体是利用的哪种日志实现，有点于类似JDBC的功能。Struts 1.1中支持的日志实现包括：Log4J，JDK Logging API， LogKit，NoOpLog和SimpleLog。

你可以按照如下的方式来使用Commons Logging接口（可以参照Struts源文中的许多类实现）：

package com.foo;
            // ...
            import org.apache.commons.logging.Log;
            import org.apache.commons.logging.LogFactory;
            //...
            public class Foo {
            // ...
            private static Log log = LogFactory.getLog(Foo.class);
            // ...
            public void setBar(Bar bar) {
            if (log.isTraceEnabled()) {
            log.trace("Setting bar to " + bar);
            }
            this.bar = bar;
            }
            // ...
            }

而开启日志功能最简单的办法就是在WEB-INF/classes目录下添加以下两个文件：

commons-logging.properties文件：

# Note: The Tiles framework now uses the commons-logging package to output different information or debug statements.
            Please refer to this package documentation to enable it. The simplest way to enable logging is to create two files in
            WEB-INF/classes:
            # commons-logging.properties
            # org.apache.commons.logging.Log=org.apache.commons.logging.impl.SimpleLog
            # simplelog.properties
            # # Logging detail level,
            # # Must be one of ("trace", "debug", "info", "warn", "error", or "fatal").
            #org.apache.commons.logging.simplelog.defaultlog=trace
            org.apache.commons.logging.Log=org.apache.commons.logging.impl.SimpleLog

simplelog.properties文件：

# Logging detail level,
            # Must be one of ("trace", "debug", "info", "warn", "error", or "fatal").
            org.apache.commons.logging.simplelog.defaultlog=fatal

这里我们采用的日志实现是SimpleLog，你可以在simplelog.properties文件指定日志明细的级别：trace，debug，info，warn，error和fatal，从trace到fatal错误级别越来越高，同时输出的日志信息也越来越少。而这些级别是和org.apache.commons.logging.log接口中的方法一一对应的。这些级别是向后包含的，也就是前面的级别包含后面级别的信息。



心无痕 2008-07-01 22:10 发表评论
]]>Struts配置文件详解----转载http://www.blogjava.net/xinwuhen/archive/2008/07/01/211910.html心无痕心无痕Tue, 01 Jul 2008 07:16:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/07/01/211910.htmlhttp://www.blogjava.net/xinwuhen/comments/211910.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/07/01/211910.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/211910.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/211910.html相关文章:  
推荐圈子: IBM WebSphere专区
更多相关推荐 Struts应用采用两个基于XML的配置文件来配置,分别是web.xml和struts-cofig.xml文件.web.xml文件是配置所有 web应用的而struts-config.xml文件是struts专用的配置文件,事实上也是可以根据需要给这个配置文件起其他名称的.
Web应用的发布描述文件:web应用发布描述文件可以在应用开着者,发布者和组装者之间传递配置信息,Web容器在启动的时候从该文件中读取配置信息, 根据它来装载和配置web应用.文档类型定义DTD对XML文档的格式做了定义,DTD吧XML文档划分为元素,属性,实体每一种XML文档都有独自的 DTD文件.可以从网上下载.<web-app>元素是web.xml的根元素,其他元素必须嵌入在<web-app>元素之内.要注意的是子元素也是有顺序的比如必须是首先<servlet>,然后<servlet-mapping>最后< taglib>.

为Struts应用配置Web.xml文件:首先最重要的一步是配置ActionServlet,这个用<servlet>标签的 servlet-name属性起一个名字叫action,然后用servlet-class属性指定ActionServlet的类.然后用< servlet-mapping>标签的servlet-name属性指定action,在用url-pattern指定接收范围是*.do的请求.不管应用中包含了多少子应用,都只需要配置一个ActionServlet,类来出来应用中的不同的功能,其实者就是不必要的,因为Servlet本身就是多线程的,而且目前Struts只允许配置一个ActionServlet.声明ActionServlet的初始化参数:< servlet>的<init-param>子元素用来配置Servlet的初始化参数.param-name设置config参数名.param-value设置struts-config.xml的路径参数值.

配置欢迎使用清单:如果客户访问Web的时候值是访问了WEB应用的根目录URL.没有具体的指定文件,Web会自动调用Web的欢迎文件.< welcome-file-list>元素来配置的.通过其中的<welcome-file>欢迎页面</welcome- file>来配置.

配置错误处理:尽管Struts框架功能强大的错误处理机制,但是不能保证处理所有的错误或者异常.当错误发生时,如果框架不能处理这种错误,把错误抛弃给Web容器,在默认的情况下web容器会想客户端返回错误信息.如果想避免让客户看到原始的错误信息,可以在Web应用发布描述文件中配置< error-page>元素.通过<error-code>404来定义错误的类型.然后通过<location>要处理错误的JSP页面来对错误进行处理.还可以用<exception-type>来设置异常,然后通过<location>来处理异常的JSP页面来处理异常.

配置Struts标签库:这个就和以前学到的JSP自定义标签类似,配置元素为<taglib>来配置.<taglib- uri>这个指定标签库的uri,类似起一个名称.<taglib-location>这个是标签库的位置也就是实际所在的路径.通过这样的方法引入一个标签库,然后在前台JSP页面就可以通过自己定义的URI来调用标签.

Struts配置文件:struts-config.xml文件.首先研讨一下org.apache.struts.config包,在struts应用启动的时候会把Struts配置文件信息读取到内存中,并把它们存放在config包中相关的JavaBean类的实例中.包中的每一个类都和 struts配置文件中特定的配置元素对应,ModuleConfig在Struts框架中扮演了十分重要的角色,它是整个config包的核心,在 Struts运行时来存放整个应用的配置信息.如果有多个子应用都会有一个ModuleConfig对象,它和Struts文件根元素的< struts-config>对应.根元素中包含<form-bean><action><forward> 等元素.

<struts-config>元素:时Struts配置文件的根元素,和它对应的配置类ModuleConfig类,<struts -config>元素有8个子元素.他们的DTD定义是data-sources?form-bean? global-exception?global-forwards?action-mapping?controller?message-resources? plug-in*在Struts配置文件中,必须按照DTD指定的先手顺序来配置<struts-config>元素的各个子元素,如果颠倒了这些子元素的顺序,会产生错误.

<data-sources>元素:用来配置应用所需要的数据源,数据源负责创建和特定的数据库的连接.许多数据源采用连接池的机制实现.以便提高数据库访问的性能.JAVA语言提供了javax.sql.DataSource接口,所有的数据源都必须实现这个接口.许多应用服务器和Web服务器都提供了数据源组件.很多数据库厂商也提供了数据源的实现.<data-sources>元素包含多个<data- source>子元素永远配置特定的数据源.他们可以包含多个<set-property>子元素用于设置数据源的各种属性.配置了数据源以后,就可以在Action类中访问数据源,在Action中定义了getDataSource(HttpRequest)方法,用于获取数据源对象的引用.然后可以利用DataSource对象调用getConnection获取一个连接对象对数据库进行操作.在配置文件中声明多个数据源的时候需要为每一个数据源分配唯一的Key值,通过这个来表示特定的数据源.获取特定的数据源的时候可以用dataSource = getDataSource(reqeust,”A”);

<form-beans>元素:用来配置多个ActionForm,包含一个或者N个<form-bean>子元素.每个 <form-bean>元素都包含多个属性.className指定和<form-bean>匹配的类.name指定该 ActionForm的唯一标识符,这个属性是必须的以后作为引用使用.type指定ActionForm类的完整类名,这个属性也是必须的.注意包名也要加上.<form-property>是指定动态的Form的元素,以后会深入了解.

<global-exception>元素:用于配置异常处理,元素可以包含一个或者多个<exception>元素,用来设置 JAVA异常和异常处理类ExceptionHandler之间的映射.className指定和元素对应的配置类,默认的不用动.handler指定异常处理类默认是ExceptionHandler.key指定在本地资源文件中异常的消息Key,path指定当前异常发生的时候转发的路径.scope 指定ActionMessages实例存放的范围.type指定需要处理异常类的名字,必须的.bundle指定Resource Bundle.

<global-forwards>元素:用来声明全局转发,元素可以有一个或者N个<forward>元素组成,用于把一个逻辑名映射到特定的URL,通过这种方法Action类或者JSP页面无需指定URL,只要指定逻辑名称就可以实现请求转发或者重定向.这样可以减少控制组件和视图的聚合.易于维护.className对应的配置类.contextRelative如果为true表示当path属性以/开头的时候,给出的是对应的上下文URL默认是false.name转发路径的逻辑名,必须写.path转发或者重定向的URL,必须写必须是以/开头.redirect设置为true的时候表示执行重定向操作,此项为false的时候,表示执行请求转发操作.重定向与请求转发的区别以后就是重定向是把请求生成应答给客户端然后在重新发送给定向的URL,浏览器地址栏会有显示.而转发就是直接把请求转发给本应用的另一个文件,不生成应答所以客户端IE没显示.

<action-mapping>元素:包含一个或者N个<action>元素,描述了从特定的请求路径到响应的Action的映射.在<action>元素中可以包含多个<exception>和<forward>子元素,他们分别配置局部异常处理和局部转发.attribute设置Action关联的ActionForm在request或者session范围内的key.就是在 request或者session共享内的名称.className对应配置元素的类.默认的是ActionMapping.forward指定转发 URL路径include指定包含URL路径.input指定包含表单的URL,当表单验证失败的时候发送的URL.name,指定和该Action关联的Form名字.该名字必须是在form-bean中定义过的,可写可不写.path必须/开头的方位Action的路径.parameter指定 Action配置参数.在Action的execute()方法中可以调用ActionMapping的getParameter()方法来读取匹配的参数.roles指定允许调用该Action的安全角色,多个角色之间逗号格开.scope指定Form的存在范围.默认是session.tyep指定 Action的完整类名.unknown如果是true表示可以处理用户发出的所有的无效的ActionURL默认是false.validate指定是否调用ActionForm的validate方法.

<controller>元素:用于配置ActionServlet.buffreSize指定上载文件的输入缓冲大小.该属性为可选默认 4096.className指定元素对应的配置类,ControllerConfig.然后是contentType指定响应结果内容类型和字符编码, 该属性为可选,默认是text/html如果在Action或者JSP网页也设置了类型内容,会覆盖这个.locale指定是否把Locale对象保存到当前用户的session中默认false.tempDir指定处理文件上载的临时工作目录.nochache如果是true在响应结果中加入特定的头参数.

<message-resources>元素:用来配置Resource Bundle.用于存放本地文本消息文件.className元素对应的配置类.MessageResourcesConfig.factory指定消息的工厂类.key指定文件存放的Servlet对象中采用的属性Key.null指定如何处理未知消息.parameter指定消息的文件名.

<plug-in>元素:用于配置Struts插件.

配置多应用模块:所有的子应用都可以共享同一个ActionServlet实例,但是每个子应用都有单独的配置文件.把应用划分为多个子应用模块. 首先为每个应用创建单独的Struts配置文件,在web.xml的ActionServlet配置代码中添加几个子应用信息.采用< forward>元素来实现应用之间的切换.

Digester组件:是一个Apache的另一个开源代码项目.当Struts被初始化的时候,首先会读取并解析配置文件,框架采用Digester组件来且西配置文件.然后创建config包中的对象.者对象用于存放配置信息.

其实配置文件不难,只要都理其中的原理就OK了.真正实际的项目开发中,采用的工具例如Eclipse系列,提供了相应的插件,在创建一个Struts工程的时候配置文件的标签都是自动生成的,而我们只需要往里面填写属性就OK了.


心无痕 2008-07-01 15:16 发表评论
]]>搭建MyEclipse+Tomcat开发环境http://www.blogjava.net/xinwuhen/archive/2008/06/30/211769.html心无痕心无痕Mon, 30 Jun 2008 14:26:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/06/30/211769.htmlhttp://www.blogjava.net/xinwuhen/comments/211769.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/06/30/211769.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/211769.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/211769.html本文转自:http://esoft.bokee.com/5081515.html

一、安装JDK
首先下载JDK 5.0 Update7（JDK 5.0 Update7的下载页面为：
http://java.sun.com/javase/downloads/index.jsp）；
然后运行JDK 5.0安装程序jdk-1_5_0_07-windows-i586-p.exe，安装过程中所有选项保持默认；
最后配置JDK的环境变量：在“我的电脑”上点右键—>“属性”—>“高级”—> “环境变量(N)”。

新建系统变量JAVA_HOME：C:\Program Files\Java\jdk1.5.0_06
新建系统变量CLASSPATH：.;%JAVA_HOME%\lib;（注意：点号表示当前目录，不能省略）
在系统变量Path的值的前面加入以下内容：%JAVA_HOME%\bin;(注意:这里的分号不能省略)
到这里，JDK安装完毕。
下面我们测试一下JDK是否安装成功：
将以下内容复制到记事本中：
public class HelloJAVA
{
public static void main(String srg[])
{
System.out.println("Hello JAVA!");
}
}
另存为“HelloJAVA.java”（不含引号，下同），并保存到D盘根目录下。
在命令行依次输入下图中红线所标注的命令：

如果出现上图红框中所标注的内容，则说明JDK安装成功！

注意:如果以后要安装诸如Eclipse、Borland JBuilder、JCreator、IntelliJ IDEA等集成开发环境(IDE,Integrated Development Environment),应该在IDE中编译运行一个简单的HelloWorld程序，以保证IDE可以识别出JDK的位置。

二、安装Tomcat
首先下载jakarta-tomcat-5.0.30.zip，之所以下载免安装版的好处是可以使用多个Tomcat（jakarta-tomcat-5.0.30.zip的下载页面为：
http://apache.linuxforum.net/tomcat/tomcat-5/v5.0.30/bin/）；
然后将jakarta-tomcat-5.0.30.zip直接解压到D盘根目录：

最后配置Tomcat的环境变量：在“我的电脑”上点右键—>“属性”—>“高级”—> “环境变量(N)”。
新建系统变量CATALINA_HOME：D:\jakarta-tomcat-5.0.30
在系统变量CLASSPATH的值的后面加入：%CATALINA_HOME%\common\lib;
在系统变量Path的值中"%JAVA_HOME%\bin;"的后面加入以下内容：%CATALINA_HOME%\bin;

到这里，Tomcat安装完毕。

相关链接：
Tomcat 4和Tomcat 5安装配置指南
Tomcat 5.5安装配置指南

进行完一、二两步的设置以后，各系统变量的值如下：

JAVA_HOME:C:\Program Files\Java\jdk1.5.0_06
CATALINA_HOME:D:\jakarta-tomcat-5.0.30
CLASSPATH:.;%JAVA_HOME%\lib;%CATALINA_HOME%\common\lib;
Path:%JAVA_HOME%\bin;%CATALINA_HOME%\bin;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem

三、安装Eclipse
首先下载eclipse-SDK-3.1.2-win32.zip（eclipse-SDK-3.1.2-win32.zip下载地址为：
http://www.eclipse.org/downloads/）；
然后将eclipse-SDK-3.1.2-win32.zip直接解压到D盘根目录：

到这里， Eclipse安装完毕。

四、安装MyEclipse
首先下载EnterpriseWorkbenchInstaller_4.1.1GA_E3.1.exe（EnterpriseWorkbenchInstaller_4.1.1GA_E3.1.exe 的下载地址为：
http://www.myeclipseide.com/ContentExpress-display-ceid-10.html）；
然后安装EnterpriseWorkbenchInstaller_4.1.1GA_E3.1.exe。注意：当安装到下图所示的步骤的时候要选择Eclipse的安装路径（如图），其他选项保持默认。

安装完毕之后，将MyEclipse安装目录下的features和plugins这2个目录覆盖到Eclipse的安装目录下。
最后将刚才安装的 MyEclipse 卸载。
解释一下上面这样做的原因： 因为MyEclipse是Eclipse的插件，所以只要把features和plugins这2个目录覆盖到Eclipse的安装目录，Eclipse就会自动认出这些插件。
到这里，MyEclipse安装完毕。

五、破解MyEclipse
运行MyEclipse4.1.1注册机MyEclipseKeyGen.exe，选择MyEclipse的版本号，输入注册名，生成序列号。（MyEclipse4.x注册机的下载地址为：
http://esoft.g8.com.cn/UploadFiles/2006-5/520753587.rar）
运行eclipse.exe（首次运行要求指定Workspace），依次点击Window ----> Preferences ---->MyEclipse---->Subscription ----> Enter Subscription，输入注册名以及注册机生成的注册码。
到这里，MyEclipse破解完毕。

六、指定Eclipse+MyEclipse的JRE 和Tomcat 服务器
1.设定Eclipse+MyEclipse的JRE
一般情况下，Eclipse可以自动找到JRE，我们不用进行过多的设置。
2.设定Eclipse+MyEclipse的Tomcat 服务器
只需设置图中所标注的两处即可，图中其余部分是自动生成的。

到这里，我们的Eclipse+MyEclipse开发环境就搭建完毕了！

七、新建一个项目来测试一下Eclipse+MyEclipse开发环境是否搭建成功
1.在Eclipse中依次点击“ File ----> New ----> Project” , 在弹出的“New Project”对话框中依次点击“Web Project ---->MyEclipse---->J2EE Projects---->Web Project”， 再点“Next”，在“Project Name”中输入项目的名字“test”,最后点“Finish”。
2.在Eclipse左边Package Explorer列表中点击“test”，将项目test展开。右键点击 WebRoot ----> New ----> JSP , 新建一个名为hello.jsp的 JSP 页面 。 代码如下图（图中标注部分需要我们手动添加，其余部分是系统自动生成的）：



3. 再用同样的方法， 新建一个叫 hello_result.jsp 的JSP文件， 代码如下图：

4. deploy（部署）项目。
点击 deploy 按钮（用红线画了的按钮就是 deploy 按钮）， 在弹出的窗口中点击Add， 部署test项目（如图所示）。

5. 启动Tomcat服务器。
如下图所示（用红线画了的按钮就是 启动Tomcat 的按钮）：

Tomcat 启动输出信息如下图：

6.项目test的运行结果：

我们可以去Eclipse的Workspace目录下看看test项目的代码，也可以去Tomcat的webapps目录下，看看部署之后的 test项目的结构。



心无痕 2008-06-30 22:26 发表评论
]]>用DTree实现树型结构数据展现http://www.blogjava.net/xinwuhen/archive/2008/06/03/205483.html心无痕心无痕Tue, 03 Jun 2008 01:48:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/06/03/205483.htmlhttp://www.blogjava.net/xinwuhen/comments/205483.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/06/03/205483.html#Feedback1http://www.blogjava.net/xinwuhen/comments/commentRss/205483.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/205483.html这两天发现了dtree,做的很不错,想和大家交流一下
下载地址：http://www.destroydrop.com/javascripts/tree/dtree.zip
或从附件里下载
看看里面的example01.html例子。
在这个基础上我做了一个动态的树型结构数据的展现（其实就是动态生成js代码而已）。
java类代码
Java代码 复制代码
  1. import java.io.Serializable;   
  2. public class TreeNode implements Serializable{   
  3.     private String id ;          //节点编号   
  4.     private String pid ;         //父节点编号   
  5.     private String name ;        //节点名称   
  6.     private String url ;         //链接地址   
  7.     private String title ;       //节点描述   
  8.     private String target ;      //Target   
  9.     private String icon ;        //图标路径   
  10.     private String iconOpen ;    //展开状态下的图标路径   
  11.     private String open ;        //是否展开   
  12.        
  13.     //构造函数   
  14.     public TreeNode(){   
  15.         id = "" ;   
  16.         pid = "" ;   
  17.         name = "" ;   
  18.         url = "" ;   
  19.         title = "" ;   
  20.         target = "" ;   
  21.         icon = "" ;   
  22.         iconOpen = "" ;   
  23.         open = "" ;   
  24.     }   
  25.     //------get set functions  

Java代码 复制代码
  1. public class TreeNodeUtil {   
  2.     //返回js代码   
  3.     public static String createJsArray(TreeNode[] tn , String dtree) {   
  4.         if(tn == null || tn.length == 0 ){   
  5.             System.out.println("TreeNode is empty");   
  6.             return "";   
  7.         }   
  8.         StringBuffer contents = new StringBuffer(100);   
  9.         contents.append("new dTree('"+dtree+"');");   
  10.         for (int i = 0; i < tn.length; i++) {    
  11.             contents.append("\n");   
  12.             contents.append(dtree+".add('");   
  13.             contents.append(tn[i].getId());   
  14.             contents.append("','");   
  15.             contents.append(tn[i].getPid());   
  16.             contents.append("','");   
  17.             contents.append(tn[i].getName());   
  18.             contents.append("','");   
  19.             contents.append(tn[i].getUrl());   
  20.             contents.append("','");   
  21.             contents.append(tn[i].getTitle());   
  22.             contents.append("','");   
  23.             contents.append(tn[i].getTarget());   
  24.             contents.append("','");   
  25.             contents.append(tn[i].getIcon());   
  26.             contents.append("','");   
  27.             contents.append(tn[i].getIconOpen());   
  28.             contents.append("','");   
  29.             contents.append(tn[i].getOpen());   
  30.             contents.append("');");   
  31.         }   
  32.         return contents.toString();   
  33.     }   
  34. }  

根据实际情况生成TreeNode对象
Java代码 复制代码
  1. public void execute() throws EpochalException {   
  2.     // TODO Auto-generated method stub   
  3.     String sql = "";   
  4.     String url = "" ;   
  5.     sql = "SELECT id,parentId,name,seq ,remark FROM t_testtree ORDER BY  seq DESC" ;   
  6.     TableData tableData = null;   
  7.     TreeNode[] treeNodes = null;   
  8.     try{   
  9.         tableData = TableSelector.select(sql);   
  10.         if(tableData!=null){   
  11.             treeNodes = new TreeNode[tableData.getRowCount()] ;   
  12.             for(int i = 0; i<tableData.getRowCount();i++){   
  13.                 treeNodes[i] = new TreeNode();   
  14.                 treeNodes[i].setId(tableData.getString(i,"id"));   
  15.                 treeNodes[i].setName(tableData.getString(i,"name"));   
  16.                 treeNodes[i].setPid(tableData.getString(i,"parentId"));   
  17.                 //根据实际情况生成连接地址   
  18.                 url = "programList.x?category="+tableData.getString(i,"name") ;   
  19.                 treeNodes[i].setUrl(url);   
  20.                 treeNodes[i].setTitle(tableData.getString(i,"remark"));   
  21.                 treeNodes[i].setTarget("_blank");//打开新窗口   
  22.             }   
  23.             dataBean.setParameter("treeNodeArray",treeNodes) ;   
  24.         }   
  25.     }catch(Exception e){   
  26.         System.out.println(e.toString());   
  27.     }   
  28. }  

jsp这边取"treeNodeArray"后通过TreeNodeUtil类生成js代码
Java代码 复制代码
  1. <%   
  2. TreeNode[] treeNodes = (TreeNode[])dataBean.getParameterObject("treeNodeArray") ;   
  3. %>   
  4. <p><a href="javascript: d.openAll();">全部展开</a> | <a href="javascript: d.closeAll();">全部关闭</a></p>   
  5. <script language="javascript">   
  6. d = <%=TreeNodeUtil.createJsArray(treeNodes,"d")%>   
  7. document.write(d);   
  8. </script>  

客户端生成的js代码
Java代码 复制代码
  1. <script language="javascript">   
  2. d = new dTree('d');   
  3. d.add('1','-1','栏目','programList.x?category=栏目','','_blank','','','');   
  4. d.add('2','1','电影','programList.x?category=电影','','_blank','','','');   
  5. d.add('3','1','电视剧','programList.x?category=电视剧','','_blank','','','');   
  6. d.add('4','1','专题','programList.x?category=专题','','_blank','','','');   
  7. d.add('5','1','远程教育','programList.x?category=远程教育','','_blank','','','');   
  8. d.add('6','1','期刊','programList.x?category=期刊','','_blank','','','');   
  9. d.add('7','2','动作片','programList.x?category=动作片','','_blank','','','');   
  10. d.add('8','2','喜剧片','programList.x?category=喜剧片','','_blank','','','');   
  11. d.add('9','2','鬼片','programList.x?category=鬼片','','_blank','','','');   
  12. d.add('10','3','韩剧','programList.x?category=韩剧','','_blank','','','');   
  13. d.add('11','3','古装剧','programList.x?category=古装剧','','_blank','','','');   
  14. d.add('12','5','英语沙龙','programList.x?category=英语沙龙','','_blank','','','');   
  15. d.add('13','4','热门推荐','programList.x?category=热门推荐','','_blank','','','');   
  16. d.add('14','7','港台片','programList.x?category=港台片','','_blank','','','');   
  17. d.add('15','7','欧美片','programList.x?category=欧美片','','_blank','','','');   
  18. d.add('16','14','成龙全集','programList.x?category=成龙全集','','_blank','','','');   
  19. d.add('17','14','李连杰全集','programList.x?category=李连杰全集','','_blank','','','');   
  20. document.write(d);   
  21. </script>  


感觉使用很方便，数据量不是很大（一般的树型结构的数据量不会很大的，数据量大了就不直观了）的情况下能够满足大多数人的需要。
注意的是root节点的pid必须为'-1'
  • dtree.zip (14.6 KB)
  • 描述: dtree.zip
  • 下载次数: 507


心无痕 2008-06-03 09:48 发表评论
]]>JSP数据导出到EXCEL简便方法http://www.blogjava.net/xinwuhen/archive/2008/05/19/201363.html心无痕心无痕Mon, 19 May 2008 04:55:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/05/19/201363.htmlhttp://www.blogjava.net/xinwuhen/comments/201363.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/05/19/201363.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/201363.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/201363.html试试看从网页中把表格直接生成excel，虽然不是直接从sql到excel，不过反而更加方便而且人性化。。

网上倒是找到了不少的资料，发现一段javascript的功能实现代码，很不错：
var elTable = document.getElementById("tb");
var oRangeRef = document.body.createTextRange();
oRangeRef.moveToElementText( elTable );
oRangeRef.execCommand( "Copy" );

var appExcel = new ActiveXObject( "Excel.Application" );
appExcel.Visible = true;
appExcel.Workbooks.Add().Worksheets.Item(1).Paste();
appExcel = null;

实现功能就是把id为tb的表格内的数据都生成为excel，我试试了可行，但是放到服务器来运行就是script error的提示，然后网上到处求问，也找了百度空间的几位高手朋友问了下，可是还是不得其法。。不过还是很感谢他们的热心帮助

没办法，我只能用别的方法来实现了，其实满喜欢上面的这个javascript的功能的，比较人性化。。可惜我黔驴技穷，无法用上它，哎！~

既然我帮客户用jsp写的程序，那么我就还是用jsp来实现这个功能吧。。

于是找到了这么一个方法：
原文出自：http://www.jsp.mlc.edu.tw/viewitem.jsp?itemid=0000000065

***************************************************************************************************
一、将网页资料以excel报表以线上浏览方式呈现
xls651.jsp原始码如下


<%@ page contentType="application/msexcel; charset=gb2312" %>
<!-- 以上这行设定本网页为excel格式的网页 -->
<%
   response.setHeader("Content-disposition","inline; filename=test1.xls");
   //以上这行设定传送到前端浏览器时的档名为test1.xls
   //就是靠这一行，让前端浏览器以为接收到一个excel档
%>
<html>
<head>
<title>Excel档案呈现方式</title>
</head>
<body>
  <table border="1" width="100%">
    <tr>
      <td>姓名</td><td>身份证字号</td><td>生日</td>
    </tr>
    <tr>
      <td>李玟</td><td>N111111111</td><td>1900/11/12</td>
    </tr>
    <tr>
      <td>梁静如</td><td>N222222222</td><td>1923/10/1</td>
    </tr>
    <tr>
      <td>张惠妹</td><td>N333333333</td><td>1934/12/18</td>
    </tr>
  </table>
</body>
</html>

二、将网页资料以excel报表以下载的方式呈现
这个jsp档和上一个差不多，只有差别在这一行：
线上浏览的方式： response.setHeader("Content-disposition","inline; filename=test1.xls");
下载的方式： response.setHeader("Content-disposition","attachment; filename=test2.xls");
附注： 1.以上纯以静态网页的方式呈现excel档，配合资料库，你便能以动态的报表方式做出excel报表了
2.完全不用安装任何元件，或只能受限於win平台，一个简单的方式解决你的报表需求
3.聪明的你，应该能举一反三，知道如何将网页资料以word的doc格式展现了吧！
(是不是只要把contentType改成"application/msword"以及filename的副档名改成.doc就可以了！)

心无痕 2008-05-19 12:55 发表评论
]]>关于ANT构建应用时，根据判定条件执行不同任务的实例(以操作系统类型为判定条件举例)http://www.blogjava.net/xinwuhen/archive/2008/05/14/200371.html心无痕心无痕Wed, 14 May 2008 03:36:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/05/14/200371.htmlhttp://www.blogjava.net/xinwuhen/comments/200371.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/05/14/200371.html#Feedback1http://www.blogjava.net/xinwuhen/comments/commentRss/200371.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/200371.html 一：）下载apache-ant-版本号-bin.zip文件（此处是apache-ant-1.7.0-bin.zip）：
               下载apache-ant-1.7.0-bin.zip
二：）下载ant-contrib-版本号.jar文件（此处是ant-contrib-1.0b3.jar）：
              下载ant-contrib-1.0b3.jar
三：）解压ANT安装文件（apache-ant-1.7.0-bin.zip）到某一目录，如：

            D:\Program Files\Apache_ANT_1.7.0

四：）配置环境变量（path与classpath）：
            ANT_HOME=D:\Program Files\Apache_ANT_1.7.0

            path=%path%;%ANT_HOME%\bin;
            classpath=%ANT_HOME%\lib;
五：）安装ant-contrib-1.0b3.jar，下面是ant-contrib-1.0b3.jar解压包中的指南对安装的说明，如下：
            

Installation

First you must install Apache Ant itself, most of the Ant-Contrib tasks require Ant 1.5 or higher to work properly, however, there are some tasks, specifically <for> which require Ant 1.6. You can download Ant from Apache.

Then you need the Ant-Contrib tasks themselves. As there is no release of these tasks yet, you have to build them from sources. Fortunately this is easy, check out the sources (grab the ant-contrib module from CVS), change into the source directory of ant-contrib and type ant. After Ant has completed, you'll find ant-contrib-version.jar in the lib subdirectory.

You now have the choice:

  1. Copy ant-contrib-version.jar to the lib directory of your Ant installation, or on your CLASSPATH environment variable. If you want to use one of the tasks in your project, add the line 
    <taskdef resource="net/sf/antcontrib/antlib.xml"/>
    to your build file.

  2. Keep ant-contrib-version.jar in a separate location. You now have to tell Ant explicitly where to find it (say in /usr/share/java/lib): 
    <taskdef resource="net/sf/antcontrib/antlib.xml">
    <classpath>
    <pathelement location="/usr/share/java/lib/ant-contrib-version.jar"/>
    </classpath>
    </taskdef>
  3. If you would like to use run with Ant Version 1.5 you must use the the .properties file instead. Keep in mind that some tasks will not be available to you , such as the <for> task: 
    <taskdef resource="net/sf/antcontrib/antcontrib.properties">
    <classpath>
    <pathelement location="/usr/share/java/lib/ant-contrib-version.jar"/>
    </classpath>
    </taskdef>
六：）现在可以使用ant-contrib的功能来添加到ANT构建文件中，下面是本项目（湖北质检）的构建文件，如下(注意红色部分的条件定义与判断的执行):
<?xml version="1.0" encoding="UTF-8" ?>
<project name="QCSystem" default="startWebApplication" basedir=".">

 <description>湖北质检ANT构建与Tomcat应用起动配置文件，起动应用时根据不同的操作系统调用不同的Tomcat起运脚本（startup.sh或startup.bat）!</description>
 
 <!-- ********** 构件文件相关属性 *********** -->
 <!-- 系统环境变量 -->
 <property environment="sys-env"/> 

 <!-- 通用路径或文件夹名称 -->
 <property name="srcDir" location="src"/>
 <property name="webAppDir" location="webapp"/>

 <property name="webInfName" value="WEB-INF"/>
 <property name="destDirName" value="classes"/>

 <property name="tomcatCommonName" value="common"/>
 

 <!-- 添加"Ant-Contrib"对ANT构建文件的支持 -->  

 <taskdef resource="net/sf/antcontrib/antcontrib.properties">   

    <classpath>    

        <pathelement location="${sys-env.ANT_HOME}/Ant-Contrib/ant-contrib-1.0b3.jar"/>  

    </classpath>  

 </taskdef>



 <!-- 初始化操作系统判断条件 -->  

 <property name="winOS" value="win"/>

 <property name="unixOS" value="unix"/>
 <target name="init">   

    <echo message="初始化操作系统判断条件[开始]..." />   

    <condition property="OSType" value="${winOS}">    

        <os family="Windows"/>   

    </condition>

    <condition property="OSType" value="${unixOS}">

        <os family="UNIX"/>

    </condition>   

    <echo message="初始化操作系统判断条件[结束]..." />  

  </target>
 <!-- 第三方类库-->
 <path id="compileLibFiles">
  <fileset dir="${webAppDir}/${webInfName}/lib">
      <include name="**/*.jar"/>
  </fileset>

  <fileset dir="${sys-env.CATALINA_HOME}/${tomcatCommonName}/lib">
   <include name="**/*.jar"/>
  </fileset>
 </path>
 

 <!-- 编译工程 -->
 <target name="compile">
  <echo message="湖北质检项目编译[开始] ..."/>
  <javac srcdir="${srcDir}" debug="on" destdir="${webAppDir}/${webInfName}/${destDirName}" includes="**/*.java">
   <classpath refid="compileLibFiles"/>
  </javac>

  <!-- 拷贝配置文件到编译目录 -->
  <copy todir="${webAppDir}/${webInfName}/${destDirName}">
   <fileset dir="${srcDir}" excludes="**/*.java"/>
  </copy>
  <echo message="湖北质检项目编译[结束] ..."/>
 </target>

 <!-- 根据不同的操作系统调用不同的Tomcat起动程序(Windows操作系统:startup.bat  Unix操作系统:startup.sh) -->
 <target name="startWebApplication" depends="init, compile">
  <echo message="起动湖北质检应用[开始] ..."/>
  <if>    

    <equals arg1="${OSType}" arg2="${winOS}"/>    

    <!-- 下边这种方式直接判断操作系统也可以 -->    

    <!--os family="WINDOWS"/-->    

    <then>     

        <exec dir="${sys-env.CATALINA_HOME}/bin" executable="${sys-env.CATALINA_HOME}/bin/startup.bat"/>

    </then>    

    <else>     

        <exec dir="${sys-env.CATALINA_HOME}/bin" executable="${sys-env.CATALINA_HOME}/bin/startup.sh"/>    

    </else>   

  </if>  

  <echo message="起动湖北质检应用[结束] ..."/>
 </target>

</project>




心无痕 2008-05-14 11:36 发表评论
]]>Subversion使用手记--转载http://www.blogjava.net/xinwuhen/archive/2008/04/22/194676.html心无痕心无痕Tue, 22 Apr 2008 01:23:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/04/22/194676.htmlhttp://www.blogjava.net/xinwuhen/comments/194676.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/04/22/194676.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/194676.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/194676.html一直以来对于自己的项目都是使用CVS进行管理，听说Subversion很久了，但是都没有时间去尝试。想想时间都是省出来的，于是决定，一天学一点，不多，积累成河嘛。
  Subversion和CVS相比，除了包含了CVS的全部特性之外，也加入了新的理念。
                                    新理念
  1、路径、改名、以及文件meta-data也可进入版本控制范围。
  缺少这些特性是CVS被抱怨最多的方面之一，subversion不止对文件内容和文件存放位置加入控制，也对目录，拷贝，重命名操作加入版本控制。它也允许文件/目录的相关元数据meta-data和文件/目录本身一起被版本控制起来，并提供一种机制对文件的执行权限进行控制。
  2、Commit动作真正成为原子级的操作了。
直到整个commit动作都成功前不会有任何部分的commit会生效。版本修订号只是预确认，而不是对文件预确认。(翻译不出来 -_-;)日志信息将绑定到修订信息，而不是象CVS那样冗余的存储下来。
 3、提供Apache网络服务器选项，支持WebDAV/DeltaV协议。
Subversion可以使用基于http协议的WebDAV/DeltaV协议进行网络通讯，并由Apache服务器提供源码仓库方的网络浏览服务。这为Subversion提供了比CVS更好的协同工作能力，并提供了各式各样的自由的关键特性：授权，基于路径的授权，线性压缩，以及基本源码仓库浏览。
4、独立服务器选项
Subversion也能提供独立服务器选项，使用自定的协议（不是每个人都想运行Apache2.x）独立服务器可以作为系统的inetd服务运行，并提供基本的授权。它也能使用ssh进行加密。
 5、建立分支和标签操作成为不耗时的操作。
这些动作没理由耗时，所以我们不再让它们耗时。
6、分支与标签的实现都是基于底层的拷贝操作，一个拷贝占用一块固定大小的空间。任何拷贝都可以作为一份标签；假如你开始对某个版本的拷贝进行commit动作，那它也就成为一个分支。(这与CVS的"分支节点做标签"方式不同)
7、天然的client/server结构，层次化库设计。
Subversion从设计之初即采用client/server机构；因此避免了困扰CVS了许久的一些维护性难题。
代码被构建为一组带有详细接口说明的模块，用以方便的由其他应用程序进行调用。
8、Client/server协议向双方发送对比差异。
网络协议利用宽带有效地发送对比差异给客户端和服务器端双方。( CVS只是 server->client,?没有client->server )
 9、资源消耗与数据改变的大小成正比，而不是与数据本身大小成正比一般来说，一项Subversion操作所需时间与操作最终变化的大小成正比。而不是与操作所触及的整个项目的大小成正比，这是Subversion源代码仓库模型的一个特性。
 10、有效的处理二进制文件
Subversion对于二进制文件和文本文件的处理同样有效，因为subversion使用一种二进制差异比较算法来增量存储那些连续的修订本。
 11、易于语法分析的输出。
所有Subversion命令行客户端的输出都是仔细设计的，可轻松为人所理解，也适于程序自动解析。可进行脚本语言处理将是下一步优先考虑的特性。
 好了，开始使用吧。
Subversion到目前的安装已经非常简单了。到Subversion网站下载Windows下的安装文件，简单的步骤就可以完成安装，而且安装程序已经自动注册Path，直接在命令行模式就可以使用了。
  首先初始化Repository，输入命令:
 svnadmin create D:"TestRepository"
然后，把现有的项目的目录结构以及文件导入到Repository中：
 svn import D:"Projects"Project1 file:///D:"TestRepository"Project1 -m “初始化“
 用启动服务
 svnserve -d -r D:"TestRepository"
 客户端Checkout
 svn checkout svn://主机名/Project1?? (即获取Project1的项目)
 以上都是很简单的命令。而且上面只用到了一种服务模式，Apache的还在尝试中。
 目前只用到了Subversion的基本功能，就已经感觉不错了，觉得入门很轻松，帮助文档也比CVS要好的多。
 Subversion也有图形的客户端，可以在 TortoiseSVN 找到。
 Subversion也VS.Net的插件，可以在AnkhSVN 找到。
 TortoiseSVN相信不错，因为以前用过它的另一个For CVS的工具，可以和浏览器结合在一起，非常方便和美观。
服务
    Subversion具有两种服务模式，一个是作为Apache的模块，另一个是自定义协议的Subserve服务。作为Apache的模块，客户端可以通过WebDAV/DeltaV协议访问Repository，而使用Subserve则使用
Subversion的自定义协议。
下表是两种服务模式的比较：

功能

 

Apache + mod_dav_sub

 

Svnserve

 

验证方式

 

基于HTTPS的X.509、LDAP、NTLM或其他Apache支持的验证

 

CRAM-MD5或者SSH

 

用户帐户管理

 

私有的用户文件

 

私有的用户文件或已有的系统帐户

 

授权管理

 

blanket read/write access或单一目录的访问控制

 

blanket read/write access

 

加密

 

可选的SSL

 

可选的SSH隧道

 

交互性

 

可通过支持WebDAV的客户端访问

 

无交互性

 

Web访问

 

有限的内置支持，或通过第三方的工具，例如ViewCVS

 

通过第三方的支持，如ViewCVS

 

速度

 

稍慢

 

稍快

 

初始安装

 

稍复杂

 

相当简单

 

 
                                   启动svnserve服务
svnserve 是一个轻量级的服务， 使用自定义的协议通过TCP/IP与客户端通讯。
客户端通过由 svn:// 或者 svn+ssh:// 开始的URL访问svnserve服务器。
启动服务器
端口监控（inetd）模式
如果你打算用端口监控来启动处理客户的访问请求的进程，你可以通过传入参数-i来启动：
svnserve -i
当使用-i参数启动服务的时候，svnserve通过stdin和stdout用自定义协议和客户端
通讯。同时服务侦听3690端口。
独立端口监控进程
使用参数-d启动服务作为一个独立的端口监控进程。
svnserve -d
当运行svnserve在独立端口监控模式时，你可以使用--listen-port=和--listen-host=参数来自定义需要的端口和主机名称。当前模式默认的端口是3690。
当然，也有第三种方法启动svnserve，也就是使用“隧道模式”，使用-t参数启动服务。这个模式要求远程服务程序，如RSH或SSH，已经成功验证用户，并且使用已经校验的用户启动一个属于该用户的svnserve进程。当使用该模式提供服务时，要确认启动的用户帐户具备对Repository的读/写权限。
设置项目目录
当svnserve开始运行时，它将会暴露所有的Repository到网络上。不过，当客户端需要获取一个Repository的内容时，需要指定Reopsitory的绝对路径。例如：一个Repository放在文件路径
C:/Project Repository/Project1
那么当客户端访问时，需要指定绝对路径：
svn://host/C:/Project Repository/Project1
所以，为了增加保密性，你可以使用参数-r指定需要暴露的Repository的路径，当用户访问时，只需指定Repository的名称即可。例如上面的Repository，当启动服务时，使用如下的方法：
svn -d -r C:/Project Repository
那么当客户端访问时，则使用
svn://host/Project1
就可以获取数据了。
内置的验证和授权
当客户端连接到一个svnserve进程时，下面的流程就会触发：
1、客户选择一个指定的Repository；
2、服务处理Repository的配置文件 conf/svnserve.conf文件，并且开始执行在其中定义的所有验证和授权策略；
3、依赖与情形和授权策略：
a)客户端也许允许匿名访问而不需要验证，或者
b)客户但也许需要在任何时候被要求验证，或者
c)假如处于"隧道模式"中，客户端将声明自己已经可以被外部验证。
很显然，如上所说，用户文件是一个名为svnserve.conf的，放在conf目录下的文件。
现在我们来看看如何配置这个文件：
这个配置文件放置在Repository的目录中的conf目录下，它有两个节点：
[general]
[users]
其中，[general]的配置信息有：
anon-access = read
auth-access = write
其中表示对于验证有效的以及没通过验证的用户可以做什么事情。分别有read, write和none
[users]的标签的配置内容有：
USERNAME = PASSWORD
password-db = passwd
realm = My First Repository
其中表示，用户名对应的密码是什么，或者指定一个存储用户名和密码的文件的相对或绝对路径以及指定了Repository的验证领域。如果两个Repository有相同的验证领域，那么它们应该有相同的密码数据库，反之亦然。默认的领域就是指向当前的Repository的路径，与服务器的Repository的根目录相关。

几个版本控制工具的比较:

cvs是开源项目，其功能比vss强大很多，可以支持版本合并，多个分支。而vss是比较简单和易用的配置管理工具。在这两个工具的选择上还是要看是项目决定，一般10个人以下的团队vss可能更方便一些~~~

cvs是并行版本管理器，开源，可以多人同时修改一个文件，当出现冲突的时候自动合入或者提示；
vss是微软visual studio中附带的版本管理器，只能在windows局域网环境下使用。使用一个文件同时只能由一个人来修改的方法来避免冲突。最大的优点是易学，并且跟visual studio可以无缝集成。
cvs,vss 都是版本控制的软件工具，可以把源代码或者其他文件的每一次修改的内容都保存起来，算是可以看以前版本的代码。
vss 基于文件共享的机制，易用性好，安全性不太好。vss 对于同时增加删除多个目录的支持很好。分支合并管理也很容易使用，打标签功能不太好用。vss 基于文件锁机制，同一时刻，只能有一个人修改同一个文件。
cvs 基于 c/s 结构，也有工具可以让它 b/s 运行，不过 b/s 速度慢，使用者不多。cvs 安全控制比较好，对于同时增加多个目录的支持不太好。cvs 中删除目录很难。cvs可以同一时刻多人修改统一文件然后合并，不过只支持文本文件；对于 office 或者其他格式的文档，多个人同时修改同一个文件很难合并，浪费大家时间。我在网上搜索让cvs支持锁机制，只有少数文章提到在 server 端用 script 控制，语焉不详。
总体来说，cvs 功能比vss强。


心无痕 2008-04-22 09:23 发表评论
]]>log4j 配置http://www.blogjava.net/xinwuhen/archive/2008/04/17/193689.html心无痕心无痕Thu, 17 Apr 2008 03:31:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/04/17/193689.htmlhttp://www.blogjava.net/xinwuhen/comments/193689.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/04/17/193689.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/193689.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/193689.html      log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，     当时在log4j完成时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中实际使用最多的还是log4j，     人们遗忘了sun的日志工具类。     它的一个独有特性包括在类别中继承的概念。通过使用类别层次结构，这样就减少了日志记录输出量，并将日志记录的开销降到最低。
  
     它允许开发者控制以任意间隔输出哪些日志语句。通过使用外部配置文件，完全可以在运行时进行配置。几乎每个大的应用程序都包括其自己的日志记录或跟踪 API。经验表明日志记录是开发周期中的重要组成部分。同样，日志记录提供一些优点。首先，它可以提供运行应用程序的确切 上下文。一旦插入到代码中，生成日志记录输出就不需要人为干涉。其次，日志输出可以保存到永久媒体中以便以后研究。最后，除了在开发阶段中使用，十分丰富 的日志记录包还可以用作审计工具。

    依照该规则，在 1996 年初，EU SEMPER（欧洲安全电子市场）项目就决定编写自己的跟踪 API。 在无数次改进、几次具体化和许多工作之后，该 API 已经演变成 log4j，一种流行的 Java 日志记录包。  这个包按 IBM 公共许可证分发，由开放源码权威机构认证。

    日志记录有其自己的缺点。它会降低应用程序的速度。如果太详细，它可能会使屏幕滚动变得看不见。  为了减低这些影响，log4j 被设计成快速且灵活的。由于应用程序很少将日志记录当作是主要功能，  log4j API 力争易于了解和使用。
     log4j，它可以控制以任意间隔输出哪些日志语句。

二、主要组件

1、根类别（在类别层次结构的顶部，即全局性的日志级别）
 
配置根Logger，其语法为：

log4j.rootLogger = [ level ] , appenderName, appenderName, ...

level 是日志记录的类别
appenderName就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。

类别level 为 OFF、FATAL、ERROR、WARN、INFO、DEBUG、log、ALL或自定义的优先级。
og4j常用的优先级FATAL>ERROR>WARN>INFO>DEBUG
配置根Logger，其语法为：
log4j.rootLogger = [ level ] , appenderName, appenderName, …
如果为log4j.rootLogger=WARN，则意味着只有WARN,ERROR,FATAL被输出，DEBUG,INFO将被屏蔽掉。

举例：log4j.rootCategory=INFO,stdout,Runlog,Errorlog
根日志类别为INFO，DEBUG将被屏蔽，其他的将被输出。 stdout,Runlog,Errorlog分别为3个输出目的地。

 2、常用输出格式

 -X号:X信息输出时左对齐；
 %p:日志信息级别
 %d{}:日志信息产生时间
 %c:日志信息所在地（类名）
 %m:产生的日志具体信息
 %n:输出日志信息换行
 举例：
log4j.appender.stdout.layout.ConversionPattern= %5p %d{yyyy-MM-dd HH:mm:ss} %c %m %n
log4j.appender.Runlog.layout.ConversionPattern= %5p %d{yyyy-MM-dd HH:mm:ss} %c %m %n
log4j.appender.Errorlog.layout.ConversionPattern= %5p %d{yyyy-MM-dd HH:mm:ss} %c %m %n

3、布局
使用的输出布局，其中log4j提供4种布局：
org.apache.log4j.HTMLLayout（以HTML表格形式布局）
org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

举例：
输出格式为HTML表格
log4j.appender.stdout.layout=org.apache.log4j.HTMLLayout

输出格式为可以灵活地指定布局模式
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

输出格式为包含日志信息的级别和信息字符串
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout

输出格式为包含日志产生的时间、线程、类别等等信息
log4j.appender.stdout.layout=org.apache.log4j.TTCCLayout


4、目的地

配置日志信息输出目的地Appender，其语法为


log4j.appender.appenderName = fully.qualified.name.of.appender.class
log4j.appender.appenderName.option1 = value1
...
log4j.appender.appenderName.option = valueN
appenderName就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。

log4j支持的输出目的地：
org.apache.log4j.ConsoleAppender 控制台
org.apache.log4j.FileAppender 文件
org.apache.log4j.DailyRollingFileAppender 每天产生一个日志文件
org.apache.log4j.RollingFileAppender （文件大小到达指定尺寸的时候产生一个新的文件），
org.apache.log4j.WriterAppender （将日志信息以流格式发送到任意指定的地方）
org.apache.log4j.net.SMTPAppender 邮件
org.apache.log4j.jdbc.JDBCAppender 数据库
其他如：GUI组件、甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等

举例：


输出到控制台
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender（指定输出到控制台）
log4j.appender.Threshold=DEBUG（指定输出类别）
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout（指定输出布局）
log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n（指定输出格式）

输出到文件

   log4j.appender.FILE=org.apache.log4j.FileAppender（指定输出到文件）
   log4j.appender.FILE.File=file.log（指定输出的路径及文件名）
   log4j.appender.FILE.Append=false
   log4j.appender.FILE.layout=org.apache.log4j.PatternLayout（指定输出的布局）
   log4j.appender.FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n（指定输出的格式）

输出到文件（轮换"日志文件",当日志文件达到指定大小时，该文件就被关闭并备份，然后创建一个新的日志文件）

  log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender（指定输出到文件）
  log4j.appender.ROLLING_FILE.Threshold=ERROR（指定输出类别）
  log4j.appender.ROLLING_FILE.File=rolling.log（指定输出的路径及文件名）
  log4j.appender.ROLLING_FILE.Append=true
  log4j.appender.ROLLING_FILE.MaxFileSize=10KB（指定输出到文件的大小）
  log4j.appender.ROLLING_FILE.MaxBackupIndex=1
  log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout（指定采用输出布局）
  log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n（指定采用输出格式）

输出到Socket
 log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender（指定输出到Socket）
 log4j.appender.SOCKET.RemoteHost=localhost（远程主机）
 log4j.appender.SOCKET.Port=5001（远程主机端口）
 log4j.appender.SOCKET.LocationInfo=true
 log4j.appender.SOCKET.layout=org.apache.log4j.PatternLayout（布局）
 log4j.appender.SOCET.layout.ConversionPattern =[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n %m[MESSAGE]%n%n（输出格式）

输出到邮件
log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender（指定输出到邮件）
 log4j.appender.MAIL.Threshold=FATAL
 log4j.appender.MAIL.BufferSize=10
 log4j.appender.MAIL.From=chenyl@hollycrm.com（发件人）
 log4j.appender.MAIL.SMTPHost=mail.hollycrm.com（SMTP服务器）
 log4j.appender.MAIL.Subject=Log4J Message
 log4j.appender.MAIL.To=chenyl@hollycrm.com（收件人）
 log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout（布局）
 log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n（格式）


输出到数据库
 log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender（指定输出到数据库）
 log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test（指定数据库URL）
 log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver（指定数据库driver）
 log4j.appender.DATABASE.user=root（指定数据库用户）
 log4j.appender.DATABASE.password=root（指定数据库用户密码）
 log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')（组织SQL语句）
 log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout（布局）
 log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n（格式）

5、日志类别补充
有时我们需要对某个特定的部分指定有别于根类别的日志类别，可以指定某个包的优先级
如：
  log4j.category.com.neusoft.mbip.dm.util=ERROR ，其中com.neusoft.mbip.dm.util为我们需要特别指定日志类别的部分。
 
  或者可以指定输出文件的优先级
  log4j.appender.Errorlog.Threshold=ERROR
 
 
 三、 常用log4j配置 

常用log4j配置，一般可以采用两种方式，.properties和.xml,下面举两个简单的例子：

1、log4j.properties

### 设置org.zblog域对应的级别INFO,DEBUG,WARN,ERROR和输出地A1，A2 ##
log4j.category.org.zblog=ERROR,A1
log4j.category.org.zblog=INFO,A2

log4j.appender.A1=org.apache.log4j.ConsoleAppender
### 设置输出地A1，为ConsoleAppender(控制台) ##
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
### 设置A1的输出布局格式PatterLayout,(可以灵活地指定布局模式）##
log4j.appender.A1.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} [%c]-[%p] %m%n
### 配置日志输出的格式##

log4j.appender.A2=org.apache.log4j.RollingFileAppender
### 设置输出地A2到文件（文件大小到达指定尺寸的时候产生一个新的文件）##
log4j.appender.A2.File=E:/study/log4j/zhuwei.html
### 文件位置##
log4j.appender.A2.MaxFileSize=500KB
### 文件大小##
log4j.appender.A2.MaxBackupIndex=1
log4j.appender.A2.layout=org.apache.log4j.HTMLLayout
##指定采用html方式输出

2、log4j.xml

<?xml version="1.0" encoding="GB2312" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

<appender name="org.zblog.all" class="org.apache.log4j.RollingFileAppender">
<!-- 设置通道ID:org.zblog.all和输出方式：org.apache.log4j.RollingFileAppender -->
    <param name="File" value="E:/study/log4j/all.output.log" /><!-- 设置File参数：日志输出文件名 -->
    <param name="Append" value="false" /><!-- 设置是否在重新启动服务时，在原有日志的基础添加新日志 -->
    <layout class="org.apache.log4j.PatternLayout">
        <param name="ConversionPattern" value="%p (%c:%L)- %m%n" /><!-- 设置输出文件项目和格式 -->
    </layout>
</appender>

<appender name="org.zblog.zcw" class="org.apache.log4j.RollingFileAppender">
    <param name="File" value="E:/study/log4j/zhuwei.output.log" />
    <param name="Append" value="true" />
    <param name="MaxFileSize" value="10240" /> <!-- 设置文件大小 -->
    <layout class="org.apache.log4j.PatternLayout">
        <param name="ConversionPattern" value="%p (%c:%L)- %m%n" />
    </layout>
</appender>

<logger name="zcw.log"> <!-- 设置域名限制，即zcw.log域及以下的日志均输出到下面对应的通道中 -->
    <level value="debug" /><!-- 设置级别 -->
    <appender-ref ref="org.zblog.zcw" /><!-- 与前面的通道id相对应 -->
</logger>

<root> <!-- 设置接收所有输出的通道 -->
    <appender-ref ref="org.zblog.all" /><!-- 与前面的通道id相对应 -->
</root>

</log4j:configuration>


3、配置文件加载方法：

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.xml.DOMConfigurator;

public class Log4jApp {
    public static void main(String[] args) {
        DOMConfigurator.configure("E:/study/log4j/log4j.xml");//加载.xml文件
        //PropertyConfigurator.configure("E:/study/log4j/log4j.properties");//加载.properties文件

        Logger log=Logger.getLogger("org.zblog.test");
        log.info("测试");
    }
}

4、项目使用log4j
在web应用中，可以将配置文件的加载放在一个单独的servlet中，并在web.xml中配置该servlet在应用启动时候加载。
对于在多人项目中，可以给每一个人设置一个输出通道，这样在每个人在构建Logger时，用自己的域名称，让调试信
息输出到自己的log文件中。

四、log4j配置举例（properties）

#log4j.rootLogger = [ level ] , appenderName, appenderName,
#类别level 为 OFF、FATAL、ERROR、WARN、INFO、DEBUG、log、ALL或自定义的优先级
#Log4j常用的优先级FATAL>ERROR>WARN>INFO>DEBUG

#stdout为控制台 ，Errorlog为错误记录日志 ，
log4j.rootCategory=INFO,stdout,Runlog,Errorlog


#输出的appender的格式为
#log4j.appender.appenderName = fully.qualified.name.of.appender.class
#log4j.appender.appenderName.option1 = value1
#log4j.appender.appenderName.option = valueN
#Log4j中appender支持的输出
#org.apache.log4j.ConsoleAppender 控制台
#org.apache.log4j.FileAppender 文件
#org.apache.log4j.DailyRollingFileAppender 每天产生一个日志文件
#org.apache.log4j.RollingFileAppender （文件大小到达指定尺寸的时候产生一个新的文件），
#org.apache.log4j.WriterAppender （将日志信息以流格式发送到任意指定的地方）
#org.apache.log4j.net.SMTPAppender 邮件
#org.apache.log4j.jdbc.JDBCAppender 数据库

＃定义输出的形式
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.Runlog=org.apache.log4j.DailyRollingFileAppender
log4j.appender.Errorlog=org.apache.log4j.DailyRollingFileAppender


#可以指定输出文件的优先级
log4j.appender.Errorlog.Threshold=ERROR

#指定输出的文件
log4j.appender.Runlog.File=D:\UserInfoSyn\WebRoot\WEB-INF\runlog\runlog.log
log4j.appender.Errorlog.File=D:\UserInfoSyn\WebRoot\WEB-INF\errorlog\errorlog.log


#Log4j的layout布局
#org.apache.log4j.HTMLLayout 以HTML表格形式布局
#org.apache.log4j.PatternLayout 可以灵活地指定布局模式
#org.apache.log4j.SimpleLayout  包含日志信息的级别和信息字符串
#org.apache.log4j.TTCCLayout    包含日志产生的时间、线程、类别等等信息

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.Runlog.layout=org.apache.log4j.PatternLayout
log4j.appender.Errorlog.layout=org.apache.log4j.PatternLayout

#输出格式,log4j javadoc org.apache.log4j.PatternLayout
#-X号:X信息输出时左对齐；
#%p:日志信息级别
# %d{}:日志信息产生时间
# %c:日志信息所在地（类名）
# %m:产生的日志具体信息
# %n:%n:输出日志信息换行
log4j.appender.stdout.layout.ConversionPattern= %5p %d{yyyy-MM-dd HH:mm:ss} %c %m %n
log4j.appender.Runlog.layout.ConversionPattern= %5p %d{yyyy-MM-dd HH:mm:ss} %c %m %n
log4j.appender.Errorlog.layout.ConversionPattern= %5p %d{yyyy-MM-dd HH:mm:ss} %c %m %n

#指定某个包的优先级
log4j.category.com.neusoft.mbip.dm.util=ERROR


#示例
###################
# Console Appender
###################
#log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
#log4j.appender.Threshold=DEBUG
#log4j.appender.CONSOLE.Target=System.out
#log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
#log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
#log4j.appender.CONSOLE.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD] n%c[CATEGORY]%n%m[MESSAGE]%n%n


#####################
# File Appender
#####################
#log4j.appender.FILE=org.apache.log4j.FileAppender
#log4j.appender.FILE.File=file.log
#log4j.appender.FILE.Append=false
#log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
#log4j.appender.FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
# Use this layout for LogFactor 5 analysis

########################
# Rolling File????? RollingFileAppender??????????????????
########################
#log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender
#log4j.appender.ROLLING_FILE.Threshold=ERROR
# 文件位置
#log4j.appender.ROLLING_FILE.File=rolling.log
#log4j.appender.ROLLING_FILE.Append=true
#文件大小
#log4j.appender.ROLLING_FILE.MaxFileSize=10KB
#指定采用输出布局和输出格式
#log4j.appender.ROLLING_FILE.MaxBackupIndex=1
#log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout
#log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

####################
# Socket Appender
####################
#log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender
#log4j.appender.SOCKET.RemoteHost=localhost
#log4j.appender.SOCKET.Port=5001
#log4j.appender.SOCKET.LocationInfo=true
# Set up for Log Facter 5
#log4j.appender.SOCKET.layout=org.apache.log4j.PatternLayout
#log4j.appender.SOCET.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n%m[MESSAGE]%n%n

########################
# SMTP Appender
#######################
#log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
#log4j.appender.MAIL.Threshold=FATAL
#log4j.appender.MAIL.BufferSize=10
#log4j.appender.MAIL.From=chenyl@hollycrm.com
#log4j.appender.MAIL.SMTPHost=mail.hollycrm.com
#log4j.appender.MAIL.Subject=Log4J Message
#log4j.appender.MAIL.To=chenyl@hollycrm.com
#log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout
#log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

########################
# JDBC Appender
#######################
#log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
#log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test
#log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver
#log4j.appender.DATABASE.user=root
#log4j.appender.DATABASE.password=
#log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')
#log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
#log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

########################
# Log Factor 5 Appender
########################
#log4j.appender.LF5_APPENDER=org.apache.log4j.lf5.LF5Appender
#log4j.appender.LF5_APPENDER.MaxNumberOfRecords=2000

###################
#自定义Appender
###################
#log4j.appender.im = net.cybercorlin.util.logger.appender.IMAppender
#log4j.appender.im.host = mail.cybercorlin.net
#log4j.appender.im.username = username
#log4j.appender.im.password = password
#log4j.appender.im.recipient = corlin@cybercorlin.net
#log4j.appender.im.layout=org.apache.log4j.PatternLayout
#log4j.appender.im.layout.ConversionPattern =[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n



心无痕 2008-04-17 11:31 发表评论
]]>关于web.xml配置的详细说明http://www.blogjava.net/xinwuhen/archive/2008/04/15/193043.html心无痕心无痕Tue, 15 Apr 2008 03:42:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/04/15/193043.htmlhttp://www.blogjava.net/xinwuhen/comments/193043.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/04/15/193043.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/193043.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/193043.html1 定义头和根元素

部署描述符文件就像所有XML文件一样，必须以一个XML头开始。这个头声明可以使用的XML版本并给出文件的字符编码。
DOCYTPE声明必须立即出现在此头之后。这个声明告诉服务器适用的servlet规范的版本（如2.2或2.3）并指定管理此文件其余部分内容的语法的DTD(Document Type Definition，文档类型定义)。
所有部署描述符文件的顶层（根）元素为web-app。请注意，XML元素不像HTML，他们是大小写敏感的。因此，web-App和WEB-APP都是不合法的，web-app必须用小写。

2 部署描述符文件内的元素次序

XML 元素不仅是大小写敏感的，而且它们还对出现在其他元素中的次序敏感。例如，XML头必须是文件中的第一项，DOCTYPE声明必须是第二项，而web- app元素必须是第三项。在web-app元素内，元素的次序也很重要。服务器不一定强制要求这种次序，但它们允许（实际上有些服务器就是这样做的）完全拒绝执行含有次序不正确的元素的Web应用。这表示使用非标准元素次序的web.xml文件是不可移植的。
下面的列表给出了所有可直接出现在web-app元素内的合法元素所必需的次序。例如，此列表说明servlet元素必须出现在所有servlet-mapping元素之前。请注意，所有这些元素都是可选的。因此，可以省略掉某一元素，但不能把它放于不正确的位置。
l icon icon元素指出IDE和GUI工具用来表示Web应用的一个和两个图像文件的位置。
l display-name display-name元素提供GUI工具可能会用来标记这个特定的Web应用的一个名称。
l description description元素给出与此有关的说明性文本。
l context-param context-param元素声明应用范围内的初始化参数。
l filter 过滤器元素将一个名字与一个实现javax.servlet.Filter接口的类相关联。
l filter-mapping 一旦命名了一个过滤器，就要利用filter-mapping元素把它与一个或多个servlet或JSP页面相关联。
l listener servlet API的版本2.3增加了对事件监听程序的支持，事件监听程序在建立、修改和删除会话或servlet环境时得到通知。Listener元素指出事件监听程序类。
l servlet 在向servlet或JSP页面制定初始化参数或定制URL时，必须首先命名servlet或JSP页面。Servlet元素就是用来完成此项任务的。
l servlet-mapping 服务器一般为servlet提供一个缺省的URL：http://host/webAppPrefix/servlet/ServletName。但是，常常会更改这个URL，以便servlet可以访问初始化参数或更容易地处理相对URL。在更改缺省URL时，使用servlet-mapping元素。
l session-config 如果某个会话在一定时间内未被访问，服务器可以抛弃它以节省内存。可通过使用HttpSession的setMaxInactiveInterval方法明确设置单个会话对象的超时值，或者可利用session-config元素制定缺省超时值。
l mime-mapping 如果Web应用具有想到特殊的文件，希望能保证给他们分配特定的MIME类型，则mime-mapping元素提供这种保证。
l welcom-file-list welcome-file-list元素指示服务器在收到引用一个目录名而不是文件名的URL时，使用哪个文件。
l error-page error-page元素使得在返回特定HTTP状态代码时，或者特定类型的异常被抛出时，能够制定将要显示的页面。
l taglib taglib元素对标记库描述符文件（Tag Libraryu Descriptor file）指定别名。此功能使你能够更改TLD文件的位置，而不用编辑使用这些文件的JSP页面。
l resource-env-ref resource-env-ref元素声明与资源相关的一个管理对象。
l resource-ref resource-ref元素声明一个资源工厂使用的外部资源。
l security-constraint security-constraint元素制定应该保护的URL。它与login-config元素联合使用
l login-config 用login-config元素来指定服务器应该怎样给试图访问受保护页面的用户授权。它与sercurity-constraint元素联合使用。
l security-role security-role元素给出安全角色的一个列表，这些角色将出现在servlet元素内的security-role-ref元素的role-name子元素中。分别地声明角色可使高级IDE处理安全信息更为容易。
l env-entry env-entry元素声明Web应用的环境项。
l ejb-ref ejb-ref元素声明一个EJB的主目录的引用。
l ejb-local-ref ejb-local-ref元素声明一个EJB的本地主目录的应用。

3 分配名称和定制的UL

在web.xml中完成的一个最常见的任务是对servlet或JSP页面给出名称和定制的URL。用servlet元素分配名称，使用servlet-mapping元素将定制的URL与刚分配的名称相关联。
3.1 分配名称
为了提供初始化参数，对servlet或JSP页面定义一个定制URL或分配一个安全角色，必须首先给servlet或JSP页面一个名称。可通过 servlet元素分配一个名称。最常见的格式包括servlet-name和servlet-class子元素（在web-app元素内），如下所示：
<servlet>
<servlet-name>Test</servlet-name>
<servlet-class>moreservlets.TestServlet</servlet-class>
</servlet>
这表示位于WEB-INF/classes/moreservlets/TestServlet的servlet已经得到了注册名Test。给 servlet一个名称具有两个主要的含义。首先，初始化参数、定制的URL模式以及其他定制通过此注册名而不是类名引用此servlet。其次,可在 URL而不是类名中使用此名称。因此，利用刚才给出的定义，URL http://host/webAppPrefix/servlet/Test 可用于 http://host/webAppPrefix/servlet/moreservlets.TestServlet 的场所。
请记住：XML元素不仅是大小写敏感的，而且定义它们的次序也很重要。例如，web-app元素内所有servlet元素必须位于所有servlet- mapping元素（下一小节介绍）之前，而且还要位于5.6节和5.11节讨论的与过滤器或文档相关的元素（如果有的话）之前。类似地，servlet 的servlet-name子元素也必须出现在servlet-class之前。5.2节"部署描述符文件内的元素次序"将详细介绍这种必需的次序。
例如，程序清单5-1给出了一个名为TestServlet的简单servlet，它驻留在moreservlets程序包中。因为此servlet是扎根在一个名为deployDemo的目录中的Web应用的组成部分，所以TestServlet.class放在deployDemo/WEB- INF/classes/moreservlets中。程序清单5-2给出将放置在deployDemo/WEB-INF/内的web.xml文件的一部分。此web.xml文件使用servlet-name和servlet-class元素将名称Test与TestServlet.class相关联。图 5-1和图5-2分别显示利用缺省URL和注册名调用TestServlet时的结果。

程序清单5-1 TestServlet.java
package moreservlets;

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

/** Simple servlet used to illustrate servlet naming
* and custom URLs.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* © 2002 Marty Hall; may be freely used or adapted.
*/

public class TestServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String uri = request.getRequestURI();
out.println(ServletUtilities.headWithTitle("Test Servlet") +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"<H2>URI: " + uri + "</H2>\n" +
"</BODY></HTML>");
}
}


程序清单5-2 web.xml（说明servlet名称的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- … -->
<servlet>
<servlet-name>Test</servlet-name>
<servlet-class>moreservlets.TestServlet</servlet-class>
</servlet>
<!-- … -->
</web-app>

3.2 定义定制的URL
大多数服务器具有一个缺省的serlvet URL：
http://host/webAppPrefix/servlet/packageName.ServletName。虽然在开发中使用这个URL很方便，但是我们常常会希望另一个URL用于部署。例如，可能会需要一个出现在Web应用顶层的URL（如，http: //host/webAppPrefix/Anyname），并且在此URL中没有servlet项。位于顶层的URL简化了相对URL的使用。此外，对许多开发人员来说，顶层URL看上去比更长更麻烦的缺省URL更简短。
事实上，有时需要使用定制的URL。比如，你可能想关闭缺省URL映射，以便更好地强制实施安全限制或防止用户意外地访问无初始化参数的servlet。如果你禁止了缺省的URL，那么你怎样访问servlet呢？这时只有使用定制的URL了。
为了分配一个定制的URL，可使用servlet-mapping元素及其servlet-name和url-pattern子元素。Servlet- name元素提供了一个任意名称，可利用此名称引用相应的servlet；url-pattern描述了相对于Web应用的根目录的URL。url- pattern元素的值必须以斜杠（/）起始。
下面给出一个简单的web.xml摘录，它允许使用URL http://host/webAppPrefix/UrlTest而不是http://host/webAppPrefix/servlet/Test或
http: //host/webAppPrefix/servlet/moreservlets.TestServlet。请注意，仍然需要XML头、 DOCTYPE声明以及web-app封闭元素。此外，可回忆一下，XML元素出现地次序不是随意的。特别是，需要把所有servlet元素放在所有 servlet-mapping元素之前。
<servlet>
<servlet-name>Test</servlet-name>
<servlet-class>moreservlets.TestServlet</servlet-class>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name>Test</servlet-name>
<url-pattern>/UrlTest</url-pattern>
</servlet-mapping>
URL模式还可以包含通配符。例如，下面的小程序指示服务器发送所有以Web应用的URL前缀开始，以..asp结束的请求到名为BashMS的servlet。
<servlet>
<servlet-name>BashMS</servlet-name>
<servlet-class>msUtils.ASPTranslator</servlet-class>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name>BashMS</servlet-name>
<url-pattern>/*.asp</url-pattern>
</servlet-mapping>
3.3 命名JSP页面
因为JSP页面要转换成sevlet，自然希望就像命名servlet一样命名JSP页面。毕竟，JSP页面可能会从初始化参数、安全设置或定制的URL中受益，正如普通的serlvet那样。虽然JSP页面的后台实际上是servlet这句话是正确的，但存在一个关键的猜疑：即，你不知道JSP页面的实际类名（因为系统自己挑选这个名字）。因此，为了命名JSP页面，可将jsp-file元素替换为servlet-calss元素，如下所示：
<servlet>
<servlet-name>Test</servlet-name>
<jsp-file>/TestPage.jsp</jsp-file>
</servlet>
命名JSP页面的原因与命名servlet的原因完全相同：即为了提供一个与定制设置（如，初始化参数和安全设置）一起使用的名称，并且，以便能更改激活 JSP页面的URL（比方说，以便多个URL通过相同页面得以处理，或者从URL中去掉.jsp扩展名）。但是，在设置初始化参数时，应该注意，JSP页面是利用jspInit方法，而不是init方法读取初始化参数的。
例如，程序清单5-3给出一个名为TestPage.jsp的简单JSP页面，它的工作只是打印出用来激活它的URL的本地部分。TestPage.jsp放置在deployDemo应用的顶层。程序清单5-4给出了用来分配一个注册名PageName，然后将此注册名与http://host/webAppPrefix/UrlTest2/anything 形式的URL相关联的web.xml文件（即，deployDemo/WEB-INF/web.xml）的一部分。

程序清单5-3 TestPage.jsp
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>
JSP Test Page
</TITLE>
</HEAD>
<BODY BGCOLOR="#FDF5E6">
<H2>URI: <%= request.getRequestURI() %></H2>
</BODY>
</HTML>


程序清单5-4 web.xml（说明JSP页命名的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- ... -->
<servlet>
<servlet-name>PageName</servlet-name>
<jsp-file>/TestPage.jsp</jsp-file>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name> PageName </servlet-name>
<url-pattern>/UrlTest2/*</url-pattern>
</servlet-mapping>
<!-- ... -->
</web-app>


4 禁止激活器servlet

对servlet或JSP页面建立定制URL的一个原因是，这样做可以注册从 init（servlet）或jspInit（JSP页面）方法中读取得初始化参数。但是，初始化参数只在是利用定制URL模式或注册名访问 servlet或JSP页面时可以使用，用缺省URL http://host/webAppPrefix/servlet/ServletName 访问时不能使用。因此，你可能会希望关闭缺省URL，这样就不会有人意外地调用初始化servlet了。这个过程有时称为禁止激活器servlet，因为多数服务器具有一个用缺省的servlet URL注册的标准servlet，并激活缺省的URL应用的实际servlet。
有两种禁止此缺省URL的主要方法：
l 在每个Web应用中重新映射/servlet/模式。
l 全局关闭激活器servlet。
重要的是应该注意到，虽然重新映射每个Web应用中的/servlet/模式比彻底禁止激活servlet所做的工作更多，但重新映射可以用一种完全可移植的方式来完成。相反，全局禁止激活器servlet完全是针对具体机器的，事实上有的服务器（如ServletExec）没有这样的选择。下面的讨论对每个Web应用重新映射/servlet/ URL模式的策略。后面提供在Tomcat中全局禁止激活器servlet的详细内容。
4.1 重新映射/servlet/URL模式
在一个特定的Web应用中禁止以http://host/webAppPrefix/servlet/ 开始的URL的处理非常简单。所需做的事情就是建立一个错误消息servlet，并使用前一节讨论的url-pattern元素将所有匹配请求转向该 servlet。只要简单地使用：
<url-pattern>/servlet/*</url-pattern>
作为servlet-mapping元素中的模式即可。
例如，程序清单5-5给出了将SorryServlet servlet（程序清单5-6）与所有以http://host/webAppPrefix/servlet/ 开头的URL相关联的部署描述符文件的一部分。

程序清单5-5 web.xml（说明JSP页命名的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- ... -->
<servlet>
<servlet-name>Sorry</servlet-name>
<servlet-class>moreservlets.SorryServlet</servlet-class>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name> Sorry </servlet-name>
<url-pattern>/servlet/*</url-pattern>
</servlet-mapping>
<!-- ... -->
</web-app>


程序清单5-6 SorryServlet.java
package moreservlets;

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

/** Simple servlet used to give error messages to
* users who try to access default servlet URLs
* (i.e., http://host/webAppPrefix/servlet/ServletName)
* in Web applications that have disabled this
* behavior.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* © 2002 Marty Hall; may be freely used or adapted.
*/

public class SorryServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Invoker Servlet Disabled.";
out.println(ServletUtilities.headWithTitle(title) +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"<H2>" + title + "</H2>\n" +
"Sorry, access to servlets by means of\n" +
"URLs that begin with\n" +
"http://host/webAppPrefix/servlet/\n" +
"has been disabled.\n" +
"</BODY></HTML>");
}

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


4.2 全局禁止激活器：Tomcat
Tomcat 4中用来关闭缺省URL的方法与Tomcat 3中所用的很不相同。下面介绍这两种方法：
1．禁止激活器： Tomcat 4
Tomcat 4用与前面相同的方法关闭激活器servlet，即利用web.xml中的url-mapping元素进行关闭。不同之处在于Tomcat使用了放在 install_dir/conf中的一个服务器专用的全局web.xml文件，而前面使用的是存放在每个Web应用的WEB-INF目录中的标准 web.xml文件。
因此，为了在Tomcat 4中关闭激活器servlet，只需在install_dir/conf/web.xml中简单地注释出/servlet/* URL映射项即可，如下所示：
<!--
<servlet-mapping>
<servlet-name>invoker</servlet-name>
<url-pattern>/servlet/*</url-pattern>
</servlet-mapping>
-->
再次提醒，应该注意这个项是位于存放在install_dir/conf的Tomcat专用的web.xml文件中的，此文件不是存放在每个Web应用的WEB-INF目录中的标准web.xml。
2．禁止激活器：Tomcat3
在Apache Tomcat的版本3中，通过在install_dir/conf/server.xml中注释出InvokerInterceptor项全局禁止缺省 servlet URL。例如，下面是禁止使用缺省servlet URL的server.xml文件的一部分。
<!--
<RequsetInterceptor
className="org.apache.tomcat.request.InvokerInterceptor"
debug="0" prefix="/servlet/" />
-->

5 初始化和预装载servlet与JSP页面

这里讨论控制servlet和JSP页面的启动行为的方法。特别是，说明了怎样分配初始化参数以及怎样更改服务器生存期中装载servlet和JSP页面的时刻。
5.1 分配servlet初始化参数
利用init-param元素向servlet提供初始化参数，init-param元素具有param-name和param-value子元素。例如，在下面的例子中，如果initServlet servlet是利用它的注册名（InitTest）访问的，它将能够从其方法中调用getServletConfig(). getInitParameter("param1")获得"Value 1"，调用getServletConfig().getInitParameter("param2")获得"2"。
<servlet>
<servlet-name>InitTest</servlet-name>
<servlet-class>moreservlets.InitServlet</servlet-class>
<init-param>
<param-name>param1</param-name>
<param-value>value1</param-value>
</init-param>
<init-param>
<param-name>param2</param-name>
<param-value>2</param-value>
</init-param>
</servlet>
在涉及初始化参数时，有几点需要注意：
l 返回值。GetInitParameter的返回值总是一个String。因此，在前一个例子中，可对param2使用Integer.parseInt获得一个int。
l JSP中的初始化。JSP页面使用jspInit而不是init。JSP页面还需要使用jsp-file元素代替servlet-class。
l 缺省URL。初始化参数只在通过它们的注册名或与它们注册名相关的定制URL模式访问Servlet时可以使用。因此，在这个例子中，param1和 param2初始化参数将能够在使用URL http://host/webAppPrefix/servlet/InitTest 时可用，但在使用URL http://host/webAppPrefix/servlet/myPackage.InitServlet 时不能使用。
例如，程序清单5-7给出一个名为InitServlet的简单servlet，它使用init方法设置firstName和emailAddress字段。程序清单5-8给出分配名称InitTest给servlet的web.xml文件。
程序清单5-7 InitServlet.java
package moreservlets;

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

/** Simple servlet used to illustrate servlet
* initialization parameters.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* © 2002 Marty Hall; may be freely used or adapted.
*/

public class InitServlet extends HttpServlet {
private String firstName, emailAddress;

public void init() {
ServletConfig config = getServletConfig();
firstName = config.getInitParameter("firstName");
emailAddress = config.getInitParameter("emailAddress");
}

public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String uri = request.getRequestURI();
out.println(ServletUtilities.headWithTitle("Init Servlet") +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"<H2>Init Parameters:</H2>\n" +
"<UL>\n" +
"<LI>First name: " + firstName + "\n" +
"<LI>Email address: " + emailAddress + "\n" +
"</UL>\n" +
"</BODY></HTML>");
}
}


程序清单5-8 web.xml（说明初始化参数的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- ... -->
<servlet>
<servlet-name>InitTest</servlet-name>
<servlet-class>moreservlets.InitServlet</servlet-class>
<init-param>
<param-name>firstName</param-name>
<param-value>Larry</param-value>
</init-param>
<init-param>
<param-name>emailAddress</param-name>
<param-value>Ellison@Microsoft.com</param-value>
</init-param>
</servlet>
<!-- ... -->
</web-app>

5.2 分配JSP初始化参数
给JSP页面提供初始化参数在三个方面不同于给servlet提供初始化参数。
1）使用jsp-file而不是servlet-class。因此，WEB-INF/web.xml文件的servlet元素如下所示：
<servlet>
<servlet-name>PageName</servlet-name>
<jsp-file>/RealPage.jsp</jsp-file>
<init-param>
<param-name>...</param-name>
<param-value>...</param-value>
</init-param>
...
</servlet>
2) 几乎总是分配一个明确的URL模式。对servlet，一般相应地使用以http://host/webAppPrefix/servlet/ 开始的缺省URL。只需记住，使用注册名而不是原名称即可。这对于JSP页面在技术上也是合法的。例如，在上面给出的例子中，可用URL http://host/webAppPrefix/servlet/PageName 访问RealPage.jsp的对初始化参数具有访问权的版本。但在用于JSP页面时，许多用户似乎不喜欢应用常规的servlet的URL。此外，如果 JSP页面位于服务器为其提供了目录清单的目录中（如，一个既没有index.html也没有index.jsp文件的目录），则用户可能会连接到此 JSP页面，单击它，从而意外地激活未初始化的页面。因此，好的办法是使用url-pattern（5.3节）将JSP页面的原URL与注册的 servlet名相关联。这样，客户机可使用JSP页面的普通名称，但仍然激活定制的版本。例如，给定来自项目1的servlet定义，可使用下面的 servlet-mapping定义：
<servlet-mapping>
<servlet-name>PageName</servlet-name>
<url-pattern>/RealPage.jsp</url-pattern>
</servlet-mapping>
3）JSP页使用jspInit而不是init。自动从JSP页面建立的servlet或许已经使用了inti方法。因此，使用JSP声明提供一个init方法是不合法的，必须制定jspInit方法。
为了说明初始化JSP页面的过程，程序清单5-9给出了一个名为InitPage.jsp的JSP页面，它包含一个jspInit方法且放置于 deployDemo Web应用层次结构的顶层。一般，http://host/deployDemo/InitPage.jsp 形式的URL将激活此页面的不具有初始化参数访问权的版本，从而将对firstName和emailAddress变量显示null。但是， web.xml文件（程序清单5-10）分配了一个注册名，然后将该注册名与URL模式/InitPage.jsp相关联。

程序清单5-9 InitPage.jsp
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD><TITLE>JSP Init Test</TITLE></HEAD>
<BODY BGCOLOR="#FDF5E6">
<H2>Init Parameters:</H2>
<UL>
<LI>First name: <%= firstName %>
<LI>Email address: <%= emailAddress %>
</UL>
</BODY></HTML>
<%!
private String firstName, emailAddress;

public void jspInit() {
ServletConfig config = getServletConfig();
firstName = config.getInitParameter("firstName");
emailAddress = config.getInitParameter("emailAddress");
}
%>


程序清单5-10 web.xml（说明JSP页面的init参数的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- ... -->
<servlet>
<servlet-name>InitPage</servlet-name>
<jsp-file>/InitPage.jsp</jsp-file>
<init-param>
<param-name>firstName</param-name>
<param-value>Bill</param-value>
</init-param>
<init-param>
<param-name>emailAddress</param-name>
<param-value>gates@oracle.com</param-value>
</init-param>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name> InitPage</servlet-name>
<url-pattern>/InitPage.jsp</url-pattern>
</servlet-mapping>
<!-- ... -->
</web-app>


5.3 提供应用范围内的初始化参数
一般，对单个地servlet或JSP页面分配初始化参数。指定的servlet或JSP页面利用ServletConfig的getInitParameter方法读取这些参数。但是，在某些情形下，希望提供可由任意servlet或JSP页面借助ServletContext的getInitParameter方法读取的系统范围内的初始化参数。
可利用context-param元素声明这些系统范围内的初始化值。context-param元素应该包含param-name、param-value以及可选的description子元素，如下所示：
<context-param>
<param-name>support-email</param-name>
<param-value>blackhole@mycompany.com</param-value>
</context-param>
可回忆一下，为了保证可移植性，web.xml内的元素必须以正确的次序声明。但这里应该注意，context-param元素必须出现任意与文档有关的元素（icon、display-name或description）之后及filter、filter-mapping、listener或 servlet元素之前。
5.4 在服务器启动时装载servlet
假如servlet或JSP页面有一个要花很长时间执行的init （servlet）或jspInit（JSP）方法。例如，假如init或jspInit方法从某个数据库或ResourceBundle查找产量。这种情况下，在第一个客户机请求时装载servlet的缺省行为将对第一个客户机产生较长时间的延迟。因此，可利用servlet的load-on- startup元素规定服务器在第一次启动时装载servlet。下面是一个例子。
<servlet>
<servlet-name> … </servlet-name>
<servlet-class> … </servlet-class> <!-- Or jsp-file -->
<load-on-startup/>
</servlet>
可以为此元素体提供一个整数而不是使用一个空的load-on-startup。想法是服务器应该在装载较大数目的servlet或JSP页面之前装载较少数目的servlet或JSP页面。例如，下面的servlet项（放置在Web应用的WEB-INF目录下的web.xml文件中的web-app元素内）将指示服务器首先装载和初始化SearchServlet，然后装载和初始化由位于Web应用的result目录中的index.jsp文件产生的 servlet。
<servlet>
<servlet-name>Search</servlet-name>
<servlet-class>myPackage.SearchServlet</servlet-class> <!-- Or jsp-file -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet>
<servlet-name>Results</servlet-name>
<servlet-class>/results/index.jsp</servlet-class> <!-- Or jsp-file -->
<load-on-startup>2</load-on-startup>
</servlet>

6 声明过滤器

servlet版本2.3引入了过滤器的概念。虽然所有支持servlet API版本2.3的服务器都支持过滤器，但为了使用与过滤器有关的元素，必须在web.xml中使用版本2.3的DTD。
过滤器可截取和修改进入一个servlet或JSP页面的请求或从一个servlet或JSP页面发出的相应。在执行一个servlet或JSP页面之前，必须执行第一个相关的过滤器的doFilter方法。在该过滤器对其FilterChain对象调用doFilter时，执行链中的下一个过滤器。如果没有其他过滤器，servlet或JSP页面被执行。过滤器具有对到来的ServletRequest对象的全部访问权，因此，它们可以查看客户机名、查找到来的cookie等。为了访问servlet或JSP页面的输出，过滤器可将响应对象包裹在一个替身对象（stand-in object）中，比方说把输出累加到一个缓冲区。在调用FilterChain对象的doFilter方法之后，过滤器可检查缓冲区，如有必要，就对它进行修改，然后传送到客户机。
例如，程序清单5-11帝国难以了一个简单的过滤器，只要访问相关的servlet或JSP页面，它就截取请求并在标准输出上打印一个报告（开发过程中在桌面系统上运行时，大多数服务器都可以使用这个过滤器）。

程序清单5-11 ReportFilter.java
package moreservlets;

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

/** Simple filter that prints a report on the standard output
* whenever the associated servlet or JSP page is accessed.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* © 2002 Marty Hall; may be freely used or adapted.
*/

public class ReportFilter implements Filter {
public void doFilter(ServletRequest request,
ServletResponse response,
FilterChain chain)
throws ServletException, IOException {
HttpServletRequest req = (HttpServletRequest)request;
System.out.println(req.getRemoteHost() +
" tried to access " +
req.getRequestURL() +
" on " + new Date() + ".");
chain.doFilter(request,response);
}

public void init(FilterConfig config)
throws ServletException {
}

public void destroy() {}
}

一旦建立了一个过滤器，可以在web.xml中利用filter元素以及filter-name（任意名称）、file-class（完全限定的类名）和（可选的）init-params子元素声明它。请注意，元素在web.xml的web-app元素中出现的次序不是任意的；允许服务器（但不是必需的）强制所需的次序，并且实际中有些服务器也是这样做的。但这里要注意，所有filter元素必须出现在任意filter-mapping元素之前， filter-mapping元素又必须出现在所有servlet或servlet-mapping元素之前。
例如，给定上述的ReportFilter类，可在web.xml中作出下面的filter声明。它把名称Reporter与实际的类ReportFilter（位于moreservlets程序包中）相关联。
<filter>
<filter-name>Reporter</filter-name>
<filter-class>moresevlets.ReportFilter</filter-class>
</filter>
一旦命名了一个过滤器，可利用filter-mapping元素把它与一个或多个servlet或JSP页面相关联。关于此项工作有两种选择。
首先，可使用filter-name和servlet-name子元素把此过滤器与一个特定的servlet名（此servlet名必须稍后在相同的 web.xml文件中使用servlet元素声明）关联。例如，下面的程序片断指示系统只要利用一个定制的URL访问名为SomeServletName 的servlet或JSP页面，就运行名为Reporter的过滤器。
<filter-mapping>
<filter-name>Reporter</filter-name>
<servlet-name>SomeServletName</servlet-name>
</filter-mapping>
其次，可利用filter-name和url-pattern子元素将过滤器与一组servlet、JSP页面或静态内容相关联。例如，相面的程序片段指示系统只要访问Web应用中的任意URL，就运行名为Reporter的过滤器。
<filter-mapping>
<filter-name>Reporter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
例如，程序清单5-12给出了将ReportFilter过滤器与名为PageName的servlet相关联的web.xml文件的一部分。名字 PageName依次又与一个名为TestPage.jsp的JSP页面以及以模式http: //host/webAppPrefix/UrlTest2/ 开头的URL相关联。TestPage.jsp的源代码已经JSP页面命名的谈论在前面的3节"分配名称和定制的URL"中给出。事实上，程序清单5- 12中的servlet和servlet-name项从该节原封不动地拿过来的。给定这些web.xml项，可看到下面的标准输出形式的调试报告（换行是为了容易阅读）。
audit.irs.gov tried to access
http://mycompany.com/deployDemo/UrlTest2/business/tax-plan.html
on Tue Dec 25 13:12:29 EDT 2001.

程序清单5-12 Web.xml（说明filter用法的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<filter>
<filter-name>Reporter</filter-name>
<filter-class>moresevlets.ReportFilter</filter-class>
</filter>
<!-- ... -->
<filter-mapping>
<filter-name>Reporter</filter-name>
<servlet-name>PageName</servlet-name>
</filter-mapping>
<!-- ... -->
<servlet>
<servlet-name>PageName</servlet-name>
<jsp-file>/RealPage.jsp</jsp-file>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name> PageName </servlet-name>
<url-pattern>/UrlTest2/*</url-pattern>
</servlet-mapping>
<!-- ... -->
</web-app>


7 指定欢迎页

假如用户提供了一个像http: //host/webAppPrefix/directoryName/ 这样的包含一个目录名但没有包含文件名的URL，会发生什么事情呢？用户能得到一个目录表？一个错误？还是标准文件的内容？如果得到标准文件内容，是 index.html、index.jsp、default.html、default.htm或别的什么东西呢？
Welcome-file-list 元素及其辅助的welcome-file元素解决了这个模糊的问题。例如，下面的web.xml项指出，如果一个URL给出一个目录名但未给出文件名，服务器应该首先试用index.jsp，然后再试用index.html。如果两者都没有找到，则结果有赖于所用的服务器（如一个目录列表）。
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
虽然许多服务器缺省遵循这种行为，但不一定必须这样。因此，明确地使用welcom-file-list保证可移植性是一种良好的习惯。

8 指定处理错误的页面

现在我了解到，你在开发servlet和JSP页面时从不会犯错误，而且你的所有页面是那样的清晰，一般的程序员都不会被它们的搞糊涂。但是，是人总会犯错误的，用户可能会提供不合规定的参数，使用不正确的URL或者不能提供必需的表单字段值。除此之外，其它开发人员可能不那么细心，他们应该有些工具来克服自己的不足。
error-page元素就是用来克服这些问题的。它有两个可能的子元素，分别是：error-code和exception- type。第一个子元素error-code指出在给定的HTTP错误代码出现时使用的URL。第二个子元素excpetion-type指出在出现某个给定的Java异常但未捕捉到时使用的URL。error-code和exception-type都利用location元素指出相应的URL。此 URL必须以/开始。location所指出的位置处的页面可通过查找HttpServletRequest对象的两个专门的属性来访问关于错误的信息，这两个属性分别是：javax.servlet.error.status_code和javax.servlet.error.message。
可回忆一下，在web.xml内以正确的次序声明web-app的子元素很重要。这里只要记住，error-page出现在web.xml文件的末尾附近，servlet、servlet-name和welcome-file-list之后即可。

8.1 error-code元素
为了更好地了解error-code元素的值，可考虑一下如果不正确地输入文件名，大多数站点会作出什么反映。这样做一般会出现一个404错误信息，它表示不能找到该文件，但几乎没提供更多有用的信息。另一方面，可以试一下在www.microsoft.com、www.ibm.com 处或者特别是在www.bea.com 处输出未知的文件名。这是会得出有用的消息，这些消息提供可选择的位置，以便查找感兴趣的页面。提供这样有用的错误页面对于Web应用来说是很有价值得。事实上rm-error-page子元素）。由form-login-page给出的HTML表单必须具有一个j_security_check的 ACTION属性、一个名为j_username的用户名文本字段以及一个名为j_password的口令字段。
例如，程序清单5-19指示服务器使用基于表单的验证。Web应用的顶层目录中的一个名为login.jsp的页面将收集用户名和口令，并且失败的登陆将由相同目录中名为login-error.jsp的页面报告。

程序清单5-19 web.xml（说明login-config的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- ... -->
<security-constraint> ... </security-constraint>
<login-config>
<auth-method> FORM </auth-method>
<form-login-config>
<form-login-page>/login.jsp</form-login-page>
<form-error-page>/login-error.jsp</form-error-page>
</form-login-config>
</login-config>
<!-- ... -->
</web-app>


9.2 限制对Web资源的访问
现在，可以指示服务器使用何种验证方法了。"了不起，"你说道，"除非我能指定一个来收到保护的 URL，否则没有多大用处。"没错。指出这些URL并说明他们应该得到何种保护正是security-constriaint元素的用途。此元素在 web.xml中应该出现在login-config的紧前面。它包含是个可能的子元素，分别是：web-resource-collection、 auth-constraint、user-data-constraint和display-name。下面各小节对它们进行介绍。
l web-resource-collection
此元素确定应该保护的资源。所有security-constraint元素都必须包含至少一个web-resource-collection项。此元素由一个给出任意标识名称的web-resource-name元素、一个确定应该保护的URL的url-pattern元素、一个指出此保护所适用的 HTTP命令（GET、POST等，缺省为所有方法）的http-method元素和一个提供资料的可选description元素组成。例如，下面的 Web-resource-collection项（在security-constratint元素内）指出Web应用的proprietary目录中所有文档应该受到保护。
<security-constraint>
<web-resource-coolection>
<web-resource-name>Proprietary</web-resource-name>
<url-pattern>/propritary/*</url-pattern>
</web-resource-coolection>
<!-- ... -->
</security-constraint>
重要的是应该注意到，url-pattern仅适用于直接访问这些资源的客户机。特别是，它不适合于通过MVC体系结构利用 RequestDispatcher来访问的页面，或者不适合于利用类似jsp:forward的手段来访问的页面。这种不匀称如果利用得当的话很有好处。例如，servlet可利用MVC体系结构查找数据，把它放到bean中，发送请求到从bean中提取数据的JSP页面并显示它。我们希望保证决不直接访问受保护的JSP页面，而只是通过建立该页面将使用的bean的servlet来访问它。url-pattern和auth-contraint元素可通过声明不允许任何用户直接访问JSP页面来提供这种保证。但是，这种不匀称的行为可能让开发人员放松警惕，使他们偶然对应受保护的资源提供不受限制的访问。
l auth-constraint
尽管web-resource-collention元素质出了哪些URL应该受到保护，但是auth-constraint元素却指出哪些用户应该具有受保护资源的访问权。此元素应该包含一个或多个标识具有访问权限的用户类别role- name元素，以及包含（可选）一个描述角色的description元素。例如，下面web.xml中的security-constraint元素部门规定只有指定为Administrator或Big Kahuna（或两者）的用户具有指定资源的访问权。
<security-constraint>
<web-resource-coolection> ... </web-resource-coolection>
<auth-constraint>
<role-name>administrator</role-name>
<role-name>kahuna</role-name>
</auth-constraint>
</security-constraint>
重要的是认识到，到此为止，这个过程的可移植部分结束了。服务器怎样确定哪些用户处于任何角色以及它怎样存放用户的口令，完全有赖于具体的系统。
例如，Tomcat使用install_dir/conf/tomcat-users.xml将用户名与角色名和口令相关联，正如下面例子中所示，它指出用户joe（口令bigshot）和jane（口令enaj）属于administrator和kahuna角色。
<tomcat-users>
<user name="joe" password="bigshot" roles="administrator,kahuna" />
<user name="jane" password="enaj" roles="kahuna" />
</tomcat-users>
l user-data-constraint
这个可选的元素指出在访问相关资源时使用任何传输层保护。它必须包含一个transport-guarantee子元素（合法值为NONE、 INTEGRAL或CONFIDENTIAL），并且可选地包含一个description元素。transport-guarantee为NONE值将对所用的通讯协议不加限制。INTEGRAL值表示数据必须以一种防止截取它的人阅读它的方式传送。虽然原理上（并且在未来的HTTP版本中），在 INTEGRAL和CONFIDENTIAL之间可能会有差别，但在当前实践中，他们都只是简单地要求用SSL。例如，下面指示服务器只允许对相关资源做 HTTPS连接：
<security-constraint>
<!-- ... -->
<user-data-constraint>
<transport-guarantee>CONFIDENTIAL</transport-guarantee>
</user-data-constraint>
</security-constraint>
l display-name
security-constraint的这个很少使用的子元素给予可能由GUI工具使用的安全约束项一个名称。
9.3 分配角色名
迄今为止，讨论已经集中到完全由容器（服务器）处理的安全问题之上了。但servlet以及JSP页面也能够处理它们自己的安全问题。
例如，容器可能允许用户从bigwig或bigcheese角色访问一个显示主管人员额外紧贴的页面，但只允许bigwig用户修改此页面的参数。完成这种更细致的控制的一种常见方法是调用HttpServletRequset的isUserInRole方法，并据此修改访问。
Servlet的 security-role-ref子元素提供出现在服务器专用口令文件中的安全角色名的一个别名。例如，假如编写了一个调用 request.isUserInRole（"boss"）的servlet，但后来该servlet被用在了一个其口令文件调用角色manager而不是boss的服务器中。下面的程序段使该servlet能够使用这两个名称中的任何一个。
<servlet>
<!-- ... -->
<security-role-ref>
<role-name>boss</role-name> <!-- New alias -->
<role-link>manager</role-link> <!-- Real name -->
</security-role-ref>
</servlet>
也可以在web-app内利用security-role元素提供将出现在role-name元素中的所有安全角色的一个全局列表。分别地生命角色使高级IDE容易处理安全信息。

10 控制会话超时

如果某个会话在一定的时间内未被访问，服务器可把它扔掉以节约内存。可利用HttpSession的setMaxInactiveInterval方法直接设置个别会话对象的超时值。如果不采用这种方法，则缺省的超时值由具体的服务器决定。但可利用session-config和session- timeout元素来给出一个适用于所有服务器的明确的超时值。超时值的单位为分钟，因此，下面的例子设置缺省会话超时值为三个小时（180分钟）。
<session-config>
<session-timeout>180</session-timeout>
</session-config>

11 Web应用的文档化

越来越多的开发环境开始提供servlet和JSP的直接支持。例子有Borland Jbuilder Enterprise Edition、Macromedia UltraDev、Allaire JRun Studio（写此文时，已被Macromedia收购）以及IBM VisuaAge for Java等。
大量的web.xml元素不仅是为服务器设计的，而且还是为可视开发环境设计的。它们包括icon、display-name和discription等。
可回忆一下，在web.xml内以适当地次序声明web-app子元素很重要。不过，这里只要记住icon、display-name和description是web.xml的web-app元素内的前三个合法元素即可。
l icon
icon元素指出GUI工具可用来代表Web应用的一个和两个图像文件。可利用small-icon元素指定一幅16 x 16的GIF或JPEG图像，用large-icon元素指定一幅32 x 32的图像。下面举一个例子：
<icon>
<small-icon>/images/small-book.gif</small-icon>
<large-icon>/images/tome.jpg</large-icon>
</icon>
l display-name
display-name元素提供GUI工具可能会用来标记此Web应用的一个名称。下面是个例子。
<display-name>Rare Books</display-name>
l description
description元素提供解释性文本，如下所示：
<description>
This Web application represents the store developed for
rare-books.com, an online bookstore specializing in rare
and limited-edition books.
</description>

12 关联文件与MIME类型

服务器一般都具有一种让Web站点管理员将文件扩展名与媒体相关联的方法。例如，将会自动给予名为mom.jpg的文件一个image/jpeg的MIME 类型。但是，假如你的Web应用具有几个不寻常的文件，你希望保证它们在发送到客户机时分配为某种MIME类型。mime-mapping元素（具有 extension和mime-type子元素）可提供这种保证。例如，下面的代码指示服务器将application/x-fubar的MIME类型分配给所有以.foo结尾的文件。
<mime-mapping>
<extension>foo</extension>
<mime-type>application/x-fubar</mime-type>
</mime-mapping>
或许，你的Web应用希望重载（override）标准的映射。例如，下面的代码将告诉服务器在发送到客户机时指定.ps文件作为纯文本（text/plain）而不是作为PostScript（application/postscript）。
<mime-mapping>
<extension>ps</extension>
<mime-type>application/postscript</mime-type>
</mime-mapping>


13 定位TLD

JSP taglib元素具有一个必要的uri属性，它给出一个TLD（Tag Library Descriptor）文件相对于Web应用的根的位置。TLD文件的实际名称在发布新的标签库版本时可能会改变，但我们希望避免更改所有现有JSP页面。此外，可能还希望使用保持taglib元素的简练性的一个简短的uri。这就是部署描述符文件的taglib元素派用场的所在了。Taglib包含两个子元素：taglib-uri和taglib-location。taglib-uri元素应该与用于JSP taglib元素的uri属性的东西相匹配。Taglib-location元素给出TLD文件的实际位置。例如，假如你将文件chart-tags- 1.3beta.tld放在WebApp/WEB-INF/tlds中。现在，假如web.xml在web-app元素内包含下列内容。
<taglib>
<taglib-uri>/charts.tld</taglib-uri>
<taglib-location>
/WEB-INF/tlds/chart-tags-1.3beta.tld
</taglib-location>
</taglib>
给出这个说明后，JSP页面可通过下面的简化形式使用标签库。
<%@ taglib uri="/charts.tld" prefix="somePrefix" %>

14 指定应用事件监听程序

应用事件监听器程序是建立或修改servlet环境或会话对象时通知的类。它们是servlet规范的版本2.3中的新内容。这里只简单地说明用来向Web应用注册一个监听程序的web.xml的用法。
注册一个监听程序涉及在web.xml的web-app元素内放置一个listener元素。在listener元素内，listener-class元素列出监听程序的完整的限定类名，如下所示：
<listener>
<listener-class>package.ListenerClass</listener-class>
</listener>
虽然listener元素的结构很简单，但请不要忘记，必须正确地给出web-app元素内的子元素的次序。listener元素位于所有的servlet 元素之前以及所有filter-mapping元素之后。此外，因为应用生存期监听程序是serlvet规范的2.3版本中的新内容，所以必须使用 web.xml DTD的2.3版本，而不是2.2版本。
例如，程序清单5-20给出一个名为ContextReporter的简单的监听程序，只要Web应用的Servlet-Context建立（如装载Web应用）或消除（如服务器关闭）时，它就在标准输出上显示一条消息。程序清单5-21给出此监听程序注册所需要的web.xml文件的一部分。

程序清单5-20 ContextReporterjava
package moreservlets;

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

/** Simple listener that prints a report on the standard output
* when the ServletContext is created or destroyed.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* © 2002 Marty Hall; may be freely used or adapted.
*/

public class ContextReporter implements ServletContextListener {
public void contextInitialized(ServletContextEvent event) {
System.out.println("Context created on " +
new Date() + ".");
}

public void contextDestroyed(ServletContextEvent event) {
System.out.println("Context destroyed on " +
new Date() + ".");
}
}


程序清单5-21 web.xml（声明一个监听程序的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>
<!-- ... -->
<filter-mapping> … </filter-mapping>
<listener>
<listener-class>package.ListenerClass</listener-class>
</listener>
<servlet> ... </servlet>
<!-- ... -->
</web-app>


15 J2EE元素

本节描述用作J2EE环境组成部分的Web应用的web.xml元素。这里将提供一个简明的介绍，详细内容可以参阅http://java.sun.com/j2ee/j2ee-1_3-fr-spec.pdf的Java 2 Plantform Enterprise Edition版本1.3规范的第5章。
l distributable
distributable 元素指出，Web应用是以这样的方式编程的：即，支持集群的服务器可安全地在多个服务器上分布Web应用。例如，一个可分布的应用必须只使用 Serializable对象作为其HttpSession对象的属性，而且必须避免用实例变量（字段）来实现持续性。distributable元素直接出现在discription元素之后，并且不包含子元素或数据，它只是一个如下的标志。
<distributable />
l resource-env-ref
resource -env-ref元素声明一个与某个资源有关的管理对象。此元素由一个可选的description元素、一个resource-env-ref- name元素（一个相对于java:comp/env环境的JNDI名）以及一个resource-env-type元素（指定资源类型的完全限定的类），如下所示：
<resource-env-ref>
<resource-env-ref-name>
jms/StockQueue
</resource-env-ref-name>
<resource-env-ref-type>
javax.jms.Queue
</resource-env-ref-type>
</resource-env-ref>
l env-entry
env -entry元素声明Web应用的环境项。它由一个可选的description元素、一个env-entry-name元素（一个相对于java: comp/env环境JNDI名）、一个env-entry-value元素（项值）以及一个env-entry-type元素（java.lang程序包中一个类型的完全限定类名，java.lang.Boolean、java.lang.String等）组成。下面是一个例子：
<env-entry>
<env-entry-name>minAmout</env-entry-name>
<env-entry-value>100.00</env-entry-value>
<env-entry-type>minAmout</env-entry-type>
</env-entry>
l ejb-ref
ejb -ref元素声明对一个EJB的主目录的应用。它由一个可选的description元素、一个ejb-ref-name元素（相对于java: comp/env的EJB应用）、一个ejb-ref-type元素（bean的类型，Entity或Session）、一个home元素（bean的主目录接口的完全限定名）、一个remote元素（bean的远程接口的完全限定名）以及一个可选的ejb-link元素（当前bean链接的另一个 bean的名称）组成。
l ejb-local-ref
ejb-local-ref元素声明一个EJB的本地主目录的引用。除了用local-home代替home外，此元素具有与ejb-ref元素相同的属性并以相同的方式使用。






17:42 | 固定链接 | 评论 (0) | 引用通告 (0) | 记录它 | 计算机与 Internet


固定链接 关闭

http://spaces.msn.com/members/tsfy/Blog/cns!1pFtRRZqZXTCdE5YlUjqVIcQ!116.entry







4月14日



给你的session加个监听器


今天一个学生问我怎么实现在网页里显示在线用户的名称——他已经使用了session，但是无法处理用户离开的情况，然后导致在线用户列表的无限增大。跟他说了自己在application中进行超时检查，更新application的时候就比较当前所有列表中的session是否超过自己指定的时间间隔。后来想了想，又给他提了使用给session加监听器的方法。但是提的时候自己也没有做过，所以只是说这种方式很复杂，建议他还是自己进行超时检查。刚才又看了看资料，发现实际上给session加监听器的方式很简单，不禁觉得自己有点误人子弟了，现在将方法写在这，借以告诫自己以后要严谨。
首先写一个SessionBinder类,它实现了HttpSessionBindingListener接口的valueBound方法和valueUnbound方法，示例代码如下：
public class SessionBinder implements HttpSessionBindingListener {
  public void valueBound(HttpSessionBindingEvent event){
    //you can do anything you want!this method will be called when this binder is bind with any session.
  }

  public void valueUnbound(HttpSessionBindingEvent event) {
    //you can do something while this session is invalidate
  }
}
现在写好了SessionBinder，我们现在选择在一个servlet中向session中加入这个监听器——在jsp中的代码书写与此相同
//省略前面的代码，此操作可能发生在servlet的doGet方法中，也可能是doPost方法中
  HttpSession session = req.getSession(true);//首先获得需要加入监听器的session对象，req是HttpRequest对象
  SessionBinder sb = new SessionBinder();//建立一个监听器对象
  session.putValue("BinderObject",sb);//将监听器加入此session中，从此时开始执行sb的valueBound方法
//省略后面的代码
随后，如果整个session超时或者被用户中止之后，sb的valueUnbound自动执行
呵呵，以上代码以供参考


心无痕 2008-04-15 11:42 发表评论
]]>Tomcat启动分析http://www.blogjava.net/xinwuhen/archive/2008/04/15/193030.html心无痕心无痕Tue, 15 Apr 2008 03:14:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/04/15/193030.htmlhttp://www.blogjava.net/xinwuhen/comments/193030.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/04/15/193030.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/193030.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/193030.html1 - Tomcat Server的组成部分

1.1 - Server

A Server element represents the entire Catalina servlet container. (Singleton)

1.2 - Service

A Service element represents the combination of one or more Connector components that share a single Engine
Service是这样一个集合：它由一个或者多个Connector组成，以及一个Engine，负责处理所有Connector所获得的客户请求

1.3 - Connector

一个Connector将在某个指定端口上侦听客户请求，并将获得的请求交给Engine来处理，从Engine处获得回应并返回客户
TOMCAT有两个典型的Connector，一个直接侦听来自browser的http请求，一个侦听来自其它WebServer的请求
Coyote Http/1.1 Connector 在端口8080处侦听来自客户browser的http请求
Coyote JK2 Connector 在端口8009处侦听来自其它WebServer(Apache)的servlet/jsp代理请求

1.4 - Engine

The Engine element represents the entire request processing machinery associated with a particular Service
It receives and processes all requests from one or more Connectors
and returns the completed response to the Connector for ultimate transmission back to the client
Engine下可以配置多个虚拟主机Virtual Host，每个虚拟主机都有一个域名
当Engine获得一个请求时，它把该请求匹配到某个Host上，然后把该请求交给该Host来处理
Engine有一个默认虚拟主机，当请求无法匹配到任何一个Host上的时候，将交给该默认Host来处理

1.5 - Host

代表一个Virtual Host，虚拟主机，每个虚拟主机和某个网络域名Domain Name相匹配
每个虚拟主机下都可以部署(deploy)一个或者多个Web App，每个Web App对应于一个Context，有一个Context path
当Host获得一个请求时，将把该请求匹配到某个Context上，然后把该请求交给该Context来处理
匹配的方法是“最长匹配”，所以一个path==""的Context将成为该Host的默认Context
所有无法和其它Context的路径名匹配的请求都将最终和该默认Context匹配

1.6 - Context

一个Context对应于一个Web Application，一个Web Application由一个或者多个Servlet组成
Context在创建的时候将根据配置文件$CATALINA_HOME/conf/web.xml和$WEBAPP_HOME/WEB-INF/web.xml载入Servlet类
当Context获得请求时，将在自己的映射表(mapping table)中寻找相匹配的Servlet类
如果找到，则执行该类，获得请求的回应，并返回

2 - Tomcat Server的结构图

3 - 配置文件$CATALINA_HOME/conf/server.xml的说明

该文件描述了如何启动Tomcat Server 


<!----------------------------------------------------------------------------------------------->


<!-- 启动Server
在端口8005处等待关闭命令
如果接受到"SHUTDOWN"字符串则关闭服务器
-->

<Server port="8005" shutdown="SHUTDOWN" debug="0">

<!-- Listener ???
目前没有看到这里
-->

<Listener className="org.apache.catalina.mbeans.ServerLifecycleListener" debug="0"/>
<Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" debug="0"/>

<!-- Global JNDI resources ???
目前没有看到这里，先略去
-->

<GlobalNamingResources>
... ... ... ...
</GlobalNamingResources>

<!-- Tomcat的Standalone Service
Service是一组Connector的集合
它们共用一个Engine来处理所有Connector收到的请求
-->

<Service name="Tomcat-Standalone">

<!-- Coyote HTTP/1.1 Connector
className : 该Connector的实现类是org.apache.coyote.tomcat4.CoyoteConnector
port : 在端口号8080处侦听来自客户browser的HTTP1.1请求
minProcessors : 该Connector先创建5个线程等待客户请求，每个请求由一个线程负责
maxProcessors : 当现有的线程不够服务客户请求时，若线程总数不足75个，则创建新线程来处理请求
acceptCount : 当现有线程已经达到最大数75时，为客户请求排队
当队列中请求数超过100时，后来的请求返回Connection refused错误
redirectport : 当客户请求是https时，把该请求转发到端口8443去
其它属性略
-->

<Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8080"
minProcessors="5" maxProcessors="75" acceptCount="100"
enableLookups="true"
redirectPort="8443"
debug="0"
connectionTimeout="20000"
useURIValidationHack="false"
disableUploadTimeout="true" />

<!-- Engine用来处理Connector收到的Http请求
它将匹配请求和自己的虚拟主机，并把请求转交给对应的Host来处理
默认虚拟主机是localhost
-->

<Engine name="Standalone" defaultHost="localhost" debug="0">

<!-- 日志类，目前没有看到，略去先 -->

<Logger className="org.apache.catalina.logger.FileLogger" .../>

<!-- Realm，目前没有看到，略去先 -->

<Realm className="org.apache.catalina.realm.UserDatabaseRealm" .../>

<!-- 虚拟主机localhost
appBase : 该虚拟主机的根目录是webapps/
它将匹配请求和自己的Context的路径，并把请求转交给对应的Context来处理
-->

<Host name="localhost" debug="0" appBase="webapps" unpackWARs="true" autoDeploy="true">

<!-- 日志类，目前没有看到，略去先 -->

<Logger className="org.apache.catalina.logger.FileLogger" .../>

<!-- Context，对应于一个Web App
path : 该Context的路径名是""，故该Context是该Host的默认Context
docBase : 该Context的根目录是webapps/mycontext/
-->

<Context path="" docBase="mycontext" debug="0"/>

<!-- 另外一个Context，路径名是/wsota -->

<Context path="/wsota" docBase="wsotaProject" debug="0"/>
</Host>
</Engine>
</Service>
</Server>

<!----------------------------------------------------------------------------------------------->

 

4 - Context的部署配置文件web.xml的说明

一个Context对应于一个Web App，每个Web App是由一个或者多个servlet组成的
当一个Web App被初始化的时候，它将用自己的ClassLoader对象载入“部署配置文件web.xml”中定义的每个servlet类
它首先载入在$CATALINA_HOME/conf/web.xml中部署的servlet类
然后载入在自己的Web App根目录下的WEB-INF/web.xml中部署的servlet类
web.xml文件有两部分：servlet类定义和servlet映射定义
每个被载入的servlet类都有一个名字，且被填入该Context的映射表(mapping table)中，和某种URL PATTERN对应
当该Context获得请求时，将查询mapping table，找到被请求的servlet，并执行以获得请求回应

分析一下所有的Context共享的web.xml文件，在其中定义的servlet被所有的Web App载入


<!----------------------------------------------------------------------------------------------->

<web-app>

<!-- 概述：
该文件是所有的WEB APP共用的部署配置文件，
每当一个WEB APP被DEPLOY，该文件都将先被处理，然后才是WEB APP自己的/WEB-INF/web.xml
-->


<!--  +-------------------------+  -->
<!--  |    servlet类定义部分    |  -->
<!--  +-------------------------+  -->


<!-- DefaultServlet
当用户的HTTP请求无法匹配任何一个servlet的时候，该servlet被执行
URL PATTERN MAPPING : /
-->

<servlet>
<servlet-name>default</servlet-name>
<servlet-class>
org.apache.catalina.servlets.DefaultServlet
</servlet-class>
<init-param>
<param-name>debug</param-name>
<param-value>0</param-value>
</init-param>
<init-param>
<param-name>listings</param-name>
<param-value>true</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

<!-- InvokerServlet
处理一个WEB APP中的匿名servlet
当一个servlet被编写并编译放入/WEB-INF/classes/中，却没有在/WEB-INF/web.xml中定义的时候
该servlet被调用，把匿名servlet映射成/servlet/ClassName的形式
URL PATTERN MAPPING : /servlet/*
-->

<servlet>
<servlet-name>invoker</servlet-name>
<servlet-class>
org.apache.catalina.servlets.InvokerServlet
</servlet-class>
<init-param>
<param-name>debug</param-name>
<param-value>0</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>

<!-- JspServlet
当请求的是一个JSP页面的时候（*.jsp）该servlet被调用
它是一个JSP编译器，将请求的JSP页面编译成为servlet再执行
URL PATTERN MAPPING : *.jsp
-->

<servlet>
<servlet-name>jsp</servlet-name>
<servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
<init-param>
<param-name>logVerbosityLevel</param-name>
<param-value>WARNING</param-value>
</init-param>
<load-on-startup>3</load-on-startup>
</servlet>

<!--  +---------------------------+  -->
<!--  |    servlet映射定义部分    |  -->
<!--  +---------------------------+  -->

<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>invoker</servlet-name>
<url-pattern>/servlet/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>jsp</servlet-name>
<url-pattern>*.jsp</url-pattern>
</servlet-mapping>

<!--  +------------------------+  -->
<!--  |    其它部分，略去先    |  -->
<!--  +------------------------+  -->

... ... ... ...
</web-app>

<!----------------------------------------------------------------------------------------------->

 

5 - Tomcat Server处理一个http请求的过程

假设来自客户的请求为：
http://localhost:8080/wsota/wsota_index.jsp

1) 请求被发送到本机端口8080，被在那里侦听的Coyote HTTP/1.1 Connector获得
2) Connector把该请求交给它所在的Service的Engine来处理，并等待来自Engine的回应
3) Engine获得请求localhost/wsota/wsota_index.jsp，匹配它所拥有的所有虚拟主机Host
4) Engine匹配到名为localhost的Host（即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机）
5) localhost Host获得请求/wsota/wsota_index.jsp，匹配它所拥有的所有Context
6) Host匹配到路径为/wsota的Context（如果匹配不到就把该请求交给路径名为""的Context去处理）
7) path="/wsota"的Context获得请求/wsota_index.jsp，在它的mapping table中寻找对应的servlet
8) Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类
9) 构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法
10)Context把执行完了之后的HttpServletResponse对象返回给Host
11)Host把HttpServletResponse对象返回给Engine
12)Engine把HttpServletResponse对象返回给Connector
13)Connector把HttpServletResponse对象返回给客户browser



心无痕 2008-04-15 11:14 发表评论
]]>深入浅出hibernate之PO,VO,load,gethttp://www.blogjava.net/xinwuhen/archive/2008/04/09/191666.html心无痕心无痕Wed, 09 Apr 2008 04:58:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/04/09/191666.htmlhttp://www.blogjava.net/xinwuhen/comments/191666.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/04/09/191666.html#Feedback1http://www.blogjava.net/xinwuhen/comments/commentRss/191666.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/191666.html今天老师重新详细讲解了hibernate 里的POVO.

      最开始理解的POVO,感觉就是通过SAVE()方法,将OBJ 持久化到数据库.如果要UPDATE,只要将oBJ 里属性SET一个新值,然后执行下UPDATE就好(这是种错误的概念),因为那时还没怎么接触POVO,一开始看到这个已经感到很强大了,马上就在脑子中记住了POVO.
      本以为在项目中可以得心应手的利用这个好处,结果错误的理解让我出了很多异常:
      a different object with the same identifier value was already associated with the session;
      上面就是其中一个,原因是对于POVO的理解错误,引起的,先看下面的一段代码:
        Cat princess = new Cat();//新建一个Cat对象
  princess.setId("402881830c2cf0f3010c2cf0f8b40001");//将对象set一个数据库中已存在的ＩＤ
  princess.setName("Princess");
  princess.setSex('F');
  princess.setWeight(18.8f);
  
  Cat princess2 = new Cat();//又新建一个Cat对象
  princess2.setId("402881830c2cf0f3010c2cf0f8b40001");//同时将这个对象也set相同的ＩＤ
  princess2.setName("Princess");
  princess2.setSex('F');
  princess2.setWeight(19.8f);
  
  Session session = HibernateSessionFactory.currentSession();//好戏出场了，我们先current a Session
  Transaction tx = session.beginTransaction();//开始事物(Transaction到底是什么也不太懂，我只知道它可以将缓存中数据写入数据库)
//  Cat c = (Cat)session.load(Cat.class, "402881830c2cf0f3010c2cf0f8b40001");
//  c.setWeight(20.3f);
  session.saveOrUpdate(princess);//此时我们用session保存了princess，这之后的princess应该是持久化了，成了ＰＯ
  session.saveOrUpdate(princess2);//如果按我一开始的理解，此时princess2应该也是可以持久化的（看上面兰色部分），因为princess2只是将princess更新了而已（这是致命的错误）．
  tx.commit();
  
  HibernateSessionFactory.closeSession();
　　
　　　执行的结果总是那么讽刺， a different object with the same identifier value was already associated with the session
　　　遇到了问题，总是最让人兴奋与无奈的时候．还是来看看为什么出错吧：
　　首先来讲讲ＰＯＶＯ，ＰＯ又名persistence　object，持久化对象，是指在对象通过save(),update(),load(),get();后，在session的Entity map实体容器里将持久话的对象add进去，也就是说，在我session.saveOrUpdate(princess);时，实体容器里已经将key和对象加入了．因为map是通过不同key来加ＯＢＪ的,而在hibernate里ＩＤ是唯一标识，使用ＩＤ来当做key是最好不过的了．因此Session 的实体容器只能加入一个id的对象．当session.saveOrUpdate(princess2);的时候，session准备把princess2也add到entityMap里时，由于相同的id,也就是key，它就报异常了a different object with the same identifier ..恭喜中标．
 
　　也就是说ＰＯ是在session 的实体容器里可引用的对象，当我要更新ＰＯ时，可以set一个属性值，然后只要tx.commit();动作，就可以更新了（让我个人感到非常惊讶的地方）．
　　除了save();之外，同样通过load,update,get也可以获得ＰＯ．不过load和get有一少许区别（在使用的版本3.0中）,get(id)就直接把ＤＯ获得（马上执行select操作），而load则不同，它会先对要load的ＩＤ做个标记，当要使用这个导出的对象时，它再执行.用上面的例子:
 
    Cat c = (Cat)session.load(Cat.class, "402881830c2cf0f3010c2cf0f8b40001");//此时只是做标记
    c.setWeight(20.3f);//这个时候才真正的执行了select 语句．


心无痕 2008-04-09 12:58 发表评论
]]>java序列化---转载http://www.blogjava.net/xinwuhen/archive/2008/03/26/188791.html心无痕心无痕Wed, 26 Mar 2008 08:45:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/03/26/188791.htmlhttp://www.blogjava.net/xinwuhen/comments/188791.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/03/26/188791.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/188791.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/188791.html文件I/O：文件流→序列化
★文件流
     文件操作是最简单最直接也是最容易想到的一种方式，我们说的文件操作不仅仅是通过FileInputStream/FileOutputStream这么“裸”的方式直接把数据写入到本地文件（像我以前写的一个扫雷的小游戏JavaMine就是这样保存一局的状态的），这样就比较“底层”了。

主要类与方法和描述
  1. FileInputStream.read() //从本地文件读取二进制格式的数据
  2. FileReader.read() //从本地文件读取字符（文本）数据
  3. FileOutputStream.write() //保存二进制数据到本地文件
  4. FileWriter.write() //保存字符数据到本地文件

★XML
     和上面的单纯的I/O方式相比，XML就显得“高档”得多，以至于成为一种数据交换的标准。以DOM方式为例，它关心的是首先在内存中构造文档树，数据保存在某个结点上（可以是叶子结点，也可以是标签结点的属性），构造好了以后一次性的写入到外部文件，但我们只需要知道文件的位置，并不知道I/O是怎么操作的，XML操作方式可能多数人也实践过，所以这里也只列出相关的方法，供初学者预先了解一下。主要的包是javax.xml.parsers，org.w3c.dom，javax.xml.transform。

主要类与方法和描述
  1. DocumentBuilderFactory.newDocumentBuilder().parse() //解析一个外部的XML文件，得到一个Document对象的DOM树
  2. DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument() //初始化一棵DOM树
  3. Document.getDocumentElement().appendChild() //为一个标签结点添加一个子结点
  4. Document.createTextNode() //生成一个字符串结点
  5. Node.getChildNodes() //取得某个结点的所有下一层子结点
  6. Node.removeChild()  //删除某个结点的子结点
  7. Document.getElementsByTagName() 查找所有指定名称的标签结点  
  8. Document.getElementById() //查找指定名称的一个标签结点，如果有多个符合，则返回某一个，通常是第一个
  9. Element.getAttribute() //取得一个标签的某个属性的的值
  10. Element.setAttribute() //设置一个标签的某个属性的的值
  11. Element.removeAttribute() //删除一个标签的某个属性
  12. TransformerFactory.newInstance().newTransformer().transform() //将一棵DOM树写入到外部XML文件

★序列化
     使用基本的文件读写方式存取数据，如果我们仅仅保存相同类型的数据，则可以用同一种格式保存，譬如在我的JavaMine中保存一个盘局时，需要保存每一个方格的坐标、是否有地雷，是否被翻开等，这些信息组合成一个“复合类型”；相反，如果有多种不同类型的数据，那我们要么把它分解成若干部分，以相同类型（譬如String）保存，要么我们需要在程序中添加解析不同类型数据格式的逻辑，这就很不方便。于是我们期望用一种比较“高”的层次上处理数据，程序员应该花尽可能少的时间和代码对数据进行解析，事实上，序列化操作为我们提供了这样一条途径。
     序列化（Serialization）大家可能都有所接触，它可以把对象以某种特定的编码格式写入或从外部字节流（即ObjectInputStream/ObjectOutputStream）中读取。序列化一个对象非常之简单，仅仅实现一下Serializable接口即可，甚至都不用为它专门添加任何方法：
  1. public class MySerial implements java.io.Serializable
  2. {
  3.   //...
  4. }

但有一个条件：即你要序列化的类当中，它的每个属性都必须是是“可序列化”的。这句话说起来有点拗口，其实所有基本类型（就是int，char，boolean之类的）都是“可序列化”的，而你可以看看JDK文档，会发现很多类其实已经实现了Serializable（即已经是“可序列化”的了），于是这些类的对象以及基本数据类型都可以直接作为你需要序列化的那个类的内部属性。如果碰到了不是“可序列化”的属性怎么办？对不起，那这个属性的类还需要事先实现Serializable接口，如此递归，直到所有属性都是“可序列化”的。

主要类与方法和描述
  1. ObjectOutputStream.writeObject() //将一个对象序列化到外部字节流
  2. ObjectInputStream.readObject() //从外部字节流读取并重新构造对象

     从实际应用上看来，“Serializable”这个接口并没有定义任何方法，仿佛它只是一个标记（或者说像是Java的关键字）而已，一旦虚拟机看到这个“标记”，就会尝试调用自身预定义的序列化机制，除非你在实现Serializable接口的同时还定义了私有的readObject()或writeObject()方法。这一点很奇怪。不过你要是不愿意让系统使用缺省的方式进行序列化，那就必须定义上面提到的两个方法：
  1. public class MySerial implements java.io.Serializable
  2. {
  3.   private void writeObject(java.io.ObjectOutputStream out) throws IOException
  4.    {
  5.     //...
  6.    }
  7.   private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException
  8.    {
  9.     //...
  10.    }
  11.   //...
  12. }  

     譬如你可以在上面的writeObject()里调用默认的序列化方法ObjectOutputStream.defaultWriteObject();譬如你不愿意将某些敏感的属性和信息序列化，你也可以调用ObjectOutputStream.writeObject()方法明确指定需要序列化那些属性。关于用户可定制的序列化方法，我们将在后面提到。

★Bean
     上面的序列化只是一种基本应用，你把一个对象序列化到外部文件以后，用notepad打开那个文件，只能从为数不多的一些可读字符中猜到这是有关这个类的信息文件，这需要你熟悉序列化文件的字节编码方式，那将是比较痛苦的（在《Core Java 2》第一卷里提到了相关编码方式，有兴趣的话可以查看参考资料），某些情况下我们可能需要被序列化的文件具有更好的可读性。另一方面，作为Java组件的核心概念“JavaBeans”，从JDK 1.4开始，其规范里也要求支持文本方式的“长期的持久化”（long-term persistence）。
     打开JDK文档，java.beans包里的有一个名为“Encoder”的类，这就是一个可以序列化bean的实用类。和它相关的两个主要类有XMLEcoder和XMLDecoder，显然，这是以XML文件的格式保存和读取bean的工具。他们的用法也很简单，和上面ObjectOutputStream/ObjectInputStream比较类似。

主要类与方法和描述
  1. XMLEncoder.writeObject() //将一个对象序列化到外部字节流
  2. XMLDecoder.readObject() //从外部字节流读取并重新构造对象

     如果一个bean是如下格式：
  1. public class MyBean
  2. {
  3.   int i;
  4.   char[] c;
  5.   String s;
  6.   //...(get和set操作省略)...
  7. }  

那么通过XMLEcoder序列化出来的XML文件具有这样的形式：

<?xml version="1.0" encoding="UTF-8"?>
<java version="1.4.0" class="java.beans.XMLDecoder">
   <object class="MyBean">
     <void property="i">
       <int>1</int>
     </void>
     <void property="c">
       <array class="char" length="3">
         <void index="0">
           <int>a</int>
         </void>
         <void index="1">
           <int>b</int>
         </void>
         <void index="2">
           <int>c</int>
         </void>
       </array>
     </void>
     <void property="s">
       <string>fox jump!</string>
     </void>
   </object>
</java>

     像AWT和Swing中很多可视化组件都是bean，当然也是可以用这种方式序列化的，下面就是从JDK文档中摘录的一个JFrame序列化以后的XML文件：

<?xml version="1.0" encoding="UTF-8"?>
<java version="1.0" class="java.beans.XMLDecoder">
   <object class="javax.swing.JFrame">
     <void property="name">
       <string>frame1</string>
     </void>
     <void property="bounds">
       <object class="java.awt.Rectangle">
         <int>0</int>
         <int>0</int>
         <int>200</int>
         <int>200</int>
       </object>
     </void>
     <void property="contentPane">
       <void method="add">
         <object class="javax.swing.JButton">
           <void property="label">
             <string>Hello</string>
           </void>
         </object>
       </void>
     </void>
     <void property="visible">
       <boolean>true</boolean>
     </void>
   </object>
</java>

     因此但你想要保存的数据是一些不是太复杂的类型的话，把它做成bean再序列化也不失为一种方便的选择。

★Properties
     在以前我总结的一篇关于集合框架的小文章里提到过，Properties是历史集合类的一个典型的例子，这里主要不是介绍它的集合特性。大家可能都经常接触一些配置文件，如Windows的ini文件，Apache的conf文件，还有Java里的properties文件等，这些文件当中的数据以“关键字-值”对的方式保存。“环境变量”这个概念都知道吧，它也是一种“key-value”对，以前也常常看到版上问“如何取得系统某某信息”之类的问题，其实很多都保存在环境变量里，只要用一条
  1. System.getProperties().list(System.out);  

就能获得全部环境变量的列表：

-- listing properties --
java.runtime.name=Java(TM) 2 Runtime Environment, Stand...
sun.boot.library.path=C:\Program Files\Java\j2re1.4.2_05\bin
java.vm.version=1.4.2_05-b04
java.vm.vendor=Sun Microsystems Inc.
java.vendor.url=http://java.sun.com/
path.separator=;
java.vm.name=Java HotSpot(TM) Client VM
file.encoding.pkg=sun.io
user.country=CN
sun.os.patch.level=Service Pack 1
java.vm.specification.name=Java Virtual Machine Specification
user.dir=d:\my documents\项目\eclipse\SWTDemo
java.runtime.version=1.4.2_05-b04
java.awt.graphicsenv=sun.awt.Win32GraphicsEnvironment
java.endorsed.dirs=C:\Program Files\Java\j2re1.4.2_05\li...
os.arch=x86
java.io.tmpdir=C:\DOCUME~1\cn2lx0q0\LOCALS~1\Temp\
line.separator=

java.vm.specification.vendor=Sun Microsystems Inc.
user.variant=
os.name=Windows XP
sun.java2d.fontpath=
java.library.path=C:\Program Files\Java\j2re1.4.2_05\bi...
java.specification.name=Java Platform API Specification
java.class.version=48.0
java.util.prefs.PreferencesFactory=java.util.prefs.WindowsPreferencesFac...
os.version=5.1
user.home=D:\Users\cn2lx0q0
user.timezone=
java.awt.printerjob=sun.awt.windows.WPrinterJob
file.encoding=GBK
java.specification.version=1.4
user.name=cn2lx0q0
java.class.path=d:\my documents\项目\eclipse\SWTDemo\bi...
java.vm.specification.version=1.0
sun.arch.data.model=32
java.home=C:\Program Files\Java\j2re1.4.2_05
java.specification.vendor=Sun Microsystems Inc.
user.language=zh
awt.toolkit=sun.awt.windows.WToolkit
java.vm.info=mixed mode
java.version=1.4.2_05
java.ext.dirs=C:\Program Files\Java\j2re1.4.2_05\li...
sun.boot.class.path=C:\Program Files\Java\j2re1.4.2_05\li...
java.vendor=Sun Microsystems Inc.
file.separator=\
java.vendor.url.bug=http://java.sun.com/cgi-bin/bugreport...
sun.cpu.endian=little
sun.io.unicode.encoding=UnicodeLittle
sun.cpu.isalist=pentium i486 i386


主要类与方法和描述
  1. load() //从一个外部流读取属性
  2. store() //将属性保存到外部流（特别是文件）
  3. getProperty() //取得一个指定的属性
  4. setProperty() //设置一个指定的属性
  5. list() //列出这个Properties对象包含的全部“key-value”对
  6. System.getProperties() //取得系统当前的环境变量


     你可以这样保存一个properties文件：

  1. Properties prop = new Properties();
  2. prop.setProperty("key1", "value1");
  3. ...
  4. FileOutputStream out = new FileOutputStream("config.properties");
  5. prop.store(out, "--这里是文件头，可以加入注释--");  

★Preferences
     如果我说Java里面可以不使用JNI的手段操作Windows的注册表你信不信？很多软件的菜单里都有“Setting”或“Preferences”这样的选项用来设定或修改软件的配置，这些配置信息可以保存到一个像上面所述的配置文件当中，如果是Windows平台下，也可能会保存到系统注册表中。从JDK 1.4开始，Java在java.util下加入了一个专门处理用户和系统配置信息的java.util.prefs包，其中一个类Preferences是一种比较“高级”的玩意。从本质上讲，Preferences本身是一个与平台无关的东西，但不同的OS对它的SPI（Service Provider Interface）的实现却是与平台相关的，因此，在不同的系统中你可能看到首选项保存为本地文件、LDAP目录项、数据库条目等，像在Windows平台下，它就保存到了系统注册表中。不仅如此，你还可以把首选项导出为XML文件或从XML文件导入。

主要类与方法和描述
  1. systemNodeForPackage() //根据指定的Class对象得到一个Preferences对象，这个对象的注册表路径是从“HKEY_LOCAL_MACHINE\”开始的
  2. systemRoot() //得到以注册表路径HKEY_LOCAL_MACHINE\SOFTWARE\Javasoft\Prefs 为根结点的Preferences对象
  3. userNodeForPackage() //根据指定的Class对象得到一个Preferences对象，这个对象的注册表路径是从“HKEY_CURRENT_USER\”开始的
  4. userRoot() //得到以注册表路径HKEY_CURRENT_USER\SOFTWARE\Javasoft\Prefs 为根结点的Preferences对象
  5. putXXX() //设置一个属性的值，这里XXX可以为基本数值型类型，如int、long等，但首字母大写，表示参数为相应的类型，也可以不写而直接用put，参数则为字符串
  6. getXXX() //得到一个属性的值
  7. exportNode() //将全部首选项导出为一个XML文件
  8. exportSubtree() //将部分首选项导出为一个XML文件
  9. importPreferences() //从XML文件导入首选项

     你可以按如下步骤保存数据：
  1. Preferences myPrefs1 = Preferences.userNodeForPackage(this);// 这种方法是在“HKEY_CURRENT_USER\”下按当前类的路径建立一个注册表项
  2. Preferences myPrefs2 = Preferences.systemNodeForPackage(this);// 这种方法是在“HKEY_LOCAL_MACHINE\”下按当前类的路径建立一个注册表项
  3. Preferences myPrefs3 = Preferences.userRoot().node("com.jungleford.demo");// 这种方法是在“HKEY_CURRENT_USER\SOFTWARE\Javasoft\Prefs\”下按“com\jungleford\demo”的路径建立一个注册表项
  4. Preferences myPrefs4 = Preferences.systemRoot().node("com.jungleford.demo");// 这种方法是在“HKEY_LOCAL_MACHINE\SOFTWARE\Javasoft\Prefs\”下按“com\jungleford\demo”的路径建立一个注册表项
  5. myPrefs1.putInt("key1", 10);
  6. myPrefs1.putDouble("key2", -7.15);
  7. myPrefs1.put("key3", "value3");
  8. FileOutputStream out = new FileOutputStream("prefs.xml");
  9. myPrefs1.exportNode(out);

网络I/O：Socket→RMI


★Socket
     Socket编程可能大家都很熟，所以就不多讨论了，只是说通过socket把数据保存到远端服务器或从网络socket读取数据也不失为一种值得考虑的方式。

★RMI
     RMI机制其实就是RPC（远程过程调用）的Java版本，它使用socket作为基本传输手段，同时也是序列化最重要的一个应用。现在网络传输从编程的角度来看基本上都是以流的方式操作，socket就是一个例子，将对象转换成字节流的一个重要目标就是为了方便网络传输。
     想象一下传统的单机环境下的程序设计，对于Java语言的函数（方法）调用（注意与C语言函数调用的区别）的参数传递，会有两种情况：如果是基本数据类型，这种情况下和C语言是一样的，采用值传递方式；如果是对象，则传递的是对象的引用，包括返回值也是引用，而不是一个完整的对象拷贝！试想一下在不同的虚拟机之间进行方法调用，即使是两个完全同名同类型的对象他们也很可能是不同的引用！此外对于方法调用过程，由于被调用过程的压栈，内存“现场”完全被被调用者占有，当被调用方法返回时，才将调用者的地址写回到程序计数器（PC），恢复调用者的状态，如果是两个虚拟机，根本不可能用简单压栈的方式来保存调用者的状态。因为种种原因，我们才需要建立RMI通信实体之间的“代理”对象，譬如“存根”就相当于远程服务器对象在客户机上的代理，stub就是这么来的，当然这是后话了。
     本地对象与远程对象（未必是物理位置上的不同机器，只要不是在同一个虚拟机内皆为“远程”）之间传递参数和返回值，可能有这么几种情形：
  • 值传递：这又包括两种子情形：如果是基本数据类型，那么都是“可序列化”的，统统序列化成可传输的字节流；如果是对象，而且不是“远程对象”（所谓“远程对象”是实现了java.rmi.Remote接口的对象），本来对象传递的应该是引用，但由于上述原因，引用是不足以证明对象身份的，所以传递的仍然是一个序列化的拷贝（当然这个对象也必须满足上述“可序列化”的条件）。
  • 引用传递：可以引用传递的只能是“远程对象”。这里所谓的“引用”不要理解成了真的只是一个符号，它其实是一个留在（客户机）本地stub中的，和远端服务器上那个真实的对象张得一模一样的镜像而已！只是因为它有点“特权”（不需要经过序列化），在本地内存里已经有了一个实例，真正引用的其实是这个“孪生子”。

     由此可见，序列化在RMI当中占有多么重要的地位。

数据库I/O：CMP、Hibernate


★什么是“Persistence”
     用过VMWare的朋友大概都知道当一个guest OS正在运行的时候点击“Suspend”将虚拟OS挂起，它会把整个虚拟内存的内容保存到磁盘上，譬如你为虚拟OS分配了128M的运行内存，那挂起以后你会在虚拟OS所在的目录下找到一个同样是128M的文件，这就是虚拟OS内存的完整镜像！这种内存的镜像手段其实就是“Persistence”（持久化）概念的由来。

★CMP和Hibernate
     因为我对J2EE的东西不是太熟悉，随便找了点材料看看，所以担心说的不到位，这次就不作具体总结了，人要学习……真是一件痛苦的事情[cry]

序列化再探讨


     从以上技术的讨论中我们不难体会到，序列化是Java之所以能够出色地实现其鼓吹的两大卖点??分布式（distributed）和跨平台（OS independent）的一个重要基础。TIJ（即“Thinking in Java”）谈到I/O系统时，把序列化称为“lightweight persistence”??“轻量级的持久化”，这确实很有意思。

★为什么叫做“序列”化？
     开场白里我说更习惯于把“Serialization”称为“序列化”而不是“串行化”，这是有原因的。介绍这个原因之前先回顾一些计算机基本的知识，我们知道现代计算机的内存空间都是线性编址的（什么是“线性”知道吧，就是一个元素只有一个唯一的“前驱”和唯一的“后继”，当然头尾元素是个例外；对于地址来说，它的下一个地址当然不可能有两个，否则就乱套了），“地址”这个概念推广到数据结构，就相当于“指针”，这个在本科低年级大概就知道了。注意了，既然是线性的，那“地址”就可以看作是内存空间的“序号”，说明它的组织是有顺序的，“序号”或者说“序列号”正是“Serialization”机制的一种体现。为什么这么说呢？譬如我们有两个对象a和b,分别是类A和B的实例，它们都是可序列化的，而A和B都有一个类型为C的属性，根据前面我们说过的原则，C当然也必须是可序列化的。
  1. import java.io.*;
  2. ...
  3. class A implements Serializable
  4. {
  5.    C c;
  6.    ...
  7. }
  9. class B implements Serializable
  10. {
  11.    C c;
  12.    ...
  13. }
  15. class C implements Serializable
  16. {
  17.    ...
  18. }
  20. A a;
  21. B b;
  22. C c1;
  23. ...

     注意，这里我们在实例化a和b的时候，有意让他们的c属性使用同一个C类型对象的引用，譬如c1，那么请试想一下，但我们序列化a和b的时候，它们的c属性在外部字节流（当然可以不仅仅是文件）里保存的是一份拷贝还是两份拷贝呢？序列化在这里使用的是一种类似于“指针”的方案：它为每个被序列化的对象标上一个“序列号”（serial number），但序列化一个对象的时候，如果其某个属性对象是已经被序列化的，那么这里只向输出流写入该属性的序列号；从字节流恢复被序列化的对象时，也根据序列号找到对应的流来恢复。这就是“序列化”名称的由来！这里我们看到“序列化”和“指针”是极相似的，只不过“指针”是内存空间的地址链，而序列化用的是外部流中的“序列号链”。
     使用“序列号”而不是内存地址来标识一个被序列化的对象，是因为从流中恢复对象到内存，其地址可能就未必是原来的地址了??我们需要的只是这些对象之间的引用关系，而不是死板的原始位置，这在RMI中就更是必要，在两台不同的机器之间传递对象（流），根本就不可能指望它们在两台机器上都具有相同的内存地址。

★更灵活的“序列化”：transient属性和Externalizable
     Serializable确实很方便，方便到你几乎不需要做任何额外的工作就可以轻松将内存中的对象保存到外部。但有两个问题使得Serializable的威力收到束缚：
     一个是效率问题，《Core Java 2》中指出，Serializable使用系统默认的序列化机制会影响软件的运行速度，因为需要为每个属性的引用编号和查号，再加上I/O操作的时间（I/O和内存读写差的可是一个数量级的大小），其代价当然是可观的。
     另一个困扰是“裸”的Serializable不可定制，傻乎乎地什么都给你序列化了，不管你是不是想这么做。其实你可以有至少三种定制序列化的选择。其中一种前面已经提到了，就是在implements Serializable的类里面添加私有的writeObject()和readObject()方法（这种Serializable就不裸了，[:E]），在这两个方法里，该序列化什么，不该序列化什么，那就由你说了算了，你当然可以在这两个方法体里面分别调用ObjectOutputStream.defaultWriteObject()和ObjectInputStream.defaultReadObject()仍然执行默认的序列化动作（那你在代码上不就做无用功了？呵呵），也可以用ObjectOutputStream.writeObject()和ObjectInputStream.readObject()方法对你中意的属性进行序列化。但虚拟机一看到你定义了这两个方法，它就不再用默认的机制了。
     如果仅仅为了跳过某些属性不让它序列化，上面的动作似乎显得麻烦，更简单的方法是对不想序列化的属性加上transient关键字，说明它是个“暂态变量”，默认序列化的时候就不会把这些属性也塞到外部流里了。当然，你如果定义writeObject()和readObject()方法的化，仍然可以把暂态变量进行序列化。题外话，像transient、violate、finally这样的关键字初学者可能会不太重视，而现在有的公司招聘就偏偏喜欢问这样的问题 :(
     再一个方案就是不实现Serializable而改成实现Externalizable接口。我们研究一下这两个接口的源代码，发现它们很类似，甚至容易混淆。我们要记住的是：Externalizable默认并不保存任何对象相关信息！任何保存和恢复对象的动作都是你自己定义的。Externalizable包含两个public的方法：
  1. public void writeExternal(ObjectOutput out) throws IOException;
  2. public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;

     乍一看这和上面的writeObject()和readObject()几乎差不多，但Serializable和Externalizable走的是两个不同的流程：Serializable在对象不存在的情况下，就可以仅凭外部的字节序列把整个对象重建出来；但Externalizable在重建对象时，先是调用该类的默认构造函数（即不含参数的那个构造函数）使得内存中先有这么一个实例，然后再调用readExternal方法对实例中的属性进行恢复，因此，如果默认构造函数中和readExternal方法中都没有赋值的那些属性，特别他们是非基本类型的话，将会是空（null）。在这里需要注意的是，transient只能用在对Serializable而不是Externalizable的实现里面。

★序列化与克隆
     从“可序列化”的递归定义来看，一个序列化的对象貌似对象内存映象的外部克隆，如果没有共享引用的属性的化，那么应该是一个深度克隆。关于克隆的话题有可以谈很多，这里就不细说了，有兴趣的话可以参考IBM developerWorks上的一篇文章：JAVA中的指针,引用及对象的clone

一点启示


     作为一个实际的应用，我在写那个简易的邮件客户端JExp的时候曾经对比过好几种保存Message对象（主要是几个关键属性和邮件的内容）到本地的方法，譬如XML、Properties等，最后还是选择了用序列化的方式，因为这种方法最简单， 大约可算是“学以致用”罢。这里“存取程序状态”其实只是一个引子话题罢了，我想说的是??就如同前面我们讨论的关于logging的话题一样??在Java面前对同一个问题你可以有很多种solution：熟悉文件操作的，你可能会觉得Properties、XML或Bean比较方便，然后又发现了还有Preferences这么一个东东，大概又会感慨“天外有天”了，等到你接触了很多种新方法以后，结果又会“殊途同归”，重新反省Serialization机制本身。这不仅是Java，科学也是同样的道理。

++++++++ 相关链接 ++++++++
1:> Java序列化技术
2:> Bean与XML的序列化与反序列化
++++++++++++++++++++++++


心无痕 2008-03-26 16:45 发表评论
]]>Keytool工具介绍http://www.blogjava.net/xinwuhen/archive/2008/03/13/185958.html心无痕心无痕Thu, 13 Mar 2008 03:02:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/03/13/185958.htmlhttp://www.blogjava.net/xinwuhen/comments/185958.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/03/13/185958.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/185958.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/185958.htmlSun Java Keytool 基本介绍

Keytool 是一个JAVA环境下的安全钥匙与证书的管理工具.它管理一个存储了私有钥匙和验证相应公共钥匙的与它们相关联的X.509 证书链的keystore(相当一个数据库，里面可存放多个X.509标准的证书).

Keytool 是一个有效的安全钥匙和证书的管理工具. 它能够使用户使用数字签名来管理他们自己的私有/公共钥匙对,管理用来作自我鉴定的相关的证书,管理数据完整性和鉴定服务.它还能使用户在通信时缓存它们的公共钥匙.

一个证书是某一实体(个人,公司等)的数字签名,指出其他实体的公共钥匙(或其他信息)的详细的值.当数据被签名后,这个签名信息被用来检验数据的完整性和真实性.完整性指数据没有被修改和篡改,真实性指数据从任何产生和签名的一方真正的传输到达.

Keytool 把钥匙和证书储存到一个keystore.默任的实现keystore的是一个文件.它用一个密码保护钥匙.

Keystore有两个不同的入口:

1.钥匙入口:保存了非常敏感的加密的钥匙信息,并且是用一个保护的格式存储以防止未被授权的访问.以这种形式存储的钥匙是秘密钥匙,或是一个对应证书链中公有钥匙的私有钥匙.

2.信任证书入口:包含一个属于其他部分的单一公共钥匙证书.它之所以被称为"信任证书",是因为keystore信任的证书中的公共钥匙真正属于证书所有者的身份识别.

Keystore的别名:

所有的keystore入口(钥匙和信任证书入口)是通过唯一的别名访问.别名是 不区分大小写的.如别名Hugo和hugo指向同一个keystore入口.

可以在加一个入口到keystore的时候使用-genkey参数来产生一个钥匙对(公共钥匙和私有钥匙)时指定别名.也可以用-import参数加一个证书或证书链到信任证书,例如：

keytool -genkey -alias myssl -keypass mysslpasswd

其中myssl为别名,mysslpasswd为myssl别名的密码.这行命令的作用是产生一个新的公共/私有钥匙对.

假如你想修改密码,可以用:

keytool -keypasswd -alias myssl -keypass mysslpasswd -new newpass

将旧密码mysslpasswd改为newpass.

Keystore的产生:

1.当使用-genkey 或-import或-identitydb命令添加数据到一个keystore,而当这个keystore不存在时,产生一个keystore.默认名是.keystore,存放到user-home目录.

2.当用-keystore指定时,将产生指定的keystore.

Keystore的实现:

Keytool 类位于java.security包下,提供一个非常好的接口去取得和修改一个keystore中的信息. 目前有两个命令行:keytool和jarsinger,一个GUI工具Policy 可以实现keystore.由于keystore是公开的,用户可以用它写一些额外的安全应用程序.

Keystore还有一个sun公司提供的內在实现.它把keystore作为一个文件来实现.利用了一个keystore类型(格式)"JKS".它用单独的密码保护每一个私有钥匙.也用可能不同的密码保护整个keystore的完整性.

Keystore支持的算法和钥匙大小:

keytool允许用户指定钥匙对和注册密码服务供应者所提供的签名算法.缺省的钥匙对产生算法是"DSA".假如私有钥匙是"DSA"类型,缺省签名算法是"SHA1withDSA",假如私有钥匙是"RSA"类型,缺省算法是"MD5withRSA".

当产生一个DSA钥匙对,钥匙必须在512-1024位之间.对任何算法的缺省钥匙大小是1024位.

Keytool应用实例:

1.产生一个keystore:

keytool -genkey -alias myssl -keyalg RSA -keystore myssl.jks

运行这个命令,系统提示:

Enter keystore password:(输入keystore密码:)
yourpassword(输入密码)

What is your first and last name?(您的名字与姓氏是什么？)
[Unknown]: www.myssl.cn(输入申请的证书的域名)

What is the name of your organizational unit? (您的组织单位名称是什么？)
[Unknown]:Fastcom(输入你所在组织单位的名字)

What is the name of your organization? (您的组织名称是什么？)
[Unknown]:Fastcom (输入你所在组织的名字)

What is the name of your City or Locality?(您所在的城市或区域名称是什么？)
[Unknown]:Shanghai(输入所在城市的名字)

What is the name of your State or Province? (您所在的州或省份名称是什么？)
[Unknown]:Shanghai(输入所在省份名字)

What is the two-letter country code for this unit?(该单位的两字母国家代码是什么？)
[Unknown]:CN(输入国家名字,如果是中国，请输入CN)

Is CN=www.myssl.cn, OU=fastcom, O=fastcom, L=Shanghai, ST=Shanghai, C=CN correct? [no]:
yes

2.检查一个keystore:

keytool -list -v -keystore myssl.jks

Enter keystore password:yourpassword(输入密码)

将显示keystore內容如下:

Keystore type: jks
Keystore provider: SUN
Your keystore contains 1 entry
Alias name: myssl
Creation date: Nov 24 , 2006
Entry type: keyEntry
Certificate chain length: 1
Certificate[1]:
Owner: CN=www.myssl.cn, OU=fatcom, O=fastcom, L=Shanghai, ST=Shanghai, C=CN
Issuer: CN=www.myssl.cn, OU=fastcom, O=fastcom, L=Shanghai, ST=Shanghai, C=CN
Serial number: 3c22adc1
Valid from: Thu Nov 24 19:34:25 PST 2006 until: Thu Nov 24 19:34:25 PST 2007
Certificate fingerprints:
MD5: F1:5B:9B:A1:F7:16:CF:25:CF:F4:FF:35:3F:4C:9C:F0
SHA1: B2:00:50:DD:B6:CC:35:66:21:45:0F:96:AA:AF:6A:3D:E4:03:7C:74

3.输出keystore到一个文件:testkey:

keytool -export -alias myssl -keystore myssl.jks -rfc -file testkey

系统输出:

Enter keystore password:your password(输入密码)

Certificate stored in file

4.输入证书到一个新的truststore:

keytool -import -alias myssl -file testkey -keystore truststore

Enter keystore password:your new password.(输入truststore新密码)

5.检查truststore:

keytool -list -v -keystore truststore

系统将显示truststore的信息.

 

Keytool命令行参数说明:

参数 说明
-genkey 在用户主目录中创建一个默认文件".keystore",还会产生一个mykey的别名，mykey中包含用户的公钥、私钥和证书
-alias 别名
-keystore 指定密钥库的名称(产生的各类信息将不在.keystore文件中
-keyalg 指定密钥的算法
-validity 指定创建的证书有效期多少天
-keysize 指定密钥长度
-storepass 指定密钥库的密码
-keypass 指定别名条目的密码
-dname 指定证书拥有者信息 例如： "CN=sagely,OU=atr,O=szu,L=sz,ST=gd,C=cn"
-list 显示密钥库中的证书详细信息
-export 将别名指定的证书导出到文件 keytool -export -alias caroot -file caroot.crt
-file 参数指定导出到文件的文件名
-delete 删除密钥库中某条目
-keypasswd 修改密钥库中指定条目口令 keytool -keypasswd -alias sage -keypass .... -new .... -storepass ... -keystore sage
-import 将已签名数字证书导入密钥库 keytool -import -alias sage -keystore sagely -file sagely.crt
导入已签名数字证书用keytool -list -v 以后可以明显发现多了认证链长度，并且把整个CA链全部打印出来


心无痕 2008-03-13 11:02 发表评论
]]>OO 设计原则--转载http://www.blogjava.net/xinwuhen/archive/2008/03/12/185710.html心无痕心无痕Wed, 12 Mar 2008 07:31:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/03/12/185710.htmlhttp://www.blogjava.net/xinwuhen/comments/185710.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/03/12/185710.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/185710.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/185710.html关键字: oo 原则 设计
最近在审查(review)代码时,常常发现一大堆代码充满了各种bad smell.即使工作了三五年的同事,也不会例外.沟通时往往发现他们对OO的理解只是表现出简单的概念理解.对OO的一些原则不甚了解,或者写代码也是跟着感觉走.

我最初做开发的时候也是跟着感觉走,初次听到OCP如天外来物.使用Java或C#不代表你就是在做OO开发,熟练使用OO语言不代表已经对OO非常了解.感谢Uncle Bob的经典巨著<Agile Software Development>,坚持阅读的习惯让我接触并努力理解OO原则.一旦对这些原则有了深入的认识,写代码时就已经从更高的角度来分析问题,解决问题,力争写出优雅的代码.

我对OO的了解也不算多深刻,只在这里抛砖引玉.因为原则比较多,用一个系列来介绍会让大家更容易沟通.

同时,原则是死的,人是活的,不要被这些原则束缚,有一些原则在特定的情况下才会有效.

Single Choice Principle(SCP)
所有的判断只在一处进行.违反此原则的典型情况是不同的方法中充斥着相同的if ... else ...或类似的语句.

Linguistic Modular Units

Few Interfaces

Small Interfaces

Explicit Interfaces

Behavioral Completeness
一个完整的类必须包含完整的方法.如果类没有完成它的职责,或者没有完成其父类需要完成的工作,那么它就是不完整的类.

Law Of Demeter
只与直接协作的类交互.

The Principle of Essential Representation(PER)
类应该包含而且只包含其本质的定义和表现,与SRP比较接近.

Single Responsibility Principle(SRP)
一个类只承担一项职责,只能有一个发生变化的理由,那就是它的职责变化了.

Open-Colse Principle(OCP)
类应该对扩展是开放的,对修改是封闭的.

Liskov Substitution (LSP)
子类必须可以替换父类.

Dependency-Inversion Principles(DIP)
高层应该不依赖于低层,双方都应该依赖于抽象.抽象不依赖于细节,细节应该依赖于抽象.

Interface Segregation Principles(ISP)
接口属于客户程序.

---------------------------------
Reuse Release Equivalence Principle(REP)
重用的粒度等于发布的粒度.

Common Reuse Principle(CRP)
包中的类应该是共同重用的.

Common Closure Principle(CCP)
包中的类对同一类变化共同封闭的,一个类发生变化,可能所有的类都要发生变化.

---------------------------------
Acyclic Dependencies Principle(ADP)
包之间的依赖结构不应该存在环依赖.

Stable Dependencies Principle (SDP)
包应该依赖于比它更稳定的包.

Stable Abstractions Principle(SAP)
包的稳定程度与抽象程度成正比,越抽象的包越稳定.

---------------------------------
开发时应该避免的bad design smell:
僵化(Rigidity) 一处变化会影响系统中的很多地方.
脆弱(Fragility) 一处变化会影响系统中不应该被影响的地方.
牢固(Immobility) 很难被重用.

还有一些原则可能被遗漏掉,如果你发现了,请及时提醒我.


心无痕 2008-03-12 15:31 发表评论
]]>项目研发中用到的一个对JAR进行数字签名的ANT构建文件(备忘录)http://www.blogjava.net/xinwuhen/archive/2008/03/12/185703.html心无痕心无痕Wed, 12 Mar 2008 06:58:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/03/12/185703.htmlhttp://www.blogjava.net/xinwuhen/comments/185703.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/03/12/185703.html#Feedback1http://www.blogjava.net/xinwuhen/comments/commentRss/185703.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/185703.html<?xml version="1.0" encoding="UTF-8"?>
<project name="MakeTopoJar" default="deployTopoJar" basedir=".">
 <!-- 设定系统环境变量名为env,以备下边使用 -->
 <property environment="env"/>
 
 <!-- 设定构建JAR时的路径与文件名参数,注意:下边的属性设定时,如果属性代表路径,则为了适应相应操作系统可用location代替value;
   如果属性代表文件名,则必须用value. -->
 <property name="src" value="./src" />
 <property name="webRoot" location="WebRoot"/>
 <property name="webInf" location="${webRoot}/WEB-INF"/>
 <property name="destDir" location="${webInf}/classes"/>
 <property name="classPath" location="${webInf}/lib"/>
 <property name="topoJarPath" location="${webRoot}/topo/lib"/>
 <property name="jarName" value="topo.jar"/>
 
 <!-- 数字签名用的密钥信息参数 -->
 <property name="keystoreName" value="esmkeystore"/>

 <property name="storepass" value="esmsystem"/>
 <property name="keystore" location="${topoJarPath}/${keystoreName}"/>
 <property name="keypass" value="esmsystem"/>
 <property name="keysize" value="1024"/>
 <property name="alias" value="esmkey"/>
 <property name="validity" value="365"/>

 <property name="jarsigner" value="${env.JAVA_HOME}/bin/jarsigner.exe"/>
 
 <!-- 部署数字签名后的JAR到TOMCAT相应目录 -->
 <property name="deployJarPath" location="${env.TOMCAT_HOME}/webapps/QT_ESM/topo/lib"/>

 <target name="build">
  <mkdir dir="${destDir}" />
  <javac failonerror="false" encoding="utf-8" nowarn="true" debug="true" optimize="on" srcdir="${src}"
    destdir="${destDir}" includes="com/quantanetwork/esm/**/*.java, org/acegisecurity/ui/webapp/**/*.java">
   <classpath>
    <fileset dir="${classPath}">
     <include name="**/*.jar" />
    </fileset>
   </classpath>
  </javac>
 </target>
 
 <!-- 构建JAR文件 -->
 <target name="makeJar" depends="build">
  <copy todir="${destDir}/classes">
   <fileset dir="${src}">
    <include name="com/quantanetwork/esm/ui/topo/show/icons/*.*" />
   </fileset>
  </copy>
  <jar jarfile="${topoJarPath}/${jarName}" basedir="${destDir}"
    includes="com/quantanetwork/esm/logic/topo/**, com/quantanetwork/esm/ui/topo/**">
  </jar>
 </target>

 <!-- 创建证书 -->
 <target name="genericKey">
  <echo message="genkey..."/>
  <delete>
   <fileset dir="${topoJarPath}">
       <include name="${keystoreName}"/>
   </fileset>
  </delete>

  <genkey keystore="${keystore}" storepass="${storepass}" alias="${alias}" keypass="${keypass}" keysize="${keysize}"
    verbose="true" validity="${validity}" dname="CN=Ant Group, OU=Jakarta Division, O=Apache.org, C=ZH">
  </genkey>
  <echo message="genkey... done"/>
 </target>
 
 <!-- 对JAR进行数字签名 -->
 <target name="signJar" depends="makeJar, genericKey">
  <echo message="jarsigner..." />
  <exec executable="${jarsigner}" dir="${topoJarPath}">
   <arg line="-keystore"/>
   <arg value="${keystore}"/>
   <arg line="-storepass"/>
   <arg value="${storepass}"/>
   <arg line="${jarName}"/>
   <arg line="${alias}"/>
  </exec>
  <!-- 下边这种方式也可以 -->
  <!--signjar keystore="${keystore}" storepass="esmsystem" jar="${jarName}" alias="${alias}">
   <fileset dir="${topoJarPath}">
    <include name="${jarName}" />
   </fileset>
  </signjar-->
  <echo message="jarsigner... done." />
 </target>
 
 <!-- 部署JAR文件 -->
 <target name="deployTopoJar" depends="signJar">
  <copy todir="${deployJarPath}" file="${topoJarPath}/${jarName}">
  </copy>
 </target>
</project>



心无痕 2008-03-12 14:58 发表评论
]]>Hashtable和HashMap的区别http://www.blogjava.net/xinwuhen/archive/2008/03/09/184896.html心无痕心无痕Sun, 09 Mar 2008 13:41:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/03/09/184896.htmlhttp://www.blogjava.net/xinwuhen/comments/184896.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/03/09/184896.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/184896.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/184896.html 1.Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类；
2.Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。即是说，在多线程应用程序中，不用专门的操作就安全地可以使用Hashtable了；而对于HashMap，则需要额外的同步机制。但HashMap的同步问题可通过Collections的一个静态方法得到解决：
Map Collections.synchronizedMap(Map m)
这个方法返回一个同步的Map，这个Map封装了底层的HashMap的所有方法，使得底层的HashMap即使是在多线程的环境中也是安全的。
3.在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。

4.HashTable使用Enumeration，HashMap使用Iterator。


以上只是表面的不同，它们的实现也有很大的不同。



5.HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。



6.哈希值的使用不同，HashTable直接使用对象的hashCode，代码是这样的：
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
而HashMap重新计算hash值，而且用与代替求模：
int hash = hash(k);
int i = indexFor(hash, table.length);

static int hash(Object x) {
　　int h = x.hashCode();



　　h += ~(h << 9);
　　h ^= (h >>> 14);
　　h += (h << 4);
　　h ^= (h >>> 10);
　　return h;
}
static int indexFor(int h, int length) {
　　return h & (length-1);
}


心无痕 2008-03-09 21:41 发表评论
]]>Tomcat或Resin使用security-manager的问题--转载http://www.blogjava.net/xinwuhen/archive/2008/03/08/184657.html心无痕心无痕Sat, 08 Mar 2008 03:46:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/03/08/184657.htmlhttp://www.blogjava.net/xinwuhen/comments/184657.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/03/08/184657.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/184657.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/184657.html      由于是用户自主通过FTP上传程序，我们必须控制这些程序可以执行的权限，不能让用户随便浏览硬盘上的文件，但又要能让resin可以正常运行。比如：/data/user_a目录中的程序，只能在/data/user_a目录及其子目录中读写，如果想要访问其他目录，就没有权限。
     通过研究resin的文档以及JAVA的机制，我认为要实现以上构想，可以通过使用java权限管理器来构建一个resin的沙箱来对java的具体操作进行授权。
参考文档：http://www.caucho.com/resin-3.0/security/securitymanager.xtp ，http://www.jscud.com/srun/news/viewhtml/3_2005_10/148.htm

     当我认为胜利在望的时候，发现resin好像不支持grant codeBase "file:xxxx 。

grant codeBase "file:/data/ftpdata/user01.test.com/-" {
 permission java.io.FilePermission "/data/ftpdata/user01.test.com/-", "read,write,delete";
};
     上面的语句，语法上没有问题，但就是不起作用。那个codebase目录下的文件，对本目录没有任何权限。

        resin的官方论坛里面，有人在2001年，针对resin1.2.5就提出了和我一摸一样的疑问（http://www.caucho.com/support/resin-interest/0105/0106.html），作者发现问题是由于resin的classloader是非安全的，因此改了resin原文件后解决了问题（http://www.caucho.com/support/resin-interest/0105/0112.html），但是我看resin3的源代码，里面已经基于java.security.SecureClassLoader，因此应该不是这个原因了。
     以下是我的resin.policy文件：

grant codeBase "file:${java.home}/lib/-" {
 permission java.security.AllPermission;
};

grant codeBase "file:${java.home}/jre/lib/-" {
 permission java.security.AllPermission;
};

grant codeBase "file:${resin.home}/lib/-" {
 permission java.security.AllPermission;
};

grant {
 permission java.util.PropertyPermission "*", "read";
 permission java.io.SerializablePermission "enableSubstitution";
 permission java.lang.reflect.ReflectPermission "suppressAccessChecks"; 
 permission java.lang.RuntimePermission "accessClassInPackage.*";
 permission java.lang.RuntimePermission "getClassLoader";
 permission java.lang.RuntimePermission "accessDeclaredMembers";
 permission java.lang.RuntimePermission "modifyThreadGroup";
 permission java.lang.RuntimePermission "setContextClassLoader";
 permission java.lang.RuntimePermission "setIO";
 permission java.lang.RuntimePermission "stopThread";
 permission java.lang.RuntimePermission "createClassLoader";
 permission java.lang.RuntimePermission "getProtectionDomain";
 permission java.lang.RuntimePermission "defineClassInPackage";
 permission java.security.SecurityPermission "putProviderProperty.SunJCE";
 permission java.security.SecurityPermission "insertProvider.SunJCE";
 permission java.util.logging.LoggingPermission "control";
 permission java.lang.RuntimePermission "getAttribute";
 permission java.util.PropertyPermission "jaxp.debug", "read";
 permission ognl.OgnlInvokePermission "invoke.*";
 permission java.net.SocketPermission "localhost:3306","connect";
 permission java.io.FilePermission "${resin.home}/-", "read";
 permission java.io.FilePermission "${java.home}/-", "read";
 permission java.io.FilePermission "/tmp/-","read,write,delete";
 permission java.io.FilePermission "/tmp","read,write,delete";
 permission java.io.FilePermission ".","read";
 permission java.io.FilePermission "/home/apps/java/jdk/lib/tools.jar","read";
 permission java.io.FilePermission "/bin/sh", "read,execute";
};

//以下语句没有任何作用，/data/ftpdata/user01.test.com/下的jsp对这个目录没有读的权限
grant codeBase "file:/data/ftpdata/user01.test.com/-" {
 permission java.io.FilePermission "/data/ftpdata/user01.test.com/-", "read,write,delete";
};



心无痕 2008-03-08 11:46 发表评论
]]>JAR文件揭密--转载http://www.blogjava.net/xinwuhen/archive/2008/03/08/184645.html心无痕心无痕Sat, 08 Mar 2008 02:47:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/03/08/184645.htmlhttp://www.blogjava.net/xinwuhen/comments/184645.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/03/08/184645.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/184645.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/184645.html

JAR 文件揭密

探索 JAR 文件格式的强大功能

developerWorks
文档选项
将打印机的版面设置成横向打印模式

打印本页
将此页作为电子邮件发送

将此页作为电子邮件发送

级别： 初级

Pagadala J. Suresh (pjsuresh@in.ibm.com), 软件工程师, IBM Global Services India
Palaniyappan Thiagarajan (tpalaniy@in.ibm.com), 软件工程师, IBM Global Services India

2003 年 11 月 15 日

大多数 Java 程序员都熟悉对 JAR 文件的基本操作。但是只有少数程序员了解 JAR 文件格式的 强大功能。在本文中，作者探讨了JAR 格式的许多功能和优势，包括打包、可执行的 JAR 文件、安全性和索引。

JAR 文件是什么？

JAR 文件格式以流行的 ZIP 文件格式为基础，用于将许多个文件聚集为一个文件。与 ZIP 文件不同的是，JAR 文件不仅用于压缩和发布，而且还用于部署和封装库、组件和插件程序，并可被像编译器和 JVM 这样的工具直接使用。在 JAR 中包含特殊的文件，如 manifests 和部署描述符，用来指示工具如何处理特定的 JAR。

一个 JAR 文件可以用于：

  • 用于发布和使用类库
  • 作为应用程序和扩展的构建单元
  • 作为组件、applet 或者插件程序的部署单位
  • 用于打包与组件相关联的辅助资源

JAR 文件格式提供了许多优势和功能，其中很多是传统的压缩格式如 ZIP 或者 TAR 所没有提供的。它们包括：

  • 安全性。可以对 JAR 文件内容加上数字化签名。这样，能够识别签名的工具就可以有选择地为您授予软件安全特权，这是其他文件做不到的，它还可以检测代码是否被篡改过。
  • 减少下载时间。 如果一个 applet 捆绑到一个 JAR 文件中，那么浏览器就可以在一个 HTTP 事务中下载这个 applet 的类文件和相关的资源，而不是对每一个文件打开一个新连接。
  • 压缩。JAR 格式允许您压缩文件以提高存储效率。
  • 传输平台扩展。 Java 扩展框架(Java Extensions Framework)提供了向 Java 核心平台添加功能的方法，这些扩展是用 JAR 文件打包的(Java 3D 和 JavaMail 就是由 Sun 开发的扩展例子)。
  • 包密封。存储在 JAR 文件中的包可以选择进行 密封，以增强版本一致性和安全性。密封一个包意味着包中的所有类都必须在同一 JAR 文件中找到。
  • 包版本控制。一个 JAR 文件可以包含有关它所包含的文件的数据，如厂商和版本信息。
  • 可移植性。处理 JAR 文件的机制是 Java 平台核心 API 的标准部分。

压缩的和未压缩的 JAR

jar 工具(有关细节参阅 jar 工具 )在默认情况下压缩文件。未压缩的 JAR 文件一般可以比压缩过的 JAR 文件更快地装载，因为在装载过程中要解压缩文件，但是未压缩的文件在网络上的下载时间可能更长。

META-INF 目录

大多数 JAR 文件包含一个 META-INF 目录，它用于存储包和扩展的配置数据，如安全性和版本信息。Java 2 平台识别并解释 META-INF 目录中的下述文件和目录，以便配置应用程序、扩展和类装载器：

  • MANIFEST.MF。这个 manifest 文件定义了与扩展和包相关的数据。
  • INDEX.LIST。 这个文件由 jar 工具的新选项 -i 生成，它包含在应用程序或者扩展中定义的包的位置信息。它是 JarIndex 实现的一部分，并由类装载器用于加速类装载过程。
  • xxx.SF。 这是 JAR 文件的签名文件。占位符 xxx标识了签名者。
  • xxx.DSA。 与签名文件相关联的签名程序块文件，它存储了用于签名 JAR 文件的公共签名。

jar 工具

为了用 JAR 文件执行基本的任务，要使用作为Java Development Kit 的一部分提供的 Java Archive Tool ( jar 工具)。用 jar 命令调用 jar 工具。表 1 显示了一些常见的应用：

表 1. 常见的 jar 工具用法

功能 命令
用一个单独的文件创建一个 JAR 文件 jar cf jar-file input-file...
用一个目录创建一个 JAR 文件 jar cf jar-file dir-name
创建一个未压缩的 JAR 文件 jar cf0 jar-file dir-name
更新一个 JAR 文件 jar uf jar-file input-file...
查看一个 JAR 文件的内容 jar tf jar-file
提取一个 JAR 文件的内容 jar xf jar-file
从一个 JAR 文件中提取特定的文件 jar xf jar-file archived-file...
运行一个打包为可执行 JAR 文件的应用程序 java -jar app.jar





回页首


可执行的 JAR

一个 可执行的 jar 文件是一个自包含的 Java 应用程序，它存储在特别配置的JAR 文件中，可以由 JVM 直接执行它而无需事先提取文件或者设置类路径。要运行存储在非可执行的 JAR 中的应用程序，必须将它加入到您的类路径中，并用名字调用应用程序的主类。但是使用可执行的 JAR 文件，我们可以不用提取它或者知道主要入口点就可以运行一个应用程序。可执行 JAR 有助于方便发布和执行 Java 应用程序。

创建可执行 JAR

创建一个可执行 JAR 很容易。首先将所有应用程序代码放到一个目录中。假设应用程序中的主类是 com.mycompany.myapp.Sample 。您要创建一个包含应用程序代码的 JAR 文件并标识出主类。为此，在某个位置(不是在应用程序目录中)创建一个名为 manifest 的文件，并在其中加入以下一行： 

Main-Class: com.mycompany.myapp.Sample

然后，像这样创建 JAR 文件：

jar cmf manifest ExecutableJar.jar application-dir

所要做的就是这些了 -- 现在可以用 java -jar 执行这个 JAR 文件 ExecutableJar.jar。

一个可执行的 JAR 必须通过 menifest 文件的头引用它所需要的所有其他从属 JAR。如果使用了 -jar 选项，那么环境变量 CLASSPATH 和在命令行中指定的所有类路径都被 JVM 所忽略。

启动可执行 JAR

既然我们已经将自己的应用程序打包到了一个名为 ExecutableJar.jar 的可执行 JAR 中了，那么我们就可以用下面的命令直接从文件启动这个应用程序：

java -jar ExecutableJar.jar





回页首


包密封

密封 JAR 文件中的一个包意味着在这个包中定义的所有类都必须在同一个 JAR 文件中找到。这使包的作者可以增强打包类之间的版本一致性。密封还提供了防止代码篡改的手段。

要密封包，需要在 JAR 的 manifest 文件中为包添加一个 Name 头，然后加上值为“true”的 Sealed 头。与可执行的 JAR 一样，可以在创建 JAR 时，通过指定一个具有适当头元素的 manifest 文件密封一个 JAR，如下所示： 

Name: com/samplePackage/
                        Sealed: true

Name 头标识出包的相对路径名。它以一个“/”结束以与文件名区别。在 Name 头后面第一个空行之前的所有头都作用于在 Name 头中指定的文件或者包。在上述例子中，因为 Sealed 头出现在 Name 头后并且中间没有空行，所以 Sealed 头将被解释为只应用到包 com/samplePackage 上。

如果试图从密封包所在的 JAR 文件以外的其他地方装载密封包中的一个类，那么 JVM 将抛出一个 SecurityException 。

扩展打包
扩展为 Java 平台增加了功能，在 JAR 文件格式中已经加入了扩展机制。扩展机制使得 JAR 文件可以通过 manifest 文件中的 Class-Path 头指定所需要的其他 JAR 文件。

假设 extension1.jar 和 extension2.jar 是同一个目录中的两个 JAR 文件，extension1.jar 的 manifest 文件包含以下头：

Class-Path: extension2.jar

这个头表明 extension2.jar 中的类是 extension1.jar 中的类的 扩展类。extension1.jar 中的类可以调用 extension2.jar 中的类，并且不要求 extension2.jar 处在类路径中。

在装载使用扩展机制的 JAR 时，JVM 会高效而自动地将在 Class-Path 头中引用的 JAR 添加到类路径中。不过，扩展 JAR 路径被解释为相对路径，所以一般来说，扩展 JAR 必须存储在引用它的 JAR 所在的同一目录中。

例如，假设类 ExtensionClient 引用了类 ExtensionDemo ,它捆绑在一个名为 ExtensionClient.jar 的 JAR 文件中，而类 ExtensionDemo 则捆绑在 ExtensionDemo.jar 中。为了使 ExtensionDemo.jar 可以成为扩展，必须将 ExtensionDemo.jar 列在 ExtensionClient.jar 的 manifest 的 Class-Path 头中，如下所示： 

Manifest-Version: 1.0
                        Class-Path: ExtensionDemo.jar

在这个 manifest 中 Class-Path 头的值是没有指定路径的 ExtensionDemo.jar，表明 ExtensionDemo.jar 与 ExtensionClient JAR 文件处在同一目录中。





回页首


JAR 文件中的安全性

JAR 文件可以用 jarsigner 工具或者直接通过 java.security API 签名。一个签名的 JAR 文件与原来的 JAR 文件完全相同，只是更新了它的 manifest，并在 META-INF 目录中增加了两个文件，一个签名文件和一个签名块文件。

JAR 文件是用一个存储在 Keystore 数据库中的证书签名的。存储在 keystore 中的证书有密码保护，必须向 jarsigner 工具提供这个密码才能对 JAR 文件签名。


图 1. Keystore 数据库
Keystore 数据库

JAR 的每一位签名者都由在 JAR 文件的 META-INF 目录中的一个具有 .SF 扩展名的签名文件表示。这个文件的格式类似于 manifest 文件 -- 一组 RFC-822 头。如下所示，它的组成包括一个主要部分，它包括了由签名者提供的信息、但是不特别针对任何特定的 JAR 文件项，还有一系列的单独的项，这些项也必须包含在 menifest 文件中。在验证一个签名的 JAR 时，将签名文件的摘要值与对 JAR 文件中的相应项计算的摘要值进行比较。


清单 1. 签名 JAR 中的 Manifest 和 signature 文件
Contents of signature file META-INF/MANIFEST.MF
                        Manifest-Version: 1.0
                        Created-By: 1.3.0 (Sun Microsystems Inc.)
                        Name: Sample.java
                        SHA1-Digest: 3+DdYW8INICtyG8ZarHlFxX0W6g=
                        Name: Sample.class
                        SHA1-Digest: YJ5yQHBZBJ3SsTNcHJFqUkfWEmI=
                        Contents of signature file META-INF/JAMES.SF
                        Signature-Version: 1.0
                        SHA1-Digest-Manifest: HBstZOJBuuTJ6QMIdB90T8sjaOM=
                        Created-By: 1.3.0 (Sun Microsystems Inc.)
                        Name: Sample.java
                        SHA1-Digest: qipMDrkurQcKwnyIlI3Jtrnia8Q=
                        Name: Sample.class
                        SHA1-Digest: pT2DYby8QXPcCzv2NwpLxd8p4G4=

数字签名

一个数字签名是.SF 签名文件的已签名版本。数字签名文件是二进制文件，并且与 .SF 文件有相同的文件名，但是扩展名不同。根据数字签名的类型 -- RSA、DSA 或者 PGP -- 以及用于签名 JAR 的证书类型而有不同的扩展名。

Keystore

要签名一个 JAR 文件，必须首先有一个私钥。私钥及其相关的公钥证书存储在名为 keystores 的、有密码保护的数据库中。JDK 包含创建和修改 keystores 的工具。keystore 中的每一个密钥都可以用一个别名标识，它通常是拥有这个密钥的签名者的名字。

所有 keystore 项(密钥和信任的证书项)都是用唯一别名访问的。别名是在用 keytool -genkey 命令生成密钥对(公钥和私钥)并在 keystore 中添加项时指定的。之后的 keytool 命令必须使用同样的别名引用这一项。

例如，要用别名“james”生成一个新的公钥/私钥对并将公钥包装到自签名的证书中，要使用下述命令：

keytool -genkey -alias james -keypass jamespass
                        -validity 80 -keystore jamesKeyStore
                        -storepass jamesKeyStorePass

这个命令序列指定了一个初始密码“jamespass”，后续的命令在访问 keystore “jamesKeyStore”中与别名“james”相关联的私钥时，就需要这个密码。如果 keystore“jamesKeyStore”不存在，则 keytool 会自动创建它。

jarsigner 工具

jarsigner 工具使用 keystore 生成或者验证 JAR 文件的数字签名。

假设像上述例子那样创建了 keystore “jamesKeyStore”，并且它包含一个别名为“james”的密钥，可以用下面的命令签名一个 JAR 文件：

jarsigner -keystore jamesKeyStore -storepass jamesKeyStorePass
                        -keypass jamespass -signedjar SSample.jar Sample.jar james

这个命令用密码“jamesKeyStorePass”从名为“jamesKeyStore”的 keystore 中提出别名为“james”、密码为“jamespass”的密钥，并对 Sample.jar 文件签名、创建一个签名的 JAR -- SSample.jar。

jarsigner 工具还可以验证一个签名的 JAR 文件，这种操作比签名 JAR 文件要简单得多，只需执行以下命令： 

jarsigner -verify SSample.jar

如果签名的 JAR 文件没有被篡改过，那么 jarsigner 工具就会告诉您 JAR 通过验证了。否则，它会抛出一个 SecurityException ， 表明哪些文件没有通过验证。

还可以用 java.util.jar 和 java.security API 以编程方式签名 JAR(有关细节参阅 参考资料)。也可以使用像 Netscape Object Signing Tool 这样的工具。





回页首


JAR 索引

如果一个应用程序或者 applet 捆绑到多个 JAR 文件中，那么类装载器就使用一个简单的线性搜索算法搜索类路径中的每一个元素，这使类装载器可能要下载并打开许多个 JAR 文件，直到找到所要的类或者资源。如果类装载器试图寻找一个不存在的资源，那么在应用程序或者 applet 中的所有 JAR 文件都会下载。对于大型的网络应用程序和 applet，这会导致启动缓慢、响应迟缓并浪费带宽。

从 JDK 1.3 以后，JAR 文件格式开始支持索引以优化网络应用程序中类的搜索过程，特别是 applet。JarIndex 机制收集在 applet 或者应用程序中定义的所有 JAR 文件的内容，并将这些信息存储到第一个 JAR 文件中的索引文件中。下载了第一个 JAR 文件后，applet 类装载器将使用收集的内容信息高效地装载 JAR 文件。这个目录信息存储在根 JAR 文件的 META-INF 目录中的一个名为 INDEX.LIST 的简单文本文件中。

创建一个 JarIndex
可以通过在 jar 命令中指定 -i 选项创建一个 JarIndex。假设我们的目录结构如下图所示：


图 2. JarIndex
JarIndex Demo

您将使用下述命令为 JarIndex_Main.jar、JarIndex_test.jar 和 JarIndex_test1.jar 创建一个索引文件：

jar -i JarIndex_Main.jar JarIndex_test.jar SampleDir/JarIndex_test1.jar

INDEX.LIST 文件的格式很简单，包含每个已索引的 JAR 文件中包含的包或者类的名字，如清单 2 所示：


清单 2. JarIndex INDEX.LIST 文件示例
JarIndex-Version: 1.0
                        JarIndex_Main.jar
                        sp
                        JarIndex_test.jar
                        Sample
                        SampleDir/JarIndex_test1.jar
                        org
                        org/apache
                        org/apache/xerces
                        org/apache/xerces/framework
                        org/apache/xerces/framework/xml4j





回页首


结束语

JAR 格式远远超出了一种压缩格式，它有许多可以改进效率、安全性和组织 Java 应用程序的功能。因为这些功能已经建立在核心平台 -- 包括编译器和类装载器 -- 中了，所以开发人员可以利用 JAR 文件格式的能力简化和改进开发和部署过程。.



参考资料

  • 您可以参阅本文在 developerWorks 全球站点上的 英文原文.

  • 参阅 jar 实用程序的命令行选项的文档。


  • Raffi Krikorian 在 ONJava 上发表的文章提供了有关 programmatically signing a JAR file的帮助。


  • 文章“ Java Web Start”( developerWorks，2001 年 9 月)描述了如何使用这种技术，以便允许应用程序可以指定所需的 JAR 文件并动态下载它们。


  • 在 developerWorks Java 技术专区 上可以找到数百篇关于 Java 编程的各个方面的文章。


心无痕 2008-03-08 10:47 发表评论
]]>深入研究Servlet线程安全性问题--转载http://www.blogjava.net/xinwuhen/archive/2008/03/08/184633.html心无痕心无痕Sat, 08 Mar 2008 01:36:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/03/08/184633.htmlhttp://www.blogjava.net/xinwuhen/comments/184633.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/03/08/184633.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/184633.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/184633.html安全性问题。然而，很多人编写Servlet/JSP程序时并没有注意到多线程安全性的问题，这往往造成编写的程序在少量用户访问时没有任何问题，而在并发用户上升到一定值时，就会经常出现一些莫明其妙的问题。
　　
　　Servlet的多线程机制
　　
　　Servlet体系结构是建立在Java多线程机制之上的，它的生命周期是由Web容器负责的。当客户端第一次请求某个Servlet时，Servlet容器将会根据web.xml配置文件实例化这个Servlet类。当有新的客户端请求该Servlet时，一般不会再实例化该Servlet类，也就是有多个线程在使用这个实例。Servlet容器会自动使用线程池等技术来支持系统的运行，如图1所示。
　　
　

　　
图1 Servlet线程池

　　
　　这样，当两个或多个线程同时访问同一个Servlet时，可能会发生多个线程同时访问同一资源的情况，数据可能会变得不一致。所以在用Servlet构建的Web应用时如果不注意线程安全的问题，会使所写的Servlet程序有难以发现的错误。
　　
　　Servlet的线程安全问题
　　
　　Servlet的线程安全问题主要是由于实例变量使用不当而引起的，这里以一个现实的例子来说明。
　　
　　Import javax.servlet. *;
　　Import javax.servlet.http. *;
　　Import java.io. *;
　　Public class Concurrent Test extends HttpServlet {PrintWriter output;
　　Public void service (HttpServletRequest request,
　　HttpServletResponse response) throws ServletException, IOException {String username;
　　Response.setContentType ("text/html; charset=gb2312");
　　Username = request.getParameter ("username");
　　Output = response.getWriter ();
　　Try {Thread. sleep (5000); //为了突出并发问题，在这设置一个延时
　　} Catch (Interrupted Exception e){}
　　output.println("用户名:"+Username+"<BR>");
　　}
　　}
　　
　　该Servlet中定义了一个实例变量output，在service方法将其赋值为用户的输出。当一个用户访问该Servlet时，程序会正常的运行，但当多个用户并发访问时，就可能会出现其它用户的信息显示在另外一些用户的浏览器上的问题。这是一个严重的问题。为了突出并发问题，便于测试、观察，我们在回显用户信息时执行了一个延时的操作。假设已在web.xml配置文件中注册了该Servlet，现有两个用户a和b同时访问该Servlet（可以启动两个IE浏览器，或者在两台机器上同时访问）,即同时在浏览器中输入：
　　
　　a： http://localhost: 8080/servlet/ConcurrentTest? Username=a
　　
　　b： http://localhost: 8080/servlet/ConcurrentTest? Username=b
　　
　　如果用户b比用户a回车的时间稍慢一点，将得到如图2所示的输出：
　　
　

　　
图2 a用户和b用户的浏览器输出

　　
　　从图2中可以看到，Web服务器启动了两个线程分别处理来自用户a和用户b的请求，但是在用户a的浏览器上却得到一个空白的屏幕，用户a的信息显示在用户b的浏览器上。该Servlet存在线程不安全问题。下面我们就从分析该实例的内存模型入手,观察不同时刻实例变量output的值来分析使该Servlet线程不安全的原因。
　　
　　Java的内存模型JMM（Java Memory Model）JMM主要是为了规定了线程和内存之间的一些关系。根据JMM的设计，系统存在一个主内存(Main Memory)，Java中所有实例变量都储存在主存中，对于所有线程都是共享的。每条线程都有自己的工作内存(Working Memory)，工作内存由缓存和堆栈两部分组成，缓存中保存的是主存中变量的拷贝，缓存可能并不总和主存同步，也就是缓存中变量的修改可能没有立刻写到主存中；堆栈中保存的是线程的局部变量，线程之间无法相互直接访问堆栈中的变量。根据JMM，我们可以将论文中所讨论的Servlet实例的内存模型抽象为图3所示的模型。
　　
　

　　
图3 Servlet实例的JMM模型

　　
　　下面根据图3所示的内存模型，来分析当用户a和b的线程（简称为a线程、b线程）并发执行时，Servlet实例中所涉及变量的变化情况及线程的执行情况，如图4所示。
　　

　　
图4 Servlet实例的线程调度情况

　　
　　从图4中可以清楚的看到，由于b线程对实例变量output的修改覆盖了a线程对实例变量output的修改，从而导致了用户a的信息显示在了用户b的浏览器上。如果在a线程执行输出语句时，b线程对output的修改还没有刷新到主存，那么将不会出现图2所示的输出结果，因此这只是一种偶然现象，但这更增加了程序潜在的危险性。



心无痕 2008-03-08 09:36 发表评论
]]>用JDK中提供的java.util.logging.*包创建Logger对象----原创http://www.blogjava.net/xinwuhen/archive/2008/03/07/184591.html心无痕心无痕Fri, 07 Mar 2008 13:00:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/03/07/184591.htmlhttp://www.blogjava.net/xinwuhen/comments/184591.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/03/07/184591.html#Feedback1http://www.blogjava.net/xinwuhen/comments/commentRss/184591.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/184591.html由于项目中用到了Applet与Servlet之间(客户端用Applet、Server端用Servlet)的通信，要求：
       1:>客户端与服务端必须出Log.
       2:>浏览器在加载Applet时已有好多个JAR文件需要加载，故不想再附加Log4J对应的JAR包。
基于上面的要求，便想到了使用JDK自带的LOG输出功能，具体Logger对象的工厂类如下：
        

package com.quantanetwork.esm.logic.topo;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Locale;
import java.util.logging.FileHandler;
import java.util.logging.Formatter;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

/**
 * 拓扑Logger。
 * @author xinwuhen
 *
 */
public class TopoLogger {
 // Log文件的路径及格式：%h 代表用户主目录 %g 代表自动编号
 private static final String logFile = "%h/topo%g.log";
 // 写入到任何一个文件的最大字节数
 private static final int limit = 5 * 1024;
 // 要使用的文件数
 private static final int count = 20;
 // 指定 append 模式
 private static final boolean append = true;
 // 默认LOG级别
 private static final Level defaultLevel = Level.INFO;
 
 // Logger存储器
 private static final HashMap<String, Logger> hmLogger = new HashMap<String, Logger>();
 
 // 为对Logger存储器访问提供的同步锁对象
 private static final Object syncLock = new Object();
 
/**
*   此处是测试方法。
**/
public static void main(String[] args) {
    Logger logger = getLogger(null); // 此处用Null代表用本类（TopoLogger）的类名作为Logger的名称
    try {
        System.out.println(Long.parseLong(null));
    } catch(Exception ex) {
        TopoLogger.getLogger(null).log(Level.SEVERE, "很严重哟", ex);
  }
}
 
 /**
  * 从Logger存储器取得Logger对象。
  * @param strClassName
  * @return
  */
 public static Logger getLogger(String strClassName) {
  Logger logger = null;
  synchronized (syncLock) {
   if (strClassName == null) {  // 取当前Logger类默认的Logger对象
    String strDefaultClassName = TopoLogger.class.getName();
    logger = hmLogger.get(strDefaultClassName);
    if (logger == null) {
     logger = Logger.getLogger(strDefaultClassName);
     hmLogger.put(strDefaultClassName, logger);
    }
   } else { // 新生成一个指定名称的Logger对象
    logger = hmLogger.get(strClassName);
    if (logger == null) {
     logger = Logger.getLogger(strClassName);
     hmLogger.put(strClassName, logger);
    }
   }
  }
  
  // 添加默认的文件处理句柄
  logger.addHandler(getFileHandler());
  
  return logger;
 }
 
 /**
  * 取默认的文件处理句柄。
  * @return
  */
 private static FileHandler getFileHandler() {
  FileHandler fileHandler = null;
  try {
   fileHandler = new FileHandler(logFile, limit, count, append);
  } catch (SecurityException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
   
  }
  if (fileHandler != null) {
   fileHandler.setLevel(defaultLevel);
   fileHandler.setFormatter(new TopoLoggerFormatter());
  }
  return fileHandler;
 }
 
 
 /**
  * Logger格式化处理器。
  *
  * @author xinwuhen
  */
 final static class TopoLoggerFormatter extends Formatter {
  @Override
  public String format(LogRecord record) {
   StringBuffer strOutput = new StringBuffer();
   
   strOutput.append("[");
   strOutput.append(getFormattedTime(record.getMillis(), "yyyy-MM-dd HH:mm:SS, sss"));
   strOutput.append("], ");
   strOutput.append(record.getLevel());
   strOutput.append(", ");
   strOutput.append(record.getSourceClassName());
   strOutput.append(",");
   strOutput.append(record.getSourceMethodName());
   strOutput.append(" ");
   strOutput.append(record.getMessage());
   strOutput.append(":");
   strOutput.append(System.getProperty("line.separator"));
   Throwable throwAble = record.getThrown();
   if (throwAble != null) {
    strOutput.append(getThrowAbleInfo(throwAble));
   }

   return strOutput.toString();
  }
  
  /**
   * 根据指定格式转换时间。
   * @param lngMillTimes
   * @param strTimeFormat
   * @return
   */
  private String getFormattedTime(long lngMillTimes, String strTimeFormat) {
   Date lvDate = new Date();
   lvDate.setTime(lngMillTimes);
   SimpleDateFormat lvFormat = new SimpleDateFormat(strTimeFormat, Locale.CHINA);
   return lvFormat.format(lvDate);
  }
  
  /**
   * 取例外对象的信息。
   * @param throwAble
   * @return
   */
  private String getThrowAbleInfo(Throwable throwAble) {
   String throwAbleInfo = "";
   StackTraceElement[] ste = throwAble.getStackTrace();
   if (ste != null) {
    final String strLineSeparator = System.getProperty("line.separator");
    StringBuffer sbStackTraceEle = new StringBuffer();
    for (StackTraceElement stackTraceElement : ste) {
     sbStackTraceEle.append("        at ");
     sbStackTraceEle.append(stackTraceElement.toString());
     sbStackTraceEle.append(strLineSeparator);
    }
    throwAbleInfo = throwAble.toString() + strLineSeparator + sbStackTraceEle;
   }
   return throwAbleInfo;
  }
 }
}

++++ 输出结果如下（注意内容是通过程序中定义的文件来存储的，在$USER_HOME/topo0.log中）：++++
[2008-03-07 21:01:328, 000], SEVERE, com.quantanetwork.esm.logic.topo.TopoLogger,main 很严重哟:
java.lang.NumberFormatException: null
        at java.lang.Long.parseLong(Long.java:372)
        at java.lang.Long.parseLong(Long.java:461)
        at com.quantanetwork.esm.logic.topo.TopoLogger.main(TopoLogger.java:40)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
以上内容抛砖引玉，望大家有其它输出方式的更好实现。。。。。。另外，本人博客中的“JAVA技术文档”链接分类也有对JDK的Logger的描述，可以参见该文档互相学习。。。。。谢谢！！！



心无痕 2008-03-07 21:00 发表评论
]]>学习使用java.util.logging.Logger类--转载http://www.blogjava.net/xinwuhen/archive/2008/03/07/184583.html心无痕心无痕Fri, 07 Mar 2008 11:27:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/03/07/184583.htmlhttp://www.blogjava.net/xinwuhen/comments/184583.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/03/07/184583.html#Feedback5http://www.blogjava.net/xinwuhen/comments/commentRss/184583.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/184583.html1.在程序里面写死需要哪些log级别,使用哪些subscribe

import java.util.logging.*;
public class LoggingProgramSetPubSubpro
{
 public static void main(String[] args)
 {
  Logger logger = Logger.getLogger("loggingTest");
  logger.setLevel(Level.INFO);//这个设定最重要
  
  ConsoleHandler consoleHandler = new ConsoleHandler();
  consoleHandler.setLevel(Level.OFF);//这个好像不起作用
  
  logger.addHandler(consoleHandler);
  
  logger.severe("嚴重訊息");
  logger.warning("警示訊息");
  logger.info("一般訊息");
  logger.config("設定方面的訊息");
  logger.fine("細微的訊息");
  logger.finer("更細微的訊息");
  logger.finest("最細微的訊息");
 }
}

2.如何在配置文件里面改,好处是不用重新编译原文件

import java.util.logging.*;
/**

说明:我们可以在C:\Documents and Settings\yay目录下面找到java0.log文件
 它是一个xml格式的,
 我们可以在${jdk}\jar\lib下面找到logging.properties文件,你可以在这里面修改

 

*/
public class LoggingPropertiesFile
 {
  public static void main(String[] args)
   {

    Logger logger = Logger.getLogger("loggingTest");
    logger.severe("严重的信息");
    logger.warning("警告信息");
    logger.info("一般信息");
    logger.config("设定方面的信息");
    logger.fine("细微的信息");
    logger.finer("更细微的信息");
    logger.finest("最细微的信息");
    

   }
 }

3.使用log方法,使用自定义的Formatter

import java.util.logging.*;
/**

輸出格式是由java.util.logging.Formatter决定的
注意这里说得这个Formatter是属于哪里包里面的,不要搞混了

*/
public class LoggingLogMethod
{
 public static void main(String[] args)
 {
  Logger logger = Logger.getLogger("loggingTest");
  logger.setLevel(Level.ALL);
  
  ConsoleHandler consoleHandler = new ConsoleHandler();
  consoleHandler.setLevel(Level.ALL);
  
  logger.addHandler(consoleHandler);
  
  try
  {
   //%h代表用户主目录
   //%g代表自动编号
   FileHandler  fileHandler=new FileHandler("%h/loggingHome%g.log");
   fileHandler.setLevel(Level.ALL);
   fileHandler.setFormatter(new YAYFormatter());
   
   
   logger.addHandler(fileHandler);
  }
  catch (Exception e)
  {
   e.printStackTrace();
  }
  
  
  
  logger.log(Level.SEVERE, "嚴重訊息");
  logger.log(Level.WARNING, "警示訊息");
  logger.log(Level.CONFIG, "一般訊息");
  logger.log(Level.CONFIG, "設定方面的訊息");
  logger.log(Level.FINE, "細微的訊息");
  logger.log(Level.FINER, "更細微的訊息");
  logger.log(Level.FINEST, "最細微的訊息");
 }
}

4.如何自定义java.util.logging.Formatter

import java.util.logging.*;
public class YAYFormatter extends Formatter
{
 public String format(LogRecord logRecord)
 {
  return  "LogRecord info: " + logRecord.getSourceClassName() +//就是哪个类里面用的了你
   "\n" +"Level\t|\tLoggerName\t|\tMessage\t|\n" +
  logRecord.getLevel() + //是SEVERE还是WARNING还是别的
    "\t|\t" +
   logRecord.getLoggerName() +//这个logger发布者
     "\t|\t" +
   logRecord.getMessage() + //消息内容
      "\t|\n\n";   
 }
}



心无痕 2008-03-07 19:27 发表评论
]]>探讨JAR文件无限可能性--转载http://www.blogjava.net/xinwuhen/archive/2008/03/07/184422.html心无痕心无痕Fri, 07 Mar 2008 02:36:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/03/07/184422.htmlhttp://www.blogjava.net/xinwuhen/comments/184422.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/03/07/184422.html#Feedback0http://www.blogjava.net/xinwuhen/comments/commentRss/184422.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/184422.html所有Java开发者都知道JAR文件只是包含Java类树的压缩（ZIP）文件。但是，不是人人（包括一些经验丰富的开发者）了解这种文件格式的其它优点。在本文中，我将简单介绍JAR文件格式，并说明利用它可以实现的各种可能性。

JAR文件简介

JAR文件以流行的二进制ZIP文件格式为基础，用以把许多文件合并成一个文件。它还包含一个名为META-INF的可选目录，这个目录位于文件根目录下。

有两种方法可以建立JAR文件：应用命令行工具jar，或使用Java中的java.util.jar API编程。如果JAR文件包含在Java类路径中，使JVM可看到它，则JAR文件包含Java类和/或可由类加载器运行、使用及加载的资源。

在许多情况下，JAR文件不仅仅是简单的Java类档案文件和/或资源；它们还可用来为应用程序和扩展建立语句块。META-INF目录（如存在）用于存储数据包和扩展配置数据，包括安全、版本、扩展和服务。

META-INF目录的作用

META-INF目录中的下列文件和目录获得Java 2平台的认可与解释，用来配置应用程序、扩展程序、类加载器和服务：

  • MANIFEST.MF：清单文件，用来定义与扩展和数据包相关的数据。
  • INDEX.LIST：这个文件由JAR工具的新“-i”选项生成，其中包含在一个应用程序或扩展中定义的数据包的地址信息。它是JarIndex的一部分，被类加载器用来加速类加载过程。
  • x.SF：JAR文件的签名文件。x代表基础文件名。
  • x.DSA：这个签名块文件与同名基础签名文件有关。此文件存储对应签名文件的数字签名。
  • services/：这个目录存储所有服务提供程序配置文件。

下面我们来了解一下每种组合。

清单文件

清单文件由“AttributeName: Value”对构成，一个换行符将其划分成两个部分：主要部分和单独部分，这两个被另外一个换行符分开。

  • 主要部分：这个部分包含JAR文件本身的安全和配置信息，以及此JAR文件构成的应用程序或扩展。它还定义适用于每个单独清单项的主要属性。这个部分没有名为“Name”的属性。本部分以一个空行结束。
  • 单独部分：这个部分为此JAR文件中包含的数据包或文件定义各种属性。并非所有的JAR文件都必须列举在清单文件中，但必须列出所有签名文件。清单文件本身不得列出。每个部分必须以一个名为“Name”的属性开始，它的值必须是一个文件相对路径，或档案文件外的一个绝对URL参考数据。（我将在本文后部分讨论JAR签名。）

下面是清单文件最重要的属性：

  • Manifest-Version：定义清单文件版本。它的值是一个上面规范描述的合法版本号。
  • Created-By：详细说明生成这个清单文件的Java程序的版本和生产商。这个属性由JAR工具生成。
  • Signature-Version：定义JAR文件的签名版本。该值应为一个有效的版本号字符串。
  • Class-Path：这个属性值指定这个应用程序或扩展需要的扩展或库的相对URL。URL由一个或几个空格分隔。应用程序或扩展类加载器使用这个属性值建立它的内部搜索路径。
  • Main-Class：这个属性用于单机应用程序。这个属性值定义主要应用程序类的相对路径，发射器在启动时会加载这些类。这个属性值不能在类名称后附加.class扩展名。如果你已经指定这个属性，JAR文件即变成可执行文件，应用程序将通过java –jar x.jar命令自动启动。
  • Sealed：这个属性定义此JAR文件是否被密封。该值可为真或假，且忽略大小写。当JAR文件被密封时，一个可选的数据包可在某个特殊的版本中执行一贯性。在JAR中密封的数据包规定所有在那个数据包中定义的类必须源自相同的JAR；否则，就会产生一个SecurityException。例如，这段代码：

Name: javax/servlet/internal/

Sealed: true

说明javax.servlet.internal数据包被密封，且这个数据包中的所有类必须从相同的JAR文件加载。要了解可选数据包的详细内容，请查看扩展机制。

JAR签名文件

任何JAR文件都可以通过java.security API，使用命令行jarsigner工具或目录进行签名。通过文件签名，你可以保证没人能够改变一个文件的内容，以及你正在使用一个知名厂商的JAR文件。如果JAR文件用jarsigner工具签名，那么每个文件，包括META-INF目录中的相关非签名文件，都将被签名。下面是与签名有关的文件：

  • META-INF/MANIFEST.MF
  • META-INF/*.SF
  • META-INF/*.DSA
  • META-INF/*.RSA
  • META-INF/SIG-*

每个签名器由一个扩展名为.SF的签名文件说明，这个文件的主要内容与清单文件相似。它由一个主要部分构成，其中包含由签名器提供的信息，但并不特别针对某个特定的JAR文件。主要部分的项目x-Digest-Manifest-Main-Attributes（这里的x是一个摘要算法）包含清单主要属性的摘要值。

要使一个文件生效，首先将签名文件的一个摘要值与根据清单文件中对应的项目计算的摘要进行比较；然后，再将清单文件中的一个摘要值与根据“Name：”属性中的实际引用数据计算的摘要比较。“Name：”属性指定一个相对文件路径或RUL。

例如，下面是一个签名JAR的清单文件：

Manifest-Version: 1.0

Created-By: 1.3 (Sun Microsystems, Inc)?br>

Name: common/class1.class

MD5-Digest: (base64 representation of MD5 digest)?br>

Name: common/class2.class

MD5-Digest: (base64 representation of MD5 digest)

SHA-Digest: (base64 representation of SHA digest)

下面是对应的签名：

Signature-Version: 1.0

MD5-Digest-Manifest-Main-Attributes: (base64 representation of MD5 digest)?br>

Name: common/class1.class

MD5-Digest: (base64 representation of MD5 digest)?br>

Name: common/class2.class

MD5-Digest: (base64 representation of MD5 digest)

数字签名是.SF签名文件的一个签名版本。这些是人类无法解译的二进制文件。数字签名文件和.SF文件的名称相同，但扩展名不同。数字签名的类型不同，其扩展名也各不相同，通常为RSA或DSA。

JAR目录

为优化类加载器在网络应用程序，特别是applet中的类搜索过程，因此引入了JAR目录（一般称作JarIndex机制）。JarIndex机制收集在一个applet中定义的所有JAR文件，并将信息存储在applet的类路径的第一个JAR文件的一个目录文件中。下载第一个JAR文件后，applet类加载器将收集内容信息，这样可提高JAR文件的下载效率。

系统对现有的JAR工具进行强化，使其能够检查一个JAR文件列表，并生成目录信息，说明哪些类和资源位于哪个JAR文件中。这些目录信息存储在根JAR文件META-INF目录中的一个名为INDEX.LIST的简单文本文件中。当类加载器加载根JAR文件时，它阅读INDEX.LIST文件，并用它建立一个由文件和数据包名称到JAR文件名列表的映射散列表。为了找到一个类或资源，类加载器查询散列表找到正确的JAR文件，如有必要，再下载这个文件。

提供服务

META-INF/services目录中的文件为服务提供程序配置文件。一个服务通常是一组著名的界面和（一般是抽象的）类。一个服务提供程序是一项服务的特殊执行过程。提供程序中的类往往执行上述界面并继承服务本身定义的类。

服务提供程序通过把一个提供程序配置文件放在META-INF/services源目录中来识别自己。这个文件名应由完全合格的抽象服务类名称构成。

应用这些特性

了解JAR文件的这些特性后，你就可以在实际开发工作中创造性的应用它们。如果你已经有了一些有趣的使用方法，请在文章的讨论部分分享你的经验。

Peter V. Mikhalenko是一名通过Sun认证的专家，现在任德意志银行商业顾问。 

责任编辑：德东



心无痕 2008-03-07 10:36 发表评论
]]>揭密J2EE项目开发的70个问题---转载http://www.blogjava.net/xinwuhen/archive/2008/03/02/183320.html心无痕心无痕Sun, 02 Mar 2008 14:56:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/03/02/183320.htmlhttp://www.blogjava.net/xinwuhen/comments/183320.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/03/02/183320.html#Feedback2http://www.blogjava.net/xinwuhen/comments/commentRss/183320.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/183320.html 呵呵～就算给大家一个考试的机会～呵呵。

问题：选择怎样的开发模式
问题：B/S还是C/S
问题：如何谈需求
问题：如何设计用例
问题：分析师如何看用例
问题：如何管理软件需求
问题：需求管理和开发
问题：软件需求之验证和评审
问题：软件需求之风险管理
问题：软件需求之变更和需求跟踪
问题：软件需求之软件过程改进
问题：找谁来调研
问题：获取需求的沟通途径
问题：需求获取的注意事项
问题：沟通的基本技巧
问题：UML模型图各有什么意义
问题：什么是分析建模
问题：如何搭建业务对象模型
问题：如何搭建分析模型
问题：分析的经验之谈
问题：解决问题的基本方法
问题：Business Analysis 的存在
问题：如何寻找参与者
问题：文档化参与者
问题：如何寻找用例
问题：文档化用例
问题：用例设计技巧与注意事项
问题：类图与关系
问题：什么是设计模型
问题：UML建模技巧之通用篇
问题：UML建模技巧之具体篇
问题：如何定义方法调用双方的义务和权利
问题：抛出Checked Exception还是Runtime Exception
问题：如何及时释放资源
问题：怎样使用正则表达式验证数据有效性
问题：Struts的ActionForm与类型
问题：Struts如何工作
问题：ActionForm与Struts标签库
问题：如何使用Struts标签之选择框
问题：如何使用Struts标签之下拉框
问题：JSTL和Struts标签的整合
问题：页面输入乱码的解决方案
问题：如何使用AJAX构建响应快速的动态Web页面
问题：如何使用AJAX构建响应快速的动态Web页面（续）
问题：如何响应AJAX请求
问题：AJAX的常见应用场景
问题：可否使用Serializable实现持久化
问题：选择怎样的方式来实现持久层
问题：连接表的困惑
问题：如何使用临时表
问题：DAO模式是否需要接口
问题：选择最好的分页方式
问题：可以使用存储过程吗
问题：怎样解决大批量数据的条件
问题：Hibernate中的实体状态
问题：Hibernate单、双向关联与inverse属性
问题：在Hibernate中配置连接表
问题：Spring如何支持JDBC
问题：Spring如何支持IBatis
问题：Spring如何支持Hibernate
问题：Spring发布包的基本构成元素有哪些
问题：怎么理解控制反转
问题：怎么理解依赖注入
问题：如何使用Bean Factory
问题：如何装配各种Bean并使它们协作
问题：如何使用ApplicationContext
问题：如何使用Spring验证器
问题：如何使用Spring发送E-mail
问题：如何使用Spring Web MVC框架
问题：Spring如何集成Struts

心无痕 2008-03-02 22:56 发表评论
]]>JDK中的URLConnection使用总结--原创http://www.blogjava.net/xinwuhen/archive/2008/03/01/183159.html心无痕心无痕Sat, 01 Mar 2008 09:37:00 GMThttp://www.blogjava.net/xinwuhen/archive/2008/03/01/183159.htmlhttp://www.blogjava.net/xinwuhen/comments/183159.htmlhttp://www.blogjava.net/xinwuhen/archive/2008/03/01/183159.html#Feedback9http://www.blogjava.net/xinwuhen/comments/commentRss/183159.htmlhttp://www.blogjava.net/xinwuhen/services/trackbacks/183159.html阅读全文

心无痕 2008-03-01 17:37 发表评论
]]>