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

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

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

并写了一个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 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

之前公司要求做回报数据处理后结果发送给用户，用户端提供了一个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;
	}
}

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

得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

网上收到的一个关于Hibernate的配置参数问题，前几天遇到日志参数设置问题，搜索出来的东西，挺好的，收集了~~~

今天在公司做项目中，

由Ctrl层 >>> Biz层>>> Dao层 。在Ctrl注入Biz层类 ，在Biz层类注入Dao层类，使用注解的方式进行注入，例如，在Biz层注入Dao层的时候，首先需要将Dao层暴露出来，也就是将这个类标上 @Repository等注解，不然可能会出现Unable to find Bean with name的错误。原理实际上就是定义了一个Bean,没有定义的Bean使用注入自然是找不到这个Bean对象咯~~

换句话说若出现：Unable to find Bean with name 这种错误，不妨看看被注入类是否暴露给其他类咯~~也许是这个问题~

今天很郁闷的~~这个问题搞了许久，在单元测试一个Dao类的过程，出现如下错误

org.hibernate.hql.ast.QuerySyntaxException: XX  is not mapped

XX是一个POJO，按照报错的语句说是，POJO没有被映射，于是，老在POJO上打转，结果是找不到原因。

问了榕哥~~3秒解决问题~原来在spring配置文件中的需要将这个对象的目录引进来，为了调整包结构，更改了目录结构，居然忘记改配置文件中的目录了~~汗~~

用了注解总是容易让人忘记配置啊。~

今天真郁闷~~发表备份下。

初现 Not all named parameters have been set 错误。。

得榕哥帮助~~原来是查询语句参数少设置了~~

顺便悄悄改了同事写的代码~~

另外学到了一招，MyEclipse里面全局查找类快捷键：Ctrl+Shift+R

加载Spring配置文件时，如果Spring配置文件中所定义的Bean类，如果该类实现了ApplicationContextAware接口，那么在加载Spring配置文件时，会自动调用ApplicationContextAware接口中的

public void setApplicationContext(ApplicationContext context) throws BeansException

方法，并且自动可获得ApplicationContext 对象。前提必须在Spring配置文件中指定改类。

一个Demo程序如下：

Spring配置文件中配置：

<bean id="springContext" class="com.shine.spring.SpringContextHelper"></bean>

/**
 * ApplicationContext的帮助类
 * 自动装载ApplicationContext
 * 
 * @author ChenST
 * @create 2010-6-24
 * 
 */
public class SpringContextHelper implements ApplicationContextAware {
	
	private static ApplicationContext context ;
	
	/*
	 * 注入ApplicationContext
	 */
	@Override
	public void setApplicationContext(ApplicationContext context)
			throws BeansException {
		//在加载Spring时自动获得context
		SpringContextHelper.context = context;
		System.out.println(SpringContextHelper.context);
	}
	
	public static Object getBean(String beanName){
		return context.getBean(beanName);
	}
}

本来想要iText来读取pdf的，结果网上搜索下得出结论，使用iText读取pdf基本上是无法实现的。

于是还是改用了pdfBox来读取文件。于是造成了iText与pdfBox混用的尴尬。

虽然如此，但也遇到了不少问题。下面分析遇到的问题。
---------------------------------------------------------------------------------

1.首先最好要下载pdfbox 1.1的版本。处理文档方面比较完善,如果是低版本的话，是不支持字体与语言的读取。会报错。

2.另外还要下载fontbox 1.1 的包，这对多种字体以及多种语言的支持。注意版本，不然会报有一些类找不到。

3.还要加入common-loggin的包，不然进行读取的时候会遇到类找不到异常，主要是用到org.apache.commons.logging.LogFactory类

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

遇到的问题主要是使用的包版本太对，或者两者的版本不匹配造成的。

贴个使用pdfbox来读取pdf文档内容的代码：

/**
	 * 读取指定路径的pdf文件的文本内容<br>
	 * @param filePath  指定路径
	 * @return pdf文件的文本内容
	 * @throws IOException
	 */
	public String readPdf(String filePath) throws IOException{
		File file = new File(filePath);
		FileInputStream fis = new FileInputStream(file);
		//创建一个PDF解析器
		PDFParser parser = new PDFParser(fis);
		//进行解析
		parser.parse();
		//得到PDF文档对象
		PDDocument document = parser.getPDDocument();
		//新建一个PDF文件剥离器
		PDFTextStripper stripper = new PDFTextStripper();
		//从文档对象中剥离文本
		String content = stripper.getText(document);
		fis.close();
		document.close();
		return content;