BlogJava-优雅天平-文章分类-开源相关

JFreeChart完全攻略示例各种方法和属性

Victor — Sun, 22 Jan 2006 06:48:00 GMT

摘要: 封装FreeChart的Bean FreeChart.java package com.function;/*基于JFreeChart 1.0.0 Pre2.jar*/import java.io.*;import java.awt.Font;import java.awt.Color;import java.text.SimpleDateFormat;import java.text.Dec... 阅读全文

Victor 2006-01-22 14:48 发表评论

开启log4j的记录源代码行号的配置，会对系统性能产生影响！

Victor — Fri, 09 Dec 2005 03:05:00 GMT

今天看到一篇文章，谈Log4j对系统的效能的影响...整理如下：

一般，我们用log4j写log的时候，很习惯于如下面记录：

2005-01-11 09:57:57,816 DEBUG (BizProc.java:275) Begin to get connection...
2005-01-11 09:57:57,816 DEBUG (BizProc.java:275)   Obtain connection 2345@defd
2005-01-11 09:57:57,816 DEBUG (BizProc.java:275)   Begin transaction [TX_2015_RECV] processing...
2005-01-11 09:57:57,925 DEBUG (BizProc.java:328)     All of the values were:

这里会把Java Source Code中的行号带出来，查找错误很方便...

但，这也是问题之所在...文章中介绍，Log4j之所以可以得到行号，是用了JVM的一个特性，不知道大家有没有注意到，如果我们的Java程序在运行时出现错误，会出现下面的信息：

javax.naming.NamingException: Cannot create resource instance
at org.apache.naming.factory.ResourceFactory.getObjectInstance(ResourceFactory.java:189)
at javax.naming.spi.NamingManager.getObjectInstance(NamingManager.java:301)
at org.apache.naming.NamingContext.lookup(NamingContext.java:834)
at org.apache.naming.NamingContext.lookup(NamingContext.java:181)
at org.apache.naming.NamingContext.lookup(NamingContext.java:822)
at org.apache.naming.NamingContext.lookup(NamingContext.java:181)
at org.apache.naming.NamingContext.lookup(NamingContext.java:822)
at org.apache.naming.NamingContext.lookup(NamingContext.java:181)
at org.apache.naming.NamingContext.lookup(NamingContext.java:822)
at org.apache.naming.NamingContext.lookup(NamingContext.java:194)
at org.apache.naming.SelectorContext.lookup(SelectorContext.java:183)
at javax.naming.InitialContext.lookup(InitialContext.java:347)

看到黑体字没有，原来JVM已经内嵌支持Debug出行号信息了！可是，这里是出错的时候，JVM抛出的，那为什么用 log4j.info() 的时候，也可以看到行号呢？

下面就是重点，Log4j中记录行号的过程...

(1) 调用了 log4j.info() 或是log4j.debug()方法...
(2) 建立一个Throwable的对象来取得当前运行堆栈的快照...Throwable.fillInStackTrace();
(3) 从抛出的Throwable对象中，来分析出当前log信息的行号...

但是，请注意，建立运行时的堆栈跟踪，对JVM来说，是一项非常大的开销！

所以，我们在配置log4j的PatternLayout的时候，如果是要上线到正式环境，一定要记者把参数关掉，
一般来说，用 “%d %-5p %m%n" 就可以满足了！

原文请参考这里：Sneaky, sneaky Log4J

===========================================================================
补遗篇~~~~~！

log4j.rootLogger=info, Console
log4j.logger.net.csdn.blog.xport=debug, RollingFile
log4j.additivity.net.csdn.blog.xport=false

log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d %-5p [%t] %C{1} - %m%n

log4j.appender.RollingFile=org.apache.log4j.RollingFileAppender
log4j.appender.RollingFile.File=SystemLog.log
log4j.appender.RollingFile.Append=true
log4j.appender.RollingFile.MaxFileSize=2MB
log4j.appender.RollingFile.layout=org.apache.log4j.PatternLayout
log4j.appender.RollingFile.layout.ConversionPattern=%d %-5p [%t] %C{1} - %m%n

Victor 2005-12-09 11:05 发表评论

Java开源Blog实现，Roller 2.0 的安装手记！ (转)

Victor — Fri, 09 Dec 2005 02:55:00 GMT

Roller 是一个Struts + Hibernate 的 Java 开源实现，正好拿来研究研究，首先就是要把它安装起来了，整理
了一下步骤和注意事项，记录如下：

准备需要的基本环境：

1. Java 2 SDK 1.4.2_10
2. Tomcat 5.0.28
3. Roller 2.0
4. MySQL 5.0.16

首先，确保MySQL开启了对InnoDB和UTF-8的支持，在my.ini中开启下面的参数：

[mysqld]
default-storage-engine=innodb
default-character-set=utf8

启动好MySQL待用...D:\MySQL\mysqld.exe --console --datadir=I:\MyData\Data

假设我的Tomcat主目录为：$CATALINA_HOME=D:\J2EE_HOME\AppServer\Tomcat

把压缩的Roller文件 roller-2.0-incubating.tar 解开...
并放到$CATALINA_HOME\WebApp\roller下面...如图...

开始建立MySQL中的数据库：

    I:> CD %CATALINA_HOME%\webapps\roller\WEB-INF\dbscripts\mysql
    I:> mysql -u root -p
    password: *****
    mysql> create database roller;
    mysql> grant all on roller.* to scott@'%' identified by 'tiger';
    mysql> grant all on roller.* to scott@'localhost' identified by 'tiger';
    mysql> use roller;
    mysql> source createdb.sql
    mysql> quit

在 $CATALINA_HOME\conf\Catalina\localhost 中放置Roller的Web Application的部署
配置档案 roller.xml，内容如下：


            driverName="com.mysql.jdbc.Driver" 
        connectionURL="jdbc:mysql://localhost:3306/roller?autoReconnect=true&useUnicode=true&characterEncoding=utf-8&mysqlEncoding=utf8"
        connectionName="scott"
        connectionPassword="tiger"
        userTable="rolleruser"
        userNameCol="username"
        userCredCol="passphrase"
        userRoleTable="userrole"
        roleNameCol="rolename" debug="0" />

    
    
        
            factory
            org.apache.commons.dbcp.BasicDataSourceFactory
        
        
            driverClassName
            com.mysql.jdbc.Driver
        
        
            url
            jdbc:mysql://localhost:3306/roller?autoReconnect=true&useUnicode=true&characterEncoding=utf-8&mysqlEncoding=utf8
        
        
            username
            scott
        
        
            password
            tiger
        
        
            maxActive
            20
        
        
            maxIdle
            3
        
        
            removeAbandoned
            true
        
        
            maxWait
            3000

完成上面的设定后，接下来，我们修改一下Tomcat中的Connector的设定，使它能够支持UTF-8的编码，
打开 $CATALINA_HOME\conf\server.xml，做如下修改...

    URIEncoding="UTF-8"
    maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
    enableLookups="false" redirectPort="8443" acceptCount="100"
    debug="0" connectionTimeout="20000"
    disableUploadTimeout="true" />

到这里，基本上Tomcat相关的设定就完成了，因为Roller Blog可以支持上传附件和全文检索等功能，
所以，我们还有一个设定的动作...

在 $CATALINA_HOME\WebApp\roller 中新建下面层次的目录：

$CATALINA_HOME\WebApp\roller
                         |
                         +---data
                               |
                               +---search-index
                               +---uploads

找到 $CATALINA_HOME\webapps\roller\WEB-INF\classes\roller.properties ，做如下修改：

# The directory in which Roller will upload files
# uploads.dir=${user.home}/roller_data/uploads
uploads.dir=${TOMCAT_HOME}/webapps/roller/data/uploads

# force Roller to recreate the entire search index)
# search.index.dir=${user.home}/roller_data/search-index
search.index.dir=${TOMCAT_HOME}/webapps/roller/data/search-index

好了，大功告成，启动Tomcat，可以运行Roller了！

Victor 2005-12-09 10:55 发表评论

Jakarta-Common-BeanUtils研究心得(2)[转载]

Victor — Wed, 30 Nov 2005 02:39:00 GMT

作者 :SonyMusic    2003.05.13

六、ConstructorUtils补遗
创建对象还有一个方法：invokeExactConstructor，该方法对参数要求
更加严格，传递进去的参数必须严格符合构造方法的参数列表。
例如：
Object[] args={new Integer(1), "Jan"};
Class[] argsType={int.class, String.class};
Object obj;
//下面这句调用将不会成功，因为args[0]的类型为Integer，而不是int
//obj = ConstructorUtils.invokeExactConstructor(Month.class, args);

//这一句就可以，因为argsType指定了类型。
obj = ConstructorUtils.invokeExactConstructor(Month.class, args, argsType);
Month month=(Month)obj;
System.out.println(BeanUtils.getProperty(month,"value"));

七、MethodUtils
与ConstructorUtils类似，不过调用的时候，通常需要再指定一个method name的参数。

八、DynaClass/DynaBean
这似乎是BeanUtils中最有趣的部分之一了，很简单，简单到光看这两个接口中的方法会不明白
为什么要设计这两个接口。不过看到ResultSetDynaClass后，就明白了。下面是java doc中的代码：
   ResultSet rs = ...;
   ResultSetDynaClass rsdc = new ResultSetDynaClass(rs);
   Iterator rows = rsdc.iterator();
   while (rows.hasNext())  {
     DynaBean row = (DynaBean) rows.next();
     ... process this row ...
   }
   rs.close();
原来这是一个ResultSet的包装器，ResultSetDynaClass实现了DynaClass，它的iterator方法返回一个
ResultSetIterator，则是实现了DynaBean接口。
在获得一个DynaBean之后，我们就可以用
     DynaBean row = (DynaBean) rows.next();
     System.out.println(row.get("field1")); //field1是其中一个字段的名字

再看另一个类RowSetDynaClass的用法，代码如下：
String driver="com.mysql.jdbc.Driver";
String url="jdbc:mysql://localhost/2hu?useUnicode=true&characterEncoding=GBK";
String username="root";
String password="";

java.sql.Connection con=null;
PreparedStatement ps=null;
ResultSet rs=null;
try {
Class.forName(driver).newInstance();
con = DriverManager.getConnection(url);
ps=con.prepareStatement("select * from forumlist");
rs=ps.executeQuery();
//先打印一下，用于检验后面的结果。
while(rs.next()){
System.out.println(rs.getString("name"));
}
rs.beforeFirst();//这里必须用beforeFirst，因为RowSetDynaClass只从当前位置向前滚动

RowSetDynaClass rsdc = new RowSetDynaClass(rs);
rs.close();
ps.close();
List rows = rsdc.getRows();//返回一个标准的List，存放的是DynaBean
for (int i = 0; i DynaBean b=(DynaBean)rows.get(i);
System.out.println(b.get("name"));
}
} catch (Exception e) {
e.printStackTrace();
}
finally{
try {
con.close();
} catch (Exception e) {
}
}

是不是很有趣？封装了ResultSet的数据，代价是占用内存。如果一个表有10万条记录，rsdc.getRows()
就会返回10万个记录。@_@

需要注意的是ResultSetDynaClass和RowSetDynaClass的不同之处：
1，ResultSetDynaClass是基于Iterator的，一次只返回一条记录，而RowSetDynaClass是基于
List的，一次性返回全部记录。直接影响是在数据比较多时ResultSetDynaClass会比较的快速，
而RowSetDynaClass需要将ResultSet中的全部数据都读出来（并存储在其内部），会占用过多的
内存，并且速度也会比较慢。
2，ResultSetDynaClass一次只处理一条记录，在处理完成之前，ResultSet不可以关闭。
3，ResultSetIterator的next()方法返回的DynaBean其实是指向其内部的一个固定
对象，在每次next()之后，内部的值都会被改变。这样做的目的是节约内存，如果你需要保存每
次生成的DynaBean，就需要创建另一个DynaBean，并将数据复制过去，下面也是java doc中的代码：
   ArrayList results = new ArrayList(); // To hold copied list
   ResultSetDynaClass rsdc = ...;
   DynaProperty properties[] = rsdc.getDynaProperties();
   BasicDynaClass bdc =
     new BasicDynaClass("foo", BasicDynaBean.class,
                        rsdc.getDynaProperties());
   Iterator rows = rsdc.iterator();
   while (rows.hasNext()) {
     DynaBean oldRow = (DynaBean) rows.next();
     DynaBean newRow = bdc.newInstance();
     PropertyUtils.copyProperties(newRow, oldRow);
     results.add(newRow);
   }

事实上DynaClass/DynaBean可以用于很多地方，存储各种类型的数据。自己想吧。嘿嘿。

九、自定义的CustomRowSetDynaClass
两年前写过一个与RowSetDynaClass目标相同的类，不过多一个功能，就是分页，只取需要的数据，
这样内存占用就会减少。

先看一段代码：
String driver="com.mysql.jdbc.Driver";
String url="jdbc:mysql://localhost/2hu?useUnicode=true&characterEncoding=GBK";
String username="root";
String password="";

java.sql.Connection con=null;
PreparedStatement ps=null;
ResultSet rs=null;
try {
Class.forName(driver).newInstance();
con = DriverManager.getConnection(url);
ps=con.prepareStatement("select * from forumlist order by name");
rs=ps.executeQuery();
/*
while(rs.next()){
System.out.println(rs.getString("name"));
}
rs.beforeFirst();
*/

//第二个参数表示第几页，第三个参数表示页的大小
CustomRowSetDynaClass rsdc = new CustomRowSetDynaClass(rs, 2, 5);
//RowSetDynaClass rsdc = new RowSetDynaClass(rs);
rs.close();
ps.close();
List rows = rsdc.getRows();
for (int i = 0; i DynaBean b=(DynaBean)rows.get(i);
System.out.println(b.get("name"));
}
} catch (Exception e) {
e.printStackTrace();
}
finally{
try {
con.close();
} catch (Exception e) {
}
}
在这里用到了一个CustomRowSetDynaClass类，构造方法中增加了page和pageSize两个参数，
这样，不管数据库里有多少条记录，最多只取pageSize条记录，若pageSize==-1，则功能和
RowSetDynaClass一样。这在大多数情况下是适用的。该类的代码如下：

package test.jakarta.commons.beanutils;

import java.io.*;
import java.sql.*;
import java.util.*;

import org.apache.commons.beanutils.*;

/**
* @author SonyMusic
*
* To change this generated comment edit the template variable "typecomment":
* Window>Preferences>Java>Templates.
* To enable and disable the creation of type comments go to
* Window>Preferences>Java>Code Generation.
*/
public class CustomRowSetDynaClass implements DynaClass, Serializable {

// ----------------------------------------------------------- Constructors

/**
*

Construct a new {@link RowSetDynaClass} for the specified
* ResultSet. The property names corresponding
* to column names in the result set will be lower cased.

*
* @param resultSet The result set to be wrapped
*
* @exception NullPointerException if resultSet
* is null
* @exception SQLException if the metadata for this result set
* cannot be introspected
*/
public CustomRowSetDynaClass(ResultSet resultSet) throws SQLException {

this(resultSet, true);

}

/**
*

Construct a new {@link RowSetDynaClass} for the specified
* ResultSet. The property names corresponding
* to the column names in the result set will be lower cased or not,
* depending on the specified lowerCase value.

*
*

WARNING - If you specify false
* for lowerCase, the returned property names will
* exactly match the column names returned by your JDBC driver.
* Because different drivers might return column names in different
* cases, the property names seen by your application will vary
* depending on which JDBC driver you are using.

*
* @param resultSet The result set to be wrapped
* @param lowerCase Should property names be lower cased?
*
* @exception NullPointerException if resultSet
* is null
* @exception SQLException if the metadata for this result set
* cannot be introspected
*/
public CustomRowSetDynaClass(ResultSet resultSet, boolean lowerCase)
throws SQLException {

this(resultSet, 1, -1, lowerCase);

}

public CustomRowSetDynaClass(
ResultSet resultSet,
int page,
int pageSize,
boolean lowerCase)
throws SQLException {

if (resultSet == null) {
throw new NullPointerException();
}
this.lowerCase = lowerCase;
this.page = page;
this.pageSize = pageSize;

introspect(resultSet);
copy(resultSet);

}

public CustomRowSetDynaClass(ResultSet resultSet, int page, int pageSize)
throws SQLException {
this(resultSet, page, pageSize, true);
}

// ----------------------------------------------------- Instance Variables

/**
*

Flag defining whether column names should be lower cased when
* converted to property names.

*/
protected boolean lowerCase = true;

protected int page = 1;
protected int pageSize = -1;

/**
*

The set of dynamic properties that are part of this
* {@link DynaClass}.

*/
protected DynaProperty properties[] = null;

/**
*

The set of dynamic properties that are part of this
* {@link DynaClass}, keyed by the property name. Individual descriptor
* instances will be the same instances as those in the
* properties list.

*/
protected Map propertiesMap = new HashMap();

/**
*

The list of {@link DynaBean}s representing the contents of
* the original ResultSet on which this
* {@link RowSetDynaClass} was based.

*/
protected List rows = new ArrayList();

// ------------------------------------------------------ DynaClass Methods

/**
*

Return the name of this DynaClass (analogous to the
* getName() method of java.lang.Class* allows the same DynaClass implementation class to support * different dynamic classes, with different sets of properties.


*/
public String getName() {

return (this.getClass().getName());

}

/**
* Return a property descriptor for the specified property, if it
* exists; otherwise, return null.

*
* @param name Name of the dynamic property for which a descriptor
*  is requested
*
* @exception IllegalArgumentException if no property name is specified
*/
public DynaProperty getDynaProperty(String name) {

if (name == null) {
throw new IllegalArgumentException("No property name specified");
}
return ((DynaProperty) propertiesMap.get(name));

}

/**
* Return an array of ProperyDescriptors for the properties
* currently defined in this DynaClass.  If no properties are defined, a
* zero-length array will be returned.

*/
public DynaProperty[] getDynaProperties() {

return (properties);

}

/**
* Instantiate and return a new DynaBean instance, associated
* with this DynaClass.  NOTE - This operation is not
* supported, and throws an exception.

*
* @exception IllegalAccessException if the Class or the appropriate
*  constructor is not accessible
* @exception InstantiationException if this Class represents an abstract
*  class, an array class, a primitive type, or void; or if instantiation
*  fails for some other reason
*/
public DynaBean newInstance()
throws IllegalAccessException, InstantiationException {

throw new UnsupportedOperationException("newInstance() not supported");

}

// --------------------------------------------------------- Public Methods

/**
* Return a List containing the {@link DynaBean}s that
* represent the contents of each Row from the
* ResultSet that was the basis of this
* {@link RowSetDynaClass} instance.  These {@link DynaBean}s are
* disconnected from the database itself, so there is no problem with
* modifying the contents of the list, or the values of the properties
* of these {@link DynaBean}s.  However, it is the application's
* responsibility to persist any such changes back to the database,
* if it so desires.

*/
public List getRows() {

return (this.rows);

}

// ------------------------------------------------------ Protected Methods

/**
* Copy the column values for each row in the specified
* ResultSet into a newly created {@link DynaBean}, and add
* this bean to the list of {@link DynaBean}s that will later by
* returned by a call to getRows().

*
* @param resultSet The ResultSet whose data is to be
*  copied
*
* @exception SQLException if an error is encountered copying the data
*/
protected void copy(ResultSet resultSet) throws SQLException {
int abs = 0;
int rowsCount = 0;
int currentPageRows = 0;
resultSet.last();
rowsCount = resultSet.getRow();
if (pageSize != -1) {
int totalPages = (int) Math.ceil(((double) rowsCount) / pageSize);
if (page > totalPages)
page = totalPages;
if (page < 1)
page = 1;
abs = (page - 1) * pageSize;

//currentPageRows=(page==totalPages?rowsCount-pageSize*(totalPages-1):pageSize);
} else
pageSize = rowsCount;
if (abs == 0)
resultSet.beforeFirst();
else
resultSet.absolute(abs);
//int 
while (resultSet.next() && ++currentPageRows <= pageSize) {
DynaBean bean = new BasicDynaBean(this);
for (int i = 0; i < properties.length; i++) {
String name = properties[i].getName();
bean.set(name, resultSet.getObject(name));
}
rows.add(bean);
}

}

/**
* Introspect the metadata associated with our result set, and populate
* the properties and propertiesMap instance
* variables.

*
* @param resultSet The resultSet whose metadata is to
*  be introspected
*
* @exception SQLException if an error is encountered processing the
*  result set metadata
*/
protected void introspect(ResultSet resultSet) throws SQLException {

// Accumulate an ordered list of DynaProperties
ArrayList list = new ArrayList();
ResultSetMetaData metadata = resultSet.getMetaData();
int n = metadata.getColumnCount();
for (int i = 1; i <= n; i++) { // JDBC is one-relative!
DynaProperty dynaProperty = createDynaProperty(metadata, i);
if (dynaProperty != null) {
list.add(dynaProperty);
}
}

// Convert this list into the internal data structures we need
properties =
(DynaProperty[]) list.toArray(new DynaProperty[list.size()]);
for (int i = 0; i < properties.length; i++) {
propertiesMap.put(properties[i].getName(), properties[i]);
}

}

/**
* Factory method to create a new DynaProperty for the given index
* into the result set metadata.

* 
* @param metadata is the result set metadata
* @param i is the column index in the metadata
* @return the newly created DynaProperty instance
*/
protected DynaProperty createDynaProperty(
ResultSetMetaData metadata,
int i)
throws SQLException {

String name = null;
if (lowerCase) {
name = metadata.getColumnName(i).toLowerCase();
} else {
name = metadata.getColumnName(i);
}
String className = null;
try {
className = metadata.getColumnClassName(i);
} catch (SQLException e) {
// this is a patch for HsqlDb to ignore exceptions
// thrown by its metadata implementation
}

// Default to Object type if no class name could be retrieved
// from the metadata
Class clazz = Object.class;
if (className != null) {
clazz = loadClass(className);
}
return new DynaProperty(name, clazz);

}

/**
* Loads and returns the Class of the given name.
* By default, a load from the thread context class loader is attempted.
* If there is no such class loader, the class loader used to load this
* class will be utilized.

*
* @exception SQLException if an exception was thrown trying to load
*  the specified class
*/
protected Class loadClass(String className) throws SQLException {

try {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
if (cl == null) {
cl = this.getClass().getClassLoader();
}
return (cl.loadClass(className));
} catch (Exception e) {
throw new SQLException(
"Cannot load column class '" + className + "': " + e);
}

}

}

大部分代码从BeanUtils的源码中取得，只做了简单的修改，没有加多余的注释。如果要正式使用，
需要再做精加工。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
关于这个包，只准备测试到这里了，不过已经有了大概的印象了，至少，知道这个包可以做些什么。
其实这个笔记也只是起到这个作用。@_@


Victor 2005-11-30 10:39 发表评论



Jakarta-Common-BeanUtils研究心得(1)[转载]
Victor — Wed, 30 Nov 2005 02:38:00 GMT
作者: SonyMusic         2003.05.13

一、概述
第一次看到BeanUtils包，是在Struts项目中，作为Struts一个工具来使用的，
估计功能越弄越强，就移到Common项目中了吧。

BeanUtils一共有四个package:
org.apache.commons.beanutils
org.apache.commons.beanutils.converters
org.apache.commons.beanutils.locale
org.apache.commons.beanutils.locale.converters
后三个包主要是用于数据的转换，围绕着一个Converter接口，该接口只有一个方法：
java.lang.Object convert(java.lang.Class type, java.lang.Object value) ，
用于将一个value转换成另一个类型为type的Object。在一些自动化的应用中应该会有用。
这里不作评论，以后有兴趣了，或者觉得有用了，再行研究。
这里只讲第一个包。

二、测试用的Bean
在开始所有的测试之前，我写了一个简单的Bean，以便于测试，代码如下：
package test.jakarta.commons.beanutils;

/**
 * @author SonyMusic
 *
 */
public class Month {
 private int value;
 private String name;
 private int[] days={11,22,33,44,55};

 public Month(int v, String n){
   value=v;
   name=n;
 }
 
 /**
  * Returns the name.
  * @return String
  */
 public String getName() {
   return name;
 }

 /**
  * Returns the value.
  * @return int
  */
 public int getValue() {
   return value;
 }

 /**
  * Sets the name.
  * @param name The name to set
  */
 public void setName(String name) {
   this.name = name;
 }

 /**
  * Sets the value.
  * @param value The value to set
  */
 public void setValue(int value) {
   this.value = value;
 }

 /**
  * @see java.lang.Object#toString()
  */
 public String toString() {
   return value+"("+name+")";
 }

 public int[] getDays() {
   return days;
 }

 public void setDays(int[] is) {
   days = is;
 }

}

三、BeanUtils
这是一个主要应用于Bean的Util（呵呵，这个解释很绝吧），以下是其中几个方法的例子

//static java.util.Map describe(java.lang.Object bean) 
//这个方法返回一个Object中所有的可读属性，并将属性名/属性值放入一个Map中，另外还有
//一个名为class的属性，属性值是Object的类名，事实上class是java.lang.Object的一个属性
 Month month=new Month(1, "Jan");
 
 try {
   Map map=BeanUtils.describe(month);
   Set keySet=map.keySet();
   for (Iterator iter = keySet.iterator(); iter.hasNext();) {
     Object element = (Object) iter.next();
     System.out.println("KeyClass:"+element.getClass().getName());
     System.out.println("ValueClass:"+map.get(element).getClass().getName());
     System.out.print(element+"\t");
     System.out.print(map.get(element));
     System.out.println();
   }
 } catch (IllegalAccessException e) {
   e.printStackTrace();
 } catch (InvocationTargetException e) {
   e.printStackTrace();
 } catch (NoSuchMethodException e) {
   e.printStackTrace();
 }
输出为：
KeyClass:java.lang.String
ValueClass:java.lang.String
value  1
KeyClass:java.lang.String
ValueClass:java.lang.String
class  class test.jakarta.commons.beanutils.Month
KeyClass:java.lang.String
ValueClass:java.lang.String
name  Jan
注意到所有Map中的key/value都是String，而不管object中实际的值是多少。
与此对应的还有static void populate(java.lang.Object bean, java.util.Map properties)
用于将刚才describe出的Map再装配成一个对象。


再看这样一段代码
曹晓钢也许还记得，为了取一个不确定对象的property，着实花了不少时间，
难度不大，但要做到100%的正确，仍然需要付出很大的精力。
//static java.lang.String getProperty(java.lang.Object bean, java.lang.String name) 
 Month month=new Month(1, "Jan");
 
 try {
   System.out.println(BeanUtils.getProperty(month,"value"));
 } catch (Exception e) {
   e.printStackTrace();
 }
//输出是：1

与getProperty类似的还有getIndexedProperty, getMappedProperty，
以getIndexedProperty为例：
 Month month=new Month(1, "Jan");
 
 try {
   System.out.println(BeanUtils.getIndexedProperty(month,"days",1));
   System.out.println(BeanUtils.getIndexedProperty(month,"days[1]"));
 } catch (Exception e) {
   e.printStackTrace();
 }
这两个调用是相同的。


BeanUtils中还有一个方法：
static void copyProperties(java.lang.Object dest, java.lang.Object orig) 
它真是太有用，还记得struts中满天飞的都是copyProperties，我甚至怀疑整个BeanUtils最初
是不是因为这个方法的需求才写出来的。
它将对象orig中的属性复制到dest中去。


四、PropertyUtils
这个类和BeanUtils类很多的方法在参数上都是相同的，但返回值不同。
BeanUtils着重于"Bean"，返回值通常是String，而PropertyUtils着重于属性，
它的返回值通常是Object。


五、ConstructorUtils
这个类中的方法主要分成两种，一种是得到构造方法，一种是创建对象。
事实上多数时候得到构造方法的目的就是创建对象，这里只介绍一下创建对象。
//static java.lang.Object ConstructorUtils.invokeConstructor
//(java.lang.Class klass, java.lang.Object[] args) 
//根据一个java.lang.Class以及相应的构造方法的参数，创建一个对象。
 Object obj=ConstructorUtils.invokeConstructor(Month.class, {new Integer(1), "Jan"});
 Month month=(Month)obj;
 try {
   System.out.println(BeanUtils.getProperty(month,"value"));
 } catch (Exception e) {
   e.printStackTrace();
 }
输出证明，构造方法的调用是成功的。
如果需要强制指定构造方法的参数类型，可以这样调用：
   Object[] args={new Integer(1), "Jan"};
   Class[] argsType={int.class, String.class};
   Object obj;
   obj = ConstructorUtils.invokeExactConstructor(Month.class, args, argsType);
   Month month=(Month)obj;
   System.out.println(BeanUtils.getProperty(month,"value"));
argsType指定了参数的类型。


Victor 2005-11-30 10:38 发表评论


实施Jakarta Commons-DbUtils
Victor — Wed, 30 Nov 2005 02:18:00 GMT
作者： Builder.com
Monday, April 26 2004 4:43 PM


JDBC码是Java译码的一个部分，它给已写的编码带来了数量惊人的重复。另外，JDBC码几乎会经常性的带来一些低级错误。写出好的JDBC编码并不难，但是很痛苦。







 

DbUtils组件是一个精密而简单的组件，它并不做什么复杂的事而仅仅只是使很多的JDBC任务对开发者来说变得稍容易一点。尽管这时候很多持久框架和包都可以用来使数据持久变得更容易，然而JDBC仍然是大多数Java和Java2企业版(J2EE)开发者赖以生存的工具。因此，任何能让使用JDBC工作更容易的东西都是好消息。
 
DbUtils可以免费下载，它不依赖于任何其它的通用组件而只是依赖下面这些：

Java Development Kit (JDK) 1.2 (or later) 
JDBC 2.0 (or later) 

 DbUtils文档并不是最好的，但是足以使你的工作正常进行。在下一节，你会看到DbUtils中最有用的类以及一些关于它们的用法的例子。你应该能够很容易地使用这些编码和例子，然后能够马上在你自己的项目中开始使用DbUtils。我将会集中精力于两个类（org.apache.commons.dbutils.DbUtils  和org.apache.commons.dbutils.QueryRunner）和一个接口（org.apache.commons.dbutils.ResultSethandler）.在我给你们一些关于它们的用法的例子之前，让我们深入DbUtils里面来仔细看看它给我们提供了些什么。
DbUtils 
DbUtils是一个为做一些诸如关闭连接、装载JDBC驱动程序之类的常规工作提供有用方法的类，它里面所有的方法都是静态的。

这个类里的重要方法有：

close：DbUtils类提供了三个重载的关闭方法。这些方法检查所提供的参数是不是NULL，如果不是的话，它们就关闭连接、声明和结果集（ResultSet）。 
CloseQuietly: CloseQuietly这一方法不仅能在连接、声明或者结果集（ResultSet）为NULL情况下避免关闭，还能隐藏一些在程序中抛出的SQLEeception。如果你不想捕捉这些异常的话，这对你是非常有用的。在重载CloseQuietly方法时，特别有用的一个方法是closeQuietly(Connection conn,Statement stmt,ResultSet rs)，这是因为在大多数情况下，连接、声明和结果集（ResultSet）是你要用的三样东西，而且在最后的块你必须关闭它们。使用这一方法，你最后的块就可以只需要调用这一方法即可。 
CommitAndCloseQuietly(Connection conn)：这一方法用来提交连接，然后关闭连接，并且在关闭连接时不向上抛出在关闭时发生的一些SQL异常。 
LoadDriver(String driveClassName): 这一方法装载并注册JDBC驱动程序，如果成功就返回TRUE。使用这种方法，你不需要去捕捉这个异常ClassNotFoundException。使用loadDrive方法，编码就变得更容易理解，你也就得到了一个很好的Boolean返回值，这个返回值会告诉你驱动类是不是已经加载成功了。 
ResultSetHandler 







 
正如它的名字所提示的，这一接口执行处理一个jaca.sql.ResultSet，将数据转变并处理为任何一种形式，这样有益于其应用而且使用起来更容易。这一组件提供了ArrayHandler, ArrayListHandler, BeanHandler, BeanListHandler, MapHandler, MapListHandler, and ScalarHandler等执行程序。
 
ResultSetHandler接口提供了一个单独的方法：Object handle (java.sql.ResultSet .rs)。因此任何ResultSetHandler 的执行需要一个结果集（ResultSet）作为参数传入，然后才能处理这个结果集，再返回一个对象。因为返回类型是java.lang.Object，所以除了不能返回一个原始的Java类型之外，其它的返回类型并没有什么限制。如果你发现这七个执行程序中没有任何一个提供了你想要的服务，你可以自己写执行程序并使用它。
QreryRunner 
这个类使执行SQL查询简单化了，它与ResultSetHandler串联在一起有效地履行着一些平常的任务，它能够大大减少你所要写的编码。QueryRunner类提供了两个构造器：其中一个是一个空构造器，另一个则拿一个 javax.sql.DataSource 来作为参数。因此，在你不用为一个方法提供一个数据库连接来作为参数的情况下，提供给构造器的数据源(DataSource) 被用来获得一个新的连接并将继续进行下去。
 
这一类中的重要方法包括以下这些：

query(Connection conn, String sql, Object[] params, ResultSetHandler rsh):这一方法执行一个选择查询，在这个查询中，对象阵列的值被用来作为查询的置换参数。这一方法内在地处理PreparedStatement 和ResultSet  的创建和关闭。ResultSetHandler对把从 ResultSet得来的数据转变成一个更容易的或是应用程序特定的格式来使用。 
query(String sql, Object[] params, ResultSetHandler rsh):这几乎与第一种方法一样；唯一的不同在于它不将数据库连接提供给方法，并且它是从提供给构造器的数据源(DataSource) 或使用的setDAtaSource 方法中重新获得的。 
query(Connection conn, String sql, ResultSetHandler rsh):这执行一个不要参数的选择查询。 
update(Connection conn, String sql, Object[] params):这一方法被用来执行一个插入、更新或删除操作。对象阵列为声明保存着置换参数。 
 
现在让我们来看一个例子，在这里你可以从一个数据库中获得一些数据。比如说，我正在使用MySQL 数据库.你还需要下载MYSQL JDBC驱动程序。我正在使用的MySQL数据库在本地主机，端口号为3306上运行。这个数据库地名字叫做test。你将要用到的Student表的结构如下：
Columns    Type
-------    ----
StudId     int
Name      varchar

在列表A中，你将会从Student表中得到一些信息，而且你可以按照你自己的额外需要修改这些信息。尽管你在使用JDBC，但要注意你几乎没写JDBC编码。(你可能要改变在例子中所规定的用户名和密码，这是以你的具体的数据库配置为基础的。)

这个编码遵从以下步骤：








 

1．加载JDBC驱动程序类，并用DriverManager来得到一个数据库连接。
2．例示 QueryRunner 类。
3．使用连接、SQL查询、参数和ResultSetHandler来作为输入的查询方法。你使用一个类org.apache.commons.dbutils.handlers.MapListHandler，一个类 MapListHandler来获得一个结果集（ResultSet）并返回一个jaca.util.Map的实例java.util.List。因此结果集（ResultSet） 的每一行都变成了一个java.util.Map,所有这些java.util.Map的实例绑在一起放在一个java.util.List 中。
4. 反复得到列表(List)的值就是通过在列表(List)中获得每一个Map的值。
5.用QueryRunner 来执行一个没有参数的方法。在这里你要用BeanListHandler ，它是一个非常有用的ResultSetHandler ，因为你可以把ResultSet 转变成一个指定的Bean的列表中。这时你可以指定一个Bean类到Bean StudentBean中，如同在列表B中所显示的那样。
6.　你通过反复从列表（List）中得到多个bean，然后就可从每一个StudentBean实例中获取值。
 
注释：在列表B中，StudentBean 类中的StudId 必须是int，这是因为表Student的StudId列的类型是int。坚持这个类型的匹配是我们需要遵从的唯一规则。
 
因为在这种情况下，StudentBean 类的属性和表Student 的字段是完好的对映着的，只要将StuentBean 类作为一个参数就是一个技巧。字段值用和字段名一样的名字插入到类的属性中。然而，如果你想要更多地控制bean的创建，则类BeanListHandler提供了第二个构造器：BeanListHandler(java.lang.Class type, RowProcessor convert). 接口Rowprocessor的执行把结果集（ResultSet）的各行转化成一个对象组。在 StudentBean这一案例中，RowProcessor中的BasicRowProcessor 的执行被利用上了，它能够执行这项任务。然而，你可以写一个新的执行并把它提供给BeanListHandler的构造器。
 
当然，执行这一编码的输出取决于你从表Student中获得哪些数据。对我来说，我得到了以下这些输出：
***Using MapListHandler***
  Id >>1
  Name >>One
  Id >>2
  Name >>Two
***Using BeanListHandler***
  Id >>1
  Name >>One
  Id >>2
  Name >>Two
  Id >>3
  Name >>Three

除了到目前为止你已经看了的类以外，另外一些你需要研究的类是：

org.apache.commons.dbutils.QueryLoader:QueryLoader是一个从一个文件加载查询到一个Map的简单的类。然后，当需要的时候，你从 Map 中选择一些查询。在没有专门去接触代码的情况下，一个文件中的Having查询也可以改变得尽可能的简单。 
org.apache.commons.dbutils.wrappers.SqlNullCheckedResultSet:这个类对使用一个系统方法来解决NULL值问题是很有用的。用一个 SqINullCheckedResultSet 的实例来限制一个常规的结果集（ResultSet） ，然后详细地说明在遇NULL值的情况下应该做些什么。 
org.apache.commons.dbutils.wrappers.StringTrimmedResultSet:用类StringTrimmedResultSet 来约束一个结果集，这样一来，你就可以修整所有getString()和getObject()方法返回的字符串。 
 
DbUtils 组件很好也很小巧，很值得在所有用到JDBC的项目中去使用。

DBUtils的JUnit例子：

//使用dbutils1.0版本
import java.util.*;
import java.util.logging.*;
import java.sql.*;
import org.apache.commons.dbutils.*;
import org.apache.commons.dbutils.handlers.*;
public class TestDBUnits {
 
 public static void main(String[]args) throws Exception {
  TestDBUnits test = new TestDBUnits();
  
  for(int i = 0 ; i < 1 ; i++) {   
   test.testQuery1();
   test.testQuery2();
   test.testUpdate();
  }
 }
 
 public void testQuery1(){
  try {
   QueryRunner qr = new QueryRunner() ;
   ResultSetHandler rsh = new ArrayListHandler();   
   String strsql = "select * from test1";   
   ArrayList result = (ArrayList)qr.query(getConnection() ,strsql ,rsh);
   //System.out.print("");
  } catch(Exception ex) {
   ex.printStackTrace(System.out);
  }
 }
 
 public void testQuery2(){
  try {
   QueryRunner qr = new QueryRunner() ;
   ResultSetHandler rsh = new MapListHandler();   
   String strsql = "select * from test1";   
   ArrayList result = (ArrayList)qr.query(getConnection() ,strsql ,rsh);
   for(int i = 0 ; i < result.size() ; i++) {
    Map map = (Map)result.get(i);
    //System.out.println(map);    
   }
   //System.out.print("");
  } catch(Exception ex) {
   ex.printStackTrace(System.out);
  }
 }
 
 public void testUpdate(){
  try {
   QueryRunner qr = new QueryRunner() ;
   ResultSetHandler rsh = new ArrayListHandler();
   String strsql = "insert test1(page ,writable ,content)values('ttt','ttt','faskldfjklasdjklfjasdklj')";
   qr.update(getConnection() ,strsql);
   //System.out.print("");
  } catch(Exception ex) {
   ex.printStackTrace(System.out);
  }
 }
 
 private  Connection getConnection() throws InstantiationException,
   IllegalAccessException, ClassNotFoundException, SQLException {
  
  String strDriver = "org.gjt.mm.mysql.Driver";
  String strUrl = "jdbc:mysql://localhost:3306/test";
  String strUser = "root";
  String strPass = "";
   
  Class.forName(strDriver).newInstance();  
  return DriverManager.getConnection(strUrl, strUser, strPass);
 }
}


Victor 2005-11-30 10:18 发表评论


实现图形JSF组件
Victor — Tue, 29 Nov 2005 10:11:00 GMT
--很简单地构建一个纯HTML无法轻松实现的图形Web应用程序组件





时间：2005-07-07
作者：Marc Durocher
浏览次数：

 2464 
本文关键字：JSF




文章工具
 推荐给朋友
 打印文章


　　开发人员认为，如果有合适的工具来创建交互式Web界面，他们就能将时间集中在核心需求和定制上，并在规定时间内及时得交付应用程序。与其他技术如JavaServer Pages或Apache Struts 相比，JavaServer Faces (JSF)技术为创建交互式Web应用程序带来了很多便利。JSF在程序逻辑和GUI表示之间划出一条清晰的界限，提高了对Web程序的维护能力，并为Web用户界面组件的开发和重用提供了一个框架。
　　如今，许多Web应用程序开发人员都在转而使用JSF，但是他们发现，预先定制的JSF UI组件受到基本DHTML窗口部件的限制。监管或业务流程监控之类的高级应用程序需要能与JSF框架兼容的高级可视化组件。JSF框架的标准化使它易于开发能够重用的自定义Web GUI组件。另外，Web组件开发商现在能提供更复杂的组件，并承诺Web应用程序开发人员能够轻松地使用这些组件。此类JSF用户界面组件必须集成并部署到JSF运行时框架中去，并在其中完全展开，还必须在设计时很好地集成到提供JSF支持的IDE中去。
　　尽管JSF带来了标准用户界面框架，但对于开发第一个自定义JSF组件而言，还是存在几个缺陷和漏洞。让我们看看怎样创建一个纯HTML无法轻松创建的图形JSF组件。图形JSF组件的特点不仅要求生成DHTML，而且还需要对图像生成和客户端交互提供补充支持。我们将以一个图形组件的例子来阐述这些特点。该图形组件能够提供曲线图，并为各种客户端导航和交互提供便利。我们还会了解到将该图形组件集成到JSF-enabled IDE中所需要的步骤。通过理解图形组件的设计方法，您将会更好地理解如何实现JSF组件，而这应该能使您开发出定制的JSF图形组件。
什么是JSF？
　　JSF是一种能够简化Web应用程序表示层结构的标准服务器端框架。定义JSF框架的JSR 127（参见参考资料）带有一个能提供基本UI组件（如输入栏和按纽）的参考实现。您可以将可重用用户界面组件集中起来创建Web页，将这些组件绑定到应用数据源上，并用服务器端事件控制程序处理客户端事件。根据说明书介绍，组件供应商能编写与JSF运行时框架集成的组件，并将其集成到在设计时与JSF兼容的IDE中去。
　　从很大程度上讲，JSF组件同在HTML 2.0技术要求下可用的HTML组件和标签直接相符合。对许多Web应用程序而言，这套相对简单的组件是够用的。然而，许多应用程序如监管或监控程序需要更复杂的数据显示与交互，比如制表、制图和映射。由于JSF组件在HTML中直接提交复杂图形小部件的能力有限，所以设计这些高级组件的能力并不突出。解决方案要求服务器端组件向客户传输图像，却会给自身带来问题，因为在基本HTML图像上进行交互要受到限制。最后，使用JavaScript时，必须能调用客户端交互来使用户能对数据进行导航和交互。
　　让我们看看开发一个简单的、将CSS输入HTML页面的JSF组件需要哪些步骤。当开发高级JSF图形组件时，这一简单组件的描述和代码样本会作为背景。图1显示了如何使用即将开发的组件，并显示将要得到的结果。使用这种组件的好处是能够通过改变某个JSF动作的组件值，来改变整个页面的外观。 
 
图1：显示了我们如何使用一个非常简单的JSF组件将CSS输入某个HTML页面并得出结果。
开发组件
　　JSF组件包含若干个Java类和配置文件。为创建一个自定义JSF组件，您需要开发一个扩展JSF基本组件类的Java类；为默认呈现软件包开发呈现程序；开发一个将在JSP页面中用于描述标签的Java类；编写一个标签库定义（TLD）文件；编写JSF配置文件。让我们更深入地了解这5个步骤。
　　开发组件Java类。组件类负责管理代表组件状态的属性。因此，我们必须根据组件的行为（如输入组件或输出组件），给组件选择适当的基类（参见清单1）。这里描述的组件可进行扩展javax.faces.component.UIOutput，以显示指向某个样式表文件的URL，或内联式样式表的内容。该组件可用于在JSF动作中将某个样式表转换成另一个样式表。关联属性规定着值的类型：要么是一个URL，要么是内联样式。该组件还必须能够在向服务器发送请求期间，使用经过JSF框架处理的对象，来存储并修复自己的状态。组件的状态由重建对象所需的重要属性值组成。JSF框架自动调用saveState()和restoreState()方法，我们可以在组件中实现这两种方法来达到这一目标。
清单1. 组件类管理显示组件状态的属性。可依据组件的行为，为其选择一个适当的基类。在本例中，该组件扩展javax.faces.component.UIOutput，以显示指向某个样式表文件的URL，或者某个内联式样式表的内容。
import javax.faces.component.*;
public class CSSComponent extends UIOutput {
	private Boolean link; 
	public String getFamily() { 
		return "faces.CSSFamily"; 
	} 
	public boolean isLink() { 
		if (link != null) 
			return link.booleanValue(); 
			ValueBinding vb = getValueBinding("link"); 
	if (vb != null) { 
		Boolean bvb = (Boolean) vb.getValue(
			FacesContext.getCurrentInstance()); 
		if (bvb != null) 
			return bvb.booleanValue(); 
	} 
	return false; 
	} 
	public void setLink(boolean link) { 
		this.link = new Boolean(link); 
	} 
	public Object saveState(FacesContext context) { 
		return new Object[] { super.saveState(context), 
			link }; 
	} 
	public void restoreState(FacesContext context, 
	Object stateObj) { 
		Object[] state = (Object[]) stateObj; 
		super.restoreState(context, state[0]); 
		link = (Boolean) state[1]; 
	} 
}

开发呈现程序。呈现程序有两个作用。第一，呈现程序负责发送适当的HTML程序段，该程序段能在客户端中呈现组件。通常情况下，这个HTML程序段由一些适于呈现整个Web浏览器的HTML标签组成。此JSF生存周期称作编码阶段或呈现—响应阶段。该响应阶段还能发送增强客户端交互性的JavaScript代码。
　　呈现程序的第二个作用是解析来自客户端的数据，从而对服务器端的组件状态进行更新（如用户在文本字段输入的文本）。标准呈现程序软件包具有强制性，但也可以提供其他呈现程序软件包，用于提供可替换的客户端表示法或SVG之类的语言（参见参考资料）。通过检验组件的连接属性，您实现的呈现程序（参见清单2）将选择在HTML页面中发送的CSS样式。
清单2. 标准呈现程序软件包具有强制性，但是，您可以使用其他呈现程序软件包，来提供可替换的客户端表示法或语言。通过检验组件的连接属性，您实现的呈现程序将选择在HTML页面中发出的CSS样式。
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.context.ResponseWriter;
import javax.faces.render.Renderer;
public class CSSRenderer extends Renderer {
public void encodeEnd(FacesContext context,
UIComponent component)
	throws IOException {
		super.encodeEnd(context, component);
		if (component instanceof CSSComponent) {
			CSSComponent cssComponent  =
				(CSSComponent) component;
			String css = (String)cssComponent.getValue();
			boolean isLink = cssComponent.isLink();
			if (css != null) 
				if (isLink)  
				context.getResponseWriter().write(
				"");
			else 
				context.getResponseWriter().write(
					"