BlogJava-激情梦想-文章分类-java基础http://www.blogjava.net/lcwlv929/category/26019.htmlzh-cnThu, 08 May 2008 07:39:01 GMTThu, 08 May 2008 07:39:01 GMT60framehttp://www.blogjava.net/lcwlv929/articles/199184.html炜炜Thu, 08 May 2008 03:37:00 GMThttp://www.blogjava.net/lcwlv929/articles/199184.htmlhttp://www.blogjava.net/lcwlv929/comments/199184.htmlhttp://www.blogjava.net/lcwlv929/articles/199184.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/199184.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/199184.html<html>
 <head>
  <title></title>
  <script>
function showLeftFrame() {
 if (document.all.leftTd.style.display == 'none'){
  document.all.middleTd.innerText = '3';
  document.all.leftTd.style.display = '';
 } else {
  document.all.middleTd.innerText = '4';
  document.all.leftTd.style.display = 'none';
 }
}
</script>
 </head>

 <body>
  <table width="800" height="423" align="center">
   <tr>
    <td height="100" colspan="3">
     <iframe name="top" src="top.htm" scrolling="no" frameborder="0"
      marginheight="0" marginwidth="0" width="100%" height="100%"></iframe>
    </td>
   </tr>
   <tr>
    <td id="leftTd" width="150" height="500">
     <iframe name="left" src="left.htm" scrolling="no" frameborder="0"
      marginheight="0" marginwidth="0" width="100%" height="100%"></iframe>
    </td>
    <td id="middleTd" width="10" onclick="showLeftFrame()"
     bgcolor="#ddeeff" style="font-family:Webdings;cursor:hand;">
     3
    </td>
    <td height="500">
     <iframe name="content" src="content.jsp" scrolling="no"
      frameborder="0" marginheight="0" marginwidth="0" width="100%"
      height="100%"></iframe>
    </td>
   </tr>
  </table>
 </body>
</html>



炜 2008-05-08 11:37 发表评论
]]>struts2的ONGL标签详解--1http://www.blogjava.net/lcwlv929/articles/192700.html炜炜Mon, 14 Apr 2008 03:13:00 GMThttp://www.blogjava.net/lcwlv929/articles/192700.htmlhttp://www.blogjava.net/lcwlv929/comments/192700.htmlhttp://www.blogjava.net/lcwlv929/articles/192700.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/192700.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/192700.html
(先定义一个action，有个username字段，假设value="song"想传递到页面上)

public class Login extends ActionSupport {

    private String username;
    
    public String execute() throws Exception {
        return INPUT;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

}
  下面是页面上显示username的一些尝试：


================直接把值显示出来。。。=====================<br>
 1.s:property标签   <s:property value="username"/>    

 2.$符号表达式     ${username}           
 
上面的两种方式都是可以显示"song"出来的，如果只用来显示，推荐${username} ，简单明了。不过${}不可以放在struts2自带的<s:xxx > 标签中混用，会报不支持变量表达式异常。

=============== 用#试一下。。。=====================<br>

  1.#表达式                    #username          
                                                            失败，页面输出"#username"

  2.s:property标签1:  <s:property value="#username"/>
                                                             失败，页面无输出

  3.s:property标签2:       <s:property value="#request.username"/>
                                                             成功，页面输出"song"(这种属性放进了request中)

  4.s:property标签3:  <s:property value="#session.username"/>
                                                            失败，页面无输出(没有放到session中)
                 
=============== 用%试一下。。。=====================<br>        
                            
1.%表达式                    %{username}                               
                                                           失败，页面输出"%{username}"

2.%表达式                    %{''username''}                               
                                                          失败，页面输出"%{''username''}"

3.s:property标签4:       <s:property value="%{username}"/>
                                                        成功，页面输出"song"

4.s:property标签Error4:  <s:property value="%{''username''}"/>
                                                      失败，页面输出"username"

测试了一大把，最后总结出了4种拿到值得办法：
 <s:property value="username"/>
${username}   
<s:property value="#request.username"/>  （#session. #application.类似）
<s:property value="%{username}"/>


炜 2008-04-14 11:13 发表评论
]]>使用eclipse在jsp上显示水晶报表（六）参数 （转载）http://www.blogjava.net/lcwlv929/articles/189303.html炜炜Fri, 28 Mar 2008 08:50:00 GMThttp://www.blogjava.net/lcwlv929/articles/189303.htmlhttp://www.blogjava.net/lcwlv929/comments/189303.htmlhttp://www.blogjava.net/lcwlv929/articles/189303.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/189303.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/189303.html一. 把参数完全交过水晶报表

   打开报表文件.rpt，在字段资源管理器里，右击参数－》新建

    在下面的选项属性里可以设置参数的名称，类型，提示文本，是否允许多个值，值范围类型（如果是字符串用离散，日期或数字用范围）

    注意：上面都是比填的，如果参数是用来对应某个字段的，类型必需跟该字段一样。

   在值属性里可以建一个值的列表，点上去，然后点右边的按钮就进入值列表编辑框了；是否提示时仅显示说明；编辑掩码，可以给参数的指定一定的格式；最小长度；最大长度；

   现在你可以给这个报表创建一个查看器jsp，加viewer标签的就行了。

   注意这个jsp的页面编码设置为UTF-8.

二.   参数所需包跟相关对象

     1.  需要的java类和包       

         com.crystaldecisions.sdk.occa.report.data.*

          com.crystaldecisions.reports.sdk.DataDefController

     2.  创建一个存储参数字段的 Fields 对象。 参数对象都是放在这个里面，通过Fields对象可以添加、删除和查找参数对象   

          Fields fields = new Fields();

     3.   ParameterField 参数字段对象。

          ParameterField paramField1 = new ParameterField();

     4. 为想设置的每个参数字段创建一个 Values 对象。Values对象是用来存储ParameterFieldDiscreteValue 对象或 ParameterFieldRangeValue 对象

          Values newVals1 = new Values();

     5. 离散值对象ParameterFieldDiscreteValue 对象

        ParameterFieldDiscreteValue newDiscVal1 = new ParameterFieldDiscreteValue();

        ParameterFieldDiscreteValue[ ] newDiscVals = new ParameterFieldDiscreteValue[ ];

       范围值对象ParameterFieldRangeValue 对象

        ParameterFieldRangeValue newRangeVal1 = new   ParameterFieldRangeValue();

        ParameterFieldRangeValue[ ] newRangeVals = new   ParameterFieldRangeValue[ ];

      他们的大概关系：一个Fields－》多个ParameterField

                                       一个ParameterField－》一个Values

                                      一个Values－》多个ParameterFieldDiscreteValue 或ParameterFieldRangeValue

三.   后台设置参数

      1.  参数的管理都是通过 报表DataDefController 来控制的。

          DataDefController dataDefController ＝ new DataDefController();

          对于主报表 dataDefController = reportClientDoc.getDataDefController();

          对于子报表

          dataDefController = clientDoc.getSubreportController().getSubreport(reportName).getDataDefController();

      2.  参数的设置信息是通过 IDataDefinition 来获取的。

           IDataDefinition dataDefinition = dataDefController.getDataDefinition();    

          如:Fields fields = dataDefController.getDataDefinition().getParameterFields() ;

          而对参数的设置改动是通过 ParameterFieldController 来控制的

           ParameterFieldController   paramfieldcontroller= dataDefController.getParameterFieldController( );

          如: 给主报表参数字段设置单个值

            paramFieldController.setCurrentValue("", "StringParam", new String("Hello"));         //字符串类型
            paramFieldController.setCurrentValue("", "BooleanParam", new Boolean(true));     //布尔类型
            paramFieldController.setCurrentValue("", "CurrencyParam", new Double(123.45));//货币类型
            paramFieldController.setCurrentValue("", "NumberParam", new Integer(123));         //数字类型

           给某个参数字段设置多个离散值

           Object [] multiVals = {"String1", "String2", "String3"};                     //注意要对应参数字段的类型
           paramFieldController.setCurrentValues("", "StringMultiParam", multiVals);

      3.  取得Fields

           Fields fields = dataDefController.getDataDefinition().getParameterFields() ;

       4.  对已经建立的参数字段，通过Fields的在知道名字的情况下通过Find方法取得

       ParameterField paramField = (ParameterField)dataDefController.getDataDefinition().getParameterFields().findField(parameterName, FieldDisplayNameType.fieldName, Locale.getDefault());

         参数字段七个基本类型
        布尔(Boolean) 、货币(Double)、数字(Integer)、字符串(String)、日期、日期时间、时间(Date)

        参数的值必须跟参数的类型符合才行.  

       5.  如果是新建的参数字段，那必需设置参数字段的报表名称设置为与参数关联的报表名称。如果参数字段用于主报表，则使用空白字符串 ("")。使用 setReportName 方法设置报表名称。

          paramField1.setName("Country");             //设置名字

          paramField1.setReportName("");              //如果为 "   "就是用于主报表,如果子报表，要设置字报表名

         如果是已经在rpt中存在的参数，就不用设置名字和报表名称了，也不用添加到Fields中。

          newDiscVal1.setValue("China");               //设置离散值，后面将添加到参数值列表中

          newDiscVal1.setDescription("The country is China.");//这个要不要都没关系

          将参数字段值添加到 Values 集合对象。   

           newVals1.add(newDiscVal1);                //可以添加多个

           为参数字段设置 Values 集合。

           pfield1.setCurrentValues(vals1);

           向 Fields 对象添加每个参数字段。 Fields 对象现在可用于查看器   

           fields.add(pfield1);                   //非新建参数不用

    下面是重点啦。虽然很简单，但是折磨了我三天

     6.  改动查看报表JSP页面的参数字段离散值列表或范围值列表

          先用取得paramField对象，这个前面有说怎么取得，这里不多说了

         要添加的离散值

         ParameterFieldDiscreteValue newDiscValue = new ParameterFieldDiscreteValue();
         newDiscValue.setValue(newValue);

        取得原来的Values集合，在把Values集合克隆到一个新的Values集合。我原来是用paramField.getValues()，不知道是JRC中出错还是什么，这个方法竟然完全没用，paramField.getDefaultValues().才能真正的取得参数对象的Values集合

         Values newVals = (Values)paramField.getDefaultValues().clone(true);

        在原来的离散值中再添加多个离散值

        newVals.add(newDiscValue);

       为参数字段设置新的Values集合。这里原来是用paramField.setCurrentValues(newVals)，也是不行，要用下面的   paramField.setDefaultValues(newVals);

        paramField.setDefaultValues(newVals);

7.   禁用用户提示，自动使用设置的参数字段值。这在以下情况中特别有用：所设置的参数字段值对于用户为未知（例如系统生成的参数）。

     　通过boolean multiValue = paramField.getAllowMultiValue();判断报表是否允许多值。
    
     　不允许多值的情况下：

　　clientDoc.getDataDefController().getParameterFieldController().setCurrentValue(reportName, parameterName , newValue);

　　如果是用于主报表,reportName为" ",否则为子报表名称。

　　允许多值的情况下：

　　①如果不考虑原来的离散值列表

　　 String[] newValues = new String[]{"China","USA",..........};

　　clientDoc.getDataDefController().getParameterFieldController().setCurrentValues(reportName, parameterName ,newValues);

　

　　②在原来离散值列表的基础上添加新的离散值，并设置

       DataDefController dataDefController = null;
       if(reportName.equals(""))
          dataDefController = clientDoc.getDataDefController();
      else
        dataDefController = clientDoc.getSubreportController().getSubreport (reportName).getDataDefController();
  
      ParameterField paramField = (ParameterField)dataDefController.getDataDefinition().getParameterFields().findField(parameterName, FieldDisplayNameType.fieldName, Locale.getDefault());

     ParameterFieldDiscreteValue newDiscValue = new ParameterFieldDiscreteValue();
     newDiscValue.setValue(newValue);

     Values newVals = (Values)paramField.getDefaultValues().clone(true);

     newVals.add(newDiscValue);

     clientDoc.getDataDefController().getParameterFieldController().setCurrentValue(reportName, parameterName ,newVals);

       查看器的设置

        crystalReportPageViewer.setParameterFields(fields);//这个感觉用不用都没关系

        crystalReportPageViewer.setEnableParameterPrompt(false);

       报表的参数设置好后，则调用查看器的刷新方法以应用新的参数。

       if(session.getAttribute("refresh")==null){
            crystalReportPageViewer.refresh();
            session.setAttribute("refresh","true");
      }
     调用 processHttpRequest 方法以在当前的浏览器窗口中启动此查看器。     

     crystalReportPageViewer.processHttpRequest(request, response, getServletConfig().getServletContext(), null);

    注意不要在查看器里面设置刷新按钮，一按就会丢失参数设置。页面编码UTF-8。如果不行就tomcat profect－》reload this context



炜 2008-03-28 16:50 发表评论
]]>使用eclipse在jsp上显示水晶报表（四）POJO填充报表（转载）http://www.blogjava.net/lcwlv929/articles/189301.html炜炜Fri, 28 Mar 2008 08:49:00 GMThttp://www.blogjava.net/lcwlv929/articles/189301.htmlhttp://www.blogjava.net/lcwlv929/comments/189301.htmlhttp://www.blogjava.net/lcwlv929/articles/189301.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/189301.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/189301.html在eclipse中怎么把POJO插入到水晶报表里面呢？这就是第四篇的所要做的

首先，应该就是要建立一个实体类了。

我这里用一个OrderItems.java做例子，代码

package com.JRC.beans;

public class OrderItems ...{
    public int id;                                   //对应数据库表的id
    public int quantity;                        //产品数量，数据库表所没有的
    public OrderItems(int id, int quantity) ...{
        super();
        this.id = id;
        this.quantity = quantity;
     }
    /** *//**
      * @return id
     */
    public int getId() ...{
        return id;
     }
    /** *//**
      * @param id 要设置的 id
     */
    public void setId(int id) ...{
        this.id = id;
     }
    /** *//**
      * @return quantity
     */
    public int getQuantity() ...{
        return quantity;
     }
    /** *//**
      * @param quantity 要设置的 quantity
     */
    public void setQuantity(int quantity) ...{
        this.quantity = quantity;
     }    
}

 

如果你还没建好报表，新建一个报表如Report.rpt，并打开这个报表

在项目资源管理器中，点击OrderItems.java前面的+ （发不了图片），可以看到   “绿点 OrderItems”，就是这个了，右击－》crystal reports－》添加到当前crystal报表。或者你可以直接把“绿点 OrderItems”拉到报表中

这样OrderItems就在报表的数据中了，在报表数据中再添加一个数据库表，如products（product_id，product_name,product_price,....,）

如果没出什么问题，那Report.rpt报表数据中有了OrderItems表和products表，左键按紧OrderItems表的id，把他拉到products表的products_id上，你可以发现他们中间有条线。

这样OrderItems.id就跟products.products_id关联起来了。中间的线默认属性是等于，你也可以改成其他的。

右击 Report.rpt－》Crystal Reports－》创建查看器JSP—》选择查看器API代码插入－》选中 使用POJO填充报表、连接Crystal报表页面查看器－》确定

一个新的Report-viewer.jsp页面就出来了。不过现在很不能用，你要稍微改下里面的一丁点东西才行。

注意:Report-viewer.jsp中用到JRCHelperSample类，这个在（一）中建立的CR项目中有，是非常非常好的工具类，没事就把它拷到你的项目下吧，有很多地方要用到这个类。这个类在包com.businessobjects.samples里面

 

String reportName = "";                       //填上你的报表名字

 

 

List dataSet = new ArrayList();
                      dataSet.add(new OrderItems());
                      dataSet.add(new OrderItems());
                      dataSet.add(new OrderItems());
                      dataSet.add(new OrderItems());
                      dataSet.add(new OrderItems());

你可以用OrderItems的构造函数添加数据集,你可以用到很多方法来添加dataSet数据集的，只要添加的是准确有效的OrderItems实体对象就行了

注意要把里面的/*   */这些去掉

启动tomcat，运行Report-viewer.jsp吧



炜 2008-03-28 16:49 发表评论
]]>使用eclipse在jsp上显示水晶报表（五）viewer标签应用（转载）http://www.blogjava.net/lcwlv929/articles/189302.html炜炜Fri, 28 Mar 2008 08:49:00 GMThttp://www.blogjava.net/lcwlv929/articles/189302.htmlhttp://www.blogjava.net/lcwlv929/comments/189302.htmlhttp://www.blogjava.net/lcwlv929/articles/189302.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/189302.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/189302.html一. 完全傻瓜式
  1. 将一个指向查看器标记库描述符文件的引用添加到 JSP 页面的顶部。 同时必须确保相应的 JAR 文件和附加支持文件都存在。

    <%@ taglib uri="/crystal-tags-reportviewer.tld" prefix="crviewer" %>注意：    可以为 prefix 属性指定任何名称。prefix 确定要使用什么标记前缀来访问标记库的标记。

  2. 创建一个开始 viewer 标记。 在此标记中，指定查看器名称和报表源的类型。

    <crviewer:viewer viewerName="CrystalViewer" reportSourceType="reportingComponent" >

  3. 创建必需的 report 标记。

    此标记指定要显示的报表以及要用于缓存报表源的会话变量。

    <crviewer:report reportName="/reports/sample.rpt"/>

  4. 结束 viewer 标记。 JSP 页面现在即可查看名为 sample.rpt 的报表。

              </crviewer:viewer>

二. 自定义报表源式

       1.    将一个指向查看器标记库描述符文件的引用添加到 JSP 页面的顶部。 同时必须确保相应的 JAR 文件和附加支持文件都存在。

          <%@ import="com.crystaldecisions.reports.sdk.ReportClientDocument">

          <%@ taglib uri="/crystal-tags-reportviewer.tld" prefix="crviewer" %>

         注意：    可以为 prefix 属性指定任何名称。prefix 确定要使用什么标记前缀来访问标记库的标记。

        2.   创建报表源，设置报表源的属性，把报表源缓存于session变量中（必需的）

            <%
                 final String reportName="rpt/Sample.rpt";
                 ReportClientDocument crDoc = new ReportClientDocument();
                 crDoc.open(reportName,0);
                 crDoc.getDatabaseController().logon("sa","");
                 session.setAttribute("reportSource",crDoc.getReportSource());
           %>

           注意：如果viewer标记的reportSourceVar属性的默认值是crystalReportSource，如果用这个做session变量的名称，那可以不用设置reportSourceVar。

       3.    创建一个开始 viewer 标记。 在此标记中，指定查看器名称和报表源的类型。

             <crviewer:viewer viewerName="CrystalViewer" reportSourceType="pageServer" reportSourceVar="reportSource">

        4.   结束 viewer 标记。 JSP 页面现在即可查看名为 Sample的报表。

            </crviewer:viewer>

炜 2008-03-28 16:49 发表评论
]]>使用eclipse在jsp上显示水晶报表（三）用sql语句过滤数据（转载）http://www.blogjava.net/lcwlv929/articles/189300.html炜炜Fri, 28 Mar 2008 08:48:00 GMThttp://www.blogjava.net/lcwlv929/articles/189300.htmlhttp://www.blogjava.net/lcwlv929/comments/189300.htmlhttp://www.blogjava.net/lcwlv929/articles/189300.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/189300.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/189300.html在.net中,你可以很容易的用sql语句过滤报表数据，但在CR4E中没这样的功能设定，但可以通过编写代码完成。

这里是我做的简单用sql语句过滤数据的例子。

项目还是用ǘ ├锩娴膖omcat项目。

建一个实现这个功能的类

JRC_ResultSet_DataSource.java

package com.JRC.util;
import java.sql.*;
import javax.servlet.http.*;

import com.crystaldecisions.reports.sdk.*;
import com.crystaldecisions.sdk.occa.report.lib.*;

public class JRC_ResultSet_DataSource ...{
    private String      REPORT_NAME="";
    public JRC_ResultSet_DataSource(String report_name)...{
        this.REPORT_NAME=report_name;
     }
    
    /** *//**
      * @return rEPORT_NAME
     */
    public String getREPORT_NAME() ...{
        return REPORT_NAME;
     }

    /** *//**
      * @param report_name 要设置的 rEPORT_NAME
     */
    public void setREPORT_NAME(String report_name) ...{
         REPORT_NAME = report_name;
     }
    

    /** *//**
      *    连接数据库，通过sql查询语句进行查询，返回结果集
     */
    private static ResultSet getResultSetFromQuery(String query, int scrollType)
        throws SQLException, ClassNotFoundException ...{
         Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
        final String DBUSERNAME = "username";
        final String DBPASSWORD = "password";
        final String CONNECTION_URL = "jdbc:microsoft:sqlserver://localhost:1433;database=dname";
        
         java.sql.Connection connection = DriverManager.getConnection(CONNECTION_URL, DBUSERNAME, DBPASSWORD);
         Statement statement = connection.createStatement(scrollType, ResultSet.CONCUR_READ_ONLY);
        
        return statement.executeQuery(query);

     }
    /** *//**
      * 通过sql语句过滤报表数据，在.net就不用怎么惨了
     */
    public boolean isReportSourceInSession(String session_name,HttpSession session) throws ReportSDKException, SQLException, ClassNotFoundException...{
        boolean flag=false;
        try ...{
            //打开水晶报表
             ReportClientDocument reportClientDoc = new ReportClientDocument();
             reportClientDoc.open(REPORT_NAME, 0);
            //sql查询语句,返回的字段数必须跟报表里面的一样，不能多也不能少，并且字段的类型要跟报表的一样，其他不管是什么数据都可以  
            //from 表这里要填完整，如数据库名.dbo.数据库表，最好做个别名
             String query = "select tt.test_1,tt.test_2,tt.test_3,tt.test_4 from dname.dbo.test tt";
            
             ResultSet resultSet = this.getResultSetFromQuery(query,ResultSet.TYPE_SCROLL_INSENSITIVE);
    
             String tableAlias = reportClientDoc.getDatabaseController().getDatabase().getTables().getTable(0).getAlias();
            //把结果集放进报表里，将会自动产生一个datasource
             reportClientDoc.getDatabaseController().setDataSource(resultSet,tableAlias, "resultsetTable");
             session.setAttribute(session_name, reportClientDoc.getReportSource());
             flag=true;
            return flag;
         } catch (Exception e) ...{
            // TODO: handle exception
             e.printStackTrace();
            return flag;
         }        
        
     }
}

这里要注意数据库查询结果集的字段数目要跟报表里面的字段数目一样，类型也要一样，不然就会出错。

sql语句中的表的名字要完整，如数据库名.dbo.数据库表，最好做个别名

显示页面

Result_viewer.jsp

 

<%@page import="com.JRC.util.JRC_ResultSet_DataSource" %>
<%--webreporting.jar  --%>
<%@page import="com.crystaldecisions.report.web.viewer.*" %>
<%--jrcerom.jar --%>
<%@ page import="com.crystaldecisions.reports.sdk.*" %>
<%    
     JRC_ResultSet_DataSource jrcd=new JRC_ResultSet_DataSource("resultSet.rpt");
    if(!jrcd.isReportSourceInSession("reportSource",session)
         response.sendRedirect("error.html");
     CrystalReportViewer crViewer=new CrystalReportViewer();
     crViewer.setOwnPage(true);
     crViewer.setOwnForm(true);
     crViewer.setPrintMode(CrPrintMode.ACTIVEX);
    
     Object reportSource=session.getAttribute("reportSource");
     crViewer.setReportSource(reportSource);
    
     crViewer.processHttpRequest(request,response,this.getServletConfig().getServletContext(),null);
%>

注意上面几点应该就没问题了

PS：Snippets视图最下面有Crystal reports的一些实用代码段

CR查看器标记、打开并查询报表、打开报表、查看报表、查看报表并设置数据库登录、将报表导出为pdf、将报表导出为rtf 等的代码段，简单易用



炜 2008-03-28 16:48 发表评论
]]>使用eclipse在jsp上显示水晶报表（二）后台代码例子（转载）http://www.blogjava.net/lcwlv929/articles/189299.html炜炜Fri, 28 Mar 2008 08:47:00 GMThttp://www.blogjava.net/lcwlv929/articles/189299.htmlhttp://www.blogjava.net/lcwlv929/comments/189299.htmlhttp://www.blogjava.net/lcwlv929/articles/189299.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/189299.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/189299.html在(一)中的配置保持不变,前一篇是用crviewer标签来实现jsp显示水晶报表的

这篇文章教你如何自己写代码来享受水晶报表的

report_source.jsp

<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>

<%//Crystal Java Reporting Component (JRC) imports.%>
<%-- jrcerom.jar--%>
<%@page import="com.crystaldecisions.reports.sdk.*" %>
<%-- rascore.jar--%>
<%@page import="com.crystaldecisions.sdk.occa.report.lib.*" %>

<%
//水晶报表的位置
final String REPORT_NAME = "view_report.rpt";
%>

<%

try ...{    
    //打开报表
     ReportClientDocument reportClientDoc = new ReportClientDocument();
     reportClientDoc.open(REPORT_NAME, 0);

    //把报表源放进session,传递到报表显示页面
     session.setAttribute("reportSource", reportClientDoc.getReportSource());
        
    //转到报表显示页面
     response.sendRedirect("CrystalReportViewer.jsp");
        
}
catch(ReportSDKException ex) ...{    
     out.println(ex);
}
catch(Exception ex) ...{
     out.println(ex);            
}
%>

上面的可以封装到javabean里面

reportClientDoc.getDatabaseController().logon(USERNAME, PASSWORD);

设置数据库的登陆用户,如果浏览这个报表的用户需要设置不同的权限的话,那就需要设置上面这个了

CrystalReportViewer.jsp

<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>

<%//Crystal Report Viewer imports.%>
<%-- webreporting.jar--%>
<%@page import="com.crystaldecisions.report.web.viewer.*"%>
<%-- rascore.jar--%>
<%@page import="com.crystaldecisions.reports.sdk.*" %>

<%
//建立一个viewer对象实例,并设置
CrystalReportViewer viewer = new CrystalReportViewer();
viewer.setOwnPage(true);
viewer.setOwnForm(true);
viewer.setPrintMode(CrPrintMode.ACTIVEX);

//从session中取报表源
Object reportSource = session.getAttribute("reportSource");
viewer.setReportSource(reportSource);

//显示水晶报表
viewer.processHttpRequest(request, response,this. getServletConfig().getServletContext(), null);

%>

第二种方法直接用一个页面

CrystalReportViewer.jsp

<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>

<%//Crystal Java Reporting Component (JRC) imports.%>
<%-- jrcerom.jar--%>
<%@page import="com.crystaldecisions.reports.sdk.*" %>
<%-- rascore.jar--%>
<%@page import="com.crystaldecisions.sdk.occa.report.lib.*" %>
<%-- webreporting.jar--%>
<%@page import="com.crystaldecisions.report.web.viewer.*"%>

<%
//水晶报表的位置
final String REPORT_NAME = "view_report.rpt";
%>

<%
try ......{    
    //打开报表
     ReportClientDocument reportClientDoc = new ReportClientDocument();
     reportClientDoc.open(REPORT_NAME, 0);

    //把报表源放进session,传递到报表显示页面
    //session.setAttribute("reportSource", reportClientDoc.getReportSource());

    //建立一个viewer对象实例,并设置
     CrystalReportViewer viewer = new CrystalReportViewer();
     viewer.setOwnPage(true);
     viewer.setOwnForm(true);
     viewer.setPrintMode(CrPrintMode.ACTIVEX);

    //从session中取报表源
    //Object reportSource = session.getAttribute("reportSource");
    //viewer.setReportSource(reportSource);
     viewer.setReportSource(reportClientDoc.getReportSource());

    //显示水晶报表
      viewer.processHttpRequest(request, response,this. getServletConfig().getServletContext(), null);

        
    //转到报表显示页面
    //response.sendRedirect("CrystalReportViewer.jsp");      
}
catch(ReportSDKException ex) ......{    
     out.println(ex);
}
catch(Exception ex) ......{
     out.println(ex);            
}
%>

个人感觉第一种方法好,报表源跟显示分开,安全,重用方便



炜 2008-03-28 16:47 发表评论
]]>使用eclipse在jsp上显示水晶报表（一）最简单例子（转载）http://www.blogjava.net/lcwlv929/articles/189298.html炜炜Fri, 28 Mar 2008 08:46:00 GMThttp://www.blogjava.net/lcwlv929/articles/189298.htmlhttp://www.blogjava.net/lcwlv929/comments/189298.htmlhttp://www.blogjava.net/lcwlv929/articles/189298.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/189298.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/189298.html我使用的开发IDE是eclipse3.2，服务器是tomcat5.5

新建一个 Crystal reports web项目

在Target runtime选择apache tomcat v5.5

下一步中crystal reports java reporting component、dynamic web module、java是默认选中的，这三个是必需的，你也可添加struts，后面的设置会要求你添加struts的类库。在最后面默认加入示例的数据库和报表。

这样一个Crystal Reports web项目就建立了（上面的步骤应该是地球人都可以完成吧）

在里面有个CrystalReport1.rpt和CrystalReport_viewer.jsp

右键CrystalReport_viewer.jsp－>运行方式->Run on Server,点击完成。

你应该就可以看到一个空的水晶报表了吧（为什么空的，当然啦，CrystalReport1.rpt本身是空的）

在看看sample reports文件夹里面，有4个示例的.rpt报表文件，右击其中任何一个，选中Crystal Reports－》创建查看器JSP，就会创建一个*－viewer.jsp文件。运行这个文件，你应该可以看到一个水晶报表了吧。

我想这对大部分人应该都是没有问题的，剩下的事情就是好好分析这个项目里面所有的东东了

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

上面什么东西是在任何项目中实现都必须的呢?为此我特意建立一个新的tomcat项目,最好建一个简单的jsp页面测试下你的tomcat项目是否可以正常运行.

通过本人的实验,在其他项目中JSP运行水晶报表的话,需要的类文件跟配置.

1. 添加一个用户库如 CrystalReports Libraries,把下面的*.jar添加进去

commons-collections-3.1.jar,commons-configuration-1.2.jar,
commons-lang-2.1.jar,
commons-logging.jar,
Concurrent.jar,
CrystalCharting.jar
CrystalCommon.jar
CrystalContentModels.jar
CrystalDatabaseConnectors.jar
CrystalExporters.jar
CrystalExportingBase.jar
CrystalFormulas.jar
CrystalQueryEngine.jar
CrystalReportEngine.jar
CrystalReportingCommon.jar
derby.jar
icu4j.jar
jrcadapter.jar
jrcerom.jar
keycodeDecoder.jar
log4j.jar
MetafileRenderer.jar
msbase.jar
mssqlserver.jar
msutil.jar
rasapp.jar
rascore.jar
ReportPrinter.jar
rpoifs.jar
serialization.jar
URIUtil.jar
webreporting.jar
webreporting-jsf.jar
xercesImpl.jar
xml-apis.jar
Xtreme.jar

(总共36个jar,里面有一些在其他的库已经有的了,在项目中添加这个自定义库就行了)

 

2. 把上个例子中的crystalreportviewers文件夹放在WEB-INF文件夹同一目录下。这个就是你能看到水晶报表的基本框架，相当于.net里面的水晶报表控件了的源代码了。

3. 把crystal-tags-reportviewer.tld放在WEB-INF下,主要标签

 

4. web.xml 在<web-app>中间添加，主要是读入crystalreportviewers

    <context-param>
    <param-name>crystal_image_uri</param-name>
    <param-value>crystalreportviewers</param-value>
    </context-param>
    <context-param>
        <param-name>crystal_image_use_relative</param-name>
        <param-value>webapp</param-value>
    </context-param>

 

5. 把CRConfig.xml放在src文件夹下,水晶报表的配置文件,如果你有注册,注册码也会在这文件里面

CRConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<CrystalReportEngine-configuration>
    <reportlocation>../..</reportlocation>
    <timeout>0</timeout>
    <ExternalFunctionLibraryClassNames>
     <classname/>
    </ExternalFunctionLibraryClassNames>
</CrystalReportEngine-configuration>
配置超时间隔

利用 CRConfig.xml 文件，您可以配置确定何时丢弃不活动报表源的超时间隔（以分钟为单位）。这是必要的，因为不活动报表源仍然会消耗系统资源（如数据库连接、服务器内存以及临时文件使用的磁盘空间）。可以通过在 CRConfig.xml 文件中设置 timeout 标记的值来指定超时间隔。默认情况下，超时间隔为 10 分钟。通过将该值设置为 0，可以将 Java Reporting Component 配置为没有超时。

超时间隔仅适用于不活动报表 -- 正在处理的报表不会因超出此值而超时。每次成功完成一个报表源请求时，超时定时器将会重置。如果在超时间隔内没有使用某个报表源，则会丢弃该报表源，并将其资源提供给其他进程使用。

6.   在jsp页面插入这段代码

<%@ taglib uri="/crystal-tags-reportviewer.tld" prefix="crviewer" %>
<crviewer:viewer reportSourceType="reportingComponent" viewerName="rcname-viewer" reportSourceVar="rcname" isOwnPage="true">
<crviewer:report reportName="rcname.rpt" />
</crviewer:viewer>

感觉像在用.net里面的水晶报表控件一样,不只viewer,连partviewer也可以的.



炜 2008-03-28 16:46 发表评论
]]>hibernate自动创建表通过castor自动添加数据http://www.blogjava.net/lcwlv929/articles/179199.html炜炜Sun, 03 Feb 2008 08:44:00 GMThttp://www.blogjava.net/lcwlv929/articles/179199.htmlhttp://www.blogjava.net/lcwlv929/comments/179199.htmlhttp://www.blogjava.net/lcwlv929/articles/179199.html#Feedback1http://www.blogjava.net/lcwlv929/comments/commentRss/179199.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/179199.html————————————————————————————————————
hibernate自动创建表
只要在hibernate.cfg.xml文件中加入属性
<property name="hibernate.hbm2ddl.auto">update</property>
并在每个.hbm.xml文件中加入属性
<hibernate-mapping auto-import="true" default-lazy="false">
就可以了。
————————————————————————————————————
通过castor把xml文件转成对应类
注释部分为本地项目，无注释部分为WEB项目使用。
//   File a= new File("D:\\castor/initDataBase.xml");
//   FileInputStream fin = new FileInputStream(a);
//   InputStreamReader bb = new InputStreamReader(fin, "UTF-8");
//   initinfo = (Initinfo) Unmarshaller.unmarshal(Initinfo.class, bb);
InputStream initinfoInputStream = servletConfig.getServletContext()
     .getResourceAsStream("/WEB-INF/initDataBase.xml");
   InputStreamReader initinfoInputStreamReader = new InputStreamReader(
     initinfoInputStream, "UTF-8");
   initinfo = (Initinfo) Unmarshaller.unmarshal(Initinfo.class, initinfoInputStreamReader);
————————————————————————————————————
向表中加入数据
for (int i = 0; i < initinfo.getTcommserial().length; i++) {
    commserial = dao.findByName(
      initinfo.getTcommserial()[i].getSilName());//判断表中是否有此数据
    if (commserial == null) {
     commserial = InitinfoFormat.TcommserialToCommSerial(initinfo.getTcommserial()[i]);//把castor类的数据转成entity数据
     dao.save(commserial);//保存
    }
   }
————————————————————————————————————



炜 2008-02-03 16:44 发表评论
]]>天气预报代码 http://www.blogjava.net/lcwlv929/articles/177414.html炜炜Thu, 24 Jan 2008 01:37:00 GMThttp://www.blogjava.net/lcwlv929/articles/177414.htmlhttp://www.blogjava.net/lcwlv929/comments/177414.htmlhttp://www.blogjava.net/lcwlv929/articles/177414.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/177414.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/177414.html名称：根据IP地址显示当前城市的天气预报代码1
代码：<iframe src="http://www.tianqi123.com/php/current_city.php" width=178 height=248 marginwidth=0 marginheight=0 hspace=0 vspace=0 frameborder=0 scrolling=no align=center id=url></iframe>
效果：
说明：直接调用(原码引用：http://www.tianqi123.com/)

名称：根据IP地址显示当前城市的天气预报代码2
代码：<iframe src="http://www.tianqi123.com/php/current_city.php?c0=F9DC68&c1=white&c2=FEFCE0&t1=red&bg=white&w=178&text=no" width=178 height=248 marginwidth=0 marginheight=0 hspace=0 vspace=0 frameborder=0 scrolling=no align=center id=url></iframe>
效果：
说明：直接调用(原码引用：http://www.tianqi123.com/)

名称：根据IP地址显示当前城市的天气预报代码3
代码：<iframe src="http://www.tianqi123.com/php/current_city.php?c0=red&c1=D96C00&bg=F4FFF4&w=178&h=20&text=yes" width=178 height=21 marginwidth=0 marginheight=0 hspace=0 vspace=0 frameborder=0 scrolling=no align=center id=url></iframe>
效果：
说明：直接调用(原码引用：http://www.tianqi123.com/)

天气代码高级使用方法：
 
如果您会HTML语言，您还可以在iframe代码中的url后面加参数，如：
chengshi_321.html?c0=F9DC68&c1=white&c2=FEFCE0&t1=red&bg=white&w=178&h=250&text=no
 
其中 c0 表示 表格第一行背景颜色，c1，c2表示表格其他行间隔的背景颜色，t1表示 标题颜色，bg 表示页面北京颜色，w表示表格宽度 h 表示表格高度
 
当 text=yes 时，将会出现滚动的天气文字，建议您自己调试看看，如：
chengshi_321.html??c0=red&c1=FF9900&bg=F4FFF4&w=178&h=20&text=yes
 
注意：颜色请不要加 # 符号，如 #FF9900 请写成 FF9900

------------------------------------------------------------------------------------------------------------------
以下代码（原码引用：好多网站上都有)


名称：265天气根据IP自动获得当地的天气情况
代码：<iframe src="http://weather.265.com/weather.htm" width="168" height="54" frameborder="no" border="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
效果：

说明：直接调用
-----------------------------------------------------------------------------------

名称：QQ天气预报代码（一）
代码：<iframe width="145" height="130" border="0" align="center" marginwidth="0" marginheight="0" hspace="0" vspace="0" frameborder="0" scrolling="no" src="http://minisite.qq.com/Weather/news_new.h tml" allowTransparency="true"></iframe>
效果：


说明：这种适合于在网页的边栏插入。但一个缺点是，上面的4个城市是既定的，无法改成别的。插 入时，选好网页上的位置，直接将左栏的源代码全部拷进去就行了

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

名称：QQ天气预报代码（二）
代码：<IFRAME ID='ifm2' WIDTH='189' HEIGHT='190' ALIGN='CENTER' MARGINWIDTH='0' MARGINHEIGHT='0' HSPACE='0' VSPACE='0' FRAMEBORDER='0' SCROLLING='NO' SRC='http://weather.qq.com/inc/ss258.htm'></IFRAME>
效果：


说明：这种也适合于在网页的边栏插入。上面的城市可以自定，比如厦门可改成别的。定制的方法是修改我代码中标红的数字，从1开始代表“香港”开始，每个数字都代表一个城市，厦门是287，具体要哪个城市自己找一下罢。

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

名称：新浪天气预报代码
代码：<IFRAME ID='ifm2' WIDTH='260' HEIGHT='70' ALIGN='CENTER' MARGINWIDTH='0' MARGINHEIGHT='0' HSPACE='0' VSPACE='0' FRAMEBORDER='0' SCROLLING='NO' src="http://news.sina.com.cn/iframe/weather/130101.html"></iframe>
效果：

说明：这种适合于在网页的头栏插入。上面的城市可以自定，比如 石家庄可改成别的。

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

名称：QQ天气预报代码（四）
代码：<iframe width=160 height=230 frameborder=0 scrolling=NO src=http://appnews.qq.com/cgi-bin/news_qq_search?city=南昌></iframe>
效果：


说明：直接调用

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

自己从网页中偷取天气数据
主要用到Pattern类和Matcher类在java.util.regex.包下面。
首先在网页上取得所有数据
HttpURLConnection conn = null;
        String outstr = "";
 try {
            String strUrl = "http://www.wopos.com/MainSet/WeatherSet.aspx?city="+address;
            URL url = new URL(strUrl);
            conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            BufferedReader br = new BufferedReader(new InputStreamReader(conn.
                    getInputStream(), "GBK"));
            String line = "";
            while ((line = br.readLine()) != null) {
                outstr = outstr + line;
            }
            br.close();
        } catch (Exception ex) {
            ex.printStackTrace(System.out);
        } finally {
            if (conn != null) {
                conn.disconnect();
            }
        }
然后分析数据
try{
            Pattern p = Pattern.compile("<span id=\"Label\\d\" style=\"display:inline-block;\"><font size=\"\\d\">[\u4e00-\u9fa5]*\\d*[℃]*[~]*[．]*[-]*\\d*[℃]*[-]*\\d*[．]*\\d*[：]*[\u4e00-\u9fa5]*</font></span>");
            Matcher m = p.matcher(outstr);
            while (m.find()) {
                String s = m.group();
//                System.out.println("s=" + s);
                if(s!=null){
                    hm.put(s.substring(10, 16), s);
                }
            }
        }catch(Exception ex){
            ex.printStackTrace(System.out);
        }
完整的例子为

public class WoWeatherInit {

 Weather weather = new Weather();
 SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");
 String time=df.format(date);
 public void getWeatherInit() {
        //开始分析返回的xml
        HttpURLConnection conn = null;
        String outstr = "";
        String outstrtest = "";
        ObjectInputStream input = null;
        HashMap hm = new HashMap();
        HashMap hm1 = new HashMap();
       
        try {
            String strUrl = "http://www.wopos.com/MainSet/WeatherSet.aspx?city="+address;
            URL url = new URL(strUrl);
            conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            BufferedReader br = new BufferedReader(new InputStreamReader(conn.
                    getInputStream(), "GBK"));
            String line = "";
            while ((line = br.readLine()) != null) {
                outstr = outstr + line;
            }
            br.close();
        } catch (Exception ex) {
            ex.printStackTrace(System.out);
        } finally {
            if (conn != null) {
                conn.disconnect();
            }
        }
        if(outstr == null){
            System.out.println("null");
        }
        try{
            Pattern p = Pattern.compile("<span id=\"Label\\d\" style=\"display:inline-block;\"><font size=\"\\d\">[\u4e00-\u9fa5]*\\d*[℃]*[~]*[．]*[-]*\\d*[℃]*[-]*\\d*[．]*\\d*[：]*[\u4e00-\u9fa5]*</font></span>");
            Matcher m = p.matcher(outstr);
            while (m.find()) {
                String s = m.group();
//                System.out.println("s=" + s);
                if(s!=null){
                    hm.put(s.substring(10, 16), s);
                }
            }
        }catch(Exception ex){
            ex.printStackTrace(System.out);
        }

        String sAddress = getAddress(hm);
        String sDate = getDate(hm);
        String sTianQi = getTianQi(hm);
        String sWenDu = getWenDu(hm);
        String sWind = getWind(hm);
    }

    //获取地址
    public String getAddress(HashMap hm){
     String sValue = "";
        try {
            String sText = (String)hm.get("Label5");
            String sFont = "<font size=\"2\">";
            int iBegin = sText.indexOf(sFont);
            int iEnd = sText.indexOf("</font>");
            sValue = sText.substring(iBegin+sFont.length(), iEnd);
        } catch (Exception ex) {
            ex.printStackTrace(System.out);
            sValue="";
        } finally{
         return sValue;
        }
    }

    //获取天气
    public String getTianQi(HashMap hm){
     String sValue = "";
        try {
            String sText = (String)hm.get("Label1");
            String sFont = "<font size=\"2\">";
            int iBegin = sText.indexOf(sFont);
            int iEnd = sText.indexOf("</font>");
            sValue = sText.substring(iBegin+sFont.length(), iEnd);
        } catch (Exception ex) {
            ex.printStackTrace(System.out);
            sValue="";
        } finally{
         return sValue;
        }
   }

//  获取日期
    public String getDate(HashMap hm){
     String sValue = "";
       try {
           String sText = (String)hm.get("Label7");
           String sFont = "<font size=\"2\">";
           int iBegin = sText.indexOf(sFont);
           int iEnd = sText.indexOf("</font>");
           sValue = sText.substring(iBegin+sFont.length(), iEnd);
       } catch (Exception ex) {
           ex.printStackTrace(System.out);
           sValue="";
       } finally{
        return sValue;
       }
   }
   
   //获取温度
   public String getWenDu(HashMap hm){
    String sValue = "";
       try {
           String sText = (String)hm.get("Label2");
           String sFont = "<font size=\"2\">";
           int iBegin = sText.indexOf(sFont);
           int iEnd = sText.indexOf("</font>");
           sValue = sText.substring(iBegin+sFont.length(), iEnd);
       } catch (Exception ex) {
           ex.printStackTrace(System.out);
           sValue="";
       } finally{
        return sValue;
       }
  }

// 获取风力
   public static String getWind(HashMap hm){
    String sValue = "";
       try {
           String sText = (String)hm.get("Label3");
           String sFont = "<font size=\"2\">";
           int iBegin = sText.indexOf("<font size=\"2\">");
           int iEnd = sText.indexOf("</font>");
           sValue = sText.substring(iBegin+sFont.length(), iEnd);
       } catch (Exception ex) {
           ex.printStackTrace(System.out);
       }
       return sValue;
   }
}




炜 2008-01-24 09:37 发表评论
]]>Eclipse 快捷键http://www.blogjava.net/lcwlv929/articles/176274.html炜炜Fri, 18 Jan 2008 08:43:00 GMThttp://www.blogjava.net/lcwlv929/articles/176274.htmlhttp://www.blogjava.net/lcwlv929/comments/176274.htmlhttp://www.blogjava.net/lcwlv929/articles/176274.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/176274.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/176274.html Ctrl+D: 删除当前行

Ctrl+Alt+↓ 复制当前行到下一行(复制增加)
Ctrl+Alt+↑ 复制当前行到上一行(复制增加)

Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)
Alt+↑ 当前行和上面一行交互位置(同上)
Alt+← 前一个编辑的页面
Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)

Alt+Enter 显示当前选择资源(工程,or 文件 or文件)的属性

Shift+Enter 在当前行的下一行插入空行(这时鼠标可以在当前行的任一位置,不一定是最后)
Shift+Ctrl+Enter 在当前行插入空行(原理同上条)

Ctrl+Q 定位到最后编辑的地方
Ctrl+L 定位在某行 (对于程序超过100的人就有福音了)
Ctrl+M 最大化当前的Edit或View (再按则反之)
Ctrl+/ 注释当前行,再按则取消注释
Ctrl+O 快速显示 OutLine
Ctrl+T 快速显示当前类的继承结构
Ctrl+W 关闭当前Editer
Ctrl+K 参照选中的Word快速定位到下一个
Ctrl+E 快速显示当前Editer的下拉列表(如果当前页面没有显示的用黑体表示)

Ctrl+/(小键盘) 折叠当前类中的所有代码

Ctrl+×(小键盘) 展开当前类中的所有代码

Ctrl+Space 代码助手完成一些代码的插入(但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt+/来代替)

Ctrl+Shift+E 显示管理当前打开的所有的View的管理器(可以选择关闭,激活等操作)

Ctrl+J 正向增量查找(按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显示没有找到了,查一个单词时,特别实用,这个功能Idea两年前就有了)

Ctrl+Shift+J 反向增量查找(和上条相同,只不过是从后往前查)

Ctrl+Shift+F4 关闭所有打开的Editer

Ctrl+Shift+X 把当前选中的文本全部变味小写

Ctrl+Shift+Y 把当前选中的文本全部变为小写

Ctrl+Shift+F 格式化当前代码

Ctrl+Shift+P 定位到对于的匹配符(譬如{}) (从前面定位后面时,光标要在匹配符里面,后面到前面,则反之)

下面的快捷键是重构里面常用的(注:一般重构的快捷键都是Alt+Shift开头的了)

Alt+Shift+R 重命名 (是我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力)

Alt+Shift+M 抽取方法 (这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用)

Alt+Shift+C 修改函数结构(比较实用,有N个函数调用了这个方法,修改一次搞定)

Alt+Shift+L 抽取本地变量( 可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候)

Alt+Shift+F 把Class中的local变量变为field变量 (比较实用的功能)

Alt+Shift+I 合并变量(可能这样说有点不妥Inline)
Alt+Shift+V 移动函数和变量(不怎么常用)
Alt+Shift+Z 重构的后悔药(Undo)





炜 2008-01-18 16:43 发表评论
]]>java 注释http://www.blogjava.net/lcwlv929/articles/175084.html炜炜Mon, 14 Jan 2008 02:01:00 GMThttp://www.blogjava.net/lcwlv929/articles/175084.htmlhttp://www.blogjava.net/lcwlv929/comments/175084.htmlhttp://www.blogjava.net/lcwlv929/articles/175084.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/175084.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/175084.html阅读全文

炜 2008-01-14 10:01 发表评论
]]>通用表单验证函数 http://www.blogjava.net/lcwlv929/articles/166886.html炜炜Tue, 11 Dec 2007 03:31:00 GMThttp://www.blogjava.net/lcwlv929/articles/166886.htmlhttp://www.blogjava.net/lcwlv929/comments/166886.htmlhttp://www.blogjava.net/lcwlv929/articles/166886.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/166886.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/166886.html <script language=javascript>
function check()
{

//alert("IP地址输入非法!");
var pattern=/^(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9])$/;
flag_ip=pattern.test(document.all.ip.value);
if(!flag_ip)
{
alert("IP地址输入非法!");
document.all.ip.focus();
return false;
}
}
</script>
验证是否是地址结束

============================================================================
表单定义:
<form name="form1" action="" style="behavior:url('form.htc')"></form>
客户端表单验证是由表单的onSubmit事件触发，由于表单的onSubmit事件只能由提交按钮触发,
所以如果要用函数提交表单form1.submit(),则必须同时执行form1.onSubmit()。

类型定义:

一、整型(int)
定义:
  valueType="int"
属性:
  objName   对象名称(字符串)
  mustInput 必输项(true/false)
  minInput  最小值(数字)
  maxInput  最大值(数字)
举例:
  <input type="text" name="test" valueType="int" objName="总载重吨" mustInput="true" maxInput="10000">

二、浮点型(float)
定义:
  valueType="float"
属性:
  objName   对象名称(字符串)
  mustInput 必输项(true/false)
  minInput  最小值(数字)
  maxInput  最大值(数字)
  decimalLen小数位数(数字)
举例:
  <input type="text" name="test" valueType="float" objName="运价" mustInput="true" maxInput="10000.50" decimalLen="2">

三、字符串(string)
定义:
  valueType="string"
属性:
  objName   对象名称(字符串)
  mustInput 必输项(true/false)
  stringLen 字符串长度(数字)
举例:
  <input type="text" name="test" valueType="string" objName="英文船名" mustInput="true" stringLen="100">

四、日期(date)
定义:
  valueType="date"
属性:
  objName   对象名称(字符串)
  mustInput 必输项(true/false)
举例:
  <input type="text" name="test" valueType="date" objName="开始日期" mustInput="true">
备注:
  日期现在只能校验的格式为(yyyy-mm-dd)

五、邮箱(email)
定义:
  valueType="email"
属性:
  objName   对象名称(字符串)
  mustInput 必输项(true/false)
举例:
  <input type="text" name="test" valueType="email" objName="邮箱" mustInput="true">

六、单选(radio)
定义:
  valueType="radio"
属性:
  objName   对象名称(字符串)
  mustSelect 必输项(true/false)
举例:
  <input type="radio" name="test" valueType="radio" objName="租船方式" mustSelect="true">
备注:
  对于同一组单选按钮，只需要定义第一个即可。

七、复选(checkbox)
定义:
  valueType="checkbox"
属性:
  objName   对象名称(字符串)
  minSelect 最小选择数(数字)
  maxSelect 最大选择数(数字)
举例:
  <input type="checkbox" name="test" valueType="checkbox" objName="爱好" minSelect="2" maxSelect="5">
备注:
  对于同一组复选按钮，只需要定义第一个即可。

八、下拉列表框(select)
定义:
  valueType="select"
属性:
  objName   对象名称(字符串)
  mustSelect 必输项(true/false)
举例:
  <select name="test" valueType="select" objName="租船方式" mustSelect="true">

九、列表框(list)
定义:
  valueType="list"
属性:
  objName   对象名称(字符串)
  minSelect 最小选择数(数字)
  maxSelect 最大选择数(数字)
举例:
  <select name="test" valueType="list" objName="爱好" minSelect="2" maxSelect="5">


/////////////////////////////////////////////////////////////////////////////////////////////////////////

<!-- ---------------------------------------------------------------------
//
//  File:  form.htc
//  version:    1.0
//  Description:客户端表单验证.
//  author:     伍子
//
//-------------------------------------------------------------------- -->
<PUBLIC:COMPONENT id="formCheck" urn="wwb:formCheck">
<PUBLIC:ATTACH EVENT="onsubmit" ONEVENT="checkForm()"/>
<script language="JavaScript">
function checkForm()
{
    var oForm=event.srcElement;
var eles = oForm.elements;
    //遍历所有表元素
for(var i=0;i<eles.length;i++)
    {
        //是否需要验证
        var sType=eles[i].valueType;
  if(sType)
        {
   if(eles[i].mustInput!=null && eles[i].mustInput)
   {
    if(trim(eles[i].value)=="")
    {
     if(eles[i].objName!=null)
     {
      alert(eles[i].objName+"不可以为空");
     }
     else
     {
      alert("该文本框为必输字段");
     }
     eles[i].focus();    
     event.returnValue=false;    
     return false;  
    }
   }  
   switch(sType)
   {
                //整数
    case "int":
     if(!checkInt(eles[i]))
     {
      event.returnValue=false;
      return false;
     }
     break;
    //小数
    case "float":
     if(!checkFloat(eles[i]))
     {
      event.returnValue=false;
      return false;
     }
     break;
    //字符串
    case "string":
     if(!checkString(eles[i]))
     {
      event.returnValue=false;
      return false;
     }
     break;
    //日期
    case "date":
     if(!checkDate(eles[i]))
     {
      event.returnValue=false;
      return false;
     }
     break;
    //邮件
    case "email":
     if(!checkEmail(eles[i]))
     {
      event.returnValue=false;
      return false;
     }
     break;
    //单选按钮
    case "radio":
     if(!checkRadio(eles[i]))
     {
      event.returnValue=false;
      return false;
     }
     break;
    //复选按钮
    case "checkbox":
     if(!checkBox(eles[i]))
     {
      event.returnValue=false;
      return false;
     }
     break;
    //下拉列表框
    case "select":
     if(!checkSelect(eles[i]))
     {
      event.returnValue=false;
      return false;
     }
     break;
    //列表框
    case "list":
     if(!checkList(eles[i]))
     {
      event.returnValue=false;
      return false;
     }
     break;
            }
        }
    }
event.returnValue=true;
return true;
}

/***检查是否为整数***/
function checkInt(ele)
{
if(!isInt(ele.value))
{
  alert("请输入有效整数");
  ele.focus();
  return false;
}
else
{
  if(ele.maxInput!=null && !isNaN(ele.maxInput))
   if(parseInt(ele.maxInput)<parseInt(ele.value))
   {
    alert("您输入的"+ convertNullToSpace(ele.objName)+"值应该小于"+ele.maxInput);        
    ele.focus();
    return false;
   }      
  if(ele.minInput!=null && !isNaN(ele.minInput))
   if(parseInt(ele.minInput)>parseInt(ele.value))
   {
    alert("您输入的"+ convertNullToSpace(ele.objName)+"值应该大于"+ele.minInput);
    ele.focus();
    return false;
   }  
}
return true;
}

/***检查是否为小数***/
function checkFloat(ele)
{
    if(isNaN(ele.value))
    {
  alert("请输入有效数字");
  ele.focus();
  return false;
    }
else
{
        if(ele.decimalLen!=null && !checkDecimal(ele.value,ele.decimalLen))
     {
   alert("您输入的"+convertNullToSpace(ele.objName)+"值小数位最多为"+ele.decimalLen);
   ele.focus();    
   return false;
        }
  if(ele.maxInput!=null && !isNaN(ele.maxInput))
   if(parseInt(ele.maxInput)<parseInt(ele.value))
   {
    alert("您输入的"+ convertNullToSpace(ele.objName)+"值应该小于"+ele.maxInput);          
    ele.focus();
    return false;
   }      
  if(ele.minInput!=null && !isNaN(ele.minInput))
   if(parseInt(ele.minInput)>parseInt(ele.value))
   {
    alert("您输入的"+ convertNullToSpace(ele.objName)+"值应该大于"+ele.minInput);
    ele.focus();
    return false;
   }  
}
return true;
}

/***检查是否为字符串***/
function checkString(ele)
{
if(ele.stringLen!=null && !isNaN(ele.stringLen))
{
  var value=new String(ele.value);
  if(value.length>parseInt(ele.stringLen))
  {
   alert("您输入的"+convertNullToSpace(ele.objName)+"最大长度为"+ele.stringLen);
   ele.focus();    
   return false;
  }
}
return true;
}
/***检查是否为日期格式***/
function checkDate(ele)
{
if(!isDate(ele.value))
{
  alert("请输入有效日期(yyyy-mm-dd)");
  ele.focus();
  return false;
    }
return true;
}

/***检查是否为电子邮箱***/
function checkEmail(ele)
{
if(!isEmail(ele.value))
{
  alert("请输入有效邮箱");
  ele.focus();
  return false;
    }
return true;
}
/***检查单选按钮是否需要选择***/
function checkRadio(ele)
{
//var rads = document.getElementsByName(ele.name);
    eval("var rads="+name+"."+ele.name);
var selectCount=0;
for(var i=0;i<rads.length;i++)
    {
  if(rads[i].checked)
        {
   selectCount++;
        }
    }

if(ele.mustSelect!=null && ele.mustSelect)
{
  if(selectCount==0)
  {
   alert("请选择"+convertNullToSpace(ele.objName));
   ele.focus();    
   return false;
  }
}
return true;
}
/***检查复选按钮是否需要选择***/
function checkBox(ele)
{
//var rads = document.getElementsByName(ele.name);
    eval("var chks="+name+"."+ele.name);
var selectCount=0;
for(var i=0;i<chks.length;i++)
    {
  if(chks[i].checked)
        {
   selectCount++;
        }
    }
if(ele.minSelect!=null && !isNaN(ele.minSelect))
{
  if(selectCount<parseInt(ele.minSelect))
  {
   alert(convertNullToSpace(ele.objName)+"至少选择"+ele.minSelect+"项");
   ele.focus();    
   return false;
  }
}
if(ele.maxSelect!=null && !isNaN(ele.maxSelect))
{
  if(selectCount>parseInt(ele.maxSelect))
  {
   alert(convertNullToSpace(ele.objName)+"至多选择"+ele.maxSelect+"项");
   ele.focus();    
   return false;
  }
}
return true;
}
/***检查下拉列表框是否需要选择***/
function checkSelect(ele)
{
//var rads = document.getElementsByName(ele.name);
if(ele.mustSelect!=null && ele.mustSelect)
{
  if(ele.selectedIndex==0)
  {
   alert("请选择"+convertNullToSpace(ele.objName));
   ele.focus();    
   return false;
  }
}
return true;
}
/***检查列表框的选择项数***/
function checkList(ele)
{
//var rads = document.getElementsByName(ele.name);
    var selectCount=0;
for(var i=0;i<ele.options.length;i++)
    {
        if(ele.options[i].selected)
        {
            selectCount++;
        }
    }
alert(selectCount);
if(ele.minSelect!=null && !isNaN(ele.minSelect))
{
  if(selectCount<parseInt(ele.minSelect))
  {
   alert(convertNullToSpace(ele.objName)+"至少选择"+ele.minSelect+"项");
   ele.focus();    
   return false;
  }
}
if(ele.maxSelect!=null && !isNaN(ele.maxSelect))
{
  if(selectCount>parseInt(ele.maxSelect))
  {
   alert(convertNullToSpace(ele.objName)+"至多选择"+ele.maxSelect+"项");
   ele.focus();    
   return false;
  }
}
return true;
}
/***判断是否为整数***/
function isInt(s)
{
var patrn=/^[-,+]{0,1}[0-9]{0,}$/;
if (!patrn.exec(s))
   return false;
return true;
}
/***判断是否为数字***/
function isNumber(s)
{
var patrn=/^[-,+]{0,1}[0-9]{0,}[.]{0,1}[0-9]{0,}$/;
if (!patrn.exec(s))
   return false;
return true;
}
/***判断是否为日期***/
function isDate(str)
{
var r = str.match(/^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2})$/);
if(r==null)
{
  return false;
}
var d= new Date(r[1], r[3]-1, r[4]);
if(!(d.getFullYear()==r[1]&&(d.getMonth()+1)==r[3]&&d.getDate()==r[4]))
{  
  return false;
}
return true;
}
/***判断是否为邮箱***/
function isEmail(str)
{
if(str.match(/[\w-]+@{1}[\w-]+\.{1}\w{2,4}(\.{0,1}\w{2}){0,1}/ig)!=str)
  return false;
else
  return true;
}
/***将NULL转化为空格，用于显示对象名称***/
function convertNullToSpace(paramValue)
{
  if(paramValue==null)
    return "";
  else
    return paramValue;
}
/***检查小数位数***/
function checkDecimal(num,decimalLen)
{
  var len = decimalLen*1+1;
  if(num.indexOf('.')>0)
  {
    num=num.substr(num.indexOf('.')+1,num.length-1);  
    if ((num.length)<len)
{
      return true;
    }
else
{
      return false;
    }
  }
  return true;
}
/***去除空格***/
function trim(str)
{
if (str.length > 0)
{
  while ((str.substring(0,1) == " ") && (str.length > 0))
  {
   str = str.substring(1,str.length);
  }
  while (str.substring(str.length-1,str.length) == " ")
  {
   str = str.substring(0,str.length-1);
  }
}
return str;
}
</script>
</PUBLIC:COMPONENT>


炜 2007-12-11 11:31 发表评论
]]>Html嵌入Applethttp://www.blogjava.net/lcwlv929/articles/162015.html炜炜Wed, 21 Nov 2007 02:09:00 GMThttp://www.blogjava.net/lcwlv929/articles/162015.htmlhttp://www.blogjava.net/lcwlv929/comments/162015.htmlhttp://www.blogjava.net/lcwlv929/articles/162015.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/162015.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/162015.html标签的属性介绍
属性    含义
Width    Applet在Html页面上的宽度
Height    Applet在Html页面上的高度
Name    Applet在Html页面上的名称,用于区名一个Html页面上的多个Applet
Code    Applet类名，必须带后缀”class”当没有属性archive时，直接写类名当有属性archive时，必须带包名
Codebase    Applet的类相对路径，相对于Html页面位置
Archive    Applet所在Jar包的文件名
标签< PARAM>的属性介绍
属性    含义
Name    Applet传入的参数名
Value    Applet传入的参数值
当Applet 为一个Class类文件嵌入的写法
属性Code   ==========Applet类名,必须带后缀名
属性CodeBase   ---------------Class类文件相对于Html页面的相对路径
Applet为一个JAR包，嵌入Html的写法
属性Code     ==========Applet类名，包括包名
属性CodeBase    ----------------Applet JAR包相对于Html页面的相对路径
属性Archive -----------------------Applet Jar包文件名



炜 2007-11-21 10:09 发表评论
]]>JBoss 的一些配置(端口,虚拟目录,虚拟主机,中文问题,数据库连接) http://www.blogjava.net/lcwlv929/articles/151363.html炜炜Tue, 09 Oct 2007 05:18:00 GMThttp://www.blogjava.net/lcwlv929/articles/151363.htmlhttp://www.blogjava.net/lcwlv929/comments/151363.htmlhttp://www.blogjava.net/lcwlv929/articles/151363.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/151363.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/151363.html

1、访问端口配置
编辑%jboss-4.0.2%\server\default\deploy\jbossweb-tomcat55.sar\server.xml
将8080改为你希望访问的端口（8888）
    <!-- A HTTP/1.1 Connector on port 8080 -->
      <Connector port="8888" address="${jboss.bind.address}"
         maxThreads="250" strategy="ms" maxHttpHeaderSize="8192"
         emptySessionPath="true"
         enableLookups="false" redirectPort="8443" acceptCount="100"
         connectionTimeout="20000" disableUploadTimeout="true" URIEncoding="UTF-8"/>

2、虚拟目录配置：
编辑%jboss-4.0.2%\server\default\deploy\jbossweb-tomcat55.sar\server.xml
在</Host>之前增加：
 <Context path="/test" docBase="F:\\test" debug="1" reloadable="true" override="true" crossContext="true"/>
 其中path 为虚拟目录名，docBase为硬盘路径（可为绝对路径）reloadable为类变更时是否重新加载

3、解决附件汉字问题：
a.编辑
%jboss-4.0.2%\server\default\deploy\jbossweb-tomcat55.sar\server.xml
在Connector 属性最后增加：URIEncoding="UTF-8"
 <!-- A HTTP/1.1 Connector on port 8080 -->
  <Connector port="8888" address="$"
     maxThreads="250" strategy="ms" maxHttpHeaderSize="8192"
     emptySessionPath="true"
     enableLookups="false" redirectPort="8443" acceptCount="100"
     connectionTimeout="20000" disableUploadTimeout="true" URIEncoding="UTF-8"/>
b.页面处理
将生成的附件名称进行编码转换：
<%
String n2="Redhat9中文官方文档.rar";
n2=java.net.URLEncoder.encode(n2,"UTF-8");
%>
<a href="Redhat9">http://192.168.1.112:8080/zlsf/<%=n2%>">Redhat9中文官方文档</a>

4、解决汉字问题。
在：项目/WEB-INFweb.xml中增加：
 <filter>
 <filter-name>Set Character Encoding</filter-name>
 <filter-class>filters.SetCharacterEncodingFilter</filter-class>
 <init-param>
 <param-name>encoding</param-name>
 <param-value>GBK</param-value>
 </init-param>
 </filter>
 <filter-mapping>
 <filter-name>Set Character Encoding</filter-name>
 <url-pattern>/*</url-pattern>
 </filter-mapping>
 其中
<param-value>GBK</param-value> 这里要设置GBK，而不是UTF8。为了解决标单提交后的中文问题。
filters.SetCharacterEncodingFilter  类文件在TOMCAT lib 目录下filters.jar文件中。
你只需要把filters.jar放入你应用目录下的LIB中即可。

5、虚拟主机配置
a.编辑
%jboss-4.0.2%\server\default\deploy\jbossweb-tomcat55.sar\server.xml
在 </Engine>之前添加：
<Host name="www.ytiic.com">
<Alias>www2.ytiic.com</Alias>--〉别名，通过这个名字可以访问www.ytiic.com下的应用。
<Alias>ytiic.com</Alias>--〉同上
<!-- Default context parameters -->
<DefaultContext cookies="true" crossContext="true" override="true"/>
</Host>
b.在这个目录下：%jboss-4.0.2%\server\default\deploy
创建一个目录：test.war(你的虚拟目录加.war)之后在其下创建WEB-INF目录
在WEB-INF下创建：jboss-web.xml 文件,内容如下：
<jboss-web>
<context-root>/</context-root>
<virtual-host>www.ytiic.com</virtual-host>
</jboss-web>
虚拟主机配置完成！
当jboss启动后，会自动对应2个配置文件中的虚拟主机名。

6、数据库配置：
去这个 %jboss-4.0.2%\docs\examples\jca 目录找一个你想用的数据库文件：
拷贝到%jboss-4.0.2%\server\default\deploy 下，打开编辑。
在%jboss-4.0.2%\server\default\deploy目录下自己建了一个文件：
test这个名字自己定义，后面需要保留。
test-ds.xml
内容如下：
< xml version="1.0" encoding="UTF-8" >
<!-- ===================================================================== -->
<!--                                                                       -->
<!--  JBoss Server Configuration                                           -->
<!--                                                                       -->
<!-- ===================================================================== -->
<!-- $Id: mssql-ds.xml,v 1.3 2004/09/15 14:37:40 loubyansky Exp $ -->
  <!-- ======================================================================-->
  <!-- New ConnectionManager setup for Microsoft SQL Server 2000  driver     -->
  <!-- You may download the latest Microsoft JDBC driver from *Microsoft*    -->
  <!-- http://msdn.microsoft.com/downloads/default.asp url=/downloads/sample.asp url=/MSDN-
FILES/027/001/779/msdncompositedoc.xml&frame=true -->
  <!-- ===================================================================== -->
<datasources>
  <local-tx-datasource>
    <jndi-name>test</jndi-name>
    <connection-url>jdbc:mysql://192.168.1.1/test</connection-url>
    <driver-class>org.gjt.mm.mysql.Driver</driver-class>
    <user-name>root</user-name>
    <password>password</password>
        <!-- sql to call when connection is created
        <new-connection-sql>some arbitrary sql</new-connection-sql>
        -->
      <!-- The minimum connections in a pool/sub-pool. Pools are lazily constructed on first use -->
      <min-pool-size>5</min-pool-size>
      <!-- The maximum connections in a pool/sub-pool -->
      <max-pool-size>20</max-pool-size>
        <!-- sql to call on an existing pooled connection when it is obtained from pool
        <check-valid-connection-sql>some arbitrary sql</check-valid-connection-sql>
        -->
      <!-- The time before an unused connection is destroyed -->
      <!-- NOTE: This is the check period. It will be destroyed somewhere between 1x and 2x this timeout after last use-->
      <!-- TEMPORARY FIX! - Disable idle connection removal, HSQLDB has a problem with not reaping threads on closed connections -->
      <idle-timeout-minutes>1</idle-timeout-minutes>
      <!-- corresponding type-mapping in the standardjbosscmp-jdbc.xml (optional) -->
      <metadata>
         <type-mapping>mysql</type-mapping>
      </metadata>
  </local-tx-datasource>
</datasources>

数据库配置完成。
连接数据源名为：java:/test

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
所有配置完成！！

注意问题：
(1)、你的应用下的LIB库不要和%jboss-4.0.2%\server\default\lib 下的类库相冲突。
(2)、数据库配置参考：%jboss-4.0.2%\docs\examples\jca  下的文件

7、禁止文件目录列表
编辑%jboss-4.0.2%\server\default\deploy\jbossweb-tomcat55.sar\conf\web.xml
把listing设置为false 

    <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>



炜 2007-10-09 13:18 发表评论
]]> Eclipse反编译插件: Jodeclipse与JadClipsehttp://www.blogjava.net/lcwlv929/articles/148795.html炜炜Thu, 27 Sep 2007 09:31:00 GMThttp://www.blogjava.net/lcwlv929/articles/148795.htmlhttp://www.blogjava.net/lcwlv929/comments/148795.htmlhttp://www.blogjava.net/lcwlv929/articles/148795.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/148795.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/148795.htmlJodeclipse 是Jode的Eclipse插件，JadClipse是Jad的Eclipse插件，它们都是非常好的反编译插件。
Jode Eclipse Plugin 1.0.5 for Eclipse version 3.1 / 3.2
安装方法
（1）从如下地址下载：
http://sourceforge.net/projects/jodeeclipse
把下载下来的文件jodeplugin_1.0.5.zip直接解压到eclipse的plugins目录下。
（2） 启动eclipse，help -> Software Updates-> Find and Install... -> Search for new features to install,单击"New Remote Site..." 在URL栏输入 http://www.technoetic.com/eclipse/update然 后下一步，就可以看到“jode decompiler plugin *.*”，选上安装就可以了。安装好后可以看到Window -> Preferences...-> Java -> Jode Decompiler选项卡，okay，安装成功了。

配置： Window-> Preferences... -> General -> Editors -> File Associations找到"*.class"在"Associated editors"里面可以看到"Jode class file viewer"选中它再单击Default按钮.

JadClipse Eclipse Plugin for Eclipse version 3.1 / 3.2/3.3
一、下载：
下载插件：
下载jadclipse_3.1.0.jar版本，该版本支持eclipse3.1M6～3.2M2
下载jadclipse_3.2.0.jar版本，该版本支持eclipse3.2M3和eclipse3.2M4.
下载jadclipse_3.2.4.jar版本，该版本支持eclipse3.2M5～3.3M5
下载jadclipse_3.3.0.jar版本，该版本支持eclipse3.3M6以上版本
下载Jad反编译工具：
http://www.kpdus.com/jad.html#download，在该页中找到适合自己操作系统平台的jad下载。下载后解压，然后将解压后的jad.exe文件复制到%JAVA_HOME%\bin目录下面（可以将jad.exe放到任意位置，只要记住其存放路径就好，下面要用到）。
二、安装：
Eclipse中的插件安装可以参考：Eclipse使用技巧(三)Eclipse中插件的安装
    方法1、直接将jadclipse_x.x.x.jar（x.x.x.代表版本号）复制到%ECLIPSE_HOME%\plugins目录下。
方 法2、使用link方式安装，建立D：\Myplugins\jadclipse3.2.4\eclipse\plugins的目录结构，将 jadclipse_3.2.4.jar放到plugins目录下面（注：其中D：\Myplugins为你自己定义的一个专门放置插件的目录）。再在% ECLIPSE_HOME%\links目录下面建立一个jadclipse3.2.4.link文件（该文件名随便取）。文件里面内容为：path= D：/Myplugins/jadclipse3.2.4.

三、使用：
启动eclipse，点击反编译的类文件，此时会激活jadclipse插件，在eclipse菜单中会多出一个jadclipse菜单，如下图所示：

一般地它会自动反编译相应的class文件，如果没有自动反编译，请点击jadclipse->Decompile
如下图所示：


常见问题及解决：
（一）启动eclipse，打开Window->; Preferences->Java->JadClipse，如果没有找到JadClipse，即JadClipse插件没有激活。
（1）检查插件安装的版本是否与你安装的eclipse版本对应
（2）使用 –clean参数来启动eclipse
（二）在使用JadClipse插件反编译class文件时出现如下类似错误：
/*jadclipse*/
/*
DECOMPILATION REPORT
Decompiled from: E:\Java\jre1.5.0_12\lib\ext\j3dutils.jar
Total time: 63 ms
Jad reported messages/errors:
Exit status: 0
Caught exceptions:
java.io.IOException: CreateProcess: E:\Java\jdk1.5.0_12 -p -t4 -lradix10 -radix10 KeyNavigator.class error=5
at java.lang.ProcessImpl.create(Native Method)
at java.lang.ProcessImpl.<init>(Unknown Source)
at java.lang.ProcessImpl.start(Unknown Source)
at java.lang.ProcessBuilder.start(Unknown Source)
at java.lang.Runtime.exec(Unknown Source)
at net.sf.jadclipse.JadDecompiler.decompile(JadDecompiler.java:160)
at net.sf.jadclipse.JadDecompiler.decompileFromArchive(JadDecompiler.java:217)
at net.sf.jadclipse.JadclipseSourceMapper.findSource(JadclipseSourceMapper.java:150)
at net.sf.jadclipse.JadclipseSourceMapper.findSource(JadclipseSourceMapper.java:83)
at net.sf.jadclipse.JadclipseClassFileEditor.doOpenBuffer(JadclipseClassFileEditor.java:87)
at net.sf.jadclipse.JadclipseClassFileEditor.doSetInput(JadclipseClassFileEditor.java:45)
at net.sf.jadclipse.JadclipseActionBarContributor.setActiveEditor(JadclipseActionBarContributor.java:87)
at org.eclipse.ui.internal.EditorActionBars.partChanged(EditorActionBars.java:335)
at org.eclipse.ui.internal.WorkbenchPage$3.run(WorkbenchPage.java:606)
at org.eclipse.core.runtime.SafeRunner.run(SafeRunner.java:37)
at org.eclipse.core.runtime.Platform.run(Platform.java:843)
at org.eclipse.ui.internal.WorkbenchPage.activatePart(WorkbenchPage.java:595)
at org.eclipse.ui.internal.WorkbenchPage.setActivePart(WorkbenchPage.java:3203)
at org.eclipse.ui.internal.WorkbenchPage.activate(WorkbenchPage.java:588)
at org.eclipse.ui.internal.WorkbenchPage.busyOpenEditorBatched(WorkbenchPage.java:2604)
at org.eclipse.ui.internal.WorkbenchPage.busyOpenEditor(WorkbenchPage.java:2528)
at org.eclipse.ui.internal.WorkbenchPage.access$10(WorkbenchPage.java:2520)
at org.eclipse.ui.internal.WorkbenchPage$9.run(WorkbenchPage.java:2505)
at org.eclipse.swt.custom.BusyIndicator.showWhile(BusyIndicator.java:67)
at org.eclipse.ui.internal.WorkbenchPage.openEditor(WorkbenchPage.java:2500)
at org.eclipse.ui.internal.WorkbenchPage.openEditor(WorkbenchPage.java:2485)
at org.eclipse.jdt.internal.ui.javaeditor.EditorUtility.openInEditor(EditorUtility.java:287)
at org.eclipse.jdt.internal.ui.javaeditor.EditorUtility.openInEditor(EditorUtility.java:164)
at org.eclipse.jdt.internal.ui.actions.OpenActionUtil.open(OpenActionUtil.java:49)
at org.eclipse.jdt.ui.actions.OpenAction.run(OpenAction.java:190)
at org.eclipse.jdt.ui.actions.OpenAction.run(OpenAction.java:174)
at org.eclipse.jdt.ui.actions.SelectionDispatchAction.dispatchRun(SelectionDispatchAction.java:267)
at org.eclipse.jdt.ui.actions.SelectionDispatchAction.run(SelectionDispatchAction.java:243)
at org.eclipse.jdt.internal.ui.packageview.PackageExplorerActionGroup.handleOpen(PackageExplorerActionGroup.java:306)
at org.eclipse.jdt.internal.ui.packageview.PackageExplorerPart$4.open(PackageExplorerPart.java:653)
at org.eclipse.jface.viewers.StructuredViewer$2.run(StructuredViewer.java:817)
at org.eclipse.core.runtime.SafeRunner.run(SafeRunner.java:37)
at org.eclipse.core.runtime.Platform.run(Platform.java:843)
at org.eclipse.ui.internal.JFaceUtil$1.run(JFaceUtil.java:44)
at org.eclipse.jface.util.SafeRunnable.run(SafeRunnable.java:149)
at org.eclipse.jface.viewers.StructuredViewer.fireOpen(StructuredViewer.java:815)
at org.eclipse.jface.viewers.StructuredViewer.handleOpen(StructuredViewer.java:1069)
at org.eclipse.jface.viewers.StructuredViewer$6.handleOpen(StructuredViewer.java:1168)
at org.eclipse.jface.util.OpenStrategy.fireOpenEvent(OpenStrategy.java:249)
at org.eclipse.jface.util.OpenStrategy.access$2(OpenStrategy.java:243)
at org.eclipse.jface.util.OpenStrategy$1.handleEvent(OpenStrategy.java:283)
at org.eclipse.swt.widgets.EventTable.sendEvent(EventTable.java:66)
at org.eclipse.swt.widgets.Widget.sendEvent(Widget.java:928)
at org.eclipse.swt.widgets.Display.runDeferredEvents(Display.java:3348)
at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java:2968)
at org.eclipse.ui.internal.Workbench.runEventLoop(Workbench.java:1930)
at org.eclipse.ui.internal.Workbench.runUI(Workbench.java:1894)
at org.eclipse.ui.internal.Workbench.createAndRunWorkbench(Workbench.java:422)
at org.eclipse.ui.PlatformUI.createAndRunWorkbench(PlatformUI.java:149)
at org.eclipse.ui.internal.ide.IDEApplication.run(IDEApplication.java:95)
at org.eclipse.core.internal.runtime.PlatformActivator$1.run(PlatformActivator.java:78)
at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.runApplication(EclipseAppLauncher.java:92)
at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.start(EclipseAppLauncher.java:68)
at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:400)
at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:177)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at org.eclipse.core.launcher.Main.invokeFramework(Main.java:336)
at org.eclipse.core.launcher.Main.basicRun(Main.java:280)
at org.eclipse.core.launcher.Main.run(Main.java:977)
at org.eclipse.core.launcher.Main.main(Main.java:952)

*/

请确保你的Jad路径在eclipse中正确制定。
    启动eclipse，打开：Window->; Preferences->Java->JadClipse.
1、Path to decompiler，这里设置反编译工具jad的全路径名，比如：%JAVA_HOME%\bin\jad.exe.
2、Directory for temporary files，这里设置临时文件路径。
至于Window->; Preferences->Java->JadClipse目录下的Debug，Directives，Formatting，Misc目录中的参数设置，就不再罗嗦了。
（三）安装完成后，eclipse没有自动将JadClipse Class File Viewer设置成class文件的缺省打开方式。
如 果没有默认，可以在Eclipse的Windows—> Perference—>General->Editors->File Associations中修改“*.class”默认关联的编辑器为“JadClipse Class File Viewer”。设置完成后，双击*.class文件，eclipse将自动反编译。

炜 2007-09-27 17:31 发表评论
]]>Java中ThreadLocal的设计与使用http://www.blogjava.net/lcwlv929/articles/146687.html炜炜Thu, 20 Sep 2007 01:57:00 GMThttp://www.blogjava.net/lcwlv929/articles/146687.htmlhttp://www.blogjava.net/lcwlv929/comments/146687.htmlhttp://www.blogjava.net/lcwlv929/articles/146687.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/146687.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/146687.html
　　 ThreadLocal是什么

　　 ThreadLocal是什么呢？其实ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是thread local variable（线程局部变量）。也许把它命名为ThreadLocalVar更加合适。线程局部变量（ThreadLocal）其实的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。线程局部变量并不是Java的新发明，在其它的一些语言编译器实现（如IBM XL FORTRAN）中，它在语言的层次提供了直接的支持。因为Java中没有提供在语言层次的直接支持，而是提供了一个ThreadLocal的类来提供支持，所以，在Java中编写线程局部变量的代码相对比较笨拙，这也许是线程局部变量没有在Java中得到很好的普及的一个原因吧。

　　 ThreadLocal的设计

　　 首先看看ThreadLocal的接口：

　　 　Object get() ; // 返回当前线程的线程局部变量副本 protected Object initialValue(); // 返回该线程局部变量的当前线程的初始值
　　　 void set(Object value); // 设置当前线程的线程局部变量副本的值

　　 ThreadLocal有3个方法，其中值得注意的是initialValue()，该方法是一个protected的方法，显然是为了子类重写而特意实现的。该方法返回当前线程在该线程局部变量的初始值，这个方法是一个延迟调用方法，在一个线程第1次调用get()或者set(Object)时才执行，并且仅执行1次。ThreadLocal中的确实实现直接返回一个null：

protected Object initialValue() { return null; }

　　ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。比如下面的示例实现：

public class ThreadLocal
{
　 private Map values = Collections.synchronizedMap(new HashMap());
　 public Object get()
　 {
　　 Thread curThread = Thread.currentThread();
　　 Object o = values.get(curThread);
　　 if (o == null && !values.containsKey(curThread))
　　 {
　　　 o = initialValue();
　　　 values.put(curThread, o);
　　 }
　　 return o;
　 }

　 public void set(Object newValue)
　 {
　　 values.put(Thread.currentThread(), newValue);
　 }

　 public Object initialValue()
　 {
　　 return null;
　 }
}

　　当然，这并不是一个工业强度的实现，但JDK中的ThreadLocal的实现总体思路也类似于此。

　　 ThreadLocal的使用

　　 如果希望线程局部变量初始化其它值，那么需要自己实现ThreadLocal的子类并重写该方法，通常使用一个内部匿名类对ThreadLocal进行子类化，比如下面的例子，SerialNum类为每一个类分配一个序号：

public class SerialNum
{
　 // The next serial number to be assigned

　 private static int nextSerialNum = 0;
　 private static ThreadLocal serialNum = new ThreadLocal()
　 {
　　 protected synchronized Object initialValue()
　　 {
　　　 return new Integer(nextSerialNum++);
　　 }
　 };

　 public static int get()
　 {
　　 return ((Integer) (serialNum.get())).intValue();
　 }
}

　　SerialNum类的使用将非常地简单，因为get()方法是static的，所以在需要获取当前线程的序号时，简单地调用：

int serial = SerialNum.get();

　　即可。

　　 在线程是活动的并且ThreadLocal对象是可访问的时，该线程就持有一个到该线程局部变量副本的隐含引用，当该线程运行结束后，该线程拥有的所以线程局部变量的副本都将失效，并等待垃圾收集器收集。

　　 ThreadLocal与其它同步机制的比较

　　 ThreadLocal和其它同步机制相比有什么优势呢？ThreadLocal和其它所有的同步机制都是为了解决多线程中的对同一变量的访问冲突，在普通的同步机制中，是通过对象加锁来实现多个线程对同一变量的安全访问的。这时该变量是多个线程共享的，使用这种同步机制需要很细致地分析在什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放该对象的锁等等很多。所有这些都是因为多个线程共享了资源造成的。ThreadLocal就从另一个角度来解决多线程的并发访问，ThreadLocal会为每一个线程维护一个和该线程绑定的变量的副本，从而隔离了多个线程的数据，每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的整个变量封装进ThreadLocal，或者把该对象的特定于线程的状态封装进ThreadLocal。

　　 由于ThreadLocal中可以持有任何类型的对象，所以使用ThreadLocal get当前线程的值是需要进行强制类型转换。但随着新的Java版本（1.5）将模版的引入，新的支持模版参数的ThreadLocal<T>类将从中受益。也可以减少强制类型转换，并将一些错误检查提前到了编译期，将一定程度地简化ThreadLocal的使用。

　　 总结

　　 当然ThreadLocal并不能替代同步机制，两者面向的问题领域不同。同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信的有效方式；而ThreadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源（变量），这样当然不需要对多个线程进行同步了。所以，如果你需要进行多个线程之间进行通信，则使用同步机制；如果需要隔离多个线程之间的共享冲突，可以使用ThreadLocal，这将极大地简化你的程序，使程序更加易读、简洁

炜 2007-09-20 09:57 发表评论
]]>关于web.xml配置的详细说明http://www.blogjava.net/lcwlv929/articles/145057.html炜炜Fri, 14 Sep 2007 02:02:00 GMThttp://www.blogjava.net/lcwlv929/articles/145057.htmlhttp://www.blogjava.net/lcwlv929/comments/145057.htmlhttp://www.blogjava.net/lcwlv929/articles/145057.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/145057.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/145057.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 descrīption descrīption元素给出与此有关的说明性文本。
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 Descrīptor 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.
*


* 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 ōut = response.getWriter();
String uri = request.getRequestURI();
out.println(ServletUtilities.headWithTitle("Test Servlet") +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"

URI: " + uri + "

\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>

</HEAD>
<BODY BGCOLOR="#FDF5E6">

URI: <%= request.getRequestURI() %>


</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
* behavīor.
*


* 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 ōut = response.getWriter();
String title = "Invoker Servlet Disabled.";
out.println(ServletUtilities.headWithTitle(title) +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"

" + title + "

\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.
*


* 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 ōut = response.getWriter();
String uri = request.getRequestURI();
out.println(ServletUtilities.headWithTitle("Init Servlet") +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"

Init Parameters:

\n" +
"

    \n" +
    "
  • First name: " + firstName + "\n" +
    "
  • Email address: " + emailAddress + "\n" +
    "

\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></HEAD>
<BODY BGCOLOR="#FDF5E6">

Init Parameters:


 


  • First name: <%= firstName %>
  • Email address: <%= emailAddress %>


</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以及可选的descrīption子元素，如下所示：
<context-param>
<param-name>support-email</param-name>
<param-value>blackhole@mycompany.com</param-value>
</context-param>
可回忆一下，为了保证可移植性，web.xml内的元素必须以正确的次序声明。但这里应该注意，context-param元素必须出现任意与文档有关的元素（icon、display-name或descrīption）之后及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.
*


* 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元素和一个提供资料的可选descrīption元素组成。例如，下面的 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元素，以及包含（可选）一个描述角色的descrīption元素。例如，下面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），并且可选地包含一个descrīption元素。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和discrīption等。
可回忆一下，在web.xml内以适当地次序声明web-app子元素很重要。不过，这里只要记住icon、display-name和descrīption是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 descrīption
descrīption元素提供解释性文本，如下所示：
<descrīption>
This Web application represents the store developed for
rare-books.com, an online bookstore specializing in rare
and limited-edition books.
</descrīption>

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）而不是作为Postscrīpt（application/postscrīpt）。
<mime-mapping>
<extension>ps</extension>
<mime-type>application/postscrīpt</mime-type>
</mime-mapping>


13 定位TLD

JSP taglib 元素具有一个必要的uri属性，它给出一个TLD（Tag Library Descrīptor）文件相对于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.
*


* 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元素直接出现在discrīption元素之后，并且不包含子元素或数据，它只是一个如下的标志。
<distributable />
l resource-env-ref
resource -env-ref元素声明一个与某个资源有关的管理对象。此元素由一个可选的descrīption元素、一个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应用的环境项。它由一个可选的descrīption元素、一个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的主目录的应用。它由一个可选的descrīption元素、一个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元素相同的属性并以相同的方式使用



炜 2007-09-14 10:02 发表评论
]]>java基础 Java 常用API的运用，效率及技巧http://www.blogjava.net/lcwlv929/articles/130745.html炜炜Tue, 17 Jul 2007 02:20:00 GMThttp://www.blogjava.net/lcwlv929/articles/130745.htmlhttp://www.blogjava.net/lcwlv929/comments/130745.htmlhttp://www.blogjava.net/lcwlv929/articles/130745.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/130745.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/130745.html阅读全文

炜 2007-07-17 10:20 发表评论
]]>Java反射学习http://www.blogjava.net/lcwlv929/articles/125646.html炜炜Thu, 21 Jun 2007 10:56:00 GMThttp://www.blogjava.net/lcwlv929/articles/125646.htmlhttp://www.blogjava.net/lcwlv929/comments/125646.htmlhttp://www.blogjava.net/lcwlv929/articles/125646.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/125646.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/125646.html1，获得类型类
    我们知道在Java中一切都是对象，我们一般所使用的对象都直接或间接继承自Object类。Object类中包含一个方法名叫getClass，利用这个方法就可以获得一个实例的类型类。类型类指的是代表一个类型的类，因为一切皆是对象，类型也不例外，在Java使用类型类来表示一个类型。所有的类型类都是Class类的实例。例如，有如下一段代码：
A a = new A();
if(a.getClass()==A.class)
    System.out.println("equal");
else System.out.println("unequal");

    可以看到，对象a是A的一个实例，A某一个类，在if语句中使用a.getClass()返回的结果正是A的类型类，在Java中表示一个特定类型的类型类可以用“类型.class”的方式获得，因为a.getClass()获得是A的类型类，也就是A.class，因此上面的代码执行的结果就是打印出“equal”。特别注意的是，类型类是一一对应的，父类的类型类和子类的类型类是不同的，因此，假设A是B的子类，那么如下的代码将得到“unequal”的输出：
A a = new A();
if(a.getClass()==B.class)
    System.out.println("equal");
else System.out.println("unequal");

    因此，如果你知道一个实例，那么你可以通过实例的“getClass()”方法获得该对象的类型类，如果你知道一个类型，那么你可以使用“.class”的方法获得该类型的类型类。
   
2，获得类型的信息
    在获得类型类之后，你就可以调用其中的一些方法获得类型的信息了，主要的方法有：
getName():String：获得该类型的全称名称。
getSuperClass():Class：获得该类型的直接父类，如果该类型没有直接父类，那么返回null。
getInterfaces():Class[]：获得该类型实现的所有接口。
isArray():boolean：判断该类型是否是数组。
isEnum():boolean：判断该类型是否是枚举类型。
isInterface():boolean：判断该类型是否是接口。
isPrimitive():boolean：判断该类型是否是基本类型，即是否是int，boolean，double等等。
isAssignableFrom(Class cls):boolean：判断这个类型是否是类型cls的父（祖先）类或父（祖先）接口。
getComponentType():Class：如果该类型是一个数组，那么返回该数组的组件类型。
此外还可以进行类型转换这类的操作，主要方法有：
asSubclass(Class clazz):Class：将这个类型转换至clazz，如果可以转换，那么总是返回clazz这个引用，否则抛出异常。
cast(Object obj):Object：将obj强制转换为这个类型类代表的类型，不能转换的话将抛出异常。

    除了这些以外，利用类型类还可以反射该类型中的所有属性和方法。在Java中所有的属性信息都用Field表示，所有的方法信息都用Method表示，这辆各类都是java.lang.reflect包中的类。在Class中提供了4个相关的方法获得类型的属性：
getField(String name):Field
getFields():Field[]
getDeclaredField(String name):Field
getDeclaredFields():Field[]
其中getField用于返回一个指定名称的属性，但是这个属性必须是公有的，这个属性可以在父类中定义。如果是私有属性或者是保护属性，那么都会抛出异常提示找不到这个属性。getFields则是返回类型中的所有公有属性，所有的私有属性和保护属性都找不到。getDeclaredField获得在这个类型的声明中定义的指定名称的属性，这个属性必须是在这个类型的声明中定义，但可以使私有和保护的。getDeclaredFields获得在这个类型的声明中定义的所有属性，包括私有和保护的属性都会被返回，但是所有父类的属性都不会被返回。举个例子，先考虑下面两个类的声明：
class A extends B {
    public int a1;
    private int a2;
}
class B {
 public int b1;
 private int b2;
}
如果利用A的类型类调用getFields，那么会返回a1和b1两个属性，如果调用getField("a2")则会报错；如果调用getDeclaredFields则会返回a1和a2，如果调用getDeclaredField("b1")则会报错。

    对于方法也有类似的函数即：
getMethods():Method[]
getMethod(String name, Class ... parameterTypes):Method
getDeclaredMethods():Method[]
getDeclaredMethod(Strubg name, Class ...parameterTypes):Method
不定长参数...是JDK5.0以后新加入的语法。这几个方法的用法和上面的类似，只是在获得特定方法时，除了要告知方法的名字，还需要告知方法的参数，如果没有参数，那么可以传递null，或者空数组，但是最好的方法就是什么都不写，编译器会自行解决不定长参数问题。
    如果要获得所有的属性（方法），包括公有和私有的，那么就必须利用getDeclareFields（getDeclareMethods）方法，然后再利用getSuperClass的方法获得父类，然后递归下去。
   
3，属性和方法
    所有的属性都使用Field表示，所有的方法都使用Method表示。利用Field和Method可以获得属性和方法的信息，甚至执行是获取、修改属性值和调用方法。
   
    对于属性，主要有以下方法可以使用：
getType():Class：获得该属性的类型。
getName():String：获得属性名称。
isAccessible():boolean：判断该属性是否是可以访问的，通常私有和保护的类型都是不可以访问的。
get(Object obj):Object：获得实例obj的属性值，如果该实例的类型中不包含这个属性，那么就会报错。
set(Object obj, Object value)：设置该实例的属性值
setAccessible(boolean flag)：设置该属性是否可以访问，如果你调用get和set方法，那么有可能会引发访问权限的错误，这个时候你可以调用setAccessible方法使得该属性可以访问。例如下面的代码：
A a = new A();
Field f = A.class.getDeclaredField("a2");
f.setAccessibe(true);
System.out.println(f.get(a));
f.set(a,12);
System.out.println(f.get(a));
如果移出中间的f.setAccessibe(true);那么代码会报错，反之输出0 12。
    对于属性而言，如果该属性的类型是基本类型，那么还可以使用一些便捷的set和get操作，例如getInt，setInt什么的，你可以根据自己的需要调用相应的方法。
   
    对于方法，可以有以下的方法：
getName():String：获得方法的名字。
getReturnType():Class：获得方法的返回值类型。
getParameterTypes():Class[]：获得方法的参数类型。
isAccessible():boolean：判断该方法是否是可以访问的。
setAccessible(boolean flag)：设置该方法是否可以访问。
invoke(Object obj, Object... args):Object：调用实例obj的相应方法，其参数由args给定，如果没有参数那么可以什么都不写。
getExceptionTypes():Class[]：获得该方法可能抛出的异常类类型。
这几个方法的含义和用法都和Field的类似，这里不再赘述。

4，创建实例
    利用Class对象可以创建一个类型的实例。如果一个类型拥有无参数的构造函数，那么可以简单地调用Class.newInstance()方法创建一个实例。如果该类型没有无参数的构造函数，或者你希望是用某个有参数的构造函数，那么可以首先使用getConstructors()、getConstructor(Class[] parameterTypes)和getDeclaredConstructors()、getDeclaredConstructor(Class[] parameterTypes)获得构造函数，这两个方法的返回值都使Constructor类型。特别注意的是，构造函数不能继承，因此你调用getConstructor也只能返回这个类型中定义的所有公有构造函数。
   
    Constructor的使用方法和Method的类似，它也存在getParameterTypes()方法和getExceptionTypes()方法，不同的是，它使用newInstance(Object... args)来调用一个构造函数，注意newInstance不需要实例对象，因为这个时候你还没创建出来这个实例呢。



炜 2007-06-21 18:56 发表评论
]]>java反射2http://www.blogjava.net/lcwlv929/articles/125640.html炜炜Thu, 21 Jun 2007 10:35:00 GMThttp://www.blogjava.net/lcwlv929/articles/125640.htmlhttp://www.blogjava.net/lcwlv929/comments/125640.htmlhttp://www.blogjava.net/lcwlv929/articles/125640.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/125640.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/125640.htmlJava动态程序设计：反射介绍
　　
　　使用运行的类的信息使你的程序设计更加灵活
　　
　　反射授予了你的代码访问装载进JVM内的Java类的内部信息的权限，并且允许你编写在程序执行期间与所选择的类的一同工作的代码，而不是在源代码中。这种机制使得反射成为创建灵活的应用程序的强大工具，但是要小心的是，如果使用不恰当，反射会带来很大的副作用。在这篇文章中，软件咨询顾问Dennis Sosnoski 介绍了反射的使用，同时还介绍了一些使用反射所要付出的代价。在这里，你可以找到Java反射API是如何在运行时让你钩入对象的。
　　
　　在第一部分，我向你介绍了Java程序设计的类以及类的装载。那篇文章中描述了很多出现在Java二进制类格式中的信息，现在我来介绍在运行时使用反射API访问和使用这些信息的基础。为了使那些已经了解反射基础的开发人员对这些事情感兴趣，我还会介绍一些反射与直接访问的在性能方面的比较。
　　
　　使用反射与和metadata(描述其它数据的数据)一些工作的Java程序设计是不同的。通过Java语言反射来访问的元数据的特殊类型是在JVM内部的类和对象的描述。反射使你可以在运行时访问各种类信息，它甚至可以你让在运行时读写属性字段、调用所选择的类的方法。
　　
　　反射是一个强大的工具，它让你建立灵活能够在运行时组装的代码，而不需要连接组件间的源代码。反射的一些特征也带来一些问题。在这章中，我将会探究在应用程序中不打算使用反射的原因，以为什么使用它的原因。在你了解到这些利弊之后，你就会在好处大于缺点的时候做出决定。
　　
　　初识class
　　
　　使用反射的起点总时一个java.lang.Class类的实例。如果你与一个预先确定的类一同工作，Java语言为直接获得Class类的实例提供了一个简单的快捷方式。例如：
　　
　　Class clas = MyClass.class;
　　
　　当你使用这项技术的时候，所有与装载类有关的工作都发生在幕后。如果你需要在运行时从外部的资源中读取类名，使用上面这种方法是不会达到目的的，相反你需要使用类装载器来查找类的信息，方法如下所示：
　　
　　// "name" is the class name to load
　　
　　Class clas = null;
　　
　　try {
　　
　　clas = Class.forName(name);
　　
　　} catch (ClassNotFoundException ex) {
　　
　　// handle exception case
　　
　　}
　　
　　// use the loaded class
　　
　　如果类已经装载，你将会找到当前在在的类的信息。如果类还没有被装载，那么类装载器将会装载它，并且返回最近创建的类的实例。
　　
　　关于类的反射
　　
　　Class对象给予你了所有的用于反射访问类的元数据的基本钩子。这些元数据包括有关类的自身信息，例如象类的包和子类，还有这个类所实现的接口，还包括这个类所定义的构造器、属性字段以及方法的详细信息。后面的这些项是我们在程序设计过种经常使用的，因此在这一节的后面我会给出一些用这些信息来工作的例子。
　　
　　对于类的构造中的每一种类型（构造器、属性字段、方法），java.lang.Class提供了四种独立的反射调用以不的方式来访问类的信息。下面列出了这四种调用的标准形式，它是一组用于查找构造器的调用。
　　
　　Constructor getConstructor(Class[] params)　 使用指定的参数类型来获得公共的构造器；
　　
　　Constructor[] getConstructors()　　获得这个类的所有构造器；
　　
　　Constructor getDeclaredConstructor(Class[] params) 使用指定的参数类型来获得构造器（忽略访问的级别）
　　
　　Constructor[] getDeclaredConstructors()　获得这个类的所有的构造器（忽略访问的级别）
　　
　　上述的每一种方法都返回一或多个java.lang.reflect.Constructor的实例。Constructor类定义了一个需要一个对象数据做为唯一参数的newInstance方法，然后返回一个最近创建的原始类的实例。对象数组是在构造器调用时所使用的参数值。例如，假设你有一个带有一对String 类型做为参数的构造器的TwoString类，代码如下所示：
　　
　　public class TwoString {
　　
　　private String m_s1, m_s2;
　　
　　public TwoString(String s1, String s2) {
　　
　　m_s1 = s1;
　　
　　m_s2 = s2;
　　
　　}
　　
　　}
　　
　　下面的代码显示如何获得TwoString类的构造器，并使用字符串“a”和“b”来创建一个实例：
　　
　　Class[] types = new Class[] { String.class, String.class };
　　
　　Constructor cons = TwoString.class.getConstructor(types);
　　
　　Object[] args = new Object[] { "a", "b" };
　　
　　TwoString ts = cons.newInstance(args);
　　
　　上面的代码忽略了几种可能的被不同的反射方法抛出的异常检查的类型。这些异常在Javadoc　API中有详细的描述，因此为简便起见，我会在所有的代码中忽略它们。
　　
　　在我涉及到构造器这个主题时，Java语言也定义了一个特殊的没有参数的（或默认）构造器快捷方法，你能使用它来创建一个类的实例。这个快捷方法象下面的代码这样被嵌入到类的自定义中：
　　
　　Object newInstance() ?使用默认的构造器创建新的实例。
　　
　　尽管这种方法只让你使用一个特殊的构造器，但是如果你需要的话，它是非常便利的快捷方式。这项技术在使用JavaBeans工作的时候尤其有用，因为JavaBeans需要定义一个公共的、没有参数的构造器。
　　
　　通过反射来查找属性字段
　　
　　Class类反射调用访问属性字段信息与那些用于访问构造器的方法类似，在有数组类型的参数的使用属性字段名来替代：使用方法如下所示：
　　
　　Field getField(String name)　--获得由name指定的具有public级别的属性字段
　　
　　Field getFields() ?获得一个类的所有具有public级别的属性字段
　　
　　Field getDeclaredField(String name) ?获得由name指定的被类声明的属性字段
　　
　　Field getDeclaredFields() ?获得由类定义的所有的属性字段
　　
　　尽管与构造器的调用很相似，但是在提到属性字段的时候，有一个重要的差别：前两个方法返回能过类来访问的公共（public）属性字段的信息（包括那些来自于超类的属性字段），后两个方法返回由类直接声明的所有的属性字段（忽略了属性字段的访问类型）。
　　
　　Java.lang.reflect.Field的实例通过调用定义好的getXXX和setXXX方法来返回所有的原始的数据类型，就像普通的与对象引用一起工作的get和set方法一样。尽管getXXX方法会自动地处理数据类型转换（例如使用getInt方法来获取一个byte类型的值），但使用一个适当基于实际的属性字段类型的方法是应该优先考虑的。
　　
　　下面的代码显示了如何使用属性字段的反射方法，通过指定属性字段名，找到一个对象的int类型的属性字段，并给这个属性字段值加1。
　　
　　public int incrementField(String name, Object obj) throws... {
　　
　　Field field = obj.getClass().getDeclaredField(name);
　　
　　int value = field.getInt(obj) + 1;
　　
　　field.setInt(obj, value);
　　
　　return value;
　　
　　}
　　
　　这个方法开始展现一些使用反射所可能带来的灵活性，它优于与一个特定的类一同工作，incrementField方法把要查找的类信息的对象传递给getClass方法，然后直接在那个类中查找命名的属性字段。
　　
　　通过反射来查找方法
　　
　　Class反射调用访问方法的信息与访问构造器和字段属性的方法非常相似：
　　
　　Method getMethod(String name,Class[] params)　--使用指定的参数类型获得由name参数指定的public类型的方法。
　　
　　Mehtod[] getMethods()?获得一个类的所有的public类型的方法
　　
　　Mehtod getDeclaredMethod(String name, Class[] params)?使用指定的参数类型获得由name参数所指定的由这个类声明的方法。
　　
　　Method[] getDeclaredMethods() ?获得这个类所声明的所有的方法
　　
　　与属性字段的调用一样，前两个方法返回通过这个类的实例可以访问的public类型的方法?包括那些继承于超类的方法。后两个方法返回由这个类直接声明的方法的信息，而不管方法的访问类型。
　　
　　通过调用返回的Java.lang.reflect.Mehtod实例定义了一个invoke方法，你可以使用它来调用定义类的有关实例。这个invoke方法需要两个参数，一个是提供这个方法的类的实例，一个是调用这个方法所需要的参数值的数组。



炜 2007-06-21 18:35 发表评论
]]>java反射http://www.blogjava.net/lcwlv929/articles/125516.html炜炜Thu, 21 Jun 2007 04:03:00 GMThttp://www.blogjava.net/lcwlv929/articles/125516.htmlhttp://www.blogjava.net/lcwlv929/comments/125516.htmlhttp://www.blogjava.net/lcwlv929/articles/125516.html#Feedback0http://www.blogjava.net/lcwlv929/comments/commentRss/125516.htmlhttp://www.blogjava.net/lcwlv929/services/trackbacks/125516.html一、反射的概念 ：

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基于反射机制的语言。最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。 

反射本身并不是一个新概念，它可能会使我们联想到光学中的反射概念，尽管计算机科学赋予了反射概念新的含义，但是，从现象上来说，它们确实有某些相通之处，这些有助于我们的理解。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。可以看出，同一般的反射概念相比，计算机科学领域的反射不单单指反射本身，还包括对反射结果所采取的措施。所有采用反射机制的系统（即反射系统）都希望使系统的实现更开放。可以说，实现了反射机制的系统都具有开放性，但具有开放性的系统并不一定采用了反射机制，开放性是反射系统的必要条件。一般来说，反射系统除了满足开放性条件外还必须满足原因连接（Causally-connected）。所谓原因连接是指对反射系统自描述的改变能够立即反映到系统底层的实际状态和行为上的情况，反之亦然。开放性和原因连接是反射系统的两大基本要素。13700863760

Java中，反射是一种强大的工具。它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。反射允许我们在编写与执行时，使我们的程序代码能够接入装载到JVM中的类的内部信息，而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。但需注意的是：如果使用不当，反射的成本很高。

二、Java中的类反射：

Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。

1．检测类：

1.1 reflection的工作机制

考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。

import java.lang.reflect.*;
public class DumpMethods {
    public static void main(String args[]) {
        try {
            Class c = Class.forName(args[0]);
            Method m[] = c.getDeclaredMethods();
            for (int i = 0; i < m.length; i++)
                System.out.println(m[i].toString());
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

按如下语句执行：

java DumpMethods java.util.Stack

它的结果输出为：

public java.lang.Object java.util.Stack.push(java.lang.Object)

public synchronized java.lang.Object java.util.Stack.pop()

public synchronized java.lang.Object java.util.Stack.peek()

public boolean java.util.Stack.empty()

public synchronized int java.util.Stack.search(java.lang.Object)

这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。

这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

1.2 Java类反射中的主要方法

对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用：

l         Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，

l         Constructor[] getConstructors() -- 获得类的所有公共构造函数

l         Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)

l         Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关) 

获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：

l         Field getField(String name) -- 获得命名的公共字段

l         Field[] getFields() -- 获得类的所有公共字段

l         Field getDeclaredField(String name) -- 获得类声明的命名的字段

l         Field[] getDeclaredFields() -- 获得类声明的所有字段 

用于获得方法信息函数：

l         Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法

l         Method[] getMethods() -- 获得类的所有公共方法

l         Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法

l         Method[] getDeclaredMethods() -- 获得类声明的所有方法 

 

1.3开始使用 Reflection：

用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。

下面就是获得一个 Class 对象的方法之一：

Class c = Class.forName("java.lang.String");

这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：

Class c = int.class;

或者

Class c = Integer.TYPE;

它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。

第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。

一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的第一个方法的原型。

2．处理对象：

如果要作一个开发工具像debugger之类的，你必须能发现filed values,以下是三个步骤:

a.创建一个Class对象
b.通过getField 创建一个Field对象
c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).

例如：
import java.lang.reflect.*;
import java.awt.*;

class SampleGet {

   public static void main(String[] args) {
      Rectangle r = new Rectangle(100, 325);
      printHeight(r);

   }

   static void printHeight(Rectangle r) {
      Field heightField;
      Integer heightValue;
      Class c = r.getClass();
      try {
        heightField = c.getField("height");
        heightValue = (Integer) heightField.get(r);
        System.out.println("Height: " + heightValue.toString());
      } catch (NoSuchFieldException e) {
          System.out.println(e);
      } catch (SecurityException e) {
          System.out.println(e);
      } catch (IllegalAccessException e) {
          System.out.println(e);
      }
   }
}

 

三、安全性和反射：

在处理反射时安全性是一个较复杂的问题。反射经常由框架型代码使用，由于这一点，我们可能希望框架能够全面接入代码，无需考虑常规的接入限制。但是，在其它情况下，不受控制的接入会带来严重的安全性风险，例如当代码在不值得信任的代码共享的环境中运行时。

由于这些互相矛盾的需求，Java编程语言定义一种多级别方法来处理反射的安全性。基本模式是对反射实施与应用于源代码接入相同的限制：

n         从任意位置到类公共组件的接入 

n         类自身外部无任何到私有组件的接入 

n         受保护和打包（缺省接入）组件的有限接入 

不过至少有些时候，围绕这些限制还有一种简单的方法。我们可以在我们所写的类中，扩展一个普通的基本类java.lang.reflect.AccessibleObject 类。这个类定义了一种setAccessible方法，使我们能够启动或关闭对这些类中其中一个类的实例的接入检测。唯一的问题在于如果使用了安全性管理器，它将检测正在关闭接入检测的代码是否许可了这样做。如果未许可，安全性管理器抛出一个例外。

下面是一段程序，在TwoString 类的一个实例上使用反射来显示安全性正在运行：

public class ReflectSecurity {

    public static void main(String[] args) {

        try {

            TwoString ts = new TwoString("a", "b");

            Field field = clas.getDeclaredField("m_s1");

//          field.setAccessible(true);

            System.out.println("Retrieved value is " +

                field.get(inst));

        } catch (Exception ex) {

            ex.printStackTrace(System.out);

        }

    }

}

如果我们编译这一程序时，不使用任何特定参数直接从命令行运行，它将在field .get(inst)调用中抛出一个IllegalAccessException异常。如果我们不注释field.setAccessible(true)代码行，那么重新编译并重新运行该代码，它将编译成功。最后，如果我们在命令行添加了JVM参数-Djava.security.manager以实现安全性管理器，它仍然将不能通过编译，除非我们定义了ReflectSecurity类的许可权限。

四、反射性能：

反射是一种强大的工具，但也存在一些不足。一个主要的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。

下面的程序是字段接入性能测试的一个例子，包括基本的测试方法。每种方法测试字段接入的一种形式 -- accessSame 与同一对象的成员字段协作，accessOther 使用可直接接入的另一对象的字段，accessReflection 使用可通过反射接入的另一对象的字段。在每种情况下，方法执行相同的计算 -- 循环中简单的加/乘顺序。

程序如下：

public int accessSame(int loops) {

    m_value = 0;

    for (int index = 0; index < loops; index++) {

        m_value = (m_value + ADDITIVE_VALUE) *

            MULTIPLIER_VALUE;

    }

    return m_value;

}

 

public int accessReference(int loops) {

    TimingClass timing = new TimingClass();

    for (int index = 0; index < loops; index++) {

        timing.m_value = (timing.m_value + ADDITIVE_VALUE) *

            MULTIPLIER_VALUE;

    }

    return timing.m_value;

}

 

public int accessReflection(int loops) throws Exception {

    TimingClass timing = new TimingClass();

    try {

        Field field = TimingClass.class.

            getDeclaredField("m_value");

        for (int index = 0; index < loops; index++) {

            int value = (field.getInt(timing) +

                ADDITIVE_VALUE) * MULTIPLIER_VALUE;

            field.setInt(timing, value);

        }

        return timing.m_value;

    } catch (Exception ex) {

        System.out.println("Error using reflection");

        throw ex;

    }

}

在上面的例子中，测试程序重复调用每种方法，使用一个大循环数，从而平均多次调用的时间衡量结果。平均值中不包括每种方法第一次调用的时间，因此初始化时间不是结果中的一个因素。下面的图清楚的向我们展示了每种方法字段接入的时间：

图 1：字段接入时间 ：

我们可以看出：在前两副图中(Sun JVM)，使用反射的执行时间超过使用直接接入的1000倍以上。通过比较，IBM JVM可能稍好一些，但反射方法仍旧需要比其它方法长700倍以上的时间。任何JVM上其它两种方法之间时间方面无任何显著差异，但IBM JVM几乎比Sun JVM快一倍。最有可能的是这种差异反映了Sun Hot Spot JVM的专业优化，它在简单基准方面表现得很糟糕。反射性能是Sun开发1.4 JVM时关注的一个方面，它在反射方法调用结果中显示。在这类操作的性能方面，Sun 1.4.1 JVM显示了比1.3.1版本很大的改进。

如果为为创建使用反射的对象编写了类似的计时测试程序，我们会发现这种情况下的差异不象字段和方法调用情况下那么显著。使用newInstance()调用创建一个简单的java.lang.Object实例耗用的时间大约是在Sun 1.3.1 JVM上使用new Object()的12倍，是在IBM 1.4.0 JVM的四倍，只是Sun 1.4.1 JVM上的两部。使用Array.newInstance(type, size)创建一个数组耗用的时间是任何测试的JVM上使用new type[size]的两倍，随着数组大小的增加，差异逐步缩小。

结束语：

Java语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象(根据安全性限制)，无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。例如，反射经常在持续存储对象为数据库、XML或其它外部格式的框架中使用。Java reflection 非常有用，它使类和数据结构能按名称动态检索相关信息，并允许在运行着的程序中操作这些信息。Java 的这一特性非常强大，并且是其它一些常用语言，如 C、C++、Fortran 或者 Pascal 等都不具备的。

但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。

许多应用中更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来维护问题。反射代码比相应的直接代码更复杂，正如性能比较的代码实例中看到的一样。解决这些问题的最佳方案是保守地使用反射——仅在它可以真正增加灵活性的地方——记录其在目标类中的使用。

 

 

利用反射实现类的动态加载


Bromon原创 请尊重版权

最近在成都写一个移动增值项目，俺负责后台server端。功能很简单，手机用户通过GPRS打开Socket与服务器连接，我则根据用户传过来的数据做出响应。做过类似项目的兄弟一定都知道，首先需要定义一个类似于MSNP的通讯协议，不过今天的话题是如何把这个系统设计得具有高度的扩展性。由于这个项目本身没有进行过较为完善的客户沟通和需求分析，所以以后肯定会有很多功能上的扩展，通讯协议肯定会越来越庞大，而我作为一个不那么勤快的人，当然不想以后再去修改写好的程序，所以这个项目是实践面向对象设计的好机会。

首先定义一个接口来隔离类：

package org.bromon.reflect;

public interface Operator

{

public java.util.List act(java.util.List params)

}

根据设计模式的原理，我们可以为不同的功能编写不同的类，每个类都继承Operator接口，客户端只需要针对Operator接口编程就可以避免很多麻烦。比如这个类：

package org.bromon.reflect.*;

public class Success implements Operator

{

public java.util.List act(java.util.List params)

{

List result=new ArrayList();

result.add(new String(“操作成功”));

return result;

}

}

我们还可以写其他很多类，但是有个问题，接口是无法实例化的，我们必须手动控制具体实例化哪个类，这很不爽，如果能够向应用程序传递一个参数，让自己去选择实例化一个类，执行它的act方法，那我们的工作就轻松多了。

很幸运，我使用的是Java，只有Java才提供这样的反射机制，或者说内省机制，可以实现我们的无理要求。编写一个配置文件emp.properties:

#成功响应

1000=Success

#向客户发送普通文本消息

2000=Load

#客户向服务器发送普通文本消息

3000=Store

文件中的键名是客户将发给我的消息头，客户发送1000给我，那么我就执行Success类的act方法，类似的如果发送2000给我，那就执行Load类的act方法，这样一来系统就完全符合开闭原则了，如果要添加新的功能，完全不需要修改已有代码，只需要在配置文件中添加对应规则，然后编写新的类，实现act方法就ok，即使我弃这个项目而去，它将来也可以很好的扩展。这样的系统具备了非常良好的扩展性和可插入性。

下面这个例子体现了动态加载的功能，程序在执行过程中才知道应该实例化哪个类：

package org.bromon.reflect.*;

import java.lang.reflect.*;

public class TestReflect

{

//加载配置文件,查询消息头对应的类名

private String loadProtocal(String header)

{

String result=null;

try

{

Properties prop=new Properties();

FileInputStream fis=new FileInputStream("emp.properties");

prop.load(fis);

result=prop.getProperty(header);

fis.close();

}catch(Exception e)

{

System.out.println(e);

}

return result;

}

//针对消息作出响应,利用反射导入对应的类

public String response(String header,String content)

{

String result=null;

String s=null;

try 

{

/*

* 导入属性文件emp.properties,查询header所对应的类的名字

* 通过反射机制动态加载匹配的类,所有的类都被Operator接口隔离

* 可以通过修改属性文件、添加新的类(继承MsgOperator接口)来扩展协议

*/

s="org.bromon.reflect."+this.loadProtocal(header);

//加载类

Class c=Class.forName(s);

//创建类的事例

Operator mo=(Operator)c.newInstance();

//构造参数列表

Class params[]=new Class[1];

params[0]=Class.forName("java.util.List");

//查询act方法

Method m=c.getMethod("act",params);

Object args[]=new Object[1];

args[0]=content;

//调用方法并且获得返回

Object returnObject=m.invoke(mo,args);

}catch(Exception e)

{

System.out.println("Handler-response:"+e);

}

return result;

}

public static void main(String args[])

{

TestReflect tr=new TestReflect();

tr.response(args[0],”消息内容”);

}

}



炜 2007-06-21 12:03 发表评论
]]>