Commons Collections之函子(functor)综合学习

在公司没事做，无聊自己模拟情景来练习函子（functor）的使用。

自己定的一个场景：（自己假象出来的）
公司里面的工作的人有三种角色，分别是实习生、试用期员工、正式员工。
假定：
实习生拿的基本工资是800元，试用期员工的基本工资是2000 ，正式员工的基本工资是3000。基本工资暂时是不会变的。实习生经过三个月的工作可以转成试用期员工，试用期员工经过三个月可以转到正式员工。每当一个项目完成后，正式员工可以拿到一部分分红，对于正式员工叫奖金，对于试用期员工叫补贴，实习生是没有的。

现在，有三个人，张三是实习生，李四是试用期员工，王五是正式员工。
要求模拟三个阶段：
1.刚开始，他们都在工作。
2.三个月后，张三变成了试用期员工，李四变成了正式员工。
3.项目结束后，试用期员工拿到补贴1500，正式员工拿到奖金5000
模拟三个阶段，张三、李四、王五拿到的总钱以及清单。

我用函子(functor)，就是Apache Commons Collections提供的三个函子：
Predicate（逻辑判断器）、Transformer（对象转换器）、Closure（对象执行器）

实现如下：

首先看看人员角色的定义：

工作者抽象类：

/**
 * 劳动者,具体分成:实习生、试用期员工、正式员工
 * @create 2010-7-30
 */
public abstract class Worker {
	
	//姓名
	private String name;
		
	public Worker(String name){
		this.name = name;
	}

	/**
	 * 打印收入项目
	 * @return
	 */
	public abstract void printItem();
	
	/**
	 * 获取总共收入
	 * @return
	 */
	public abstract int getTotal();

	public String getName() {
		return name;
	}
}

实习生类：

/**
 * 实习生类
 * @create 2010-7-30
 */
public class Intern extends Worker{
	
	// 实习生基本工资800
	private final int salary = 800;
	
	public Intern(String name){
		super(name);
	}

	// 取得所有收入
	@Override
	public int getTotal() {
		return salary;
	}

	// 打印收入清单
	@Override
	public void printItem() {
		System.out.println(getName() + "[实习生]当月收入总收入为 [薪水" + salary + "元]=["
				+ getTotal() + "]元");
	}
}

试用期员工类：

/**
 * 试用期员工类
 * @create 2010-7-30
 */
public class Probationer extends Worker{

	//薪水=2000
	private final int salary = 2000;
	
	//试用期员工有补贴
	private int  allowance;
	
	public Probationer(String name){
		super(name);
	}

	public void setAllowance(int allowance) {
		this.allowance = allowance;
	}

	@Override
	public int getTotal() {
		return salary+allowance;
	}

	@Override
	public void printItem() {
		System.out.println(getName() + "[试用期员工]当月收入总收入为 [薪水" + salary
				+ "元]+[补贴" + allowance + "]=[" + getTotal() + "]元");
	}
}

正式员工类：

/**
 * 正式员工
 * @create 2010-7-30
 */
public class Employee extends Worker{
	
	//薪水 = 3000
	private final int salary = 3000;
	
	//正式员工有奖金
	private int bonus;
	
	public Employee(String name){
		super(name);
	}

	public void setBonus(int bonus) {
		this.bonus = bonus;
	}

	@Override
	public int getTotal() {
		return salary+bonus;
	}

	@Override
	public void printItem() {
		System.out.println(getName() + "[正式员工]当月收入总收入为 [薪水" + salary + "元]+[奖金"
				+ bonus + "]=[" + getTotal() + "]元");
	}
}

接下来，看看定义的两个转换器

实习生转试用期员工的转换器：

/**
 * 实习生转成 试用期员工 的一个 函子(functor)
 * @create 2010-7-30
 */
public class TransProbationer implements Transformer {

	@Override
	public Object transform(Object input) {
		Intern inter = (Intern) input;
		Probationer probationer = new Probationer(inter.getName());
		return probationer;
	}

}

试用期员工转成正式员工的转换器

/**
 * 试用期员工转成正式员工 的一个 函子(functor)
 * @create 2010-7-30
 */
public class TransEmployee implements Transformer {

	@Override
	public Object transform(Object input) {
		Probationer probationer = (Probationer) input;
		Employee employee = new Employee(probationer.getName());
		return employee;
	}
}

再来看看定义的两个执行器：

给试用期员工发1500补贴的执行器：

/**
 * 试用期员工发1500补贴 的 一个 函子
 * @create 2010-7-30
 */
public class AddAllowanceClosure implements Closure {

	@Override
	public void execute(Object input) {
		Probationer probationer = (Probationer) input;
		probationer.setAllowance(1500);
	}
}

给正式员工发5000奖金的执行器

/**
 * 正式员工发5000奖金的 一个 函子
 * @create 2010-7-30
 */
public class AddGonusClosure implements Closure {

	@Override
	public void execute(Object input) {
		Employee employee = (Employee) input;
		employee.setBonus(5000);
	}
}

开始模拟场景：

public class TestFunctor {
	
	public static void main(String[] args) {
		
		//定义是否是试用期员工的一个函子
		Predicate isProbationerPredicate = new InstanceofPredicate(
				Probationer.class);
		
		//定义是否是正式员工的一个函子
		Predicate isEmployeePredicate = new InstanceofPredicate(Employee.class);
		
		//定义三个劳动者 张三[实习生]、李四[试用期员工]、王五[正式员工]
		Worker zhansan = new Intern("张三");
		Worker lisi = new Probationer("李四");
		Worker wangwu = new Employee("王五");
		
		//查看目前收入
		System.out.println("\n来看看 张三、李四、王五目前的月收入:");
		zhansan.printItem();
		lisi.printItem();
		wangwu.printItem();
		
		//经过努力~~张三转成试用期员工了,李四转成正式员工了~
		System.out.println("\n\n3个月过去了,张三转成试用期员工了,李四转成正式员工了......");
		Transformer transProbationer = new TransProbationer();
		Transformer transEmployee = new TransEmployee();
		zhansan = (Worker) transProbationer.transform(zhansan);
		lisi = (Worker) transEmployee.transform(lisi);
		
		//查看目前收入
		System.out.println("\n来看看 张三、李四、王五目前的月收入:");
		zhansan.printItem();
		lisi.printItem();
		wangwu.printItem();
		
		
		//公司项目取得良好的成就，因此规定凡是试用期员工发补贴1500元,正式员工发奖金5000元
		System.out.println("\n\n目前公司取得很好的成绩,因此凡是试用期员工发补贴1500元,正式员工发奖金5000元");
		Map<Predicate , Closure> map = new HashMap<Predicate, Closure>();
		Closure allowanceClosure = new AddAllowanceClosure();
		Closure gonusClose = new AddGonusClosure();
		
		//如果是试用期员工，则发补贴
		map.put(isProbationerPredicate, allowanceClosure);
		//如果是正式员工,则发奖金
		map.put(isEmployeePredicate, gonusClose);
		//SwitchClosure是实现了Switch的闭包
		Closure rewards = SwitchClosure.getInstance(map);
		rewards.execute(zhansan);
		rewards.execute(lisi);
		rewards.execute(wangwu);
		
		System.out.println("\n来看看 张三、李四、王五目前的月收入:");
		zhansan.printItem();
		lisi.printItem();
		wangwu.printItem();
	}
}

运行结果：

来看看 张三、李四、王五目前的月收入:
张三[实习生]当月收入总收入为 [薪水800元]=[800]元
李四[试用期员工]当月收入总收入为 [薪水2000元]+[补贴0]=[2000]元
王五[正式员工]当月收入总收入为 [薪水3000元]+[奖金0]=[3000]元


3个月过去了,张三转成试用期员工了,李四转成正式员工了......

来看看 张三、李四、王五目前的月收入:
张三[试用期员工]当月收入总收入为 [薪水2000元]+[补贴0]=[2000]元
李四[正式员工]当月收入总收入为 [薪水3000元]+[奖金0]=[3000]元
王五[正式员工]当月收入总收入为 [薪水3000元]+[奖金0]=[3000]元


目前公司取得很好的成绩,因此凡是试用期员工发补贴1500元,正式员工发奖金5000元

来看看 张三、李四、王五目前的月收入:
张三[试用期员工]当月收入总收入为 [薪水2000元]+[补贴1500]=[3500]元
李四[正式员工]当月收入总收入为 [薪水3000元]+[奖金5000]=[8000]元
王五[正式员工]当月收入总收入为 [薪水3000元]+[奖金5000]=[8000]元

可以发现，使用函子可以把逻辑判断、对象转换、对象操作分离的很开，可以任意的自由的组合，通过组合达到所要的目的，代码上可能是多了点，但是对于抗击需求的变化是很好的，可以很好的扩展，可以任意的扩展对象操作，逻辑判断等。继续研究ing~~

设计模式之Builder模式

前两天，看的Google Collections 的集合组件，看了源代码，发现很多东西都是使用builder来创建，今天也上网查了些东西学习学习，发现多看看开源的源代码还是挺有好处的。今天模仿着Google Collections里面的东东写了一个Demo，呵呵，和标准的Builder模式写法不太相同，不过思想是一样的。贴个Demo程序就好了，模拟一个Bean对象的创建。

//Builder模式的角色:[Product]要生产的最终物品
/**
 * 用户对象
 */
public class User {
	
	// 用户名
	private String userName;
	
	// 用户密码
	private String password;
	
	// 用户姓名
	private String name;
	
	// 可看做[Director] 产流水线,负责产品的生产和组织
	private User(Builder builder){
		this.userName = builder.userName;
		this.password = builder.password;
		this.name = builder.name;
	}
	
	//getter方法
	public String getUserName() {
		return userName;
	}

	public String getPassword() {
		return password;
	}

	public String getName() {
		return name;
	}

	// Builder模式的角色:[Builder]能进行生产的工作和获得生产的结果
	/**
	 * 创建该用户的建立者
	 * @param userName 用户名
	 * @return Builder对象
	 */
	public static Builder builder(String userName){
		return new Builder(userName);
	}
	
	// 创建者对象
	public static final class Builder{
		
		// Builder模式的角色:[Part]产品的基本组成部分
		//用户名无法更改
		private final String userName ;
		
		//密码
		private String password;
		
		//真实姓名
		private String name;
		
		//创建对象时必须指定用户名
		public Builder(String userName){
			this.userName = userName;
		}
		
		/**
		 * 设置密码
		 * @param password 密码
		 * @return Builder对象
		 */
		public Builder setPassword(String password){
			this.password = password;
			return this;
		}
		
		/**
		 * 设置姓名
		 * @param name 真实姓名
		 * @return Builder对象
		 */
		public Builder setName(String name){
			this.name = name;
			return this;
		}
		
		/**
		 * 创建用户对象
		 * @return 用户对象
		 */
		public User build(){
			//这里在创建对象之前可以进行验证性操作,
			//而单纯的Bean对象不能进行验证性操作.
			//普通的做法:User user = new User(); user.setXXX()...
			//普通的做法使得创建对象和对对象的赋值操作分离开来
			
			//如果用户名为空,则无法创建该对象
			if(userName == null || userName.isEmpty()){
				throw new IllegalArgumentException("用户名为空,无法创建对象");
			}
			return new User(this);
		}
	}
}

看Builder创建过程：

public class Test {

	public static void main(String[] args) {
		User.Builder builder = User.builder("cst");
		builder.setName("chenshuting");
		builder.setPassword("123");
		User user = builder.build();
		System.out.println(user.getUserName());
		System.out.println(user.getPassword());
		System.out.println(user.getName());
	}
}

继续学习ing~~~~

Commons Collections之Predicates学习

今天无聊没事做，看到Commons Collections的东西，对Predicates接口和它下面挂着的几个类做了些研究，其实看了源代码之后，就知道很简单了。总结刚才的学习结果：

补充一下一个概念,函子(functor):执行操作或功能的部件，Predicates下面挂着的实现类就是一个函子，执行了各种逻辑运算和判断，你也可以根据自己的需要，实现Predicates类，实现evaluate方法，根据自己定义的算法来实现某一特定判断。

先看，Predicates的几个实现类，清单如下：

EqualPredicate
IdentityPredicate
NotPredicate
InstanceofPredicate
NullIsTruePredicate
NullIsFalsePredicate
NotNullPredicate
TruePredicate
FalsePredicate
UniquePredicate
AndPredicate
OrPredicate
AllPredicate
AnyPredicate
OnePredicate

并写了一个Demo程序，将几个Predicates的区别写在了程序的注释中，这是我的习惯。呵呵~~

public void testPredicate(){
		
		//相当于调用equals对比
		Predicate equal = new EqualPredicate("cst");  
		boolean resultEqual = equal.evaluate("cst");
		System.out.println("EqualPredicate:"+resultEqual);
		
		//相当于调用 == 对比
		Predicate identity = new IdentityPredicate(new String("cst"));
		boolean resultIdentity = identity.evaluate(new String("cst"));
		System.out.println("IdentityPredicate:"+resultIdentity);
		
		//装饰给定的Predicate指定对象想比,并返回相反的值
		Predicate not = new NotPredicate(equal);
		boolean resultNot = not.evaluate("cst");
		System.out.println("NotPredicate:"+resultNot);
		
		//相当于instanceof 对比
		Predicate instanceOf = new InstanceofPredicate(String.class);
		boolean resultInstanceof = instanceOf.evaluate("cst");
		System.out.println("InstanceofPredicate:"+resultInstanceof);
		
		// 装饰给定的Predicate
		//如果对象为null则返回true,否则返回给定Predicate的判定值
		Predicate  nullIsTrue = new NullIsTruePredicate(equal);
		boolean resultNullIsTrue = nullIsTrue.evaluate(null);
		System.out.println("NullIsTruePredicate:"+resultNullIsTrue);
		
		// 装饰给定的Predicate
		// 如果对象为null则返回false,否则返回给定Predicate的判定值
		Predicate  nullIsFalse = new NullIsFalsePredicate(equal);
		boolean resultNullIsFalse = nullIsFalse.evaluate(null);
		System.out.println("NullIsFalsePredicate:"+resultNullIsFalse);
		
		//当对象不为null时返回true
		Predicate notNull = NotNullPredicate.getInstance(); 
		boolean resultNotNull = notNull.evaluate(null);
		System.out.println("NotNullPredicate:"+resultNotNull);
		
		// 总是返回true
		Predicate truep = TruePredicate.getInstance(); 
		boolean resultTrue = truep.evaluate("cst");
		System.out.println("TruePredicate:"+resultTrue);
		
		// 总是返回false
		Predicate  falsep = FalsePredicate.getInstance();
		boolean resultFalse = falsep.evaluate("cst");
		System.out.println("FalsePredicate:"+resultFalse);
		
		// 首次evaluate判定对象总是返回true。
		// 其内部维护一个HashSet,每次调用evaluate(obj)
		//将会调用HashSet的add方法。该类常用于Collections过滤重复的对象。
		UniquePredicate unique = new UniquePredicate();
		boolean resultUnique1 = unique.evaluate("cst");
		boolean resultUnique2 = unique.evaluate("cst");
		System.out.println("UniquePredicate1:"+resultUnique1);
		System.out.println("UniquePredicate2:"+resultUnique2);
		
		
		///////////////////以下是实现复杂的逻辑/////////////////////////
		
		//装饰两个Predicate 判断返回两个Predicate和指定对象比较后and的结果
		Predicate and = new AndPredicate(equal, identity);
		boolean resultAnd = and.evaluate("cst");
		System.out.println("AndPredicate:"+resultAnd);
		
		//装饰两个Predicate 判断返回两个Predicate和指定对象比较后or的结果
		Predicate or = new OrPredicate(equal, identity);
		boolean resultOr = or.evaluate("cst");
		System.out.println("OrPredicate:"+resultOr);
		
		//多个Predicate指定对象比较后多个and的结果
		Predicate  [] predicates = new Predicate[]{equal,identity,not};
		Predicate all = new AllPredicate(predicates);
		boolean resultAll = all.evaluate("cst");
		System.out.println("AllPredicate:"+resultAll);
		
		//多个Predicate指定对象比较后多个or的结果
		Predicate any = new AnyPredicate(predicates);
		boolean resultAny = any.evaluate("cst");
		System.out.println("AnyPredicate:"+resultAny);
		
		//多个Predicate指定对象比较后,只要有一个结果为true就为true
		Predicate one = new OnePredicate(predicates);
		boolean resultOne = one.evaluate("cst");
		System.out.println("OnePredicate:"+resultOne);
	}

运行结果：

EqualPredicate:true
IdentityPredicate:false
NotPredicate:false
InstanceofPredicate:true
NullIsTruePredicate:true
NullIsFalsePredicate:false
NotNullPredicate:false
TruePredicate:true
FalsePredicate:false
UniquePredicate1:true
UniquePredicate2:false
AndPredicate:false
OrPredicate:true
AllPredicate:false
AnyPredicate:true
OnePredicate:tru

继续学习Commons Collections的其他东东~~了解下，方便日后少写人家已经实现过的代码。

Google Collections 学习小结

今天，浏览别人的技术博客的时候，无意中看到Google Colections这个东东，下载看了相关资料，感觉还不错，某些场合还挺好用的。主要是提供了更多集合供用户使用，Google Collections是基于JDK5.0上的扩展。用起来方便，前不久1.0版本正式发布。今天花了些时间了解内容。注意几个新的集合的特点。

要用Google Collections 要导入google-collect-1.0.jar包才可以，以下是今天写的一些Demo程序，为了方便，把一些相关知识写在代码里面的注释上了。

public class GoogleCollectionsDemo {
	
	/**
	 * 比较传统的JDK与Google Collections获取不可修改的List集合
	 */
	public void testImmutableList(){
		//1.JDK5.0 传统的方式
		List<String> names = new ArrayList<String>();
		names.add("james");
		names.add("bryant");
		List<String> immutableNamesJdk = Collections.unmodifiableList(names);
		System.out.println("JDK1.5方式:"+immutableNamesJdk);
		
		//2.Google Collections 第一种方式获取
		List<String> immutableNamesGoogle1 = ImmutableList.of("james", "bryant");
		System.out.println("Google Collections获取方式1:"+immutableNamesGoogle1);
		
		//2.Google Collections 第二种方式获取
		ImmutableList.Builder<String> builder= ImmutableList.builder();
		builder.add("james","bryant");
		ImmutableList<String> immutableNamesGoogle2 = builder.build();
		System.out.println("Google Collections获取方式2:"+immutableNamesGoogle2);
	}
	
	/**
	 * 测试Multiset的用法
	 */
	public void testMultiset(){
		//对比:
		//1.JDK5.0 中的Set是一个无序不重复的集合
		//2.Google Collections的MultiSet是一个无序但是可添加重复的元素的集合
		Multiset<String> multiSet = HashMultiset.create();
		multiSet.add("james");
		multiSet.add("bryant");
		multiSet.add("james");
		//MultiSet用来计数统计是很方便的,传统的需要用Map把值取出来+1再放回去
		System.out.println("获取Multiset中的james个数:"+multiSet.count("james"));
		System.out.println("Multiset中的元素:"+multiSet);
	}
	
	/**
	 * 测试Multimap的用法
	 */
	public void testMultimap(){
		//对比:
		//Google Collections 的MultiMap<K,V> 类似于  Map<K ,Collection<V>> 
		Multimap<String, String> multiMap = HashMultimap.create();
		multiMap.put("23", "james");
		multiMap.put("24", "bryant");
		multiMap.put("23", "jordan");
		//注意,MultiMap取得的数据不是String类型,而是Collection类型
		Collection<String> collection = multiMap.get("23");
		System.out.println("23号球员有:"+collection);
	}
	
	/**
	 * 测试BiMap的用法
	 */
	public void testBiMap(){
		// Google Collections 的BiMap 是一个双向的Map
		// 可以根据Key得到value，也可以根据value得到key
		// BiMap的健唯一、值也唯一
		BiMap<String, String> biMap = HashBiMap.create();
		biMap.put("23Cel", "james");
		biMap.put("24Laker", "bryant");
		System.out.println("获取23Cel的值:"+biMap.get("23Cel"));
		
		// 将Map反向，即得到Map<V,K>
		BiMap<String , String> inverseMap = biMap.inverse();
		System.out.println("获取值为bryant的key值:"+inverseMap.get("bryant"));
	}
	
	/**
	 * 测试MapMaker
	 */
	public void testMapMaker(){
		
		//MapMaker是对ConcurrentMap的建立，对传进来的Key进行一些列操作生成Value值
		//当没有Put的时候，根据function传入的value值，计算出value值，
		//当有put的时候，对应的value值就是放入的value值
		
		//线程安全，高并发性能，异步超时清理，自定义构建元素等强大功能于一身
		ConcurrentMap<String, Integer> mapMaker = new MapMaker()
		//这一串暂时不知是啥意思,根据给出的例子是这么写的。只知道运用了Builder模式
				// new MapMaker().weakKeys()   // 指定Map保存的Key为WeakReference机制
				// new MapMaker().weakValues() // 指定Map保存的Value为WeakReference机制
				.concurrencyLevel(32).softKeys().weakValues().expiration(30,
						TimeUnit.MINUTES).makeComputingMap(
						new Function<String, Integer>() {
							@Override
							public Integer apply(String key) {
								return Integer.parseInt(key) + 100;
							}
						});
		//如果沒有Put的时候,按照Function提供的算法
		System.out.println("没有Put的情况下:"+mapMaker.get("111"));
		
		//如果有Put的情况下,按照指定的值赋予Value值
		mapMaker.put("111", 123);
		System.out.println("有Put的情况下:"+mapMaker.get("111"));
	}
	
	public static void main(String[] args) {
		GoogleCollectionsDemo demo = new GoogleCollectionsDemo();
		demo.testImmutableList();
		demo.testMultiset();
		demo.testMultimap();
		demo.testBiMap();
		demo.testMapMaker();
	}
}

运行结果：

JDK1.5方式:[james, bryant]
Google Collections获取方式1:[james, bryant]
Google Collections获取方式2:[james, bryant]
获取Multiset中的james个数:2
Multiset中的元素:[james x 2, bryant]
23号球员有:[james, jordan]
获取23Cel的值:james
获取值为bryant的key值:24Laker
没有Put的情况下:211
有Put的情况下:123

学习笔记:HttpClient的基本使用

之前公司要求做回报数据处理后结果发送给用户，用户端提供了一个Servlet用来接收数据。因此需要写一个基于Http协议的相关工具进行数据的传输，网上搜索了下，Java关于这方面的技术有两个：一是在JDK中的java.net包中已经提供了访问Http的基本功能，二是Apache Jakarta Common下的一个子项目开源API之HttpClient的子项目，提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包。我当然选择Apache的东西啦，于是搜索了相关材料，功能是实现了，不过对于这里面的一些东西还要加以再学习。

安装HttpClient 需要commons-codec-1.3.jar包、commons-httpclient-3.1.jar包、commons-logging-1.0.4.jar包

根据参考来的资料，自己写了一个基本的一个类,提供基本的功能，贴个代码：

/**
 * 
 * <pre>
 * 关于Http协议进行操作,提供转发和访问网路地址的相关操作。
 * </pre>
 *
 * @author 陈书挺
 * @create 2010-7-23
 * @version v1.0
 *
 * <pre>
 * 修改时间    修改人   修改原因
 * 2010-7-23  陈书挺   新建类
 * </pre>
 *
 */
public class HttpOperator {

	//URL地址
	private String url;
	
	/**
	 * 根据URL参数创建构造函数<br>
	 * 默认提交方式为POST提交方式
	 * @param url URL地址
	 */
	public HttpOperator(String url){
		this.url = url;
	}

	/**
	 * 获取页面内容(页面代码),可指定提交方式<br>
	 * 提交方式取值为:
	 *    SubmitMethod.GET :GET提交方式
	 *    SubmitMethod.POST : POST 提交方式
	 * @param 提交方式
	 * @return 页面内容
	 * @throws IOException
	 */
	public String getPageContent(SubmitMethod submitMethod) throws IOException{
		// 1.创建httpClient实例
		HttpClient httpClient = new HttpClient();
		if(submitMethod == SubmitMethod.GET){
			//2.GetMethod会自动处理转发过程
			GetMethod getMethod = new GetMethod(this.url);
			return this.getPageContentForGet(httpClient, getMethod);
		}else if(submitMethod == SubmitMethod.POST){
			PostMethod postMethod = new PostMethod(this.url);
			return this.getPageContentForPost(httpClient, postMethod);
		}else{
			return null;
		}
	}
	
	/**
	 * 执行转发 可进行传参数key参数名,value指定参数值
	 * @param key    参数名
	 * @param value  参数值
	 * @return Http状态码
	 * @throws HttpException
	 * @throws IOException
	 */
	public int executeForward(String key , String value) throws HttpException, IOException{
		PostMethod postMethod = null;
		try{
			HttpClient httpClient = new HttpClient();
			postMethod = new PostMethod(url);
			postMethod.setParameter(key, value);
			int statusCode = httpClient.executeMethod(postMethod);
			return statusCode;
		}catch (Exception e){
			throw new IOException(e);
		}finally{
			postMethod.releaseConnection();
		}
	}
	
	/**
	 * 执行转发 可进行传参数集体参数map ,其中Map中的key指定参数名,value指定参数值
	 * @param map 参数Map对象
	 * @return Http状态码
	 * @throws HttpException
	 * @throws IOException
	 */
	public int executeForwad(Map<String , String> map) throws HttpException, IOException{
		NameValuePair [] nameValue = new NameValuePair[map.size()];
		int k = 0;
		for(String key : map.keySet()){
			nameValue[k].setName(key);
			nameValue[k++].setValue(map.get(key));
		}
		return executeForward(nameValue);
	}
	
	/**
	 * 执行转发 可进行传参数集体参数NameValuePair数组<br>
	 * 其中NameValuePair对象封装了name 和value属性
	 * @param parameters NameValuePair对象
	 * @return Http状态码
	 * @throws HttpException
	 * @throws IOException
	 */
	public int executeForward(NameValuePair[] parameters) throws HttpException,
			IOException {
		PostMethod postMethod = null;
		try {
			HttpClient httpClient = new HttpClient();
			postMethod = new PostMethod(url);
			postMethod.setRequestBody(parameters);
			int statusCode = httpClient.executeMethod(postMethod);
			return statusCode;
		} catch (Exception e) {
			throw new IOException(e);
		} finally {
			postMethod.releaseConnection();
		}
	}
	
	/**
	 * 执行转发 将字节数组放入传输管道中进行传输数据
	 * @param data 要传输的数据
	 * @return  Http状态码
	 * @throws HttpException
	 * @throws IOException
	 */
	public int executeForward(byte[] data) throws HttpException, IOException {
		PostMethod postMethod = null;
		try {
			HttpClient httpClient = new HttpClient();
			postMethod = new PostMethod(url);
			ByteArrayInputStream bis = new ByteArrayInputStream(data);
			InputStreamRequestEntity requestEntity = new InputStreamRequestEntity(bis);
			postMethod.setRequestEntity(requestEntity);
			int statusCode = httpClient.executeMethod(postMethod);
			return statusCode;
		} catch (Exception e) {
			throw new IOException(e);
		} finally {
			postMethod.releaseConnection();
		}
	}
	
	/**
	 * 执行转发 将字符串类型放入传输管道中进行传输数据
	 * @param data 要传输的数据
	 * @return Http状态码
	 * @throws HttpException
	 * @throws IOException
	 */
	public int executeForward(String data) throws HttpException, IOException{
		return executeForward(data.getBytes());
	}
	
	/**
	 * 执行转发 将输入流中的数据放入传输管道中进行传输数据
	 * @param inputStream  输入流
	 * @return Http状态码
	 * @throws HttpException
	 * @throws IOException
	 */
	public int executeForward(InputStream inputStream) throws HttpException,
			IOException {
		PostMethod postMethod = null;
		try {
			HttpClient httpClient = new HttpClient();
			postMethod = new PostMethod(url);
			InputStreamRequestEntity requestEntity = new InputStreamRequestEntity(inputStream);
			postMethod.setRequestEntity(requestEntity);
			int statusCode = httpClient.executeMethod(postMethod);
			return statusCode;
		} catch (Exception e) {
			throw new IOException(e);
		} finally {
			postMethod.releaseConnection();
		}
	}
	
	/*
	 * 使用GET方式获取页面内容
	 * @param httpClient HttpClient对象
	 * @param getMethod  Get提交方式类
	 * @return 页面内容
	 * @throws IOException
	 */
	private  String getPageContentForGet(HttpClient httpClient , GetMethod getMethod) throws IOException{
		// 使用系统提供的默认恢复策略 重试3次
		getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,
				new DefaultHttpMethodRetryHandler());
		try {
			//3.调用httpClient实例来执行getMethod方法
			//返回服务器返回的状态码
			int statusCode = httpClient.executeMethod(getMethod);
			//如果执行成功
			if(statusCode == HttpStatus.SC_OK){
				//4.读取内容
				byte [] responseBody = getMethod.getResponseBody();
				return new String(responseBody);
			}
		} catch (HttpException e) {
			//1.协议不对
			//2.返回内容不正常
			//3.该异常是无法恢复的
			throw new HttpException(e.getMessage());
		} catch (IOException e) {
			//通常由于网络原因造成
			//出现IO异常时候HttpClient会根据制定的恢复策略进行重试
			//恢复策略可通过实现HttpMethodRetryHandler接口来实现
			throw new IOException(e);
		} finally{
			// 5.释放连接
			getMethod.releaseConnection();
		}
		return null;
	}
	
	/*
	 * 使用POST方式获取页面内容
	 * @param httpClient HttpClient对象
	 * @param postMethod  post提交方式类
	 * @return 页面内容
	 * @throws IOException
	 */
	private String getPageContentForPost(HttpClient httpClient , PostMethod postMethod) throws HttpException, IOException{
		try{
			int statusCode = httpClient.executeMethod(postMethod);
			if(statusCode == HttpStatus.SC_OK){
				byte [] responseBody = postMethod.getResponseBody();
				return new String(responseBody);
			}
		}catch(IOException e){
			throw new IOException(e);
		}finally{
			postMethod.releaseConnection();
		}
		return null;
	}
}

英文操作系统Windows上Jboss控制台显示中文问题

在公司的服务器上（英文版widows Server 2003）跑Jboss（即运行run.bat）

因为日志输入带有中文日志，所以在显示的时候显示乱码，榕哥找到的方法：解决方法如下：

在Jboss的run.bat文件中，编辑在设置Java参数（即SET_OPTS）后面加

-Ddefault.client.encoding=GBK -Dfile.encoding=GBK -Duser.language=Zh

样例如下:

set JAVA_OPTS=%JAVA_OPTS% -Xms512m -Xmx1024m -XX:MaxPermSize=256m -Ddefault.client.encoding=GBK -Dfile.encoding=GBK -Duser.language=Zh 
-server

解决百度搜索栏无法输入问题

今天，堂弟遇到这类问题：百度搜索栏无法输入，却可是输入网址。

解决方案如下：

1.查看 C:\WINDOWS\SYSTEM32 有没有mshtmled.dll和browseui.dll文件。

2.如果没有，上网下载这两个文件，并拷贝到 C:\WINDOWS\SYSTEM32目录下

3.然后分别运行命令 regsvr32 mshtmled.dll 和 regsvr32 browseui.dll 即可。

Log4j将日志输出到文件配置

今天，为了测试速度，很无奈的要去统计委托回报的数量。需要将日志输出到文件来统计。

得yoyo相助，得到如下配置可用：

log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File = D:/output.log   #这里指定文件路径 
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss}%l%m%n

另外需要注意

要设置 log4j.rootLogger=DEBUG, file