BlogJava-cAng^Er-文章分类-|:数 据 库:|http://www.blogjava.net/xiaosao/category/11006.html不懂我的人 , 离不了我 , 该了解了解我 !而懂我的人 , 更离不了我 , 因为他们爱我 。zh-cnFri, 25 Feb 2011 13:14:21 GMTFri, 25 Feb 2011 13:14:21 GMT60<转>Oracle内存共享区http://www.blogjava.net/xiaosao/articles/344895.htmlcAng^ErcAng^ErWed, 23 Feb 2011 02:49:00 GMThttp://www.blogjava.net/xiaosao/articles/344895.htmlhttp://www.blogjava.net/xiaosao/comments/344895.htmlhttp://www.blogjava.net/xiaosao/articles/344895.html#Feedback0http://www.blogjava.net/xiaosao/comments/commentRss/344895.htmlhttp://www.blogjava.net/xiaosao/services/trackbacks/344895.html原文:http://bbs.dameng.com/viewthread.php?tid=2202&extra=page%3D1

PGA是一个服务器进程的专用的私有内存区，而SGA则是共享内存区。

SGA由多个部分组成：
1， 固定SGA（Fixed SGA）
2， 块缓冲区（Db cache）
3， 重做日志缓冲区（Redo log buffer）
4， Java池（Java pool）
5， 大池（Large pool）
6， 共享池（Shared pool）
7， 流池（Stream pool）

有如下参数控制共享池相关组件大小：
1， JAVA_POOL_SIZE：控制Java池大小。
2， SHARED_POOL_SIZE：9i中控制共享池中占用最大的部分，10g以上控制共享池大小。
3， LARGE_POOL_SIZE：控制大池大小。
4， DB_*K_CACHE_SIZE：控制不同块大小的缓冲区大小。
5， LOG_BUFFER：控制重做日志缓冲区大小。
6， SGA_TARGET：10g以上控制自动SGA内存管理的总内存大小。
7， SGA_MAX_SIZE：控制SGA可以达到的最大大小，改变需重启数据库。

下面将详细介绍各个部分的作用和推荐设置。

SGA各组件作用
1， SGA：

2， 块缓冲区：
    查询时，Oracle会先把从磁盘读取的数据放入内存，以后再查询相关数据时不用再次读取磁盘。insert和update时，Oracle SGA会现在该区中缓存数据，之后批量写到硬盘中。通过块缓冲区，Oracle可以通过内存缓存提高磁盘的I/O。
    块缓冲区中有三个区域：
默认池（Default pool）：所有数据默认都在这里缓存。
保持池（Keep pool）：用来缓存需要多次重用的数据。
回收池（Recycle pool）：用来缓存很少重用的数据。

    原来只有一个默认池，所有数据都在这里缓存。这样会产生一个问题：大量很少重用的数据会把需重用的数据缓冲区，造成磁盘I/O增加，运行速度下降。后来分出了保持池和回收池根据是

否经常重用来分别缓存数据。
    这三部分内存区需要手动确定大小，并且之间没有共享。例如：保持池中已经满了，而回收池中还有大量空闲内存，这时回收池的内存不会分配给保持池。
    9i开始，还可以设置db_nk_cache。9i之前数据库只能使用相同的块大小。9i开始同一个数据库可以使用多种块大小（2KB,4KB,8KB,16KB,32KB），这些块需要在各自的db_nk_cache中缓存。如果为不

同的表空间指定了不同的块大小，需要为其设置各自的缓冲区。

3， 重做日志缓冲区（Redo log buffer）：
    数据写到重做日志文件之前在这里缓存，在以下情况中触发：
每隔3秒
缓存达到1MB或1/3满时
用户提交时
缓冲区的数据写入磁盘前

4， Java池（Java pool）：
    在数据库中运行Java代码时用到这部分内存。例如：编写Java存储过程在服务器内运行。需要注意的是，该内存与常见的Java编写的B/S系统并没关系。用JAVA语言代替PL/SQL语言在数据库中写存储

过程才会用到这部分内存。

5， 大池（Large pool）：
    下面三种情况使用到大池：
并行执行：存放进程间的消息缓冲区
RMAN：某些情况下用于磁盘I/O缓冲区
共享服务器模式：共享服务器模式下UGA在大池中分配（如果设置了大池）

6， 共享池（Shared pool）
    共享池是SGA中最重要的内存段之一。共享池太大和太小都会严重影响服务器。
SQL和PL/SQL的解释计划、代码，数据字典数据等等都在这里缓存。
SQL和PL/SQL代码在执行前会进行“解析”来获得执行计划及权限验证等相关辅助操作。“解析”很费时间。对于响应时间很短的查询，“解析”可以占到全部时间的2/3。对于响应时间较长的统计等操

作，“解析”所占用的时间比例会下降很多。执行计划及所需的数据字典数据都缓存在共享池中，让后续相同的查询可以减少很多时间。
    不使用“绑定变量”导致：
    系统需要花费大量的资源去解析查询。
    共享池中的代码从不重用，系统花费很大代价管理这部分内存。
    关于共享变量的优缺点讨论已经超过了这篇文章的范畴，简单来讲，响应时间短的查询要使用共享变量，响应时间长的统计不使用共享变量。
    需要注意的是，SHARED_POOL_SIZE参数在9i中控制共享池中占用最大的部分，10g以上控制共享池总大小。

7， 流池（Stream pool）
    9iR2以上增加了“流”技术，10g以上在SGA中增加了流池。流是用来共享和复制数据的工具。

cAng^Er 2011-02-23 10:49 发表评论
]]><转>oracle性能优化-共享池调整http://www.blogjava.net/xiaosao/articles/344893.htmlcAng^ErcAng^ErWed, 23 Feb 2011 02:33:00 GMThttp://www.blogjava.net/xiaosao/articles/344893.htmlhttp://www.blogjava.net/xiaosao/comments/344893.htmlhttp://www.blogjava.net/xiaosao/articles/344893.html#Feedback0http://www.blogjava.net/xiaosao/comments/commentRss/344893.htmlhttp://www.blogjava.net/xiaosao/services/trackbacks/344893.html原文:http://space.itpub.net/79499/viewspace-341794

一.简介:数据库调整中最为重要的一部分是重写运行效率差的SQL代码,重写之后的SQL代码在运行效率方面可能会与之前的产生极大的差别！
      但是当遇到重写之后性能还是未能突破瓶颈或者你是用户(无法访问SQL代码)的时候,可以通过调整ORACLE的共享内存结构SGA(System Global Area),最大限度地提高性能！
       SGA中比较重要的组件就是Shared Pool(共享池),它的作用就是高速缓存SQL语句!共享池由一个最近最少使用(LRU,Least Recently Used)算法来管理!
      共享池的好处:
1.select cust_id,cust_name from col_cust
2.上列语句的算法被转换成ASCII码,然后通过一个散列算法产生一个单独的散列值~~接着Process会查看该散列值在Shared Pool中是否存在,
如果存在,就执行高速缓存中语句
3.如果不存在,就必须对该语句进行语法分析,这些分析步骤会产生额外的系统开销,该操作是高代价的!
4.查找到匹配的SQL叫做一次高速缓冲区命中(Cache Hit)
5.反之叫做高速缓冲区脱靶(Cache Miss)
6.注意是区分大小写的
 SELECT CUST_ID,CUST_NAME FROM COL_CUST 
 
      二.共享池有三个组件组成,Library Cache(库高速缓存区),Data Dictionary Cache(数据目录高速缓存区),User Global Area(用户全局区)
      1.Library Cache(库高速缓存区)是用来缓存SQL语句的场所.可以通过下面这句话对动态视图进行查询,检查Library Cache的内容
 select p.username,l.sql_text,
 lpad(' ' ,4*(LEVEL-2)) || operation || ' ' || options || ' ' || object_name as "Execution Plan"
 from (
 select s.username,p.address,p.hash_value,p.operation,p.options,p.object_name,p.id,p.parent_id
 from v$sql_plan p,v$session s
 where (p.address=s.sql_address and p.hash_value=s.sql_hash_value) and s.username='citictest'
 ) p,v$sql l
 where(l.address=p.address and l.hash_value=p.hash_value)
 start with id=0
 connect by prior id = parent_id
      2.Data Dictionary Cache(数据目录高速缓存区):数据目录是用来检查SQL语句所引用的那些表是否已经存在,列名和数据类型是否也正确! Library Cache和Data Dictionary Cache使用互相独立的LRU机制,好处是后续用户发布的语句与先前用户所发布的语句类似但不一致,虽然在Library Cache中无法找到匹配的,但是在数据目录中会存在,也会有性能上的提高。

      三.(1)测量Library Cache(库高速缓存区)的性能
      select namespace,gethitratio,pinhitratio,reloads,invalidations
       from v$librarycache
       where namespace in ('SQL_AREA','TABLE/PROCEDURE','BODY','TRIGGER');
主要看gethitratio,pinhitratio>90%说明调整充分
      select sum(reloads)/sum(pins) "RELOAD　RATIO"
       from v$librarycache
当<1%意味着不是经常重新语法分析以前被装载到Library Cache的语句
 
       (2)测量Data Dictionary Cache(数据目录高速缓存区)的性能
      select 1 - (sum(getmisses)/sum(gets)) "DATA DICTIONARY HIT RATIO"
       from v$rowcache;
当>85%时说明调整充分
   四.通过改进Library Cache和Data Dictionary Cache来提高shared pool性能
(1).得到当前shared pool的大小
 select pool,sum(bytes) "SIZE" from v$sgastat where pool='shared pool' group by pool;
(2).得到推荐的shared pool大小
  set echo off
  set feedback off
  set serveroutput on
  declare
  v_total_plsql_mem number := 0;
  v_total_sql_mem   number := 0;
  v_total_sharable_mem number := 0;
  begin
       select sum(sharable_mem) into v_total_plsql_mem from v$db_object_cache;
      
       select sum(sharable_mem) into v_total_sql_mem from v$sqlarea where executions > 10;
      
       v_total_sharable_mem := v_total_plsql_mem + v_total_sql_mem;
      
       Dbms_Output.put_line('Estimated required shared pool size is:' || to_char(v_total_sharable_mem,'fm9,999,999,999,999') || ' bytes');
  end;
  /
(3).动态加大shared pool大小
alert system set shared_pool_size = 200M;
*大小不能超过SGA_MAX_SIZE的值
(4).初始SGA大小的计算
(TSGA)SGA总的大小=服务器物理内存*0.55   (1G以上物理内存的话可以相应60%-75%)
(TSGAI)每个实例的总SGA大小=TSGA/oracle上实例的个数
shared pool的总内存=TSGAI*0.45
(5).上述四点是其实完成的是同一个做法，就是使Shared Pool更大
(6).可以将PL/SQL程序包装入Shared Pool Reserved Area(共享池保留区)
Shared_Pool_Reserved_Size用来设置这一区域的大小，默认是5%，这是不够的
select owner,name,sharable_mem from v$db_object_cache
where type in('PACKAGE','PACKAGE BODY') order by sharable_mem desc;
上述这句语句可以查看当前缓存区中的PL/SQL程序包的名称和大小，当发现大小> Shared_Pool_Reserved_Size时说明保留区的大小不够，你需要增加Shared_Pool_Reserved_Size的值
(7).把重要的PL/SQL代码保持在内存中
你可以把常用的PROCEDURE销定(Pinning)在Shared_Pool_Reserved_Size中
做法如下:
          a)sys用户登录
          b)运行@%ORACLE_HOME%/rdbms\admin\dbmspool.sql
          c)SQL>execute DBMS_SHARED_POOL.KEEP('PROCEDURENAME') (销定,必须用sys完成)
          d)找到销定的对象select owner,name,type from v$db_object_cache where kept='YES';
          e)销定对单独的SQL语句无法操作,尽可能的把大语句做成PROCEDURE，可以用一下语句寻找出比较大的语句
select substr(sql_text,1,45),length(sql_text) "STMT_SIZE" from v$sqlarea where command_type=47 order by length(sql_text) desc;
          f)可以编写一个脚本，当实例启动之后运行，把所有需要销定的语句执行一下
          h)只有使用UNKEEP或者实例关闭时才会取消销定
(8).其他的一些调整Library Cache参数
a)open_cursors :默认50
b)cursor_space_for_time默认false
c)session_cached_cursors默认0(无游标高速缓存)
d)cursor_sharing默认EXACT --2条SQL语句必须完全匹配才能共享shared pool中所缓存的已分析代码.
                 SIMILAR --允许2条仅在字面上不同的SQL语句共享shared pool中所缓存的已分析代码.
例如:select cust_id from col_cust where cust_name = 'wang'
     select cust_id from col_cust where cust_name = 'huang'
上述两句在SIMILAR模式中是相等，可以使用缓存的已分析代码.


cAng^Er 2011-02-23 10:33 发表评论
]]><转>Webwork对checkbox复选框Action的处理http://www.blogjava.net/xiaosao/articles/97419.htmlcAng^ErcAng^ErFri, 02 Feb 2007 01:20:00 GMThttp://www.blogjava.net/xiaosao/articles/97419.htmlhttp://www.blogjava.net/xiaosao/comments/97419.htmlhttp://www.blogjava.net/xiaosao/articles/97419.html#Feedback0http://www.blogjava.net/xiaosao/comments/commentRss/97419.htmlhttp://www.blogjava.net/xiaosao/services/trackbacks/97419.htmlhttp://blog.csdn.net/chikai/archive/2004/12/06/206371.aspx
webwork对页面诸如像checkbox这种表单元素的处理，我们如果只是简单的用来设置字段的布尔值，就像下面的处理方式，如：
<input type="checkbox" name="user.lockedOut" value="true"/>如果用户选中这复选框，浏览器在查询串中将会送出"user.lockedOut=true"，此时OGNL执行了action.getUser().setLockedOut(true)。如果用户不选中复选框，浏览器将不会送出查询串，因此，在开始，应确保已经初始化lockedOut 为false：
private boolean m_lockedOut = false;
public void setLockedOut(boolean lockedOut) { m_lockedOut = lockedOut; }

        但更多情况下，我们是把它当做复选（多项选择）来用，这有两种情况用checkbox来设置集合：
一.checkbox name相同
在一个String 类型的Set 集合里面存放许多权限，用checkbox的HTML如下：
<input type="checkbox" name="user.priv" value="boss"/>
<input type="checkbox" name="user.priv" value="admin"/>
<input type="checkbox" name="user.priv" value="manager"/>
比方说，一个用户选中前面的两项，浏览器将会送出这查询串： user.priv=boss&user.priv=admin。
OGNL将会处理查询串：action.getUser().setPriv(String[] {"boss", "admin"})。
Action里面的方法将会是这样：
Set m_privileges = new HashSet();

    public void setPriv(String[] privs) {
        for (int i = 0; i < privs.length; i++) {
            m_privileges.add(privs[i]);
        }
    }
二.checkbox name不同
有三种处理方式：
I.
 <input type="checkbox" name="xlist[0].id" value="444">
 <input type="checkbox" name="xlist[1].id" value="443">
 <input type="checkbox" name="xlist[2].id" value="442">
 * Action中用List集合来处理：private List xlist = new XWorkList(User.class)
    public List getXlist(){            
        return xlist;
    }
II. 
 <input type="checkbox" name="xmap['0'].id" value="444">
 <input type="checkbox" name="xmap['1'].id" value="443">
 <input type="checkbox" name="xmap['2'].id" value="442">
  * Action中用Map集合来处理：private Map xmap = new XWorkMap(User.class)
    public List getXmap(){            
        return xmap;
    }
 III.
 <input type="checkbox" name="xarray[0]." value="444">
 <input type="checkbox" name="xarray[1]" value="443">
 <input type="checkbox" name="xarray[2]" value="442">
  *Action中用Object[]数组来处理（注意数组的长度必须事先确定，不可以动态改动数组的大小）：
     private Object[] xarray = new Object[3]
     public Object[] getXarray(){
                return xarray;
        }

        下面用一个稍为复杂一点的例子来加深对List集合处理方式的理解，其它处理方式都是异曲同工。
multiSelect.jsp文件
<%@page pageEncoding="gb2312" contentType="text/html;charset=gb2312"%>
<%@taglib prefix="ww" uri="webwork" %>
<html>
   <body>
   <form name="multi" method="post" action="multiSelect.action">
      <%int i = 0; %>
      <ww:iterator value="ulist">
      <%
        String cName = "xlist["+i+"].id";
        i++;
       %>
       <input type="checkbox" name="<%=cName%>" value="<ww:property value="id"/>">
       <ww:property value="username"/>
       <br>
      </ww:iterator>
      <input type="hidden" name="actionEvent" value="viewSelect">
      <input type="submit" value="选择">
   </form>
   </body>
</html>

multiSelect_result.jsp文件
<%@page pageEncoding="gb2312" contentType="text/html;charset=gb2312"%>
<%@taglib prefix="ww" uri="webwork" %>
<html>
   <body>你的选择是：<br>
       <ww:iterator value="xlist">
       <ww:property value="id"/>
       <br>
      </ww:iterator>
   </body>
</html>

MultiSelectAction.java文件

package com.wzj.rbac.webwork.action;
import java.util.List;
import com.opensymphony.xwork.Action;
import com.opensymphony.xwork.util.XWorkList;
import com.wzj.framework.spring.resource.BeanLocator;
import com.wzj.rbac.ServiceFacade.UserService;
import com.wzj.rbac.domain.object.User;
/**
 * @desc 复选框 选择提交Action类
 * @author chikai<br>
 * @link <a href="mailto:wzj616@etang.com">chikai</a>
 * @version $ MultiSelectAction.java  2004-12-5 19:11:54 $
 * @version $ Project xwork
 */
public class MultiSelectAction implements Action {

    private final static String PRE_SUCCESS = "pre_success";
    //用户列表
    private List ulist;
    //选择的用户
    private List xlist = new XWorkList(User.class);
    private UserService uService;
    //页面执行动作判断
    private String actionEvent;
   
    public String execute() throws Exception {
       if(actionEvent!=null&&actionEvent.equals("viewSelect"))
       {  
           for(int s=0;s<xlist.size();s++){
               if(((User)xlist.get(s)).getId()==null){
                   xlist.remove(s);
                   s--;
                   }
           } 
           return SUCCESS;
       }
       //获取用户业务服务
       uService = BeanLocator.getGlobalServiceLocator().getUserService();
       ulist = uService.getAllUser();
       return PRE_SUCCESS;
    }
    public List getUlist(){
        return ulist;
    }
    public List getXlist(){            
        return xlist;
    }
    public void setActionEvent(String ae){
        actionEvent = ae;
    }
}


xwork.xml文件：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" "http://www.opensymphony.com/xwork/xwork-1.0.dtd">

<xwork>
 
 <include file="webwork-default.xml" />
    <include file="config-browser.xml" />
    <package name="pklogin" extends="webwork-default">
 
    <interceptors>
        <interceptor-stack name="modelParamsStack">
     <interceptor-ref name="model-driven" />
        <interceptor-ref name="params" />
        </interceptor-stack> 
 </interceptors> 
 
 <action name="multiSelect" class="com.wzj.rbac.webwork.action.MultiSelectAction">
  <result name="success" type="dispatcher">
            <param name="location">/multiSelect_result.jsp</param>
        </result>
  <result name="pre_success" type="dispatcher">
   <param name="location">/multiSelect.jsp</param>
  </result>
  <interceptor-ref name="modelParamsStack" />
 </action>
  
 </package>

</xwork>



cAng^Er 2007-02-02 09:20 发表评论
]]><转>log4j/log4e的使用 http://stieglitzcc.spaces.live.com/Blog/cns!6A816552E3F0D074!122.entryhttp://www.blogjava.net/xiaosao/articles/93899.htmlcAng^ErcAng^ErMon, 15 Jan 2007 03:36:00 GMThttp://www.blogjava.net/xiaosao/articles/93899.htmlhttp://www.blogjava.net/xiaosao/comments/93899.htmlhttp://www.blogjava.net/xiaosao/articles/93899.html#Feedback0http://www.blogjava.net/xiaosao/comments/commentRss/93899.htmlhttp://www.blogjava.net/xiaosao/services/trackbacks/93899.htmllog4j/log4e的使用

简单的说log4j就是帮助开发人员进行日志输出管理的API类库。它最重要的特点就

可以 配置文件灵活的设置 日志信息的优先级、日志信息的输出目的地以及日志信息的输出格式。

Log4j除了可以记录程序运行日志信息外还有一重要的功能就是用来 显示调试信息。程序员经常会遇到脱离java ide环境调试程序的情况，这时大多数人会选择使用System.out.println语句输出某个变量值的方法进行调试。这样会带来一个非常麻烦的问题：一旦哪天程序员决定不要显示这些System.out.println的东西了就只能一行行的把这些垃圾语句注释掉。若哪天又需调试变量值，则只能再一行行去掉这些注释恢复System.out.println语句。使用log4j可以很好的处理类似情况。

log4j使用方法

下面介绍的是log4j一些理论方面的知识，读者觉得枯燥的话可以跳过本节直接阅读第三节实例部分。

　　1、定义配置文件

　  首先使用配置文件将使我们的应用程序更加灵活配置log日志输出方式包括输出优先级、输出目的地、输出格式。Log4j支持两种配置文件格式，一种是XML 格式的文件，一种是Java特性文件log4j.properties（键=值）。下面将介绍使用log4j.properties文件作为配置文件的方法：

　　 ① 配置根Logger，其语法为：0

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

　　其中，level 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者自定义的级别。Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定义了INFO级别，则应用程序中所有DEBUG级别的日志信息将不被打印出来。 appenderName就是指定日志信息输出到哪个地方。可同时指定多个输出目的地。

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

　　 log4j.appender.appenderName = fully.qualified.name.of.appender.class
　　log4j.appender.appenderName.option1 = value1
　　…
　　log4j.appender.appenderName.option = valueN

　　其中， Log4j提供的appender有以下几种：
　　org.apache.log4j.ConsoleAppender（控制台），
　　org.apache.log4j.FileAppender（文件），
　　org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
　　org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），
　　org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

　 ③ 配置日志信息的格式（布局），其语法为：

　　 log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
　　log4j.appender.appenderName.layout.option1 = value1
　　…
　　log4j.appender.appenderName.layout.option = valueN

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

　　Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，打印参数如下： %m 输出代码中指定的消息

　　 %p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
　　%r 输出自应用启动到输出该log信息耗费的毫秒数
　　%c 输出所属的类目，通常就是所在类的全名
　　%t 输出产生该日志事件的线程名
　　%n 输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“\n”
　　%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似： 2002年10月18日 22：10：28，921
　　%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)

　　2、在代码中使用Log4j

　　 ① 得到记录器

　　使用Log4j，第一步就是获取日志记录器，这个记录器将负责控制日志信息。其语法为：

　　public static Logger getLogger( String name)

　　通过指定的名字获得记录器，如果必要的话，则为这个名字创建一个新的记录器。Name一般取本类的名字，比如：

　　static Logger logger = Logger.getLogger ( ServerWithLog4j.class.getName () )

　　 ② 读取配置文件

　　当获得了日志记录器之后，第二步将配置Log4j环境，其语法为：

BasicConfigurator.configure ()： 自动快速地使用缺省Log4j环境。
　　PropertyConfigurator.configure ( String configFilename) ：读取使用Java的特性文件编写的配置文件。

例：PropertyConfigurator.configure (".\\src\\log4j.properties")
　　DOMConfigurator.configure ( String filename ) ：读取XML形式的配置文件。

　　 ③ 插入记录信息（格式化日志信息）

　　当上两个必要步骤执行完毕，就可轻松地使用不同优先级别的日志记录语句插入到您想记录日志的任何地方，其语法如下：

　　 Logger.debug ( Object message ) ;
　　Logger.info ( Object message ) ;
　　Logger.warn ( Object message ) ;
　　Logger.error ( Object message ) ;

log4j范例程序

下面将使用一个最简单的范例程序来进一步说明log4j的使用方法。程序代码如下：

 

import org.apache.log4j.*;

 

public class LogTest {

 

 

    static Logger logger = Logger.getLogger(LogTest.class.getName());

 

    public static void main(String[] args) {

 

        PropertyConfigurator.configure ( “.\\src\ log4j.properties ”) ；

logger.debug( "Debug ..." );

 

        logger.info( "Info ..." );

 

        logger.warn( "Warn ..." );

 

        logger.error( "Error ..." );

 

    }

}

程序说明：

① static Logger logger = Logger.getLogger(LogTest.class.getName()); 就是创建一个属于 LogTest 类的 Logger 对象，创建时要告知 Logger 你当前的 Class 是什么。

② PropertyConfigurator.configure ( “ log4j.properties ”) 就是说使用当前工程目录下的 src 文件夹中的 log4j.properties 文件作为配置文件。若将 log4j.properties 放在工程根目录下也可不写此句，程序会自动找到配置文件。

③ logger.debug 就是输出 debug 的信息， logger.info 就是输出提示信息， logger.warn 就是显示警告信息， logger.error 就是显示错误信息。

 

下面是配置文件 log4j.properties 的内容：

log4j.rootCategory=DEBUG, stdout ， R

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

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

log4j.appender.stdout.layout.ConversionPattern=%5p (%F:%L) - %m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender

log4j.appender.R.File=log.txt

log4j.appender.R.MaxFileSize=100KB

log4j.appender.R.MaxBackupIndex=1

log4j.appender.R.layout=org.apache.log4j.PatternLayout

log4j.appender.R.layout.ConversionPattern=%d { yyyy MMM dd HH:mm:ss } %-5p %c - %m%n

程序说明：

① log4j.rootCategory=DEBUG, stdout ， R

就是说我要显示所有优先权等於和高于 Debug的信息。
"stdout"， ”R” 表示我定义了两个输出端 ( 随便什么名字都好 ) 。

② 下面的三行说 stdout 输出端其实是标准输出 Console ，也就是屏幕。输出的格式是 Pattern Layout 。转换方式是 %5p (%F:%L) - %m%n ，即前五格用来显示优先权，再显示当前的文件名，加当前的行数。最后是 logger.debug() 或 logger.info() 或 logger.warn() 或 logger.error() 里的信息。 %n 表示回车空行。

③ 再加上下面六行则 log 信息不光显示在屏幕上，而且将被保存在一个叫 "log.txt" 的文件里，文件最大为 100KB 。如果文件大小超过 100KB ，文件会被备份成 "log.txt.1" ，新的 "log.txt" 继续记录 log 信息。

接下来我们可以改变 log4j.properties ，而不需重新编译就可以控制 log 信息是否显示、 log 信息的输出端类型、输出方式、输出格式，等等。举例如下：

① 在 log4j.properties 文件里把 "log4j.rootCategory=DEBUG,stdout,R" 改写成 "log4j.rootCategory=OFF, stdout,R" ，这样所有的 log信息都不会显示了；解决了本文开始提出的问题。
② 在 log4j.properties 文件里把 "log4j.rootCategory=DEBUG,stdout,R" 改写成 "log4j.rootCategory=INFO, stdout,R" ，这样只显示 INFO, WARN, ERROR 的 log 信息，而 DEBUG 信息不会被显示；

 

在web程序中使用log4j注意问题

1、    由于jsp或servlet在执行状态时没有当前路径概念，所有使用 PropertyConfigurator.configure （ String ）语句找 log4j.properties 文件时要给出相对于当前 jsp 或 servlet 的路径转化成为一个绝对的文件系统路径。方法是使用 servletcontext.getrealpath(string) 语句。例：

//得到当前jsp路径

String prefix =  getServletContext().getRealPath( "/");

//读取 log4j.properties

PropertyConfigurator.configure(prefix+ "\\WEB-INF\\log4j.properties");

2、相应的log4j.properties设置某个属性时也要在程序中设置绝对路径。例：

log4j.appender.R.File属性设置日志文件存放位置。我们可以用读写.properties配置文件的方法进行灵活设置。


log4e使用说明

在了解了log4j的功能后，我们肯定会我们的程序中 编写一些 Log4j 日志记录。对于使用 Eclipse 的程序员 Log4e 将是我们最得力的 log4j 日志编写助手，现在开始 Log4e 之旅。

Log4e 是一个免费的 Eclipse Plugin ，它可帮助你在你的 Java 工程中快速加入 Log ； 我们可以在 http://log4e.jayefem.de/index.php/Download 网站上下载 Log4e 最新版本。下载后将相应文件夹拷贝到 Eclipse 的插件目录下，重新 Eclipse ，在首选项中会多出一个 Log4e 选项。

Log4e 可以有多个插入 Log 为一个方法、类，当然也可以在当前位置插入 Log ，同时其也可以把 Sysout.out.println() 的转换为 log ；所有的这一切只需要你点点鼠标或者按一次快捷键，下面我们只以为一个方法插入 Log 为例来讲解

1.JPG

在 Java 编辑上下文中点击右键，选择 Log4E ，你将看到如下界面：

2.JPG点击 Insert Log Statement For This Method ，你将看到验证页面：

3.JPG
Finish 后这时你将看到插入 Log后的函数如下：
4.JPG


cAng^Er 2007-01-15 11:36 发表评论
]]>使用JSF和MyFaces实现文件上载http://www.blogjava.net/xiaosao/articles/87628.htmlcAng^ErcAng^ErThu, 14 Dec 2006 02:02:00 GMThttp://www.blogjava.net/xiaosao/articles/87628.htmlhttp://www.blogjava.net/xiaosao/comments/87628.htmlhttp://www.blogjava.net/xiaosao/articles/87628.html#Feedback0http://www.blogjava.net/xiaosao/comments/commentRss/87628.htmlhttp://www.blogjava.net/xiaosao/services/trackbacks/87628.html 最近要做上传，但是MultiPartRequestWrapper中的很多的方法都是过时的了，在晚上看看到这篇文章挺好的，放在这里，学习一下！
原文连接地址：
 http://www.java3z.com/cwbwebhome/article/article2a/2136.jsp?id=463
Web浏览器为我们利用Web应用程序发送文件提供了一条简单的途径，但是当前版本的Java Web标准（servlets、JSP和JSF）却无法为我们提供任何帮助。幸运的是，有一些第三方框架组件（例如Apache Commons File Upload、 Apache MyFaces和Oracle ADF Faces）实现了这种特性，它们都暴露了简单的API和定制的标记（tag）。

　　 本文的前面一部分介绍文件上载操作是如何实现的，解释了MyFaces和通用文件上载（前者在内部使用了后者）。我们了解这些开放源代码框架组件的内部工作方式是非常重要的，因为只有这样我们才能高效率地使用它们，才能根据自己的需要对它们进行修改。本文的第二部分将介绍一个简单的应用程序，它让用户使用web浏览器上载文件。


　　 基于Web的文件上载

　　 我们把"上载"这个专业术语用得有点过滥了。Web管理员在自己的站点上发布文件的时候，它会说自己"上载"了一个文件。Web开发者在建立HTML窗体和脚本，让普通用户通过web浏览器发送一个文件的时候，他也会说自己实现了文件"上载"功能。

　　 这两种含义在某些方面是重叠的，因为web管理员可能使用基于web的界面来发布文件（页面、图像、脚本等等）。免费提供个人web站点的公司（例如Yahoo），实现基于web的文件上载功能的目的是为了让人们上载自己的页面。它允许任何一个拥有web浏览器和互联网访问能力的个人发布一个小型的web站点。但是，目前有一些更好的、可用于发布web内容的方式，例如FTP或安全FTP。在这种情况下，你可以利用专用的应用程序（例如FTP客户端）代替web浏览器把自己的内容上载到web服务器上。

　　 本文从web开发者的角度来讨论文件上载的问题。例如，一个基于web的邮件应用程序（例如Yahoo邮件），就实现了文件上载，因为只有这样，用户才能够发送那些带有附件的消息。另一个比较好的例子是找工作的web站点，它允许用户把自己的简历发送给招聘人员。本文的示例应用程序计算上载文件的散列值。你可以在自己的应用程序中对上载的文件进行任意的处理，例如把它们的内容存储在数据库中或把它们作为邮件附件发送。现在，让我们看看如何在web应用程序中实现文件上载吧。

　　 一个HTML窗体中可以包含一个或多个＜input type="file"＞元素，浏览器把它们作为输入字段来显示（呈现），在这些字段中允许用户输入文件路径。在每个文件输入字段的后面，web浏览器会添加一个按钮，它会打开一个文件对话框，让用户选择一个文件（代替输入路径）：


图1：包含文件输入字段的web窗体

　　 当用户点击窗体的"提交（Submit）"按钮的时候，web浏览器对窗体的数据进行编码，其中包括被选中的文件、文件名（或路径）和窗体的其它一些参数。接着，浏览器把编码后的数据发送给web服务器，web服务器把这些数据传递给＜form＞标记的action属性所指定的脚本来处理。如果你开发一个Java web应用程序，那么操作脚本可能是一个servlet（小服务程序）或JSP页面。

　　 由于窗体数据默认的编码方式和默认的GET方法都不适合文件上载，所以包含文件输入字段的窗体必须在＜form＞标记中指定multipart/form-data编码方式和POST方法：

＜form enctype="multipart/form-data" method="POST" action="..."＞
...
＜input type="file" name="..."＞
...
＜/form＞


　　 但是事情并非这么简单，因为实现servlet和JSP规范的应用程序服务器不一定能够处理multipart/form-data编码方式。因此，你必须分析请求的输入流，例如Apache通用文件上载就是一个小型的Java程序包，它让你能够从编码的数据中获取被上载文件的内容。这个程序包的API是很灵活的，它允许你把小文件存储在内存中，把大文件存储在磁盘的临时目录中。你可以指定一个文件大小的阀值，大于这个值的文件都会被写到磁盘上，而不会保留在内存中，而且你还可以规定允许的被上载文件的最大大小。

　　 前面提到的org.apache.commons.fileupload程序包包含一个叫作DiskFileUpload的类，它的parseRequest()方法获取HttpServletRequest参数，并返回org.apache.commons.fileupload.FileItem实例列表。编码后的窗体数据从servlet请求的getInputStream()方法所返回的数据流流中读取。FileItem这个名字容易使人误解，因为这个接口的实例同时表现了被上载的文件和正常的请求参数。

　　 通用文件上载程序包所提供的API赋予了你访问分解后的窗体数据的权利，但是servlet请求的getParameter()和getParameterValues()方法却无法工作。这是一个难题，因为在输入字段、检查框、单选框和列表框后台运行的JSF组件需要调用这两个方法。我们可以利用Servlets API提供的两个特性（过滤器和请求包装器）来解决这个问题。下一部分描述了Apache MyFaces如何实现过滤器，添加了大量必要的对文件上载的支持，而不会中断已有的JSF组件。此外，MyFaces为JavaBeans提供了API，同时还提供了一个定制的JSF组件，它表现为＜input type="file"＞元素。

　　配置JSF和MyFaces扩展

　　 目前，JSF规范的主要实现是JSF参考实现（RI），与此同时，Apache提供了另外一个实现，就是MyFaces。当然可能存在其它一些JSF实现，但是JSF RI和MyFaces是其中最流行的两个。很多开发者更喜欢前者，因为Sun把它称为"官方的"实现，但是，MyFaces拥有一些有趣的扩展（例如对上载文件操作的支持）。如果你愿意，可以把MyFaces扩展与Sun的JSF RI一起使用。你只需要把myfaces-extensions.jar文件、JSF RI的JAR文件和commons-fileupload-1.0.jar文件一起放到自己的web应用程序的WEB-INF/lib目录中就可以了。下面是需要的JAR文件：

JSF 1.1 RI jsf-api.jarjsf-impl.jar
JSTL 1.1 RI jstl.jarstandard.jar
MyFaces扩展 myfaces-extensions.jar
Apache Commons（供JSF和MyFaces 扩展使用） commons-collections.jarcommons-digester.jarcommons-beanutils.jarcommons-logging.jarcommons-fileupload-1.0.jar


　　 org.apache.myfaces.component.html.util程序包中的MultipartRequestWrapper类充当MyFaces和通用文件上载之间的桥梁。这个类扩展了HttpServletRequestWrapper，重载了getParameterMap()、getParameterNames()、getParameter()和getParameterValues()方法，这样它们才能适应multipart/form-data编码方式。此外，MultipartRequestWrapper提供了两个新的方法，分别是getFileItem()和getFileItems()，它允许你通过org.apache.commons.fileupload.FileItem接口来访问被上载的文件。

　　 当MyFaces检测到编码方式的时候，org.apache.myfaces.component.html.util程序包中的ExtensionsFilter就建立MultipartRequestWrapper实例。因此，你不需要关心窗体数据的分解，但是如果你希望改变被上载文件的处理方式，那么了解它是如何实现的就很有用处了。在典型的应用程序中，你必须在自己的web应用程序的web.xml描述信息中配置ExtensionsFilter，这样它才能在JSF的FacesServlet前面截取HTTP请求：

＜?xml version="1.0" encoding="UTF-8"?＞

＜!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＞

＜context-param＞
＜param-name＞javax.faces.STATE_SAVING_METHOD＜/param-name＞
＜param-value＞client＜/param-value＞
＜/context-param＞

＜servlet＞
＜servlet-name＞FacesServlet＜/servlet-name＞
＜servlet-class＞
javax.faces.webapp.FacesServlet
＜/servlet-class＞
＜load-on-startup＞1＜/load-on-startup＞
＜/servlet＞

＜servlet-mapping＞
＜servlet-name＞FacesServlet＜/servlet-name＞
＜url-pattern＞/faces/*＜/url-pattern＞
＜/servlet-mapping＞

＜servlet-mapping＞
＜servlet-name＞FacesServlet＜/servlet-name＞
＜url-pattern＞*.faces＜/url-pattern＞
＜/servlet-mapping＞

＜filter＞
＜filter-name＞ExtensionsFilter＜/filter-name＞
＜filter-class＞
org.apache.myfaces.component.html.util.ExtensionsFilter
＜/filter-class＞
＜init-param＞
＜param-name＞uploadMaxFileSize＜/param-name＞
＜param-value＞10m＜/param-value＞
＜/init-param＞
＜init-param＞
＜param-name＞uploadThresholdSize＜/param-name＞
＜param-value＞100k＜/param-value＞
＜/init-param＞
＜/filter＞

＜filter-mapping＞
＜filter-name＞ExtensionsFilter＜/filter-name＞
＜servlet-name＞FacesServlet＜/servlet-name＞
＜/filter-mapping＞

＜welcome-file-list＞
＜welcome-file＞index.jsp＜/welcome-file＞
＜/welcome-file-list＞

＜/web-app＞


　　 前面示例中的两个过滤器（filter）参数告诉MyFaces把小于100K的文件放入内存中，并且忽略（即不处理）占用10MB以上磁盘空间的文件。大小介于uploadThresholdSize和uploadMaxFileSize之间的文件将作为临时文件存储在磁盘上。如果你试图载入一个太大的文件，MyFaces当前版本将忽略所有的窗体数据，就像用户提交了一个空表单一样。如果你希望给上载文件失败的用户一些提示信息，就需要更改MyFaces的MultipartRequestWrapper类，找到捕捉SizeLimitExceededException异常的位置，并使用FacesContext.getCurrentInstance().addMessage()来警告用户。

　　 前面提到，MyFaces扩展包含了文件上载组件，我们可以在JSF页面中使用它。下一部分将介绍如何实现这样的操作。 使用MyFaces的文件上载组件。

　　 为了在web页面中使用JSF和MyFaces，你必须在＜%@taglib%＞指令中声明它们的标记库：

＜%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%＞
＜%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%＞
＜%@ taglib uri="http://myfaces.apache.org/extensions" prefix="x"%＞


　　 JSF的＜h:form＞标记没有method属性，这是因为它只支持POST方法，但它拥有enctype属性，如果你希望上载文件，就必须使用该属性，把窗体数据设置为多部分（multipart）编码类型：

＜f:view＞
＜h:form id="MyForm" enctype="multipart/form-data" ＞
...
＜x:inputFileUpload id="myFileId"
value="#{myBean.myFile}"
storage="file"
required="true"/＞
...
＜/h:form＞
＜/f:view＞


　　 MyFaces的＜x:inputFileUpload＞标记使你能够定义UI组件的属性，它的呈现部件（renderer）生成＜input type="file"＞元素。org.apache.myfaces.custom.fileupload程序包包含了UI组件类（HtmlInputFileUpload）、呈现部件（HtmlFileUploadRenderer）、定制的标记处理程序（HtmlInputFileUploadTag）、UploadedFile接口和其它一些辅助类。HtmlInputFileUpload类扩展了JSF标准的HtmlInputText组件，重载了它的一些方法。HtmlFileUploadRenderer负责生成HTML标记，从MultipartRequestWrapper中获取FileItem。

　　 MyFaces并没有让你直接访问通用文件上载所建立的FileItem实例，它提供了自己的UploadedFile接口来获取被上载的文件的内容、内容类型、文件名和文件大小。JSF窗体的后台bean必须拥有一个UploadedFile类型的属性。前面的例子用JSF表达式（#{myBean.myFile}）把UI组件的值绑定到了这样一个bean上。JSF框架组件将获取HtmlInputFileUpload组件的值，它是一个UploadedFile实例，并且会设置后台bean的myFile属性：

import org.apache.myfaces.custom.fileupload.UploadedFile;
...
public class MyBean {
private UploadedFile myFile;

public UploadedFile getMyFile() {
return myFile;
}

public void setMyFile(UploadedFile myFile) {
this.myFile = myFile;
}
...
}


　　 MyFaces拥有UploadedFile接口的两种实现方式：UploadedFileDefaultMemoryImpl和UploadedFileDefaultFileImpl。当＜x:inputFileUpload＞标记没有带storage属性，或者这个属性的值是memory的时候，就使用前者。当storage属性的值是file的时候使用后者。

　　 UploadedFileDefaultMemoryImpl类从FileItem实例中获取被上载文件的内容、文件名、文件大小和内容类型，并把所有这些信息存储在私有字段中。因此，即使通用文件上载把这个文件保存在磁盘上，UploadedFile的这种实现也会把被上载文件的内容保存在内存中，浪费了资源。

　　 UploadedFileDefaultFileImpl类使用一个过渡字段来保存FileItem实例的指针，仅仅在调用getInputStream()方法的时候，才使用它来获取被上载文件的内容。这种实现节约了内存空间，但是，如果它是序列化的（serialize），那么在还原序列化（deserialization）之后，你就无法获取文件内容了。因此，文件上载窗体的后台bean不能保存在session作用域（scope）中，因为当应用程序重新启动或服务器关闭的时候，应用程序服务器会序列化对话（session）bean。

　　 如果你希望得到了一个工作正常的、效率很高的解决方案，那么就把后台bean保存在request作用域中，并在＜x:inputFileUpload＞中指定storage="file"以节约内存资源。你也可以通过添加writeObject()方法（它用于序列化被上载文件的内容）来解决UploadedFileDefaultFileImpl类的序列化问题。为了保证UploadedFile的这种实现的高效性，相应的readObject()方法应该重新建立一个临时文件，而不是从内存中读取内容。

　　 使用MyFaces的时候还需要注意一个问题：UploadedFile接口并没有定义一个用于删除通用文件上载在磁盘上所建立的临时文件的方法。当FileItem实例作为垃圾被清理的时候，就应该删掉这些文件。通用文件上载的DefaultFileItem类拥有一个finalize()方法，当管理临时文件的对象被从内存中删除的时候，它可以删除它们所管理的临时文件。如果你的应用程序正在上载大型文件的时候，你可能希望在它们被处理后立即删除，而不用等待垃圾清除过程。为了实现这样的功能，你必须添加一个getFileItem()方法（在UploadedFileDefaultFileImpl中），它应该返回FileItem实例，而该实例拥有delete()方法。

　　示例应用程序

　　 前面的部分介绍了是MyFaces如何在通用文件上载的帮助下支持文件上载的。现在我们来看一个实际的利用了这种特性的应用程序。JSF窗体（MyForm.jsp）让用户选择一个文件和一个报文摘要算法，后台bean（ MyBean.java）使用这个算法计算出一个散列值，显示在另外一个web页面（MyResult.jsp）中。这些页面和后台bean通过一个JSF配置文件（faces-config.xml）结合在一起。

　　 MyForm.jsp页面

　　 这个JSF窗体使用了MyFaces的＜x:inputFileUpload＞标记，同时还使用了其它一些标准的JSF标记来呈现标签、消息、包含报文摘要算法的下拉列表、使用JSF表达式（#{myBean.processMyFile}）指定了处理被上载文件的操作方法的命令按钮：

＜%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%＞
＜%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%＞
＜%@ taglib uri="http://myfaces.apache.org/extensions" prefix="x"%＞

＜f:view＞
＜h:form id="MyForm" enctype="multipart/form-data" ＞
　 ＜h:messages globalOnly="true" styleClass="message"/＞
　 ＜h:panelGrid columns="3" border="0" cellspacing="5"＞
　 ＜h:outputLabel for="myFileId" value="File: "/＞
　 ＜x:inputFileUpload id="myFileId" value="#{myBean.myFile}" storage="file" required="true"/＞
　 ＜h:message for="myFileId"/＞
　 ＜h:outputLabel for="myParamId" value="Param: "/＞
　 ＜h:selectOneMenu id="myParamId" value="#{myBean.myParam}" required="true"＞
　 ＜f:selectItem itemLabel="" itemValue=""/＞
　 ＜f:selectItem itemLabel="MD5" itemValue="MD5"/＞
　 ＜f:selectItem itemLabel="SHA-1" itemValue="SHA-1"/＞
　 ＜f:selectItem itemLabel="SHA-256" itemValue="SHA-256"/＞
　 ＜f:selectItem itemLabel="SHA-384" itemValue="SHA-384"/＞
　 ＜f:selectItem itemLabel="SHA-512" itemValue="SHA-512"/＞
＜/h:selectOneMenu＞
＜h:message for="myParamId"/＞

＜h:outputText value=" "/＞
＜h:commandButton value="Submit"
action="#{myBean.processMyFile}"/＞
＜h:outputText value=" "/＞

＜/h:panelGrid＞
＜/h:form＞
＜/f:view＞


　　 MyBean类

　　 后台bean拥有三个属性：myFile、myParam和myResult。前面已经解释了myFile属性的角色。它让你获取被上载文件的内容和文件名、文件大小、内容类型。myParam属性的值是报文摘要算法。myResult属性将保存processMyFile()方法执行之后的散列值。MyBean类为自己的所有属性提供了get和set方法：

package com.devsphere.articles.jsfupload;

import org.apache.myfaces.custom.fileupload.UploadedFile;
...
public class MyBean {
　 private UploadedFile myFile;
　 private String myParam;
　 private String myResult;

　 public UploadedFile getMyFile() {
　　 return myFile;
　 }

　 public void setMyFile(UploadedFile myFile) {
　　 this.myFile = myFile;
　 }

　 public String getMyParam() {
　　 return myParam;
　 }

　 public void setMyParam(String myParam) {
　　 this.myParam = myParam;
　 }

　 public String getMyResult() {
　　 return myResult;
　 }

　 public void setMyResult(String myResult) {
　　 this.myResult = myResult;
　 }
　 ...
}


　　 processMyFile()通过一个输入流获取被上载文件的内容，这个输入流是通过myFile.getInputStream()获得的。散列值是在java.security.MessageDigest的帮助下计算出来的，然后把它转换为字符串，这样就可以被myResult属性访问了：

package com.devsphere.articles.jsfupload;
...
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import java.io.*;

public class MyBean {
　 ...
　 public String processMyFile() {
　　 try {
　　　 MessageDigest md= MessageDigest.getInstance(myParam);
　　　 InputStream in = new BufferedInputStream(
　　　 myFile.getInputStream());
　　　 try {
　　　　 byte[] buffer = new byte[64 * 1024];
　　　　 int count;
　　　　 while ((count = in.read(buffer)) ＞ 0)
　　　　　 md.update(buffer, 0, count);
　　 } finally {
　　　 in.close();
　　 }
　　 byte hash[] = md.digest();
　　 StringBuffer buf = new StringBuffer();
　　 for (int i = 0; i ＜ hash.length; i++) {
　　　 int b = hash[i] & 0xFF;
　　　 int c = (b ＞＞ 4) & 0xF;
　　　 c = c ＜ 10 ? '0' + c : 'A' + c - 10;
　　　 buf.append((char) c);
　　　 c = b & 0xF;
　　　 c = c ＜ 10 ? '0' + c : 'A' + c - 10;
　　　 buf.append((char) c);
　　 }
　　 myResult = buf.toString();
　　 return "OK";
　 } catch (Exception x) {
　　 FacesMessage message = new FacesMessage(
　　 FacesMessage.SEVERITY_FATAL,
　　 x.getClass().getName(), x.getMessage());
　　 FacesContext.getCurrentInstance().addMessage(null, message);
　　 return null;
　 }
}

}


　　 faces-config.xml文件

　　 JSF配置文件把后台bean定义在request作用域中，并且指定了一个导航规则：

＜?xml version="1.0" encoding="UTF-8"?＞

＜!DOCTYPE faces-config PUBLIC
"-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN"
"http://java.sun.com/dtd/web-facesconfig_1_1.dtd"＞

＜faces-config＞

＜managed-bean＞
＜managed-bean-name＞myBean＜/managed-bean-name＞
＜managed-bean-class＞
com.devsphere.articles.jsfupload.MyBean
＜/managed-bean-class＞
＜managed-bean-scope＞request＜/managed-bean-scope＞
＜/managed-bean＞

＜navigation-rule＞
＜from-view-id＞/MyForm.jsp＜/from-view-id＞
＜navigation-case＞
＜from-outcome＞OK＜/from-outcome＞
＜to-view-id＞/MyResult.jsp＜/to-view-id＞
＜/navigation-case＞
＜/navigation-rule＞

＜/faces-config＞


　　 MyResult.jsp页面

　　 这个web页面显示了被上载文件的一些信息：

＜%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%＞
＜%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%＞

＜f:view＞

＜h:panelGrid columns="2" border="0" cellspacing="5"＞

＜h:outputText value="FileName:"/＞
＜h:outputText value="#{myBean.myFile.name}"/＞

＜h:outputText value="FileSize:"/＞
＜h:outputText value="#{myBean.myFile.size}"/＞

＜h:outputText value="Param:"/＞
＜h:outputText value="#{myBean.myParam}"/＞

＜h:outputText value="Result:"/＞
＜h:outputText value="#{myBean.myResult}"/＞

＜/h:panelGrid＞

＜/f:view＞


　　 被显示的文件名可能带有客户端文件系统的完整路径，如下所示：


图2：结果页面产生的输出信息

　　 总结

　　 在很多情况下，用户需要通过浏览器上载文件，但是在服务器端却没有处理这些文件的理想方法。把文件的内容保存在内存中对于小型文件来说是可以接受的，但是把被上载的文件存储在临时文件中使这种情况变复杂了。MyFaces让你能够选择一个适合应用程序需求的解决方案，但是这个框架组件也有一些小问题。当你不再需要临时文件的时候，它无法让你删除它们；文件名有时候带有文件路径；当用户上载过大的文件的时候也没有警告信息。这些缺陷是可以修补的，因为我们可以使用源代码，而且本文就介绍了MyFaces代码可以改进的一些的地方。无论如何，对于多数应用程序来说，MyFaces不做修改就合乎需求。本文的例子是使用JSF 1.1.01、MyFaces 1.0.9和通用文件上载1.0环境测试的。

cAng^Er 2006-12-14 10:02 发表评论
]]>