Composite定义,将对象以树形结构组织起来,以达成“部分－整体” 的层次结构，使得客户端对单个对象和组合对象的使用具有一致性.注意：＂部分－整体＂应具有共同的接口或者是抽象类．

Composite比较容易理解，想到Composite就应该想到树形结构图。组合体内这些对象都有共同接口,当组合体一个对象的方法被调用执行时，Composite将遍历(Iterator)整个树形结构,寻找同样包含这个方法的对象并实现调用执行。可以用牵一动百来形容。

Composite好处:
1.使客户端调用简单，客户端可以一致的使用组合结构或其中单个对象，用户就不必关系自己处理的是单个对象还是整个组合结构，这就简化了客户端代码。
2.更容易在组合体内加入对象部件. 客户端不必因为加入了新的对象部件而更改代码。

如何使用Composite?
首先定义一个接口或抽象类，这是设计模式通用方式了，其他设计模式对接口内部定义限制不多，Composite却有个规定，那就是要在接口内部定义一个用于访问和管理Composite组合体的对象们（或称部件Component）.

首先定义一个＂整体－部分＂的接口．也是Component的定义．

//设备，器材接口
public interface Equipment {
   //实际的价格
   double netPrice();
   //打折价格
   double discountPrice();
   boolean add(Equipment equipment);
   boolean remove(Equipment equipment);
   Iterator iter();
}

 Disk是组合体内的一个对象，或称一个部件，这个部件是个单独元素( Primitive)。

//硬盘
public class Disk implements Equipment {

	public boolean add(Equipment equipment) {
		// TODO Auto-generated method stub
		return false;
	}

	public double discountPrice() {
		// TODO Auto-generated method stub
		return 0.5;
	}

	public Iterator iter() {
		// TODO Auto-generated method stub
		return null;
	}

	public double netPrice() {
		// TODO Auto-generated method stub
		return 1;
	}

	public boolean remove(Equipment equipment) {
		// TODO Auto-generated method stub
		return false;
	}

}

 还有一种可能是，一个部件也是一个组合体，就是说这个部件下面还有'儿子'，这是树形结构中通常的情况，应该比较容易理解。现在我们先要定义这个组合体：

public class CompositeEquipment implements Equipment {
	private List<Equipment> equipments = new ArrayList<Equipment>();

	public boolean add(Equipment equipment) {
		// TODO Auto-generated method stub
		equipments.add(equipment);
		return true;
	}

	public double discountPrice() {
		double discountPrice = 0.0;
		for (Iterator<Equipment> iterator = equipments.iterator(); iterator
				.hasNext();) {
			discountPrice += ((Equipment) iterator.next()).discountPrice();
		}
		return discountPrice;
	}

	public Iterator<Equipment> iter() {
		return equipments.iterator();
	}

	public double netPrice() {
		double netPrice = 0.0;
		for (Iterator<Equipment> iterator = equipments.iterator(); iterator
				.hasNext();) {
			netPrice += ((Equipment) iterator.next()).netPrice();

		}
		return netPrice;
	}

	public boolean remove(Equipment equipment) {
		equipments.remove(equipment);
		return true;
	}

}

我们再看看CompositeEquipment的两个具体类:盘盒Chassis和箱子Cabinet，箱子里面可以放很多东西，如底板，电源盒，硬盘盒等；盘盒里面可以放一些小设备，如硬盘 软驱等。无疑这两个都是属于组合体性质的。

//箱子
public class Cabinet extends CompositeEquipment {
	public double netPrice() {
		return 1.0 + super.netPrice();
	}

	public double discountPrice() {
		return 0.5 + super.discountPrice();
	}
}
//盘盒
public class Chassis extends CompositeEquipment {
	public double netPrice() {
		return 1.0 + super.netPrice();
	}

	public double discountPrice() {
		return 0.5 + super.discountPrice();
	}
}

下面看一下测试：

public static void main(String[] args) {
		Cabinet cabinet = new Cabinet();

		Chassis chassis = new Chassis();
		// chassis.name = "PC Chassis" ;
		// 将PC Chassis装到Tower中 (将盘盒装到箱子里)
		cabinet.add(chassis);
		// 将一个10GB的硬盘装到 PC Chassis (将硬盘装到盘盒里)
		Disk disk = new Disk();
		// disk.name = "10 GB" ;
		chassis.add(disk);

		// 调用 netPrice()方法;
		System.out.println("netPrice=" + cabinet.netPrice());
		System.out.println("discountPrice=" + cabinet.discountPrice());

	}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

     状态模式是在程序开发时，经常用到的模式。如果没有应用过，而实现业务功能。那你也一定是按照状态模式的路子走的，只不过你没有感觉到而已。它的实现，是要根据对象的内部状态变化，而自动执行相应的功能。
费话就不说了，请看一下源代码，这也是我研究设计模式时看到的一个例子，把其翻译成中文，使个位网友能够看懂些，由于水平有限，只能达到这样，还希望网友多指证，也算是抄来的哈哈，谢谢啊。

public class GumballMachine {
	//这就是那4个状态,每个状态都用一个不同的整数代表,他们符合状态图   
    final static int SOLD_OUT = 0;      //糖果售完状态   
    final static int NO_QUARTER = 1;    //没有钱状态   
    final static int HAS_QUARTER = 2;   //有钱状态   
    final static int SOLD = 3;      //售出糖果   
    //这个实例变量跟踪当前状态,一开始被设为"糖果售完",因为糖果机安装时是没有装糖果的   
    int state = SOLD_OUT;   
    int count = 0;  //这个变量用来追踪机器内的糖果数目   
    //构造器初始糖果库存量当做参数,如果库存不为0的话,机器就进入"没有钱"的状态,等着你向里投钱
    public GumballMachine(int count) {   
        this.count = count;   
        if (count > 0) {   
            state = NO_QUARTER;   
        }   
    }   
    
  //当把钱投入进来,就会执行这里   
    public void insertQuarter() {   
        if (state == HAS_QUARTER) {   
            //如果此时的状态为有钱状态，则通知顾客   
            System.out.println("你不能再向糖果机里投钱了");   
        } else if (state == NO_QUARTER) {   
            //如果是在"没有25分钱"的状态下,我们就接受25分钱,并将状态转换到"有25分钱"   
            state = HAS_QUARTER;   
            System.out.println("你可以向糖果机里投钱");   
        } else if (state == SOLD_OUT) {   
            //如果糖果售完,就拒绝收钱   
            System.out.println("糖果已经卖完，不能再向里投钱了");   
        } else if (state == SOLD) {   
            //如果顾客买到糖果,就需要稍等下,好让状态转换完毕,恢复到"没有25分钱"的状态
            System.out.println("已向你卖出一个糖果,请稍等,再向里投钱。");   
        }   
    }   
    //现在,如果顾客试着退回25分钱...   
    public void ejectQuarter() {   
        if (state == HAS_QUARTER) {   
            //如果有25分钱,就退钱,回到"没有25分钱"的状态   
            System.out.println("退钱成功");   
            state = NO_QUARTER;   
        } else if (state == NO_QUARTER) {   
            //如果没有25分钱,当然不能退回   
            System.out.println("没有钱，你不能退钱");   
        } else if (state == SOLD) {   
            //如果顾客已经转动手柄,就不能退钱了,他已经拿到糖果了
        	state = NO_QUARTER;
            System.out.println("对不起，糖果已经卖出不能退钱。");   
        } else if (state == SOLD_OUT) {   
            //如果糖果售完,就不可能接受25分钱,当然也不可能退钱   
            System.out.println("对不起，糖果已经卖完不能退钱");   
        }   
    }   
  //顾客试着转动手柄...   
    public void turnCrank() {   
        if (state == SOLD) {   
            //别想骗过机器拿2次糖果   
            System.out.println("不能再给你了");   
        } else if (state == NO_QUARTER) {   
            //我们需要先投入25分钱   
            System.out.println("你没有投钱糖果不能卖给你");   
        } else if (state == SOLD_OUT) {   
            //没有糖果了   
            System.out.println("糖果机中没有糖果了，你不能进行交易。");   
        } else if (state == HAS_QUARTER) {   
            //成功!他拿到糖果了.改变状态到"售出糖果",然后调用机器的dispense()方法   
            System.out.println("请稍等，一会糖果你就可以拿到了...");   
            state = SOLD;   
            dispense();   
        }   
    }   
    //发放糖果   
    public void dispense() {   
        if (state == SOLD) {   
            //我们正在"售出糖果"状态   
            System.out.println("一个糖果将从这里出来....");   
            count = count - 1;   
            //我们在这里处理"糖果售完"的情况   
            if (count == 0) {//最后一颗,将机器设置到"糖果售完"状态   
                System.out.println("库存为零!");   
                state = SOLD_OUT;   
            } else {    //否则回到"没有25分钱"的状态   
                state = NO_QUARTER;   
            }   
        } else if (state == NO_QUARTER) {   //以下都不应该发生,但如果顾客这么做了,得到的应该是错误消息而不是糖果   
            System.out.println("你需要向糖果机里投钱。。");   
        } else if (state == SOLD_OUT) {   
            System.out.println("糖果已经卖没了");   
        } else if (state == HAS_QUARTER) {   
            System.out.println("请您稍等交易还没有结束。");   
        }   
    }   

}

测试就来自已写吧，我提供个思路，就是页面提供几个开关，即按纽、checkbox等在它们的单击事件上GumballMachine实例的内部状态改变。然后看其变化，就可以了。

大家看没看出来，这段代码还有一些“怪的味道”呀，这时如果业务变化了，如果客户是一个中奖的用户，需要糖果机吐出两块糖果，怎么办？，是不是还得在各个方法中把这个状态给加上呀，又得加一个if语句呢，这是一个业务发生了变化，如果业务要无限的变化下去，程序员是不是都要疯了，哈哈。所以要对其进行重构了。

要把这几个状态抽象出来。想到这里看一下代码就明白了。

public interface State {
	//投钱的状态
	public void insertQuarter();
	//退钱的状态
	public void ejectQuarter();
    //按下按纽状态
	public void turnCrank();
    //发放物品状态
	public void dispense();

}

下面是几个实现这个状态接口的实现类。

public class HasQuarterState implements State{
	GumballMachineTwo gumballMachine;   
    //增加一个随机数产生器,产生10%的机会   
    Random randomWinner = new Random(System.currentTimeMillis());   
    public HasQuarterState(GumballMachineTwo gumballMachine) {   
        this.gumballMachine = gumballMachine;   
    }   
    public void insertQuarter() {   //这是一个对当前状态不恰当的动作   
        System.out.println("不能再投钱了，已经有钱了。");   
    }   
    
    public void ejectQuarter() {    //退钱并转换状态到NoQuarterState   
        System.out.println("退钱返回");
        //把糖果机从有钱状态改成没钱状态
        gumballMachine.setState(gumballMachine.getNoQuarterState());   
    }   
    
    public void turnCrank() {   
        System.out.println("请稍等，一会糖果你就可以拿到了...");   
        int winner = randomWinner.nextInt(10);   
        //决定这个顾客是否赢了   
        if ((winner == 0) && (gumballMachine.getCount() > 1)) {   
            gumballMachine.setState(gumballMachine.getWinnerState());   
        } else {   
            gumballMachine.setState(gumballMachine.getSoldState());   
        }   
    }   
    public void dispense() {    //这是一个对当前状态不恰当的动作   
        System.out.println("请您稍等交易还没有结束。");   
    }   

}

public class NoQuarterState implements State {
	GumballMachineTwo gumballMachine;

	// 通过构造器得到糖果机的引用
	public NoQuarterState(GumballMachineTwo gumballMachine) {
		this.gumballMachine = gumballMachine;
	}

	// 分发物品
	public void dispense() {
		System.out.println("没有钱，不能分发糖果");   
	}

	// 退钱
	public void ejectQuarter() {
		System.out.println("没有钱，不能退钱");

	}

	// 投钱
	public void insertQuarter() {
		// TODO Auto-generated method stub

	}

	// 按纽操作
	public void turnCrank() {
		// TODO Auto-generated method stub

	}

}

public class SoldOutState implements State {
	GumballMachineTwo gumballMachine;

	public SoldOutState(GumballMachineTwo gumballMachine) {
		this.gumballMachine = gumballMachine;
	}

	public void dispense() {
		System.out.println("糖果已经卖没了"); 

	}

	public void ejectQuarter() {
		System.out.println("对不起，糖果已经卖完不能退钱"); 

	}

	public void insertQuarter() {
		System.out.println("糖果已经卖完，不能再向里投钱了");

	}

	public void turnCrank() {
		// TODO Auto-generated method stub

	}

}

public class SoldState implements State{
	GumballMachineTwo gumballMachine;   
    public SoldState(GumballMachineTwo gumballMachine) {   
        this.gumballMachine = gumballMachine;   
    }       
    //以下3个方法对此状态来说都是不恰当的   
    public void insertQuarter() {   
        System.out.println("已向你卖出一个糖果,请稍等,再向里投钱。");   
    }   
    public void ejectQuarter() {   
        System.out.println("对不起，糖果已经卖出不能退钱");   
    }   
    public void turnCrank() {   
        System.out.println("糖果已经卖出，不能再给你了");   
    }   
    //首先让机器发放糖果   
    public void dispense() {   
        gumballMachine.releaseBall();   
        if (gumballMachine.getCount() > 0) {   
            gumballMachine.setState(gumballMachine.getNoQuarterState());   
        } else {   
            System.out.println("Oops, out of gumballs!");   
            gumballMachine.setState(gumballMachine.getSoldOutState());   
        }   
    }   

}

public class WinnerState implements State{
	GumballMachineTwo gumballMachine;   
    //下面都跟SoldState方法一样   
    public WinnerState(GumballMachineTwo gumballMachine) {   
        this.gumballMachine = gumballMachine;   
    }   
    public void insertQuarter() {   
        System.out.println("Please wait, we're already giving you a Gumball");   
    }   
    public void ejectQuarter() {   
        System.out.println("Please wait, we're already giving you a Gumball");   
    }   
    public void turnCrank() {   
        System.out.println("Turning again doesn't get you another gumball!");   
    }   
    //我们在这里发放出2颗糖果,然后进入NoQuarterState或SoldState   
    public void dispense() {   
        System.out.println("YOU'RE A WINNER! You get two gumballs for your quarter");   
        gumballMachine.releaseBall();   
        if (gumballMachine.getCount() == 0) {   
            gumballMachine.setState(gumballMachine.getSoldOutState());   
        } else {   
            gumballMachine.releaseBall();   
            if (gumballMachine.getCount() > 0) {   
                gumballMachine.setState(gumballMachine.getNoQuarterState());   
            } else {   
                System.out.println("Oops, out of gumballs!");   
                gumballMachine.setState(gumballMachine.getSoldOutState());   
            }   
        }   
    }   

}

下面是新的糖果类：

public class GumballMachineTwo {
	 //所有的状态都在这里   
    State soldOutState;   
    State noQuarterState;   
    State hasQuarterState;   
    State soldState;   
    
    State winnerState;//十次抽中一次的游戏,新的状态   
    //以及实例变量state   
    State state = soldOutState;   
    int count = 0;//记录糖果数量   
    public GumballMachineTwo(int numberGumballs) {        
        soldOutState = new SoldOutState(this);  //每一种状态也都创建一个状态实例   
        noQuarterState = new NoQuarterState(this);   
        hasQuarterState = new HasQuarterState(this);   
        soldState = new SoldState(this);   
        this.count = numberGumballs;   
        if (numberGumballs > 0) {    //如果超过0颗糖果,状态设为noQuarterState   
            state = noQuarterState;   
        }    
    }   
    //委托给当前状态   
    public void insertQuarter() {   
        state.insertQuarter();   
    }   
    public void ejectQuarter() {   
        state.ejectQuarter();   
    }   
    //dispense()是一个内部动作方法,用户不可以直接要求机器发放糖果   
    public void turnCrank() {   
        state.turnCrank();   
        state.dispense();   
    }   
    //允许其他的对象将机器状态转换到不同的状态   
    void setState(State state) {   
        this.state = state;   
    }   
    //辅助方法释放出糖果,并将count实例变量值减1   
    void releaseBall() {   
        System.out.println("A gumball comes rolling out the slot...");   
        if (count != 0) {   
            count = count - 1;   
        }   
    }   
    int getCount() {   
        return count;   
    }   
    void refill(int count) {   
        this.count = count;   
        state = noQuarterState;   
    }   
    public State getState() {return state;}   
    public State getSoldOutState() {return soldOutState;}   
    public State getNoQuarterState() {return noQuarterState;}   
    public State getHasQuarterState() {return hasQuarterState;}   
    public State getSoldState() {return soldState;}   
    public State getWinnerState() {return winnerState;}   

}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

     Command定义如下： 将来自客户端的请求传入一个对象，无需了解这个请求激活的动作或有关接受这个请求的处理细节。

是不是有点迷糊。不知其说的是啥。哈哈。别着急下面听我慢慢到来。

本人觉得，命令模式就是把一些具体的命令封装成一此具体的类，这此类实现同一个接口或者是抽象类。然后把这些类组织到起，然后统一来执行，完成一个具体的业务流程。

它的优点是：解藉了发送者与接收者之间的联系。发送者调用一个操作，接收者接受请求执行相应的动作，说白了就是调用一个具体的类来执行相应的方法。因为使用Command模式解耦，发送者无需知道接受者任何接口。

比如说，对文件进行操作，如打开、关闭、打印。正常的操作就是用户点击“打开”按纽，就执行打开命令，在按纽的单击事件中写个方法就可以了。但如要应用Command模式，就要把其抽象出接口，把这三个操作封装成单独的类。也许有人要问，为什么要把简单的问题复杂化呢？。虽然在代码量上有所增加，这样做有利于代码的健壮性 可维护性 还有复用性。这是前人总结出来的经验。

说了半天，如何使用呢，别说费话了，“必需的”。

具体的Command模式代码各式各样,因为如何封装命令,不同系统,有不同的做法。

典型的Command模式需要有一个接口.接口中有一个统一的方法,这就是"将命令/请求封装为对象。

public interface Command {
　　public abstract void execute ( );
} 

具体不同命令/请求代码是实现接口Command,下面有三个具体命令（打开命令、关闭命令、打印命令）

public class Open implements Command {

　　public void execute( ) {
          System.out.println("打开");
　　}
} 
public class Close implements Command {

　　public void execute( ) {
          System.out.println("关闭");
　　}
}

public class Print implements Command {

　　public void execute( ) {
          System.out.println("打印");
　　}
}

按照通常做法,我们就可以直接调用这三个Command,但是使用Command模式,我们要将他们封装起来,扔到黑盒子List里去:

public class producer{
　　public static List produceRequests() {
　　　　List queue = new ArrayList();
　　　　queue.add( new Open() );
　　　　queue.add( new Close() );
　　　　queue.add( new Print() );
　　　　return queue; 
　　}

}

这三个命令进入List中后,已经失去了其外表特征,以后再取出,也可能无法分辨出谁是Open谁是Close了,看下面客户端如何调用Command模式:

public class TestCommand {
　　public static void main(String[] args) {
　　　　
　　　　List queue = Producer.produceRequests();
　　　　for (Iterator it = queue.iterator(); it.hasNext(); )
　　　　　　
　//客户端直接调用execute方法，无需知道被调用者的其它更多类的方法名。
　　　　　　　　((Command)it.next()).execute();
　　

　　}
} 

由此可见,调用者基本只和接口打交道,不合具体实现交互,这也体现了一个原则,面向接口编程,这样,以后增加第四个具体命令时,就不必修改调用者TestCommand中的代码了.

理解了上面的代码的核心原理,在使用中,就应该各人有自己方法了,特别是在如何分离调用者和具体命令上,有很多实现方法,上面的代码是使用"从List过一遍"的做法.这种做法只是为了演示.

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

         策略模式的用意是针对一组算法或者说实现，将每一个算法（实现）封装到具有共同接口（抽象类）的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。使用策略模式可以把行为和环境分割开来。
        环境类负责维持和查询行为类，各种算法则在具体策略中提供。由于算法和环境独立开来，算法的修改都不会影响环境和客户端。

public class Output {
	public void OutputMethod(char flag) {
		switch (flag) {
		case 'A':
			System.out.println("Output flag A");
			break;
		case 'B':
			System.out.println("Output flag B");
			break;
		case 'C':
			System.out.println("Output flag C");
			break;
		default:
			break;
		}
	}
}

Output output = new Output();
output.OutputMethod('B');

public interface Ioutput {
  void output();
}

public class Aoutput implements Ioutput {
     public void output() {
         System.out.println("Output flag A");
    }

}

public class Boutput implements Ioutput {
   public void output() {
      System.out.println("Output flag B");
  }

}

public class Context {
   private Ioutput output ;
   Context(Ioutput output){
       this.output = output ;
   }
   
   public void output(){
      output.output();
   }
}

Context context = new Context(new Aoutput());
context.output();
Context bcontext = new Context(new Boutput());
bcontext.output();

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

function check(obj,xh){
     var el = document.getElementsByTagName("input"); 
     for(var i=0;i<el.length;i++){
         if((el[i].type=="checkbox")&&(el[i].name!=obj.name)){
              el[i].checked=false;
         }
     }
     window.returnValue = xh ;
     window.close() ;  
}

 注意：有的IE中window.close() ;  要结合<base target="_self">使用。否则关闭不了  showModalDialog个窗体。<base target="_self">的存放位置为<html>与<body>之间。

showModalDialog和showModelessDialog数据传递技巧：

现在需要在一个showModalDialog(或showModelessDialog)里读取或设置一个变量var_name

一般的传递方式：
　　window.showModalDialog("filename.htm",var_name)
  　//传递var_name变量
　  在showModalDialog(或showModelessDialog)读取和设置时：
  　alert(window.dialogArguments)//读取var_name变量
 　window.dialogArguments="oyiboy"//设置var_name变量
　这种方式是可以满足的，但是当你想在操作var_name同时再操作第二个变理var_id时呢？就无法再进行操作了。这就是这种传递方式的局限性。
　
以下是我建议使用的传递方式：
　　　window.showModalDialog("filename.htm",window)
　　　//不管要操作什么变量，只直传递主窗口的window对象
　　　在showModalDialog(或showModelessDialog)读取和设置时：
　　　alert(window.dialogArguments.var_name)//读取var_name变量
　　　window.dialogArguments.var_name="oyiboy"//设置var_name变量

　　　同时我也可以操作var_id变量
　　　alert(window.dialogArguments.var_id)//读取var_id变量
　　　window.dialogArguments.var_id="001"//设置var_id变量

　　　同样还可以对主窗口的任何对象进行操作，如form对象里的元素。
　　　window.dialogArguments.form1.index1.value="这是在设置index1元素的值"

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

先有一个XML数据：

<?xml version="1.0" ?>
<Order>
  <Account>9900234</Account>
  <Item id="1">
    <SKU>1234</SKU>
    <PricePer>5.95</PricePer>
    <Quantity>100</Quantity>
    <Subtotal>595.00</Subtotal>
    <Description>Super Widget Clamp</Description>
  </Item>
  <Item id="2">
    <SKU>6234</SKU>
    <PricePer>22.00</PricePer>
    <Quantity>10</Quantity>
    <Subtotal>220.00</Subtotal>
    <Description>Mighty Foobar Flange</Description>
  </Item>
  <Item id="3">
    <SKU>9982</SKU>
    <PricePer>2.50</PricePer>
    <Quantity>1000</Quantity>
    <Subtotal>2500.00</Subtotal>
    <Description>Deluxe Doohickie</Description>
  </Item>
  <Item id="4">
    <SKU>3256</SKU>
    <PricePer>389.00</PricePer>
    <Quantity>1</Quantity>
    <Subtotal>389.00</Subtotal>
    <Description>Muckalucket Bucket</Description>
  </Item>
  <NumberItems>1111</NumberItems>
  <Total>3704.00</Total>
  <OrderDate>07/07/2002</OrderDate>
  <OrderNumber>8876</OrderNumber>
</Order>

然后把Item结点的数据读出。

相关的JS函数如下：

<script language="javascript">
    var i = -1;
    var orderDoc = new ActiveXObject ("MSXML2.DOMDocument.3.0");
    orderDoc.load("order.xml");
    var items = orderDoc.documentElement.selectNodes("/Order/Item");

    //获得结点文本
    function getNode(doc, xpath) {
      var retval = "";
      var value = doc.documentElement.selectSingleNode(xpath);
      if (value) retval = value.text;
      return retval;
    }
    //下一条记录
    function getDataNext() {
      i++;
      if (i > items.length - 1) i = 0;

      document.forms[0].SKU.value = getNode(orderDoc, "/Order/Item[" + i + "]/SKU");
      document.forms[0].Price.value = getNode(orderDoc, "/Order/Item[" + i + "]/PricePer");
      document.forms[0].Quantity.value = getNode(orderDoc, "/Order/Item[" + i + "]/Quantity");
      document.forms[0].Total.value = getNode(orderDoc,"/Order/Item[" + i + "]/Subtotal");
      document.forms[0].Description.value = getNode(orderDoc, "/Order/Item[" + i + "]/Description");
    }
    //前一条记录

    function getDataPrev() {
      i--;
      if (i < 0) i = items.length - 1;
      
      document.forms[0].SKU.value = getNode(orderDoc, "/Order/Item[" + i + "]/SKU");
      document.forms[0].Price.value = getNode(orderDoc,"/Order/Item[" + i + "]/PricePer");
      document.forms[0].Quantity.value = getNode(orderDoc, "/Order/Item[" + i + "]/Quantity");
      document.forms[0].Total.value = getNode(orderDoc,"/Order/Item["+ i + "]/Subtotal");
      document.forms[0].Description.value = getNode(orderDoc, "/Order/Item[" + i + "]/Description");
    }
</script>

下面是测试网页代码：

<body onload="getDataNext()">
<form>
  <table border="0">
    <tr>
	    <td>SKU</td>
		<td><input type="text" name="SKU"></td>
	</tr>
    <tr>
	   <td>Price</td>
	   <td><input type="text" name="Price"></td>
    </tr>
    <tr>
	    <td>Quantity</td>
		<td><input type="text" name="Quantity"></td>
	</tr>
    <tr>
	    <td>Total</td>
		<td><input type="text" name="Total"></td>
	</tr>
    <tr>
	    <td>Description</td>
		<td><input type="text" name="Description"></td>
     </tr>
  </table>
    <input type="button" value="<<" onClick="getDataPrev()">
     <input type="button" value=">>" onClick="getDataNext()">
  </form>
</body>

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

<script language="javascript">
     function start(){
       mybody = document.getElementsByTagName  ("body").item(0);
        mytable = document.createElement("TABLE");
        mytablebody = document.createElement("TBODY");
        for(j=0;j<2;j++){
           mycurrent_row = document.createElement("TR");
           for(i=0;i<2;i++){
               mycurrent_cell= document.createElement("TD");
              currenttext=document.createTextNode("cell is  row "+j+",  column "+i);
              mycurrent_cell.appendChild(currenttext);
              mycurrent_row.appendChild(mycurrent_cell);
           }
           mytablebody.appendChild(mycurrent_row);
       }
       mytable.appendChild(mytablebody);
       mybody.appendChild(mytable);
       mytable.setAttribute("border","2");
   }
  </script>

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

访问方法：

1. getElementById()：返回拥用传递给该方法的指定id的第一个对象的引用。
2. getElementsByName()：返回拥用传递该方法的指定name的对象集合。
3. getElementsByTagName()：返回拥用传递给该方法的指定tag名称的对象集合。

如果在页面上有一个表格，

功能描述：获得记录数：

//要把表头去掉。
function getReorderCount(){
  var reocrders = document.getElementsByTagName("tr");
  return reocrders.length -1;
}

也可以这样写：

var  table = document.getElementById("table1");
//这是表格的行数
table.rows.length;
//如查要获得数据的记录数要把表头给去掉。要减1.

getElementByTagName是文档接口（Document interface）和元素接口（Element interface）的中的方法，所以不管是根文档对象还是所有的元素对象都含有方法getElementByTagName();

功能描述：获得表格的列数

function getColumnCount(){
   var reocrders = document.getElementsByTagName("tr");
    return reocrders.item(0).childNodes.length
}

function getCellData(){
   reocrders = document.getElementsByTagName("tr");
   for(j=1;j<reocrders.length;j++){
       currentRow =  reocrders.item(j) ;
       cur_cells = currentRow.getElementsByTagName("td");   
       for(i=0;i<cur_cells.length;i++){
            alert(cur_cells.item(i).childNodes.item(0).data);
       }
   }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

    动态代理类是一个在运行时由开发人员所指定的一列接口的实现。动态代理接口是一种由代理类实现的接口，并且是一个java.lang.reflect.Proxy类的实例。每一个代理实例都与一个调用处理器对象相联，这个调用处理器实现了java.lang.reflect.InvocationHandler接口。在代理实例上的一个方法调用是通过其中之一的代理接口被转发到与这个代理实例相联的调用处理的invoke方法上。一个java.lang.reflect.Method对象会决定那一个方法会被调用，一个类型为java.lang.Object的数组包含调用的参数。调用处理器会适当地解码方法的调用（encoded method invocation as appropriate），并且它（调用处理器）的返回结果被作为在代理实例上方法调用返回的结果而返回。

例如，我们已有和装饰器模式中一文中一样的接口IMyBusinessObject和业务类MyBusinessObject。现在当我们使用动态代理时，我必须编写一个调用处理器，因为java.lang.reflect.Proxy类将会用到它。

MyDebugInvocationHandler类看起来像下面那样：

public class MyDebugInvocationHandler implements InvocationHandler {
    private Object target ;
    
	public void setTarget(Object target) {
		this.target = target;
	}

	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
	    System.out.println("Going to execute method :"+method.getName());
	    Object  retObject = method.invoke(target, args);
	    System.out.println("After execute method :"+method.getName());
		return retObject;
	}

}

 在上面的例子中，invoke ()方法是很重要的，它是被java.lang.reflect.Proxy类所调用的。在这个方法里面，我们执行了一些额外的处理，然后转至真正的目标对象的处理（在这个例子中，是实例MyBusinessObject）。
因此我们的客户端应作如下编码：

IMyBusinessObject bo = new MyBusinessObject();
		MyDebugInvocationHandler aMyDebugInvocationHandler = new MyDebugInvocationHandler();
		aMyDebugInvocationHandler.setTarget(bo);
		IMyBusinessObject proxyObject = (IMyBusinessObject) Proxy
				.newProxyInstance(IMyBusinessObject.class.getClassLoader(),
						new Class[] { IMyBusinessObject.class },
						aMyDebugInvocationHandler);
 System.out.println(proxyObject.doExecute("Hello World")); 

输出结果：

Going to execute method :doExecute 
Here in MyBusinessObject doExecute: input :Hello World 
After execute method :doExecute 
Hello World 

 在上面的代码中，我分别创建一个MyBusinessObject实例和一个MyDebugInvocationHandler实例。我们在MyDebugInvocationHandler中设定目标对象为MyBusinessObject。因此当invoke()方法被调用时，它能够把调求发向正确的目标。然后，我们使用java.lang.reflect.Proxy去创建一个IMyBusinessObject接口的代理对象。既然invoke()方法会处理java.lang.reflect.Mehtod类的生成并且其中没有特定的业务接口的方法，通常这些特定的业务接口的方法在每一个业务接口分别编写个业调用处理器是必须的,知道这一点是很重要的。还有，如果我们想实现一些横跨所有业务接口的横切面(cross-cutting aspect)，我们不必实现在业务接口中定义的所有业务方法。例如，为了在我们的业务方法中实现安全性，我们仅仅只须在一个地方编写一个方法去实现安全逻辑，这个安全方法我们将以通用的方法编写。

如果我们想在链中增加多个处理器，我们必须创建另一个调用处理器。然后在新定义的处理器中的setTarget()中我们把它设定为链中的前一个代理对象，而不是设定为MyBusinessObject对象。另一个调用处理器代码如下：

public class MyAnotherInvocationHandler implements InvocationHandler { 
      private Object target; 

      public void setTarget(Object target) { 
            this.target = target; 
      } 

      public Object invoke(Object proxy, Method method, Object[] args) 
                  throws Throwable { 
            System.out 
                        .println("AnotherConcreteDecorator: Going to execute method : doExecute"); 
            if (method.getName().equals("doExecute") && args != null 
                        && args.length >= 1) { 
                  if (args[0] instanceof String) { 
                        args[0] = args[0] + " Modified by MyAnotherInterceptor"; 
                  } 
            } 
            Object temp = method.invoke(target, args); 
            System.out 
                        .println("AnotherConcreteDecorator: After execute method : doExecute"); 
            return temp; 
      } 

} 

客户端代码如下：

IMyBusinessObject bo = new MyBusinessObject();
		MyDebugInvocationHandler aMyDebugInvocationHandler = new MyDebugInvocationHandler();
		aMyDebugInvocationHandler.setTarget(bo);
		IMyBusinessObject proxyObject = (IMyBusinessObject) Proxy
				.newProxyInstance(IMyBusinessObject.class.getClassLoader(),
						new Class[] { IMyBusinessObject.class },
						aMyDebugInvocationHandler);

		MyAnotherInvocationHandler aMyAnotherInvocationHandler = new MyAnotherInvocationHandler();
		aMyAnotherInvocationHandler.setTarget(proxyObject);
		IMyBusinessObject nextProxyObject = (IMyBusinessObject) Proxy
				.newProxyInstance(IMyBusinessObject.class.getClassLoader(),
						new Class[] {IMyBusinessObject.class},
						aMyAnotherInvocationHandler);
		
		System.out.println(nextProxyObject.doExecute("Hello World"));

输出结果：

AnotherConcreteDecorator: Going to execute method : doExecute
Going to execute method :doExecute
Here in MyBusinessObject doExecute: input :Hello World Modified by MyAnotherInterceptor
After execute method :doExecute
AnotherConcreteDecorator: After execute method : doExecute
Hello World Modified by MyAnotherInterceptor

从上面的例子我们可以看出，用动态代理比静态装饰链用更少的代码为业务对象增加额外的行为。但是，如果我们像上面一样使用动态代理仍然有一些问题：当创建和链化动态代理时你仍然必须编写大量的代码，并且你还必须处理不如普通的对象创建或工厂方法的对象创建那么友善的代理接口API，还有，当我们需要代理我们的业务对象时，在多个位置重复一些代码并不是一个好主意。

下一篇博客将试图去解决这些问题。我将会编写一个暴露简单API的通用代理工厂（在其中隐藏代理对象的创建和链化），但仍可提供动态代理的扩展性。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

动态代理的背后思想是在一个对象的周围插入动态的行为但不改变对象的已有代码和接口。装饰器模式提供一种不必改变对象代码就可以装饰一个对象（改变它的行为）并向其增加横切面的方法。现在就用静态的装饰来实现具体的业务功能

首先有一个简单业务接口：

public interface IMyBusinessObject { 
      public String doExecute(String in); 
} 

 这个接口有一个业务对象类的实现。

public class MyBusinessObject implements IMyBusinessObject { 
public String doExecute(String in) { 
System.out.println("Here in MyBusinessObject doExecute: input :" + in); 
return in; 
} 
} 

现在想要在这个业对象类的方法doExecute之前与之后增加一些行为，装饰器模式使我们十分容易增加这个功能。现在定义一个抽象类，这个抽象类实现上面的业务接口。

public abstract class ADecorator implements IMyBusinessObject { 
      protected IMyBusinessObject target; 
  
      public void setTarget(IMyBusinessObject target) { 
            this.target = target; 
      } 
  
public ADecorator(){}; 
  
      public ADecorator(IMyBusinessObject target_) { 
            setTarget(target_); 
      } 
} 

为什么要把设置业务对象的方法放到抽象类中呢，这也是重构的一种方法。就是把子类中设置业务对象的方法提到父类中。术语为方法上移。 现在定义一个从ADedorator扩展来的具体类DebugConcreteDecorator，目的是在我们业务对象被调用之前和之后加入一些调试信息：

public class DebugConcreteDecorator extends ADecorator { 
  
  
      public DebugConcreteDecorator(IMyBusinessObject target_) { 
            super(target_); 
      } 
  
      public String doExecute(String in) { 
            System.out 
                        .println("DebugConcreteDecorator: before method : doExecute "); 
            String ret = target.doExecute(in); 
            System.out.println("DebugConcreteDecorator: after method : doExecute "); 
            return ret; 
      } 
} 

现在在客户端，我们调用业务对象：

IMyBusinessObject aIMyBusinessObject = new MyBusinessObject(); 
IMyBusinessObject wrappedObject = new DebugConcreteDecorator( 
aIMyBusinessObject); 
wrappedObject.doExecute("Hello World"); 

 输出结果如下：

DebugConcreteDecorator: before method : doExecute 
Here in MyBusinessObject doExecute: input :Hello World 
DebugConcreteDecorator: after method : doExecute 

实际的业务方法调用之前链化装饰器----调用一个装饰器后再调用另一个装饰器。让我们再定义另一个装饰器去展示这个方法：

public class AnotherConcreteDecorator extends ADecorator { 
  
      public AnotherConcreteDecorator( 
                  IMyBusinessObject target_) { 
            super(target_); 
      } 
  
      public String doExecute(String in) { 
            System.out 
                        .println("AnotherConcreteDecorator: Going to execute method : doExecute"); 
            in = in + " Modified by AnotherConcreteDecorator"; 
            String ret = target.doExecute(in); 
            System.out 
                        .println("AnotherConcreteDecorator: After execute method : doExecute"); 
            return ret; 
      } 
  
} 

上面的代码片段通过在业务方法输入的字符参数后增加(" Modified by AnotherConcreteDecorator")字符串，从而实现对其进行了修改。如果我们想链化装饰器，在客户端，我们可以编写如下的代码：

IMyBusinessObject aIMyBusinessObject = new MyBusinessObject(); 
IMyBusinessObject wrappedObject = new AnotherConcreteDecorator( 
            new DebugConcreteDecorator(aIMyBusinessObject)); 
wrappedObject.doExecute("Hello World"); 

在上面的代码片段中，我在创建一个DebugConcreteDecorator实例时，向其传递了一个实际的业务对象实例。然后用一个刚才定义的notherConcreteDecorator实例去包装DebugConcreteDecorator实例。AntherConcreteDecorator首先在输入参数后增加字符串对其进行修改，然后调用DebugConcreteDecorator实例的doExecute()方法。这时，DebugConcreteDecorator会记录doExectute()方法的输出的条目，然后调用doExecute()去调用实际业务对象的doExecute()方法。
它的返回路径以相反的顺序。在从实际的业务对象(MyBusinessObject)doExecute()方法返回之后，DebugConcreteDecorator余下代码将被执行。于是，调用返回至AnotherConcreteDecorator实例并执行余下的部份代码。

输出结果如下：

AnotherConcreteDecorator: Going to execute method : doExecute 
DebugConcreteDecorator: before method : doExecute 
Here in MyBusinessObject doExecute: input :Hello World Modified by AnotherConcreteDecorator 
DebugConcreteDecorator: after method : doExecute 
AnotherConcreteDecorator: After execute method : doExecute 

静态装饰器有一个问题：不知大家注意到没有DebugConcreteDecorator 或 AnotherConcreteDecorator中doExecute()方法。它对目标对象doExecute()方法的调用进行了硬编码。并且，如果我们在IMyBusinessObject接口中定义另一个方法，我们必须改写所有装饰器并提供这个方法的实现。于是，在实践中，我们可能会因有许多装饰器和在每个装饰器中有大量的代码而止步。

下一篇博客用一个动态代理可以帮助我们去掉这些硬编码，此外，我们不必在每个装饰器去实现和改写业务接口中的每个方法。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

 在一个关系数据库中，可以表现分等级的信息。

建立的表结构如下：

CREATE TABLE employee (
emp_id          NUMBER (4) CONSTRAINT emp_pk PRIMARY KEY,
fname           VARCHAR2 (15) NOT NULL, 
lname           VARCHAR2 (15) NOT NULL, 
dept_id         NUMBER (2) NOT NULL,
manager_emp_id  NUMBER (4) CONSTRAINT emp_fk REFERENCES employee(emp_id),
salary          NUMBER (7,2) NOT NULL,
hire_date       DATE NOT NULL, 
job_id          NUMBER (3)
);

如果manager_emp_id 字段为空则表明这条记录为根结点。

简单的分级查询：

1. 找出根结点，执行如下语句：

   SELECT emp_id, lname, dept_id, manager_emp_id, salary, hire_date 
   FROM employee 
   WHERE manager_emp_id IS NULL;
   

    
2. 找出结点的父结点，本例中就是显示每个雇员的经理姓名，执行如下语句：

   SELECT e.lname "Employee", m.lname "Manager" 
   FROM employee e, employee m 
   WHERE e.manager_emp_id = m.emp_id;
   

    
3. 找出所有的页节点，本例中就是找出所有的普通雇员，使用如下语句：

   SELECT emp_id, lname, dept_id, manager_emp_id, salary, hire_date 
   FROM employee e
   WHERE emp_id NOT IN 
   (SELECT manager_emp_id FROM employee 
   WHERE manager_emp_id IS NOT NULL);

4. 能完成同样功能的语句如下：

5.    SELECT emp_id, lname, dept_id, manager_emp_id, salary, hire_date 
               FROM employee e
               WHERE NOT EXISTS 
               (SELECT emp_id FROM employee e1 WHERE e.emp_id = e1.manager_emp_id);
   

    

复杂的查询：oralce提供对于Ansi Sql的一些扩展。

start with........connect by 子句

proir 操作符

level伪列

语法如下：

start with connection1 connect by connection2

start with connection1 指定根元素。能满足connection1认为是根元素。它可以包函子查询。

connect by connection2指定父行与子行的关系，connection2必须包函prior操作符，用来确定父行里的列，connection2不能包函子查询。

1. 查找父结点与其子结点的结果，使用如下语句：

   SELECT lname, emp_id, manager_emp_id
   FROM employee
   START WITH manager_emp_id IS NULL
   CONNECT BY PRIOR emp_id = manager_emp_id

    
2. level伪列--返回每行属于哪一层，使用如下语句：

   SELECT level, lname, emp_id, manager_emp_id
               FROM employee
               START WITH manager_emp_id IS NULL
               CONNECT BY manager_emp_id = PRIOR emp_id;
   

    
3. 如何检查员工a是否可以管理员工b，由于a可能不是b的主管经理，所以我们不能直接通过manager_emp_id来判断，可以使用如下语句：

   SELECT emp_id, lname, dept_id, manager_emp_id, salary, hire_date 
               FROM employee
               WHERE lname = 'SMITH'
               START WITH lname = 'JONES'
               CONNECT BY manager_emp_id = PRIOR emp_id

    
4. 列出员工及他管理的员工的工资总数：

   SELECT t2.lname, t2.salary,
               (SELECT SUM(t1.salary) FROM employee t1
               START WITH t1.lname = t2.lname
               CONNECT BY t1.manager_emp_id = PRIOR t1.emp_id) sum_salary
               FROM employee t2;
   

    

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

这上一周项目组想做一个权限的东东，通过用户的的权限，看能不能执行某个业务方法，然后我模拟了一个环境。今天上班写出来与网友分享：

先有两个业务类

还要有被观察的对象类

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

性格才是命运的决定因素。

在人生的不同阶段要不停的反思自问：“我有什么心愿？我有宏伟的梦想，我懂不懂得什么是节制的热情？我有拼战命运的决心，我有没有面对恐惧的勇气？我有信息有机会，有没有实用智慧的心思？

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

       这几天闲着没事，看一下Bridge模式。它是实现对象与行为分离的。做一下小例子与大家分享：，希望能与大家交流。

现定义一个对数据对象操作的接口：

定义数据对象的抽象类：

具体的数据对象继承上面的这个抽象类：

根据具体的业务就可以对具体的数据对象进行操作了。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

今天做了了一个自定义PropertyEditor出现问题，字符串解析错误。下面我把相应的类与自定义的PropertyEditor写出，希望有人帮我解决一下：

自定义PropertyEditor注册配置文件如下

出现问题的代码如下：