麻豆久久久9性大片,久久久久99精品成人片试看,久久发布国产伦子伦精品

Sat, 22 Dec 2007 19:25:00 GMT

Java 多线�E�入门大�?br>2007-03-15 14:18:41 / 个�h分类�Q�java

作者：qlampskyface

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

    接触多线�E�已�l�不��时间了,也做了不��事�?但是一直觉得用��h��不那么顺�?在debug的时�?往往会比较担心在同步上出什么问�?惌��v"�E�序员最怕的是自己写的代�?�q�句�?觉得真是不假.
    �l�于有一�?我觉得是时候把�q�个问题弄清楚了,所�?我就在网上找相关的内容看,�l�果竟然是找不到在我�q�个阶段应该看的,不是太简�?��是一�W�带�q?不知所�?
    废了九牛二虎之力,�l�于差不多弄清楚�?其中有不��误�?以前认�ؓ的和真理相差甚大.惌��v自己��p��的时�?真是觉得有点�?所以把它写出来,一是防止自�׃��后又会忘�?二是�l�像我一��L��似懂非懂者留下一点可以参考的东东.
    闲话��说,转入正题!

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

先从�U�程的创��?�U�程的创��Z��共有两种形式:

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

一�U�是�l�承自Thread�c?Thread �c�L��一个具体的�c�，即不是抽象类�Q�该�c�d��装了�U�程的行为。要创徏一个线�E�，�E�序员必��d��Z��个从 Thread �c�d��出的新类。程序员通过覆盖 Thread �?run() 函数来完成有用的工作。用户�ƈ不直接调用此函数�Q�而是通过调用 Thread �?start() 函数�Q�该函数再调�?run()�?br>
例如:

    public class Test extends Thread{
      public Test(){
      }
      public static void main(String args[]){
        Test t1 = new Test();
        Test t2 = new Test();
        t1.start();
        t2.start();
      }
      public void run(){
        //do thread's things
      }
    }

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

    另一�U�是实现Runnable接口,此接口只有一个函敎ͼ�run()�Q�此函数必须由实��C��此接口的�c�d��现�?br>
    例如:

    public class Test implements Runnable{
      Thread thread1;
      Thread thread2;
      public Test(){
        thread1 = new Thread(this,"1");
        thread2 = new Thread(this,"2");
      }
      public static void main(String args[]){
        Test t = new Test();
        t.startThreads();
      }
      public void run(){
        //do thread's things
      }
      public void startThreads(){
        thread1.start();
        thread2.start();
      }
    }

两种创徏方式看�v来差别不�?但是弄不清楚的话�Q�也�怼��你的程序弄得一团糟。两者区别有以下几点�Q?/p>

1.当你想��承某一其它�c�L��,你只能用后一�U�方�?

2.�W�一�U�因为��承自Thread,只创��Z��自��n对象,但是在数量上�Q�需要几个线�E�，��得创徏几个自��n对象�Q�第二种只创��Z��个自�w�对象，却创建几个Thread对象.而两�U�方法重大的区别��在于此�Q�请你考虑�Q�如果你在第一�U�里创徏��C��自��n对象�q�且start()后，你会发现好像synchronized不�v作用了，已经加锁的代码块或者方法居然同时可以有几个�U�程�q�去�Q�而且同样一个变量，居然可以有好几个�U�程同时可以��L��改它。（例如下面的代码）�q�是因�ؓ�Q�在�q�个�E�序中，虽然你�v了数个线�E�，可是你也创徏了数个对象，而且�Q�每个线�E�对应了每个对象也就是说�Q�每个线�E�更改和占有的对象都不一��P��所以就出现了同时有几个�U�程�q�入一个方法的现象�Q�其实，那也不是一个方法，而是不同对象的相同的�Ҏ��。所以，�q�时候你要加锁的话，只能��方法或者变量声明�ؓ静态，��static加上后，你就会发玎ͼ��U�程又能��住�Ҏ��了，同时不可能有两个�U�程�q�入同样一个方法，那是因�ؓ�Q�现在不是每个对象都拥有一个方法了�Q�而是所有的对象共同拥有一个方法，�q�个�Ҏ��是静态方法�?/p>

而你如果用第二种�Ҏ��使用�U�程的话�Q�就不会有上�q�的情况�Q�因为此�Ӟ��你只创徏了一个自�w�对象，所以，自��n对象的属性和�Ҏ��对于�U�程来说是共有的�?/p>

因此�Q�我��Q�最好用后一�U�方法来使用�U�程�?/p>

public class mainThread extends Thread{
int i=0;
public static void main(String args[]){
    mainThread m1 = new mainThread();
    mainThread m2 = new mainThread();
    mainThread m3 = new mainThread();
    mainThread m4 = new mainThread();
    mainThread m5 = new mainThread();
    mainThread m6 = new mainThread();
    m1.start();
    m2.start();
    m3.start();
    m4.start();
    m5.start();
    m6.start();
}
public synchronized void t1(){
    i=++i;
    try{
      Thread.sleep(500);
    }
    catch(Exception e){}
    //每个�U�程都进入各自的t1()�Ҏ��Q�分别打印各自的i
    System.out.println(Thread.currentThread().getName()+" "+i);
}
public void run(){
    synchronized(this){
      while (true) {
        t1();
      }
    }
}
}

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

下面我们来讲synchronized�?�U�用法吧:

1.�Ҏ��声明时��?攑֜�范围操作�W?public�{?之后,�q�回�c�d��声明(void�{?之前.即一�ơ只能有一个线�E�进入该�Ҏ��,其他�U�程要想在此时调用该�Ҏ��,只能排队�{��?当前�U�程(��是在synchronized�Ҏ��内部的线�E?执行完该�Ҏ��?别的�U�程才能�q�入.

例如:

public synchronized void synMethod() {
//�Ҏ��?br> }

2.�Ҏ��一代码块��?synchronized后跟括号,括号里是变量,�q�样,一�ơ只有一个线�E�进入该代码�?例如:

      public int synMethod(int a1){
        synchronized(a1) {
          //一�ơ只能有一个线�E�进�?br>        }
      }
    3.synchronized后面括号里是一对象,此时,�U�程获得的是对象�?例如:

public class MyThread implements Runnable {
public static void main(String args[]) {
    MyThread mt = new MyThread();
    Thread t1 = new Thread(mt, "t1");
    Thread t2 = new Thread(mt, "t2");
    Thread t3 = new Thread(mt, "t3");
    Thread t4 = new Thread(mt, "t4");
    Thread t5 = new Thread(mt, "t5");
    Thread t6 = new Thread(mt, "t6");
    t1.start();
    t2.start();
    t3.start();
    t4.start();
    t5.start();
    t6.start();
}

public void run() {
    synchronized (this) {
      System.out.println(Thread.currentThread().getName());
    }
}
}

对于3,如果�U�程�q�入,则得到对象锁,那么别的�U�程在该�c�L��有对象上的�Q何操作都不能�q�行.在对象��使用锁通常是一�U�比较粗�p�的�Ҏ��。�ؓ什么要��整个对象都上锁�Q�而不允许其他�U�程短暂��C��用对象中其他同步�Ҏ��来访问共享资源？如果一个对象拥有多个资源，��׃��需要只��Z��让一个线�E��用其中一部分资源�Q�就��所有线�E�都锁在外面。由于每个对象都有锁�Q�可以如下所�C�Z��用虚拟对象来上锁�Q?/p>

class FineGrainLock {

MyMemberClass x, y;
Object xlock = new Object(), ylock = new Object();

   public void foo() {
      synchronized(xlock) {
         //access x here
      }

//do something here - but don't use shared resources

      synchronized(ylock) {
         //access y here
      }
   }

   public void bar() {
      synchronized(this) {
         //access both x and y here
      }
      //do something here - but don't use shared resources
   }
}

4.synchronized后面括号里是�c?例如:

class ArrayWithLockOrder{
private static long num_locks = 0;
private long lock_order;
private int[] arr;

public ArrayWithLockOrder(int[] a)
{
    arr = a;
    synchronized(ArrayWithLockOrder.class) {//-----------------------------------------�q�里
      num_locks++;             // 锁数�?1�?br>      lock_order = num_locks; // 为此对象实例讄��唯一�?lock_order�?br>    }
}
public long lockOrder()
{
    return lock_order;
}
public int[] array()
{
    return arr;
}
}

class SomeClass implements Runnable
{
public int sumArrays(ArrayWithLockOrder a1,
                       ArrayWithLockOrder a2)
{
    int value = 0;
    ArrayWithLockOrder first = a1;       // 保留数组引用的一�?br>    ArrayWithLockOrder last = a2;        // 本地副本�?br>    int size = a1.array().length;
    if (size == a2.array().length)
    {
      if (a1.lockOrder() > a2.lockOrder()) // ��定�q�设�|�对象的锁定
      {                                     // ��序�?br>        first = a2;
        last = a1;
      }
      synchronized(first) {              // 按正��的��序锁定对象�?br>        synchronized(last) {
          int[] arr1 = a1.array();
          int[] arr2 = a2.array();
          for (int i=0; i            value += arr1[i] + arr2[i];
        }
      }
    }
    return value;
}
public void run() {
    //...
}
}

对于4,如果�U�程�q�入,则线�E�在该类中所有操作不能进�?包括静态变量和静态方�?实际�?对于含有静态方法和静态变量的代码块的同步,我们通常�?来加�?

以上4�U�之间的关系�Q?/p>

锁是和对象相兌��的，每个对象有一把锁�Q��ؓ了执行synchronized语句�Q�线�E�必��能够获得synchronized语句中表辑ּ�指定的对象的锁，一个对象只有一把锁�Q�被一个线�E�获得之后它��׃��再拥有这把锁�Q�线�E�在执行完synchronized语句后，��获得锁交还�l�对象�?br> 在方法前面加上synchronized修饰�W�即可以��一个方法声明�ؓ同步化方法。同步化�Ҏ��在执行之前获得一个锁。如果这是一个类�Ҏ��Q�那么获得的锁是和声明方法的�cȝ��关的Class�c�d��象的锁。如果这是一个实例方法，那么此锁是this对象的锁�?/p>

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

下面谈一谈一些常用的�Ҏ��:

wait(),wait(long),notify(),notifyAll()�{�方法是当前�cȝ��实例�Ҏ��,

        wait()是��持有对象锁的�U�程释放�?
        wait(long)是��持有对象锁的�U�程释放锁时间�ؓlong(毫秒)�?再次获得�?wait()和wait(0)�{��h;
        notify()是唤醒一个正在等待该对象锁的�U�程,如果�{�待的线�E�不止一�?那么被唤醒的�U�程由jvm��定;
        notifyAll是唤醒所有正在等待该对象锁的�U�程.
        在这里我也重申一�?我们应该优先使用notifyAll()�Ҏ��,因�ؓ唤醒所有线�E�比唤醒一个线�E�更�Ҏ��让jvm扑ֈ�最适合被唤醒的�U�程.

对于上述�Ҏ��,只有在当前线�E�中才能使用,否则报运行时错误java.lang.IllegalMonitorStateException: current thread not owner.

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

下面,我谈一下synchronized和wait()、notify()�{�的关系:

1.有synchronized的地方不一定有wait,notify

2.有wait,notify的地方必有synchronized.�q�是因�ؓwait和notify不是属于�U�程�c�，而是每一个对象都��h��的方法，而且�Q�这两个�Ҏ��都和对象锁有养I��有锁的地方，必有synchronized�?/p>

另外�Q�请注意一点：如果要把notify和wait�Ҏ��攑֜�一��L��的话�Q�必��d��调用notify后调用wait�Q�因为如果调用完wait�Q�该�U�程��已�l�不是current thread了。如下例�Q?/p>

/**
* Title:        Jdeveloper's Java Projdect
* Description: n/a
* Copyright:    Copyright (c) 2001
* Company:      soho http://www.ChinaJavaWorld.com
* @author jdeveloper@21cn.com
* @version 1.0
*/
import java.lang.Runnable;
import java.lang.Thread;

public class DemoThread
implements Runnable {

public DemoThread() {
TestThread testthread1 = new TestThread(this, "1");
TestThread testthread2 = new TestThread(this, "2");

testthread2.start();
testthread1.start();

}

public static void main(String[] args) {
DemoThread demoThread1 = new DemoThread();

}

public void run() {

    TestThread t = (TestThread) Thread.currentThread();
    try {
      if (!t.getName().equalsIgnoreCase("1")) {
        synchronized (this) {
          wait();
        }
      }
      while (true) {

System.out.println("@time in thread" + t.getName() + "=" +
t.increaseTime());

        if (t.getTime() % 10 == 0) {
          synchronized (this) {
            System.out.println("****************************************");
            notify();
            if (t.getTime() == 100)
              break;
            wait();
          }
        }
      }
    }
    catch (Exception e) {
      e.printStackTrace();
    }
}

}

class TestThread
extends Thread {
private int time = 0;
public TestThread(Runnable r, String name) {
super(r, name);
}

public int getTime() {
return time;
}

public int increaseTime() {
return++time;
}

}

下面我们用生产�?消费者这个例子来说明他们之间的关�p?

    public class test {
public static void main(String args[]) {
    Semaphore s = new Semaphore(1);
    Thread t1 = new Thread(s, "producer1");
    Thread t2 = new Thread(s, "producer2");
    Thread t3 = new Thread(s, "producer3");
    Thread t4 = new Thread(s, "consumer1");
    Thread t5 = new Thread(s, "consumer2");
    Thread t6 = new Thread(s, "consumer3");
    t1.start();
    t2.start();
    t3.start();
    t4.start();
    t5.start();
    t6.start();
}
}

class Semaphore
implements Runnable {
private int count;
public Semaphore(int n) {
this.count = n;
}

public synchronized void acquire() {
    while (count == 0) {
      try {
        wait();
      }
      catch (InterruptedException e) {
        //keep trying
      }
    }
    count--;
}

public synchronized void release() {
    while (count == 10) {
      try {
        wait();
      }
      catch (InterruptedException e) {
        //keep trying
      }
    }
    count++;
    notifyAll(); //alert a thread that's blocking on this semaphore
}

public void run() {
    while (true) {
      if (Thread.currentThread().getName().substring(0,8).equalsIgnoreCase("consumer")) {
        acquire();
      }
      else if (Thread.currentThread().getName().substring(0,8).equalsIgnoreCase("producer")) {
        release();
      }
      System.out.println(Thread.currentThread().getName() + " " + count);
    }
}
}

生��者生�?消费者消�?一般没有冲�H?但当库存�?�?消费者要消费是不行的,但当库存��Z��?�q�里�?0)�?生��者也不能生��.请好好研��M��面的�E�序,你一定会比以前进步很�?

上面的代码说明了synchronized和wait,notify没有�l�对的关�p?在synchronized声明的方法、代码块�?你完全可以不用wait,notify�{�方�?但是,如果当线�E�对某一资源存在某种争用的情况下,你必��适时得将�U�程攑օ��{�待或者唤�?

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

文章�l�于写完�?基本上将我学习所得全部写出来�?不过也留下些讔R��?比如synchronized后是�c�L��的深入的说明及讨�?而且,文章�׃��自己能力有限,有些地方肯定会有错误,希望看过有何��和批�?请发帖在下面,我会修正该文.谢谢!

�?/a> 2007-12-23 03:25 发表评论

Sat, 22 Dec 2007 19:25:00 GMT

Java与XML��d��之DOM��?br>DOM
初步
DOM是Document Object Model的羃写，��x��档对象模型。前面说�q�，XML��数据组�l��ؓ一颗树�Q?br>所以DOM��是对这颗树的一个对象描叙。通俗的说�Q�就是通过解析XML文档�Q��ؓXML文档�?br>逻辑上徏立一个树模型�Q�树的节�Ҏ��一个个对象。我们通过存取�q�些对象��p��够存取XML文档
的内宏V�?br>下面我们来看一个简单的例子�Q�看看在DOM中，我们是如何来操作一个XML文档的�?br>�q�是一个XML文档�Q�也是我们要操作的对象：
下面�Q�我们需要把�q�个文档的内容解析到一个个的Java对象中去供程序��用，利用JAXP�Q�我�?br>只需几行代码��p��做到�q�一炏V��首先，我们需要徏立一个解析器工厂�Q�以利用�q�个工厂来获�?br>一个具体的解析器对象：
我们在这里��用DocumentBuilderFacotry的目的是��Z��创徏与具体解析器无关的程序，�?br>DocumentBuilderFactory�cȝ��静态方法newInstance()被调用时�Q�它�Ҏ��一个系�l�变量来军_��具体
使用哪一个解析器。又因�ؓ所有的解析器都服从于JAXP所定义的接口，所以无论具体��用哪一
个解析器�Q�代码都是一��L��。所以当在不同的解析器之间进行切换时�Q�只需要更改系�l�变量的
��|��而不用更改�Q何代码。这��是工厂所带来的好处。这个工厂模式的具体实现�Q�可以参看下
面的�c�d��?br>当获得一个工厂对象后�Q?使用它的静态方法newDocumentBuilder() �Ҏ��可以获得一�?br>DocumentBuilder对象�Q�这个对象代表了具体的DOM解析器。但具体是哪一�U�解析器�Q�微软的�?br>者IBM的，对于�E�序而言�q�不重要�?br>然后�Q�我们就可以利用�q�个解析器来对XML文档�q�行解析了：
DocumentBuilder的parse()�Ҏ��接受一个XML文档名作��入参敎ͼ��q�回一个Document对象�Q�这

Good-bye serialization, hello Java!

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse("c:/xml/message.xml");
个Document对象��׃��表了一个XML文档的树模型。以后所有的对XML文档的操作，都与解析�?br>无关�Q�直接在�q�个Document对象上进行操作就可以了。而具体对Document操作的方法，��是�?br>DOM所定义的了�?br>Jaxp支持W3C所推荐的DOM 2。如果你对DOM很熟悉，那么下面的内容就很简单了�Q�只需要按
照DOM的规范来�q�行�Ҏ��调用��可以。当�Ӟ��如果你对DOM不清楚，也不用着急，后面我们
会有详细的介�l�。在�q�儿�Q�你所要知道�ƈ牢记的是�Q�DOM是用来描叙XML文档中的数据的模型，
引入DOM的全部原因就是�ؓ了用�q�个模型来操作XML文档的中的数据。DOM规范中定义有�?br>点（卛_��象）、属性和�Ҏ��Q�我们通过�q�些节点的存取来存取XML的数据�?br>从上面得到的Document对象开始，我们��可以开始我们的DOM之旅了。��用Document对象�?br>getElementsByTagName()�Ҏ��Q�我们可以得��C��个NodeList对象�Q�一个Node对象代表了一个XML
文档中的一个标�{�օ�素，而NodeList对象�Q�观其名而知其意�Q�所代表的是一个Node对象的列表：
我们通过�q�样一条语句所得到的是XML文档中所�?lt;message>标签对应的Node对象的一个列
表。然后，我们可以使用NodeList对象的item()�Ҏ��来得到列表中的每一个Node对象�Q?br>当一个Node对象被徏立之后，保存在XML文档中的数据��p��提取出来�q�封装在�q�个Node中了�?br>NodeList nl = doc.getElementsByTagName("message");
Node my_node = nl.item(0);
在这个例子中�Q�要提取Message标签内的内容�Q�我们通常会��用Node对象的getNodeValue()�Ҏ��Q?br>��h��意，�q�里�q��用了一个getFirstChild()�Ҏ��来获得message下面的第一个子Node对象。虽然在
message 标签下面除了文本外�ƈ没有其它子标�{�或者属性，但是我们坚持在这里��?br>getFirseChild()�Ҏ��Q�这主要和W3C对DOM的定义有兟뀂W3C把标�{�ֆ�的文本部分也定义成一
个Node�Q�所以先要得��C��表文本的那个Node�Q�我们才能够使用getNodeValue()来获取文本的�?br>宏V�?br>现在�Q�既然我们已�l�能够从XML文�g中提取出数据了，我们��可以把�q�些数据用在合适的地方�Q?br>来构�{�应用程序�?br>下面的内容，我们��更多的��x��DOM�Q��ؓDOM作一个较��l�的解析�Q��我们使用��h��更�ؓ
得心应手�?br>DOM
详解
DOM的基本对象有5个：Document�Q�Node�Q�NodeList�Q�Element和Attr。下面就�q�些对象的功
能和实现的方法作一个大致的介绍�?br>Document对象代表了整个XML的文档，所有其它的Node�Q�都以一定的��序包含在Document
String message = my_node.getFirstChild().getNodeValue();
1�Q�基本的DOM对象
对象之内�Q�排列成一个树形的�l�构�Q�程序员可以通过遍历�q�颗树来得到XML文档的所有的内容�Q?br>�q�也是对XML文档操作的�v炏V��我们��L��先通过解析XML源文件而得��C��个Document对象�Q?br>然后再来执行后箋的操作。此外，Document�q�包含了创徏其它节点的方法，比如createAttribut()
用来创徏一个Attr对象。它所包含的主要的�Ҏ��有：
createAttribute(String)�Q�用�l�定的属性名创徏一个Attr对象�Q��ƈ可在其后使用setAttributeNode
�Ҏ��来放�|�在某一个Element对象上面�?br>createElement(String)�Q�用�l�定的标�{�֐�创徏一个Element对象�Q�代表XML文档中的一个标�{�，
然后��可以在�q�个Element对象上添加属性或�q�行其它的操作�?br>createTextNode(String)�Q�用�l�定的字�W�串创徏一个Text对象�Q�Text对象代表了标�{�或者属性中
所包含的纯文本字符丌Ӏ�如果在一个标�{�ֆ�没有其它的标�{�，那么标签内的文本所代表的Text
对象是这个Element对象的唯一子对象�?br>getElementsByTagName(String)�Q�返回一个NodeList对象�Q�它包含了所有给定标�{�֐�字的标签�?br>getDocumentElement()�Q�返回一个代表这个DOM树的根节点的Element对象�Q�也��是代表XML
文档根元素的那个对象�?br>Node对象是DOM�l�构中最为基本的对象�Q�代表了文档树中的一个抽象的节点。在实际使用�?br>时候，很少会真正的用到Node�q�个对象�Q�而是用到诸如Element、Attr、Text�{�Node对象的子
对象来操作文档。Node对象��些对象提供了一个抽象的、公��q��栏V��虽然在Node对象中定
义了对其子节点进行存取的�Ҏ��Q�但是有一些Node子对象，比如Text对象�Q�它�q�不存在子节点，
�q�一�Ҏ��要注意的。Node对象所包含的主要的�Ҏ��有：
appendChild(org.w3c.dom.Node)�Q��ؓ�q�个节点��d��一个子节点�Q��ƈ攑֜�所有子节点的最后，
如果�q�个子节点已�l�存在，则先把它删掉再添加进厅R�?br>getFirstChild()�Q�如果节点存在子节点�Q�则�q�回�W�一个子节点�Q�对�{�的�Q�还有getLastChild()�Ҏ��
�q�回最后一个子节点�?br>getNextSibling() �Q?�q�回在DOM 树中�q�个节点的下一个兄弟节点，对等的， �q�有
getPreviousSibling()�Ҏ��q�回其前一个兄弟节炏V�?br>getNodeName()�Q�根据节点的�c�d��q�回节点的名�U��?br>getNodeType()�Q�返回节点的�c�d��?br>getNodeValue()�Q�返回节点的倹{�?br>hasChildNodes()�Q�判断是不是存在有子节点�?br>hasAttributes()�Q�判断这个节�Ҏ��否存在有属性�?br>getOwnerDocument()�Q�返回节�Ҏ��处的Document对象�?br>insertBefore(org.w3c.dom.Node new�Q�org.w3c.dom.Node ref)�Q�在�l�定的一个子对象前再插入
一个子对象�?br>removeChild(org.w3c.dom.Node)�Q�删除给定的子节点对象�?br>replaceChild(org.w3c.dom.Node new�Q�org.w3c.dom.Node old)�Q�用一个新的Node对象代替�l?br>定的子节点对象�?br>NodeList对象�Q�顾名思义�Q�就是代表了一个包含了一个或者多个Node的列表。可以简单的把它
看成一个Node的数�l�，我们可以通过�Ҏ��来获得列表中的元素：
GetLength()�Q�返回列表的长度�?br>Item(int)�Q�返回指定位�|�的Node对象�?br>Element对象代表的是XML文档中的标签元素�Q��承于Node�Q�亦是Node的最主要的子对象。在
标签中可以包含有属性，因而Element对象中有存取其属性的�Ҏ��Q�而�Q何Node中定义的�Ҏ��Q?br>也可以用在Element对象上面�?br>getElementsByTagName(String)�Q�返回一个NodeList对象�Q�它包含了在�q�个标签中其下的子孙
节点中具有给定标�{�֐�字的标签�?br>getTagName()�Q�返回一个代表这个标�{�֐�字的字符丌Ӏ?br>getAttribute(String)�Q�返回标�{�中�l�定属性名�U�的属性的倹{��在�q�儿需要主要的是，应�ؓXML
文档中允许有实体属性出玎ͼ�而这个方法对�q�些实体属性�ƈ不适用。这时候需要用�?br>getAttributeNodes()�Ҏ��来得��C��个Attr对象来进行进一步的操作�?br>getAttributeNode(String)�Q�返回一个代表给定属性名�U�的Attr对象�?br>Attr对象代表了某个标�{�中的属性。Attr�l�承于Node�Q�但是因为Attr实际上是包含在Element�?br>的，它�ƈ不能被看作是Element的子对象�Q�因而在DOM中Attr�q�不是DOM树的一部分�Q�所以Node
中的getparentNode()�Q�getpreviousSibling()和getnextSibling()�q�回的都��是null。也��是��_��
Attr其实是被看作包含它的Element对象的一部分�Q�它�q�不作�ؓDOM树中单独的一个节点出现�?br>�q�一点在使用的时候要同其它的Node子对象相区别�?br>需要说明的是，上面所说的DOM对象在DOM中都是用接口定义的，在定义的时候��用的是与
具体语言无关的IDL语言来定义的。因而，DOM其实可以在�Q何面向对象的语言中实玎ͼ�只要
它实��C��DOM所定义的接口和功能��可以了。同�Ӟ��有些�Ҏ��在DOM中�ƈ没有定义�Q�是用IDL
的属性来表达的，当被映射到具体的语言�Ӟ��q�些属性被映射为相应的�Ҏ��?br>有了上面的介�l�，�怿�你对DOM理解的更多了吧。下面的例子��让你对DOM更加熟悉��h��?br>先说说这个例子到底要做的是什么吧�Q�我们希望在一个名为link.xml文�g中保存了一些URL�?br>址�Q�通过一个简单的�E�序�Q�我们可以通过DOM把这些URL��d��q�显�C�出来，也可以反�q�来向这
个XML文�g中写入加入的URL地址。很��单，却很实用�Q�也��_��来例�C�DOM的绝大部分用法了�?br>XML文�g本��n不复杂，��׃��l�出它的DTD了。link.xml:
2�Q�DOM实例

JSP Insider
http://www.jspinsider.com
JSP Insider

2
1
2001

A JSP information site.

The makers of Java
http://java.sun.com
Sun Microsystems

3
1
2001

Sun Microsystem's website.

�W�一个程序我们称为xmldisplay.java�Q�具体的�E�序清单可以在附件中扑ֈ�。主要的功能��是�?br>取这个XML文�g中各个节点的内容�Q�然后在格式化输出在System.out上，我们来看看这个程序：
�q�是引入必要的类�Q?因�ؓ在这里��用的是Sun 所提供的XML 解析器，因而需要引�?br>java.xml.parsers包，其中包含了有DOM解析器和SAX解析器的具体实现。org.w3c.dom包中�?br>义了w3c所制定的DOM接口�?br>除了上面讲到的，�q�有一个小技巧，对Document对象调用normalize()�Q�可以去掉XML文档中作
为格式化内容的空白而映��在DOM树中的不必要的Text Node对象。否则你得到的DOM树可�?br>�q�不如你所惌��的那栗��特别是在输出的时候，�q�个normalize()更�ؓ有用�?br>刚才说过�Q�XML文档中的�I�白�W�也会被作�ؓ对象映射在DOM树中。因而，直接调用Node�Ҏ��
的getChildNodes�Ҏ��有时候会有些问题�Q�有时不能够�q�回所期望的NodeList对象。解决的办法
是��用Element的getElementByTagName(String)�Q�返回的NodeLise��是所期待的对象了。然
后，可以用item()�Ҏ��提取惌��的元素�?br>The standard JSP container
http://jakarta.apache.org
Apache Group

4
1
2001

Some great software.

import javax.xml.parsers.*;
import org.w3c.dom.*;
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Document doc=builder.parse("links.xml");
doc.normalize();
NodeList links =doc.getElementsByTagName("link");
for (int i=0;iElement link=(Element) links.item(i);
System.out.print("Content: ");
System.out.println(link.getElementsByTagName("text").item(0).getFirstChild().getNodeValue()
上面的代码片断就完成了对XML文档内容的格式化输出。只要注意到一些细节的问题�Q�比�?br>getFirstChile()�Ҏ��和getElementsByTagName()�Ҏ��的��用，�q�些�q�是比较�Ҏ��的�?br>下面的内容，��是在修改了DOM树后重新写入到XML文档中去的问题了。这个程序名�?br>xmlwrite.java。在JAXP1.0版本中，�q�没有直接的�c�d��Ҏ��能够处理XML文档的写入问题，需
要借助其它包中的一些辅助类。而在JAXP1.1版本中，引入了对XSLT的支持，所谓XSLT�Q�就
是对XML文档�q�行变换�Q�Translation�Q�后�Q�得��C��个新的文档结构。利用这个新加入的功能，
我们��p��够很方便的把新生成或者修改后的DOM树从新写回到XML文�g中去了，下面我们来看
看代码的实现�Q�这�D�代码的主要功能是向links.xml文�g中加入一个新的link节点�Q?br>新引入的java.xml.transform包中的几个类�Q�就是用来处理XSLT变换的�?br>我们希望在上面的XML文�g中加入一个新的link节点�Q�因而首先还是要��d��links.xml文�g�Q�构�?br>一个DOM树，然后再对�q�个DOM树进行修改（��d��节点�Q�，最后把修改后的DOM写回到links.xml
文�g中：
);
System.out.print("URL: ");
System.out.println(link.getElementsByTagName("url").item(0).getFirstChild().getNodeValue());
System.out.print("Author: ");
System.out.println(link.getElementsByTagName("author").item(0).getFirstChild().getNodeVal
ue());
System.out.print("Date: ");
Element linkdate=(Element) link.getElementsByTagName("date").item(0);
String day=linkdate.getElementsByTagName("day").item(0).getFirstChild().getNodeValue();
String
month=linkdate.getElementsByTagName("month").item(0).getFirstChild().getNodeValue();
String year=linkdate.getElementsByTagName("year").item(0).getFirstChild().getNodeValue();
System.out.println(day+"-"+month+"-"+year);
System.out.print("Description: ");
System.out.println(link.getElementsByTagName("description").item(0).getFirstChild().getNod
eValue());
System.out.println();
}
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.*;
��Z��看清重点�Q�简化程序，我们把要加入的内容硬�~�码到记忆String对象中，而实际操作中�Q�往
往利用一个界面来提取用户输入�Q�或者通过JDBC从数据库中提取想要的内容�?br>首先应该明了的是�Q�无��Z��么类型的Node�Q�Text型的也好�Q�Attr型的也好�Q�Element型的也好�Q?br>它们的创建都是通过Document对象中的createXXX()�Ҏ��来创建的�Q�XXX代表具体要创建的�c?br>型）�Q�因此，我们要向XML文档中添加一个link��目�Q�首先要创徏一个link对象�Q?br>DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Document doc=builder.parse("links.xml");
doc.normalize();
//---取得变量----
String text="Hanzhong's Homepage";
String url="String author="Hzliu Liu";
String discription="A site from Hanzhong Liu, give u lots of suprise!!!";
Text textseg;
Element link=doc.createElement("link");
Element linktext=doc.createElement("text");
textseg=doc.createTextNode(text);
linktext.appendChild(textseg);
link.appendChild(linktext);
Element linkurl=doc.createElement("url");
textseg=doc.createTextNode(url);
linkurl.appendChild(textseg);
link.appendChild(linkurl);
Element linkauthor=doc.createElement("author");
textseg=doc.createTextNode(author);
linkauthor.appendChild(textseg);
link.appendChild(linkauthor);
java.util.Calendar rightNow = java.util.Calendar.getInstance();
String day=Integer.toString(rightNow.get(java.util.Calendar.DAY_OF_MONTH));
String month=Integer.toString(rightNow.get(java.util.Calendar.MONTH));
String year=Integer.toString(rightNow.get(java.util.Calendar.YEAR));
Element linkdate=doc.createElement("date");
Element linkdateday=doc.createElement("day");
textseg=doc.createTextNode(day);
linkdateday.appendChild(textseg);
Element linkdatemonth=doc.createElement("month");
创徏节点的过�E�可能有些千��一律，但需要注意的地方是，对Element中所包含的text�Q�在DOM
中，�q�些text也是代表了一个Node的，因此也必��Mؓ它们创徏相应的node�Q�，不能直接用Element
对象的setNodeValue()�Ҏ��来设�|�这些text的内容，而需要用创徏的Text对象的setNodeValue()
�Ҏ��来设�|�文本，�q�样才能够把创徏的Element和其文本内容��d��到DOM树中。看看前面的�?br>码，你会更好的理解这一点：
最后，不要忘记把创建好的节�Ҏ��加到DOM树中。Document�cȝ��getDocumentElement()�Ҏ��Q?br>�q�回代表文档根节点的Element对象。在XML文档中，根节点一定是唯一的�?br>然后��是用XSLT把DOM树输��Z��。这里的TransformerFactory也同样应用了工厂模式�Q��得具
体的代码同具体的变换器无兟뀂实现的�Ҏ��和DocumentBuilderFactory相同�Q�这儿就不赘�q�C��?br>Transformer�cȝ��transfrom�Ҏ��接受两个参数、一个数据源Source和一个输出目标Result。这�?br>分别使用的是DOMSource和StreamResult�Q�这样就能够把DOM的内容输出到一个输出流中，
当这个输出流是一个文件的时候，DOM的内容就被写入到文�g中去了�?br>好了�Q�关于DOM的话题就先到�q�里�Q�下��文章将介绍的内�Ҏ��SAX。请看Java与XML��d��?br>SAX��?br>textseg=doc.createTextNode(month);
linkdatemonth.appendChild(textseg);
Element linkdateyear=doc.createElement("year");
textseg=doc.createTextNode(year);
linkdateyear.appendChild(textseg);
linkdate.appendChild(linkdateday);
linkdate.appendChild(linkdatemonth);
linkdate.appendChild(linkdateyear);
link.appendChild(linkdate);
Element linkdiscription=doc.createElement("description");
textseg=doc.createTextNode(discription);
linkdiscription.appendChild(textseg);
link.appendChild(linkdiscription);
doc.getDocumentElement().appendChild(link);
TransformerFactory tFactory =TransformerFactory.newInstance();
Transformer transformer = tFactory.newTransformer();
DOMSource source = new DOMSource(doc);
StreamResult result = new StreamResult(new java.io.File("links.xml"));
transformer.transform(source, result);

�?/a> 2007-12-23 03:25 发表评论

【�{】java��q��解决�Ҏ��

Sat, 22 Dec 2007 19:24:00 GMT

1.字节和unicode
java内核是unicode的，��p��class文�g也是�Q�但是很多媒体，包括文�g/��的保存方式是��用字节流的。因此java要对�q�些字节��经行�{化。char是unicode的，而byte是字节。java中byte/char互�{的函数在sun.io的包中间有�?br>其中ByteToCharConverter�c�L��中调度，可以用来告诉你，你用的convertor。其中两个很常用的静态函数是
public static ByteToCharConverter getDefault();
public static ByteToCharConverter getConverter(String encoding);
如果你不指定converter�Q�则�pȝ��会自动��用当前的encoding,gb�q�_��上用gbk,en�q�_��上用8859_1�?/p>

byte ——〉char�Q?br>"�?的gb码是�Q?xc4e3 ,unicode�?x4f60
String encoding = "gb2312";
byte b[] = {(byte)'\u00c4',(byte)'\u00e3'};
ByteToCharConverter converter =
ByteToCharConverter.getConverter(encoding);
char c[] = converter.convertAll(b);
for (int i = 0; i < c.length; i++) {
System.out.println(Integer.toHexString(c[i]));
}
�l�果是什么？0x4f60
如果encoding ="8859_1"�Q�结果又是什么？0x00c4,0x00e3
如果代码改�ؓ
byte b[] = {(byte)'\u00c4',(byte)'\u00e3'};
ByteToCharConverter converter = ByteToCharConverter. getDefault();
char c[] = converter.convertAll(b);
for (int i = 0; i < c.length; i++) {
System.out.println(Integer.toHexString(c[i]));
}
�l�果��又是什么？�Ҏ��q�_��的编码而定�?/p>

char ——〉byte�Q?br>String encoding = "gb2312";
char c[] = {'\u4f60'};
CharToByteConverter converter = CharToByteConverter.getConverter(encoding);
byte b[] = converter.convertAll(c);
for (int i = 0; i < b.length; i++) {
System.out.println(Integer.toHexString(b[i]));
}
�l�果是什么？0x00c4,0x00e3
如果encoding ="8859_1"�Q�结果又是什么？0x3f
如果代码改�ؓ
String encoding = "gb2312";
char c[] = {'\u4f60'};
CharToByteConverter converter = CharToByteConverter.getDefault();
byte b[] = converter.convertAll(c);
for (int i = 0; i < b.length; i++) {
System.out.println(Integer.toHexString(b[i]));
}
�l�果��又是什么？�Ҏ��q�_��的编码而定�?br>很多中文问题��是从这两个最��单的�c�L��生出来的。而却有很多类不直接支持把encoding输入�Q�这�l�我们带来诸多不�ѝ��很多程序难得用encoding了，直接用default的encoding�Q�这��q��我们�U�L��带来了很多困难�?/p>

2.utf-8
utf-8是和unicode一一对应的，其实现很��?br>7位的unicode: 0 _ _ _ _ _ _ _
11位的unicode: 1 1 0 _ _ _ _ _ 1 0 _ _ _ _ _ _
16位的unicode: 1 1 1 0 _ _ _ _ 1 0 _ _ _ _ _ _ 1 0 _ _ _ _ _ _
21位的unicode: 1 1 1 1 0 _ _ _ 1 0 _ _ _ _ _ _ 1 0 _ _ _ _ _ _ 1 0 _ _ _ _ _ _
大多数情冉|��只��用到16位以下的unicode:
"�?的gb码是�Q?xc4e3 ,unicode�?x4f60
0xc4e3的二�q�制�Q?br>1100 �Q?100 �Q?110 �Q?011
�׃��只有两位我们按照两位的编码来排，但是我们发现�q�行不通，因�ؓ�W�７位不�?因此�Q�返�??"
0x4f60的二�q�制�Q?br>0100 �Q?111 �Q?110 �Q?000
我们用utf-8补齐�Q�变成：
1110 �Q?100 �Q?011 �Q?101 �Q?010 �Q?000
e4--bd-- a0
于是�q�回�Q?xe4,0xbd,0xa0�?/p>

3.string和byte[]
string其实核心是char[],然而要把byte转化成string�Q�必��ȝ��q�编码。string.length()其实��是char数组的长度，如果使用不同的编码，很可能会错分�Q�造成散字和�ؕ码�?br>例如�Q?br>String encoding = “”;
byte [] b={(byte)'\u00c4',(byte)'\u00e3'};
String str=new String(b,encoding);　　
如果encoding=8859_1�Q�会有两个字�Q�但是encoding=gb2312只有一个字�q�个问题在处理分��|��l�常发生 �?/p>

4.Reader,Writer / InputStream,OutputStream
Reader和Writer核心是char�Q�InputStream和OutputStream核心是byte。但是Reader和Writer的主要目的是要把char�?写InputStream/OutputStream�?br>例如�Q?br>文�gtest.txt只有一�?�?字，0xc4,0xe3
String encoding = "gb2312";
InputStreamReader reader = new InputStreamReader(new FileInputStream(
"text.txt"), encoding);
char c[] = new char[10];
int length = reader.read(c);
for (int i = 0; i < length; i++) {
System.out.println(c[i]);
}
�l�果是什么？�?br>如果encoding ="8859_1"�Q�结果是什么？??两个字符�Q�表�C�Z��认识�?br>反过来的例子自己做�?/p>

5.我们要对java的编译器有所了解 �Q?br>javac ?encoding
我们常常没有用到encoding�q�个参数。其实encoding�q�个参数对于跨��^台的操作是很重要的。如果没有指定encoding�Q�则按照�pȝ��的默认encoding,gb�q�_��上是gb2312�Q�英文��^��C��是iso8859_1�?br>java 的编译器实际上是调用sun.tools.javac.main的类�Q�对文�g�q�行�~�译�Q�这个类有compile函数中间有一个encoding的变�?- encoding的参数其实直接传�l�encoding变量。编译器��是�Ҏ��q�个变量来读取java文�g的，然后把用utf-8形式�~�译成class文�g�?br>例子代码�Q?br>String str = "�?;
FileWriter writer = new FileWriter("text.txt");
write.write(str);
writer.close();

如果用gb2312�~�译�Q�你会找到e4 bd a0的字�D?�Q?br>如果�?859_1�~�译�Q?00c4 00e3的二�q�制�Q?br>0000�Q?000 �Q?100�Q?100 �Q?000�Q?000 �Q?110�Q?011
因�ؓ每个字符都大�?位，因此�?1位编码：
1100�Q?001�Q?000�Q?100�Q?100�Q?011�Q?010�Q?011
c1-- 84--　c3--　 a3
你会扑ֈ�c1 84 c3 a3 �?/p>

但是我们往往忽略掉这个参敎ͼ�因此�q�样往往会有跨��^台的问题�Q?br>样例代码在中文��^��C��~�译�Q�生成zhclass
样例代码在英文��^��C��~�译�Q�输出enclass
(1).　 zhclass在中文��^��C��执行ok,但是在英文��^��C��不行
(2). enclass在英文��^��C��执行ok,但是在中文��^��C��不行
原因�Q?br>(1). 在中文��^��C��~�译后，其实str在运行态的char[]�?x4f60,　在中文��^��C��q�行�Q�filewriter的缺省编码是gb2312,因此 chartobyteconverter会自动用调用gb2312的converter,把str转化成byte输入到fileoutputstream 中，于是0xc4,0xe3放进了文件�?br>但是如果是在英文�q�_��下，chartobyteconverter的缺省值是8859_1, filewriter会自动调�?859_1去�{化str,但是他无法解释，因此他会输出"?"
(2). 在英文��^��C��~�译后，其实str在运行态的char[]�?x00c4 0x00e3, 在中文��^��C��q�行�Q�中文无法识别，因此会出�??�Q?br>在英文��^��C��Q?x00c4-->0xc4,0x00e3->0xe3�Q�因�?xc4,0xe3被放�q�了文�g�?/p>

6. 其它原因�Q?
讄��览器的昄��~�码�Q�如果response的数据是utf8�~�码�Q�显�C�将是�ؕ码，但是��q��和上�q�原因还不一栗��?/p>

7. 发生�~�码的地�?�Q?br>? 从数据库到java�E�序 byte——〉char
? 从java�E�序到数据库 char——〉byte
? 从文件到java�E�序 byte——〉char
? 从java�E�序到文�?char——〉byte
? 从java�E�序到页面显�C?char——〉byte
? 从页面form提交数据到java�E�序byte——〉char
? 从流到java�E�序byte——〉char
? 从java�E�序到流char——〉byte

谢志钢的解决�Ҏ��Q?br>我是使用配置�q��o器的�Ҏ��解决中文��q��的：

�Q�web-app>
�Q�filter>
�Q�filter-name>RequestFilter
�Q�filter-class>net.golden.uirs.util.RequestFilter
�Q�init-param>
�Q�param-name>charset
�Q�param-value>gb2312
�Q?init-param>
�Q?filter>
�Q�filter-mapping>
�Q�filter-name>RequestFilter
�Q�url-pattern>*.jsp
�Q?filter-mapping>
�Q?web-app>

public void doFilter(ServletRequest req, ServletResponse res,
FilterChain fChain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
HttpSession session = request.getSession();
String userId = (String) session.getAttribute("userid");
req.setCharacterEncoding(this.filterConfig.getInitParameter("charset")); // 讄��字符集？
实际上是讄��了byte ——〉char的encoding
try {
if (userId == null || userId.equals("")) {
if (!request.getRequestURL().toString().matches(
".*/uirs/logon/logon(Controller){0,1}\\x2Ejsp$")) {
session.invalidate();
response.sendRedirect(request.getContextPath() +
"/uirs/logon/logon.jsp");
}
}
else { // 看看是否��h��信息上报�pȝ��的权�?br>if (!net.golden.uirs.util.UirsChecker.check(userId, "信息上报�pȝ��",
net.golden.uirs.util.UirsChecker.ACTION_DO)) {
if (!request.getRequestURL().toString().matches(
".*/uirs/logon/logon(Controller){0,1}\\x2Ejsp$")) {
response.sendRedirect(request.getContextPath() +
"/uirs/logon/logonController.jsp");
}
}
}
}
catch (Exception ex) {
response.sendRedirect(request.getContextPath() +
"/uirs/logon/logon.jsp");
}
fChain.doFilter(req, res);
}

�?/a> 2007-12-23 03:24 发表评论

【�{】��?Java Reflection

Thu, 18 Oct 2007 03:05:00 GMT

Reflection �?Java �E�序开发语�a�的特征之一�Q�它允许�q�行中的 Java �E�序对自�w�进行检查，或者说“自审”�Q��ƈ能直接操作程序的内部属性。例如，使用它能获得 Java �c�M��各成员的名称�q�显�C�出来�?/p>

Java 的这一能力在实际应用中也许用得不是很多�Q�但是在其它的程序设计语�a�中根本就不存在这一�Ҏ��。例如，Pascal、C 或�?C++ 中就没有办法在程序中获得函数定义相关的信息�?/p>

JavaBean �?reflection 的实际应用之一�Q�它能让一些工具可视化的操作��Y件组件。这些工具通过 reflection 动态的载入�q�取�?Java �l��g(�c? 的属性�?/p>

一个简单的例子

考虑下面�q�个��单的例子�Q�让我们看看 reflection 是如何工作的�?/p>

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

它的�l�果输出为：

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)

�q�样��列��Z��java.util.Stack �cȝ��各方法名以及它们的限制符和返回类型�?/p>

�q�个�E�序使用 Class.forName 载入指定的类�Q�然后调�?getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描�q�某个类中单个方法的一个类�?/p>

开始��?Reflection

用于 reflection 的类�Q�如 Method�Q�可以在 java.lang.relfect 包中扑ֈ�。��用这些类的时候必��要遵��@三个步骤�Q�第一步是获得你想操作的类�?java.lang.Class 对象。在�q�行中的 Java �E�序中，�?java.lang.Class �c�L��描述�c�d��接口�{��?/p>

下面��是获得一�?Class 对象的方法之一�Q?/p>

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

�q�条语句得到一�?String �cȝ��c�d��象。还有另一�U�方法，如下面的语句�Q?/p>

Class c = int.class;

或�?/p>

Class c = Integer.TYPE;

它们可获得基本类型的�c�M��息。其中后一�U�方法中讉K��的是基本�c�d��的封装类 (�?Integer) 中预先定义好�?TYPE 字段�?/p>

�W�二步是调用诸如 getDeclaredMethods 的方法，以取得该�c�M��定义的所有方法的列表�?/p>

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

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

Method m[] = c.getDeclaredMethods();

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

它将以文本方式打印出 String 中定义的�W�一个方法的原型�?/p>

在下面的例子中，�q�三个步骤将��Z��?reflection 处理�Ҏ��应用�E�序提供例证�?/p>

模拟 instanceof 操作�W?/p>

得到�c�M��息之后，通常下一个步骤就是解军_��?Class 对象的一些基本的问题。例如，Class.isInstance �Ҏ��可以用于模拟 instanceof 操作�W�：

class A {}

public class instance1 {

public static void main(String args[])

{

try {

Class cls = Class.forName("A");

boolean b1

= cls.isInstance(new Integer(37));

System.out.println(b1);

boolean b2 = cls.isInstance(new A());

System.out.println(b2);

}

catch (Throwable e) {

System.err.println(e);

}

在这个例子中创徏了一�?A �cȝ�� Class 对象�Q�然后检查一些对象是否是 A 的实例。Integer(37) 不是�Q�但 new A() 是�?/p>

扑և��cȝ��Ҏ��

扑և�一个类中定义了些什么方法，�q�是一个非常有价��g��非常基础�?reflection 用法。下面的代码��实��C��q�一用法�Q?/p>

import java.lang.reflect.*;

public class method1 {

private int f1(Object p, int x) throws NullPointerException

{

if (p == null)

throw new NullPointerException();

return x;

}

public static void main(String args[])

{

try {

Class cls = Class.forName("method1");

Method methlist[]

= cls.getDeclaredMethods();

for (int i = 0; i < methlist.length;

i++) {

Method m = methlist[i];

System.out.println("name

= " + m.getName());

System.out.println("decl class = " +

m.getDeclaringClass());

Class pvec[] = m.getParameterTypes();

for (int j = 0; j < pvec.length; j++)

System.out.println("

param #" + j + " " + pvec[j]);

Class evec[] = m.getExceptionTypes();

for (int j = 0; j < evec.length; j++)

System.out.println("exc #" + j

+ " " + evec[j]);

System.out.println("return type = " +

m.getReturnType());

System.out.println("-----");

}

catch (Throwable e) {

System.err.println(e);

}

�q�个�E�序首先取得 method1 �cȝ��描述�Q�然后调�?getDeclaredMethods 来获取一�p�d��?Method 对象�Q�它们分别描�q�C��定义在类中的每一个方法，包括 public �Ҏ��、protected �Ҏ��、package �Ҏ��?private �Ҏ��{�。如果你在程序中使用 getMethods 来代�?getDeclaredMethods�Q�你�q�能获得�l�承来的各个�Ҏ��的信息�?/p>

取得�?Method 对象列表之后�Q�要昄��q�些�Ҏ��的参数类型、异常类型和�q�回值类型等��׃��难了。这些类型是基本�c�d��q�是�cȝ��型，都可以由描述�cȝ��对象按顺序给出�?/p>

输出的结果如下：

name = f1

decl class = class method1

param #0 class java.lang.Object

param #1 int

exc #0 class java.lang.NullPointerException

return type = int

-----

name = main

decl class = class method1

param #0 class [Ljava.lang.String;

return type = void

-----

获取构造器信息

获取�c�L��造器的用法与上述获取�Ҏ��的用法类��|��如：

import java.lang.reflect.*;

public class constructor1 {

public constructor1()

{

}

protected constructor1(int i, double d)

{

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor1");

Constructor ctorlist[]

= cls.getDeclaredConstructors();

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

Constructor ct = ctorlist[i];

System.out.println("name

= " + ct.getName());

System.out.println("decl class = " +

ct.getDeclaringClass());

Class pvec[] = ct.getParameterTypes();

for (int j = 0; j < pvec.length; j++)

System.out.println("param #"

+ j + " " + pvec[j]);

Class evec[] = ct.getExceptionTypes();

for (int j = 0; j < evec.length; j++)

System.out.println(

"exc #" + j + " " + evec[j]);

System.out.println("-----");

}

catch (Throwable e) {

System.err.println(e);

}

�q�个例子中没能获得返回类型的相关信息�Q�那是因为构造器没有�q�回�c�d��?/p>

�q�个�E�序�q�行的结果是�Q?/p>

name = constructor1

decl class = class constructor1

-----

name = constructor1

decl class = class constructor1

param #0 int

param #1 double

-----

获取�cȝ��字段(�?

扑և�一个类中定义了哪些数据字段也是可能的，下面的代码就在干�q�个事情�Q?/p>

import java.lang.reflect.*;

public class field1 {

private double d;

public static final int i = 37;

String s = "testing";

public static void main(String args[])

{

try {

Class cls = Class.forName("field1");

Field fieldlist[]

= cls.getDeclaredFields();

for (int i

= 0; i < fieldlist.length; i++) {

Field fld = fieldlist[i];

System.out.println("name

= " + fld.getName());

System.out.println("decl class = " +

fld.getDeclaringClass());

System.out.println("type

= " + fld.getType());

int mod = fld.getModifiers();

System.out.println("modifiers = " +

Modifier.toString(mod));

System.out.println("-----");

}

catch (Throwable e) {

System.err.println(e);

}

�q�个例子和前面那个例子非常相伹{��例中��用了一个新东西 Modifier�Q�它也是一�?reflection �c�，用来描述字段成员的修饰语�Q�如“private int”。这些修饰语自��n由整数描�q�ͼ�而且使用 Modifier.toString 来返回以“官方”��序排列的字�W�串描述 (�?#8220;static”�?#8220;final”之前)。这个程序的输出是：

name = d

decl class = class field1

type = double

modifiers = private

-----

name = i

decl class = class field1

type = int

modifiers = public static final

-----

name = s

decl class = class field1

type = class java.lang.String

modifiers =

-----

和获取方法的情况一下，获取字段的时候也可以只取得在当前�c�M��x��了的字段信息 (getDeclaredFields)�Q�或者也可以取得父类中定义的字段 (getFields) �?/p>

�Ҏ��Ҏ��的名�U�来执行�Ҏ��

文本到这里，所丄��例子无一例外都与如何获取�cȝ��信息有关。我们也可以�?reflection 来做一些其它的事情�Q�比如执行一个指定了名称的方法。下面的�C�Z��演示了这一操作�Q?/p>

import java.lang.reflect.*;

public class method2 {

public int add(int a, int b)

{

return a + b;

}

public static void main(String args[])

{

try {

Class cls = Class.forName("method2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Method meth = cls.getMethod(

"add", partypes);

method2 methobj = new method2();

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj

= meth.invoke(methobj, arglist);

Integer retval = (Integer)retobj;

System.out.println(retval.intValue());

}

catch (Throwable e) {

System.err.println(e);

}

假如一个程序在执行的某处的时候才知道需要执行某个方法，�q�个�Ҏ��的名�U�是在程序的�q�行�q�程中指定的 (例如�Q�JavaBean 开发环境中��׃��做这��L��?�Q�那么上面的�E�序演示了如何做到�?/p>

上例中，getMethod 用于查找一个具有两个整型参��C��名�ؓ add 的方法。找到该�Ҏ��q�创��Z��相应�?Method 对象之后�Q�在正确的对象实例中执行它。执行该�Ҏ��的时候，需要提供一个参数列表，�q�在上例中是分别包装了整�?37 �?47 的两�?Integer 对象。执行方法的�q�回的同��h��一�?Integer 对象�Q�它��装了返回�?84�?/p>

创徏新的对象

对于构造器�Q�则不能像执行方法那栯��行，因�ؓ执行一个构造器��意味着创徏了一个新的对�?(准确的说�Q�创��Z��个对象的�q�程包括分配内存和构造对�?。所以，与上例最�怼�的例子如下：

import java.lang.reflect.*;

public class constructor2 {

public constructor2()

{

}

public constructor2(int a, int b)

{

System.out.println(

"a = " + a + " b = " + b);

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Constructor ct

= cls.getConstructor(partypes);

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj = ct.newInstance(arglist);

}

catch (Throwable e) {

System.err.println(e);

}

�Ҏ��指定的参数类型找到相应的构造函数�ƈ执行它，以创��Z��个新的对象实例。��用这�U�方法可以在�E�序�q�行时动态地创徏对象�Q�而不是在�~�译的时候创建对象，�q�一炚w��常有价倹{�?/p>

改变字段(�?的�?/p>

reflection 的还有一个用处就是改变对象数据字�D늚�倹{��reflection 可以从正在运行的�E�序中根据名�U�找到对象的字段�q�改变它�Q�下面的例子可以说明�q�一点：

import java.lang.reflect.*;

public class field2 {

public double d;

public static void main(String args[])

{

try {

Class cls = Class.forName("field2");

Field fld = cls.getField("d");

field2 f2obj = new field2();

System.out.println("d = " + f2obj.d);

fld.setDouble(f2obj, 12.34);

System.out.println("d = " + f2obj.d);

}

catch (Throwable e) {

System.err.println(e);

}

�q�个例子中，字段 d 的��D��变�ؓ�?12.34�?/p>

使用数组

本文介绍�?reflection 的最后一�U�用法是创徏的操作数�l�。数�l�在 Java 语言中是一�U�特�D�的�cȝ��型，一个数�l�的引用可以赋给 Object 引用。观察下面的例子看看数组是怎么工作的：

import java.lang.reflect.*;

public class array1 {

public static void main(String args[])

{

try {

Class cls = Class.forName(

"java.lang.String");

Object arr = Array.newInstance(cls, 10);

Array.set(arr, 5, "this is a test");

String s = (String)Array.get(arr, 5);

System.out.println(s);

}

catch (Throwable e) {

System.err.println(e);

}

例中创徏�?10 个单位长度的 String 数组�Q��ؓ�W?5 个位�|�的字符串赋了��|��最后将�q�个字符串从数组中取得�ƈ打印了出来�?/p>

下面�q�段代码提供了一个更复杂的例子：

import java.lang.reflect.*;

public class array2 {

public static void main(String args[])

{

int dims[] = new int[]{5, 10, 15};

Object arr

= Array.newInstance(Integer.TYPE, dims);

Object arrobj = Array.get(arr, 3);

Class cls =

arrobj.getClass().getComponentType();

System.out.println(cls);

arrobj = Array.get(arrobj, 5);

Array.setInt(arrobj, 10, 37);

int arrcast[][][] = (int[][][])arr;

System.out.println(arrcast[3][5][10]);

}

例中创徏了一�?5 x 10 x 15 的整型数�l�，�q��ؓ处于 [3][5][10] 的元素赋了��gؓ 37。注意，多维数组实际上就是数�l�的数组�Q�例如，�W�一�?Array.get 之后�Q�arrobj 是一�?10 x 15 的数�l�。进而取得其中的一个元素，即长度�ؓ 15 的数�l�，�q��?Array.setInt 为它的第 10 个元素赋倹{�?/p>

注意创徏数组时的�c�d��是动态的�Q�在�~�译时�ƈ不知道其�c�d��?/p>

��结

Java reflection 非常有用�Q�它使类和数据结构能按名�U�动态检索相关信息，�q�允许在�q�行着的程序中操作�q�些信息。Java 的这一�Ҏ��非常强大，�q�且是其它一些常语言�Q�如 C、C++、Fortran 或�?Pascal �{�都不具备的�?nbsp;

�?/a> 2007-10-18 11:05 发表评论

麻豆久久久9性大片,久久久久99精品成人片试看,久久发布国产伦子伦精品

【�{】java��q��解决�Ҏ��

【�{】���?Java Reflection

【�{】��?Java Reflection