基本流程
1、 初始化IndexSearcher :Searcher searcher = new IndexSearcher(indexDir);//indexDir为索引存放路径
2、 生成Query对象: QueryParser类的parse()方法返回Query类形对象
3、 使用search(Query)方法，开始搜索，并返回Hits对象
4、 使用Hits对象的方法检索结果:
length();//结果总数量
doc(int n);//返回第n个文档;Document对象
id(int n);//第n个文档的内部ID
score(n);//第n个文档的分值，用于排序

例子:
IndexSearcher searcher = new IndexSearcher(“c:\\index”);
Query query = QueryParser.parse(“key1”,”name”,new StandardAnalyzer());
Hits hits = searcher.search(query);
If(hits.length()==0){
 Out.println(“not found”);
}
else{
 for(int i=0;i  Document d  = hits.doc(i);
 Out.println(d.get(“title”));
}
}

文档搜索结果的主要排序依据是文档的分值。改变文档分值的方法是建立索引时，在初始化Document对象后，使用Document的setBoost方法来改变文档的boost因子（分值的倍数）:
Document doc = new Document();
Doc.add(Field.Text(“contents”,”text1 text2”));
Doc.setBoost(1.5f); //改变因子，如0.3f,1.0f等

构建Query:
Query是search包中的一个抽象类，它有许多子类，代表不同类形的查询

关键字TermQuery
Term term = new Term(“contents”,”java”);//实质也是一个键/值对
//构造TermQuery
Query query = new TermQuery(term);

组合查询BooleanQuery
BooleanQuery是一个查询容器，提供专门的方法往其中加入查询，并标明条件的关系
IndexSearcher searcher = new IndexSearcher(“c:\\index”);
Query q1 = new TermQuery(new Term(“name”,”tim”));
Query q2 = new TermQuery(new Term(“name”,”fly”));
//构造容器
Query query = new BooleanQuery();
query.add(q1,true,false);
query..add(q2,true,false);
Hits hits = searcher.search(query);

BooleanQuery的add方法的第二，第三参数说明：第二参数表示是否必须满足，第三参数表示是否不需要满足，组合一起有以下三种情况:
True,false:当前查询条件是必须要满足的
False ,true:当前查询是不可以满足的
False,false:条件是可选的
True,true:这种情况是错误的
以上表明，上述例子的两个条件都是必须满足的，是“与(and)”的关系
如果查进行“或（or）”运算，相应地可改为:
query.add(q1,false,false);
query.add(q2,false,false)

范围搜索RangeQuery
RangeQuery query = new RangeQuery(begin,end,included);//最后参数为是否包含边界
例:
Term begin = new Term(“time”,”20050101”);
Term end = new Term(“time”,”20050202”);
RangeQuery query = new RangeQuery(begin,end,false);

前缀PrefixQuery
PrefixQuery query = new PrefixQuery(new Term(“name”,”ti”));//name字段中以ti开头

多关键字PhraseQuery
PhraseQuery query = new PhraseQuery();
Query.add(new Term(“content”,”hello”));
Query.add(new Term(“content”,”world”));
Query.setSlop(2);
 //设置以上加上的两个关键字坡度,此值代表两个关键字之间无关词的个数.对于两个紧连的关键字，无论将坡度设为多少都能找到，如果两个词不紧连，且坡度值小于它们之间的无关词的数量，则无法找到

短词缀PhrasePrefixQuery
Term word1 = new Term(“content”,”david”);
Term word2 = new Term(“content”,”mary”);
Term word3 = new Term(“content”,”robert”);
PhrasePrefixQuery query = new PhrasePrefixQuery();
//加入不确定的词
Query.add(new Term[]{word1,word2});//不确定，第一个关键词在Term数组中产生
//加入确定的词
query.add(word3);
query.setSlop(2);//设置坡度
//以上查询中，david robert和mary robert都会出现在查询结果,同样地，mary and robert也会被击中

相近词FuzzyQuery
FuzzyQuery query = new FuzzyQuery(new Term(“content”,”david”));

通配符WildcardQuery
WildcardQuery query = new WildcardQuery(new Term(“content”,”*im”));
WildcardQuery query = new WildcardQuery(new Term(“content”,”t?m??”));
//*代表0个或多个字符，？一个字符

QueryParser类,把用户各种输入转为Query
Query query = QueryParser.parse(keywords,filedName,new StandardAnalyer());
关键字格式:
“tim” //在默认字段搜索tim
“name:tim”;//在name字段搜tim
“tim wong”或tim or wong;//在默认字段搜搜关键字tim 或wong
“+tim +wong”或”tim and wong” //搜索tim和 wong
”tim*”//在默认字段中搜前缀为tim的
“name:tim is a programer”;//在name字段中包含短语tim is a programer
“(tim or wong) and php” //在默认字段中搜含有tim 或wong的关键字，但一定要包含php
“name:tim –title:php” //name字段搜tim,并且title不含有php

另外，QueryParser构造时需要一个分析器，它应该与建立索引时的分析器一样

QueryParser的“与”和“或”
当输入两个关键字时，默认关系是或，要改变这种关系，方法是:
QueryParser parser = new QueryParser(keyword,fieldNmae,new StandardAnalyzer());
Parser.setOperator(QueryParser.DEFAULT_OPERATOR_AND);

排序及多字段查找

默认情况下,IndexSearcher类的search方法返回查询结果时,是按文档的分值排序的,可以使用重载的search方法对结果排序

IndexSearcher.search(Query,Sort);

new Sort() 和 Sort.RELEVANCE,以及null一样,采用默认排序,要定义排序字段,方法是将字段传入Sort对象

Sort sort = new Sort(String field);

也可以对多个字段排序Sort sort = new Sort(String[] fields);

例:

Sort sort = new Sort(new SortField[]{new SortField(“title”),new SortField(“name”)});

Hits hits=searcher.search(query,Sort);

多字段查找MultiFieldQueryParser

只在某些Term中查找,不关心在哪个字段

Query query = new MultiFieldQueryParser.parse(“word”,new String[]{“title”,”content”},analyzer); //在title和content中找word

多字段时默认是OR关系,要改变它,使用以下方法:

Query query = MultiFieldQueryParser.parse(“word”,new String[]{“title”,”content”},new int[]{MultiFieldQueryParser.REQUIRED_FIELD,MultiFieldQueryParser.PROHIBITED_FIELD},analyzer);

其中:

REQUIRED_FIELD 表示该条件必须有

PROHIBITED_FIELD 表示必须不含

搜 索多个索引文件MultiSearcher

1)      建立多个索引:使用不同的索引目录,实例化不同的IndexWriter

2)      建立多索引搜索器:

Searcher[] searchers = new SEARCHER[2];

Searchers[0] = new IndexSearcher(dir1); //搜索索引目录一

Searchers[1]= new IndexSearcher(dir2);//搜索索引目录二

Searcher searcher = new MultiSearcher(serarchers);

3) 开始查询:Hits hits = searcher.search(query);

最近要做一个站内的全文检索功能，主要是针对 clob 字段的，于是去网上找了点 lucene 的资料，现在新版本的是 2.0.0 ，网上的例子多是 1.4.3 的，有些方法已经废弃了，搞了 n 久终于把 2.0.0 的功能实现了，呵呵，下面把实现的代码贴出来，实现了索引的创建、检索和删除功能，并可以从检索结果去查询数据库 ~  

    // 创建索引

    public void indexFiles() {

         // 创建索引文件存放路径

        File indexDir = new File("E:\\lucene_Learning\\lucene-

        try {

            Date start = new Date();

             // 创建分析器 , 主要用于从文本中抽取那些需要建立索引的内容 , 把不需要参与建索引的文本内容去掉 .

            // 比如去掉一些 a the 之类的常用词 , 还有决定是否大小写敏感 .

            StandardAnalyzer standardAnalyzer = new StandardAnalyzer();

             // 参数 true 用于确定是否覆盖原有索引的

            IndexWriter indexWriter = new IndexWriter(indexDir, standardAnalyzer, true);

            indexWriter.setMergeFactor(100);

            indexWriter.setMaxBufferedDocs(100);

             // 只索引这个 Field 的前 5000 个字，默认为 10000

              indexWriter.setMaxFieldLength(5000);

             // 从数据库取出所有纪录

            List articleList = articleManager.getArticles(null);

            for (int i = 0; i < articleList.size(); i++) {

                Article article = (Article) articleList.get(i);

                 // 在 Document 方法是创建索引的具体代码

                Document doc = Document(article);

                indexWriter.addDocument(doc);

            }

             // Optimize 的过程就是要减少剩下的 Segment 的数量 , 尽量让它们处于一个文件中 .

            indexWriter.optimize();

              indexWriter.close();

            Date end = new Date();

            System.out.println("create index: " + (end.getTime() - start.getTime()) + " total milliseconds");

        } catch (IOException e) {

            System.out.println(" caught a " + e.getClass() + "\n with message: " + e.getMessage());

        }

    }

    public static Document Document(Article article)

            throws java.io.IOException {

        Document doc = new Document();

         // 为 article 表的主健创建索引，关于 Field 的几个参数下面有详细解释

        Field fieldId = new Field("uid", article.getArticleId(), Field.Store.YES, Field.Index.UN_TOKENIZED, Field.TermVector.YES);

         // 为 detail 字段创建索引， detail 在 DB 中是 clob 字段，内容为 html 文本

        String contentHtml = article.getDetail();

        Reader read = new StringReader(contentHtml);

          // 用 HTMLParser 把 detail 字段中的 HTML 分析成文本在索引

        // HTMLParser 这个类可以在 lucene 的 demo 中找到

        HTMLParser htmlParser = new HTMLParser(read);

        BufferedReader breader = new BufferedReader(htmlParser.getReader());

        String htmlContent ="";

        String tempContent = breader.readLine();

        while (tempContent != null && tempContent.length() > 0) {

            htmlContent = htmlContent + tempContent;

            tempContent = breader.readLine();

        }

        Field fieldContents = new Field("content", htmlContent,

                Field.Store.COMPRESS, Field.Index.TOKENIZED,Field.TermVector.YES);

        // db 中的每条纪录对应一个 doc ，每个字段对应一个 field

        doc.add(fieldId);

        doc.add(fieldContents);

        return doc;

    }

     // 搜索文件， keyword 是你在页面上输入的查找关键字，这里查找的是 detail 字段

    public List searchFiles(String keyword){

        String index = "E:\\lucene_Learning\\lucene-

         // hitsList 用来保存 db 的纪录，这些纪录可以通过查询结果取到

        List hitsList = new ArrayList();

        try {

            Date start = new Date();

            IndexReader reader = IndexReader.open(index);

            Searcher searcher = new IndexSearcher(reader);

            Analyzer analyzer = new StandardAnalyzer();

            QueryParser parser = new QueryParser("content", analyzer);

             // 解析查询关键字，比如输入的是以空格等分开的多个查询关键字，这里解析后，可以多条件查询

            Query query = parser.parse(keyword);

             // hits 用来保存查询结果，这里的 hits 相当于 sql 中的 result

            Hits hits = searcher.search(query);

             for (int i = 0; i < hits.length(); i++) {

                Document doc = hits.doc(i);

                 // 获得 article 表的主健

                String id = doc.get("uid");

                 // 根据主健去 db 中取纪录，返回到 hitsList 中

                try {

                    Article article = articleManager.getArticle(id);

                } catch (ObjectRetrievalFailureException e) {

                    article = null;

                }

                         // 如果没有找到该纪录，表示该纪录已经不存在，不必添加到 hitsList 中

                if(article!=null)  hitsList.add(article);

            }

            searcher.close();

            reader.close();

            Date end = new Date();

            System.out.println("search files: " + (end.getTime() - start.getTime()) + " total milliseconds");

        } catch (IOException e) {

            System.out.println(" caught a " + e.getClass() + "\n with message: " + e.getMessage());

        } catch (ParseException e) {

              System.out.println(" caught a " + e.getClass() + "\n with message: " + e.getMessage());

        }

         return hitsList;

    }

     // 删除索引

    public void deleteIndex(){

        String index = "E:\\lucene_Learning\\lucene-

        try {

            Date start = new Date();

            IndexReader reader = IndexReader.open(index);

            int numFiles = reader.numDocs();

            for (int i = 0; i < numFiles; i++) {

                 // 这里的删除只是给文档做一个删除标记，你可以看到执行 deleteDocument 后会产生一个 del 后缀的文件，

                // 用来记录这些标记过的文件

                reader.deleteDocument(i);

            }

            reader.close();

            Date end = new Date();

            System.out.println("delete index: " + (end.getTime() - start.getTime()) + " total milliseconds");

        } catch (IOException e) {

             System.out.println(" caught a " + e.getClass() + "\n with message: " + e.getMessage());

        }

    }

     // 恢复已删除的索引

    public void unDeleteIndex(){

        String index = "E:\\lucene_Learning\\lucene-

        try {

             IndexReader reader = IndexReader.open(index);

            reader.undeleteAll();

            reader.close();

        } catch (IOException e) {

            System.out.println(" caught a " + e.getClass() + "\n with message: " + e.getMessage());

         }

}

Field 就像我们学过的数据库中的字段，简单的说，就是一个名值对。这个域有三种属性，分别是

isStored - 是否被存储
isIndexed - 是否被索引
isTokenized - 是否分词

这些属性的组合又构成了四种不同类型的 Field ，而且各有用途

关于 Field ， 2.0.0 版本和 1.4.3 版本方法相比改动比较大，具体见下表

1.4.3 版本中的下面方法都被 Field(String name, String value, Store store, Index index, TermVector termVector) 取代

Keyword(String name, String value) // only version 存储、索引、不分词，用于 URI （比如 MSN 聊天记录的日期域、比如 MP3 文件的文件全路径等等）
Field(String name, String value, Field.Store.YES, Field.Index.UN_TOKENIZED) // version 2.0.0

UnIndexed(String name, String value) // only version 存储、不索引、不分词，比如文件的全路径
Field(String name, String value,Field.Store.YES, Field.Index.NO)// version 2.0.0

UnStored(String name, String value) // only version 不存储、索引、分词，比如 HTML 的正文、 Word 的内容等等，这部分内容是要被索引的，但是由于具体内容通常很大，没有必要再进行存储，可以到时候根据 URI 再来挖取。所以，这部分只分词、索引，而不存储。
Field(String name, String value,Field.Store.YES, Field.Index.TOKENIZED)// version 2.0.0

Text(String name, String value) // only version 存储、索引、分词，比如文件的各种属性，比如 MP3 文件的歌手、专辑等等。 Field.Store.YES, Field(String name, String value,Field.Index.TOKENIZED)// version 2.0.0

Text(String name, Reader value) // only version

　　String str = null;

　　if(StringUtils.isEmpty(str)){

　　}

　　str = StringUtils.lowerCase(str);
　　str = StringUtils.capitalize(str);
　　str = StringUtils.swapCase(str);
　　StringUtils.isNumeric(str);
　　StringUtils.isAsciiPrintable(str);
　　StringUtils.equalsIgnoreCase(str,"");

　　其中，
　　if(StringUtils.isEmpty(str)){

　　}
　　相当于
　　if(str == null || str.length() == 0){

　　}

　　从以上代码可以看出这个工具类的特点：
　　第一、这些函数都是静态函数，并且很少抛出异常，也很少抛出控制针异常。
　　第二、这些函数的功能大多是增强标准 Java 中 java.lang.String 类的功能。

　　其实，整个 lang 包的函数基本上都在增强 java.lang 包的功能。一个有趣的设计是，虽然 StringUtils 里面的函数都是静态函数，按照通常的做法，会把构造函数设计成 private, 但是不！StringUtils 的构造函数是 public 的。构造函数里面的注释写着 "no init"。这就有意思了，你可以 new 一个 StringUtils，虽然没有特别的好处，但是也没有特别的坏处；你可以写一个 StringUtils 的子类，虽然这也不太常见。这里面的思想似乎是，使用这个工具包的软件开发人员想怎么用就怎么用，做工具类的时候不用太多限制。
　　至于不抛异常是因为现在很多人已经意识到 Java 中的异常不是什么好东西，如果不用异常也能写程序，为什么还要用异常？用了异常就要写很多 try catch，在很多场合，比如 jdbc driver，这已经证明了会使代码量增加并且代码的可读性变差。
　　这里的思路会不会影响大家写程序的习惯呢？

　　StringUtils 的函数很多，不一一列举。 Lang 中次重要的类要数 ArrayUtils，主要功能涉及到数组的比较、转换、拆分、合并、查找、增减、倒转等等操作。在 JDK 中，这类操作没有现成的函数。

　　Lang 中工具类比较多，这里介绍几个主要的：
　　ClassUtils getShortClassName，这个函数应该在 java.lang.Class 类中有的，我看到很多人自己写这个函数。getAllInterfaces，convertClassNamesToClasses，isAssignable，primitivesToWrappers，isInnerClass。
　　NumberUtils 关于数字以及数字和字符串转换的类 stringToInt，toDouble，createNumber，isAllZeros， int compare(float lhs, float rhs)， isNumber(String str)，double min(double[] array)。
　　RandomUtils 用于产生随机数的。
　　DateFormatUtils 日期时间格式转换，以及本地时间和 UTC 时间转换。
　　DateUtils 日期工具类。isSameDay，truncate，round，modify。

　　基于反射机制的几个类：
　　CompareToBuilder 比较，用在算法、排序、比较的地方。reflectionCompare，append。
　　EqualsBuilder 通过反射机制比较。reflectionEquals 很多项目中用到。
　　HashCodeBuilder 可以通过反射生成 hash code，很多算法的地方涉及到 hash code，但是并不是每个人都知道一种 hash code 的生成方法。
　　ToStringBuilder 当你需要重载 toString 函数而不想写代码把当前类的所有成员信息列出来，可以用这个函数。

　　其它的几个类我用得比较少：
　　SerializationUtils Java 中得序列化比较奥妙，容易出错啊。
　　SystemUtils 可以读取一些关于 jdk 信息，操作系统信息的工具类。

       第一次接触 BeanUtils 是在学习 Struts 的过程中，在 Struts 中它被大量用于处理 FormBean 。

BeanUtils 主要提供了对于 JavaBean 进行各种操作，

       BeanUtils 一共分 4 个包：

Ø         org.apache.commons.beanutils

Ø         org.apache.commons.beanutils.converters

Ø         org.apache.commons.beanutils.locale

Ø         org.apache.commons.beanutils.locale.converters

其中上面两个是 BeanUtils 的默认实现，它没有针对本地化的任何处理，这个可以提高执行效率。但是若你的程序对于本地化有要求的话，那还是使用下面 2 个包比较安全。

2.    org.apache.commons.beanutils

       这个包主要提供用于操作 JavaBean 的工具类， Jakarta-Common-BeanUtils 的主要功能都在这个包里实现。

    下面分别介绍几个主要的工具类：

2.1. BeanUtil

1 、首先，我先定义一个 JavaBean 作为之后例子的操作对象。

    public class Company

    {

      private String name;

      private HashMap address = new HashMap();

      private String[] otherInfo;

      private ArrayList product;

      private ArrayList employee;

      private HashMap telephone;

      public Company(){}

      public String getName()

      {

        return name;

      }

      public void setName(String name)

      {

        this.name = name;

      }

      public String getAddress(String type)

      {

        return address.get(type).toString();

      }

      public void setAddress(String type, String address)

      {

        this.address.put(type,address);

      }

      public String[] getOtherInfo()

      {

        return otherInfo;

      }

      public void setOtherInfo(String[] otherInfo)

      {

        this.otherInfo = otherInfo;

      }

      public ArrayList getProduct()

      {

        return product;

      }

      public void setProduct(ArrayList product)

      {

        this.product = product;

      }

      public ArrayList getEmployee()

      {

        return employee;

      }

      public void setEmployee(ArrayList employee)

      {

        this.employee = employee;

      }

      public HashMap getTelephone()

      {

        return telephone;

      }

      public void setTelephone(HashMap telephone)

      {

        this.telephone = telephone;

      }

    }

2 、 BeanUtils 可以直接 get 和 set 一个属性的值。它将 property 分成 3 种类型：

       Simple ——简单类型，如 Stirng 、 Int ……

       Indexed ——索引类型，如 数组、 arrayList ……

       Maped ——这个不用说也该知道，就是指 Map 啦，比如 HashMap ……

       访问不同类型的数据可以直接调用函数 getProperty 和 setProperty 。它们都只有 2 个参数，第一个是 JavaBean 对象，第二个是要操作的属性名。

Company c = new Company();

c.setName("Simple");

对于 Simple 类型，参数二直接是属性名即可

//Simple

    System.out.println(BeanUtils.getProperty(c, "name"));

    对于 Map 类型，则需要以“属性名（ key 值）”的形式

//Map

    System.out.println(BeanUtils.getProperty(c, "address (A2)"));

    HashMap am = new HashMap();

    am.put("1","234-222-1222211");

    am.put("2","021-086-1232323");

    BeanUtils.setProperty(c,"telephone",am);

    System.out.println(BeanUtils.getProperty(c, "telephone (2)"));

    对于 Indexed ，则为“属性名 [ 索引值 ] ”，注意这里对于 ArrayList 和数组都可以用一样的方式进行操作。

//index

    System.out.println(BeanUtils.getProperty(c, "otherInfo[2]"));

    BeanUtils.setProperty(c, "product[1]", "NOTES SERVER");

    System.out.println(BeanUtils.getProperty(c, "product[1]"));

       当然这 3 种类也可以组合使用啦！

    //nest

    System.out.println(BeanUtils.getProperty(c, "employee[1].name"));

3 、此外，还有一个很重要的方法 copyProperty ，可以直接进行 Bean 之间的 clone 。

       Company c2 = new Company();

        BeanUtils.copyProperties(c2, c);

        但是这种 copy 都是浅拷贝，复制后的 2 个 Bean 的同一个属性可能拥有同一个对象的 ref ，这个在使用时要小心，特别是对于属性为自定义类的情况。

4 、最后还有 populate ，它用于将一个 map 的值填充到一个 bean 中，其函数原型如下：

public void populate(java.lang.Object bean,

                java.util.Map properties)

              throws java.lang.IllegalAccessException,

                     java.lang.reflect.InvocationTargetException

在 struts 中这个函数被用于从 http request 中取得参数添加到 FormBean ，目前好像我也没有看到这个函数还有什么其他的用途？！以后想到再说吧： P

2.2. LazyDynaBean

       它实现一个动态的 Bean ，可以直接往里面加入属性，作为一个 JavaBean 一样使用，也可以用上面的 BeanUtils 或 get/set 方法进行操作，而不用事先定义一个标准的 JavaBean 类啦：）

记得在 J2ee 设计模式中有一种 Value Object 的模式，用于在 MVC 各层之间传递数据，避免直接传递大业务对象引起的性能问题，为了避免在项目中出现很多 Bean 类，在书中提供了一个动态 Value Object 的实现（通过扩展 Map ）。这里 LazyDynaBean 则可以作为一种更加成熟、稳定的实现来使用。呵呵，原来曾打算自己写一个类似的 value object 类的，现在看来可以直接用这个啦： P

       言归正传， LazyBean 的确提供了一个很不错的 DynaBean 的实现。而且就像它的名字中表述的那样，它的确是为我这样的懒人考虑的很周到，用起来几乎不需要写什么多余的代码 ^_^ ，下面就看看使用的例子吧！

         // 这里使用 LazyDynaMap ，它是 LazyBean 的一个轻量级实现

      LazyDynaMap dynaBean1 = new LazyDynaMap();

      dynaBean1.set("foo", "bar");                  // simple

      dynaBean1.set("customer", "title", "Mr");         // mapped

      dynaBean1.set("address", 0, "address1");          // indexed

      System.out.println(dynaBean1.get("address",0));

      Map myMap = dynaBean1.getMap();           // retrieve the Map

      System.out.println(myMap.toString());

       上面的例子可以看到，它可以在 set 时自动增加 bean 的 property （既赋值的同时增加 Bean 中的 property ），同时也支持 3 中类型的 property ，并且 LazyDynaMap 还可以导出为 map 。

       对于这个类还有两个重要的 Field 要注意：

       returnnull ——指定在 get 方法使用了一个没有定义过的 property 时， DynaBean 的行为。

         // 取的字段的信息

      dynaBean1.setReturnNull(true); // 设为 ture 。若 Bean 中没有此字段，返回 null

                                // 默认为 false 。若 Bean 中没有此字段，自动增加一个：）

      System.out.println(dynaBean1.get("aaa")); // 此时返回 null

       Restricted ——指定是否允许改变这个 bean 的 property 。

//MutableDynaClass.setRestricted 设为 true 后，字段不可再增删和修改 .

      // 默认为 false ，允许增删和修改

      dynaBean1.setRestricted(true);

      dynaBean1.set("test","error"); // 这里会出错！

       通过设置这两个属性，可以防止意外修改 DynaBean 的 property 。在设计架构时，你可以在后台从数据表或 xml 文件自动产生 DynaBean ，在传到控制层和表示层之前设置上述属性使其 Bean 结构不允许修改，如此就不可能无意中修改 Bean 包含的属性……这样既可以享用它的便利，有可以防止由此引入的错误可能，设计者实在深得偷懒的精髓啊！！！！！

3.    其他

3.1. BeanUtils 和 PropertyUtils

       这两个类几乎有一摸一样的功能，唯一的区别是： BeanUtils 在对 Bean 赋值是会进行类型转化。举例来说也就是在 copyProperty 时只要属性名相同，就算类型不同， BeanUtils 也可以进行 copy ；而 PropertyBean 则可能会报错！！

       针对上面的例子，新建一个 Company2 的类，其中代码与 Company 一样，只是将 otherinfo 从 String[] 改为 String 。

      Company c = init();

      Company2 c2 = new Company2();

      BeanUtils.copyProperties(c2,c);

//      PropertyUtils.copyProperties(c2,c); 这句会报错！！

      System.out.println(c2.getOtherInfo());

    当然 2 个 Bean 之间的同名属性的类型必须是可以转化的，否则用 BeanUtils 一样会报错。

       若实现了 org.apache.commons.beanutils.Converter 接口则可以自定义类型之间的转化。

由于不做类型转化，用 PropertyUtils 在速度上会有很大提高！

此外，不作类型转化还有一个好处，如下面的代码：

      //test data type convert

//      ArrayList a1 = BeanUtils.getProperty(c,"product"); //BeanUtils 返回的是 String

      System.out.println("--" + BeanUtils.getProperty(c,"product"));      // 取出后直接被转为 String

      ArrayList a = (ArrayList)PropertyUtils.getProperty(c,"product"); //PropertyUtils 返回的是 Object

      System.out.println("--" + a.get(1)) ;

用 BeanUtils 无法返回一个对象（除非自己写一个 Converter ），它会自动进行类型转化，然后返回 String 。对于想返回 java 类或自定义类的话，还是不要老它大驾转化了。

3.2. Utils 类

       所有的 XXXUtils 类都提供的是静态方法，可以直接调用，其主要实现都在相应的 XXXUtilsBean 中：

BeanUtils     ——> BeanUtilsBean

       ConvertUtils  ——> ConvertUtilsBean

    PropertyUtils ——> PropertyUtilsBean

DateUtils – 在 Calendar 和 Date 的基础上提供更方便的访问；

DurationFormatUtils – 提供格式化时间跨度的功能及相关常量；

FastDateFormat – 为 java.text.SimpleDateFormat 提供一个的线程安全的替代类；

StopWatch – 是一个方便的计时器。