https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
http://visualgo.net/


//codeforces
http://codeforces.com/

//数据结构
http://www.jisuanke.com/course

//郝斌数据结构视频
http://down.51cto.com/zt/306

//网易公开课  机器学习视频
http://open.163.com/special/opencourse/machinelearning.html

//Python网络爬虫实战-Scrapy(已完结)
http://www.maiziedu.com/course/python/458-7430/

//Mongodb最佳实践(已完结)
http://www.maiziedu.com/course/php/395-4445/
//HTML5+CSS3快速入门(已完结)
http://www.maiziedu.com/course/web/228-2627/
//scala教程
http://www.maiziedu.com/course/others/521-7132/


//高等数学
http://video.1kejian.com/video/?12395-0-0.html

**************************规范约定*******************************
//git books
https://www.gitbook.com/explore
//kancloud
http://www.kancloud.cn/explore

https://www.gitbook.com/book/wastemobile/gitbook-chinese/details //GitBook 中文解說 - 2.4

https://www.gitbook.com/book/jervyshi/google-java-styleguide-zh/details //Google JAVA编程规范

**************************JAVA*******************************

https://www.gitbook.com/book/askingwindy/gitbook-java-interview-note/details  //Java面试准备
http://www.admin10000.com/document/6919.html //Java面试准备


http://www.kancloud.cn/kancloud/the-art-of-programming //编程之法：面试和算法心得

https://waylau.gitbooks.io/jersey-2-user-guide/content/ //Jersey 2.x 用户指南

https://qbgbook.gitbooks.io/spring-boot-reference-guide-zh/content/ //Spring Boot参考指南

https://www.gitbook.com/book/kimmking/springbatchreference/details //Spring Batch参考文档中文版

https://www.gitbook.com/book/czeng/spring-data/details //Spring Data 中文版本

https://www.gitbook.com/book/waylau/apache-shiro-1-2-x-reference/details //Shiro User Guide中文翻译

**************************Python******************************
//python 学习
http://www.kancloud.cn/kancloud/python3-cookbook/


**************************前端类*******************************

https://checkcheckzz.gitbooks.io/angularjs-learning-notes/content/ //AngularJS学习笔记
//2015年50+ JavaScript 工具、资源合集
http://www.kancloud.cn/kancloud/javascript-resources-2015

**************************工具类*******************************

https://dongchuan.gitbooks.io/gradle-user-guide-/content/ //Gradle User Guide 中文版

**************************NO sql*******************************

https://kelby.gitbooks.io/rails-beginner-s-guide/content/ //Rails 4-2-stable 参考手册(Beta)

*************************运维********************************

https://www.gitbook.com/book/kisspuppet/puppet/details //Puppet运维实战

*************************大数据********************************

ELKstack 中文指南
https://www.gitbook.com/book/chenryn/kibana-guide-cn/details

************************* MQ ********************************

http://geewu.gitbooks.io/rabbitmq-quick/content/index.html//rabbitMQ 快速上手文档 

************************* 网络编程 ********************************

https://www.gitbook.com/book/waylau/apache-mina-2-user-guide/details //MINA User Guide中文翻译

http://www.kancloud.cn/kancloud/essential-netty-in-action //Essential Netty in Action 《Netty 实战(精髓)》

*************************云计算*******************************

https://yeasy.gitbooks.io/docker_practice/content/ //Docker —— 从入门到实践
https://joshhu.gitbooks.io/docker_theory_install/content/ //最完整的Docker聖經 - Docker原理圖解及全環境安裝


************************查询*********************************
http://es.xiaoleilu.com/ //Elasticsearch 权威指南（中文版）
//Spring-data-elasticsearch
http://es.yemengying.com/ 

*************************第三方*******************************

https://www.gitbook.com/book/wohugb/alipay-direct/details //支付宝即时到账交易接口

//各种技术经验总结
https://github.com/lyfeyaj/awesome-resources#web-%E5%89%8D%E7%AB%AF
//infoQ
http://www.infoq.com/cn/rest-deep-dive
//jquery之家
http://www.htmleaf.com/jQuery/
//国外java 网站
http://www.javacodegeeks.com/


//架构
http://www.aboutyun.com/thread-12095-1-1.html
//互联网公司技术架构资料：淘宝、百度、腾讯、新浪、京东资料汇总
https://github.com/Qihoo360/Atlas/blob/master/README_ZH.md//360 MySQL中间层 Atlas



//云计算 & 虚拟化 & 大数据
//openstack版本下载
https://wiki.openstack.org/wiki/Releases
//IBM Opecstack安装介绍
https://www.ibm.com/developerworks/community/blogs/5144904d-5d75-45ed-9d2b-cf1754ee936a/entry/deploy_openstack_with_packstack?lang=en
//学习linux网站
http://bbs.hh010.com/
//docker
http://yuedu.baidu.com/ebook/d817967416fc700abb68fca1?fr=aladdin&key=docker###//入门教程
http://www.aboutyun.com/forum.php//about 云

http://archive.ics.uci.edu/ml/datasets.html//hadoop 离线日志分析数据格式
http://hadooptutorial.info/category/hadoop/  //hadoop 国外学习网站
http://www.iteblog.com/ //大数据学习网站

//Spark Streaming Examples
https://github.com/apache/spark/tree/master/examples/src/main/java/org/apache/spark/examples
https://github.com/apache/spark/tree/master/examples/src/main/java/org/apache/spark/examples/streaming


//hadoop 下载地址
http://apache.fayea.com/hadoop/common/
//hadoop 大数据集测试数据
http://archive.ics.uci.edu/ml/datasets.html
//hbase中文文档
http://yankaycom-wordpress.stor.sinaapp.com/hbase/book.html?q=/wp-content/hbase/book.html
//Hadoop Shell命令
http://hadoop.apache.org/docs/r1.0.4/cn/hdfs_shell.html

Spring框架参考文档 翻译
文档地址
中文文档:http://spring.oschina.mopaas.com/
https://github.com/waylau/spring-framework-4-reference/blob/master/SUMMARY.md
http://waylau.gitbooks.io/spring-framework-4-reference/content/index.html
英文文档:http://spring.oschina.mopaas.com/html_en/
http://docs.spring.io/spring/docs/4.2.0.BUILD-SNAPSHOT/spring-framework-reference/htmlsingle/#overview-maven-bom
//spring hadoop
http://docs.spring.io/spring-hadoop/docs/current/reference/html/
//Spring Boot
http://afoo.me/posts/2015-07-09-how-spring-boot-works.html



//JAVA学习框架 和 前端技术
http://www.ideagrace.com/sf/containers/  
//Amdatu是一组开源组件和工具在Java构建模块化应用程序。
http://amdatu.org/
https://github.com/waylau/netty-4-user-guide/blob/master/SUMMARY.md//netty-4-user-guide
//jquery 插件库
http://www.jq22.com/
http://www.pintuer.com/  //pintuer
//前端开发利器 - Emmet 
http://www.gbtags.com/gb/gbliblist/3.htm

//apiCloud
http://www.apicloud.com/
http://docs.apicloud.com/APICloud/videos-and-codes
//AUI for apiCloud
http://www.kancloud.cn/liulangnan/aui


//翻墙
https://hosts.huhamhire.com/
http://ssnode.com/

https://www.zybuluo.com/mdeditor//md 编辑器在线
https://stackedit.io/editor


//工具 博客类
http://www.taobaotest.com/ //淘宝test
http://geewu.gitbooks.io/rabbitmq-quick/content/index.html//rabbitMQ 快速上手文档

http://www.java2s.com/Open-Source/Java_Free_Code/index.htm //Java Free Code


//百度云
16套游戏开发+项目实战链接: http://pan.baidu.com/s/1sjA146L 密码: akpp
IOS12月最新就业班链接: http://pan.baidu.com/s/1hqepfbm 密码: bxe9
IOS5期链接: http://pan.baidu.com/s/1mgiMepi 密码: farg
IOS4期链接: http://pan.baidu.com/s/1qWC4FJe 密码: zjs7

黑马7天hadoop链接: http://pan.baidu.com/s/1pJKD48b 密码: x7n3


//UI
http://my.chinaz.com/accounts/login.html//站长之家
http://www.sitestar.cn/default.aspx//建站之星

//运维博客
http://azhuang.blog.51cto.com/ //状大神

//小甲鱼bbs python
http://bbs.fishc.com/

//nginx 学习
http://openresty.org/download/agentzh-nginx-tutorials-zhcn.html
//开源的网站访问统计系统
http://www.piwik.cn/

的

//linux 安装rabbitmq
//  http://www.rabbitmq.com/releases/rabbitmq-server/ 下载mq地址

//****************首先需要安装mq运行环境erlang******************************
//可参照:http://amornio.iteye.com/blog/1551502
//1:下载erlang安装包 和  依赖
wget http://www.erlang.org/download/otp_src_R15B01.tar.gz

//2解压:
tar -zxvf otp_src_R16B03-1.tar.gz
//3编译安装:
/configure --prefix=/usr/local/servers/erlang

如果本步骤出现
error: no acceptable C compiler found in $PATH
说明你没有安装gcc编译器，去安装gcc编译器
//1，
yum -y install gcc

//然后在执行:配置安装环境
/configure --prefix=/usr/local/install_file/erlang

错误:
configure: error: Perl is required to generate v2 to v1 mib converter script
configure: error: /bin/sh '/usr/local/install_package/rabbitmq/otp_src_17.4b/snmp/./configure' failed for snmp/.
configure: error: /bin/sh '/usr/local/install_package/rabbitmq/otp_src_17.4b/configure' failed for lib


解决:
yum -y install perl


错误:
configure: error: No curses library functions found
configure: error: /bin/sh '/usr/local/install_package/rabbitmq/otp_src_17.4/erts/configure' failed for erts

解决:
yum -y install ncurses-devel

执行编译命令：make
执行安装:make install

//环境变量
ERL_HOME=/usr/local/install_file/erlang
PATH=$ERL_HOME/bin:$PATH
export ERL_HOME PATH


//****************安装mq*****************************
// 依赖包xmlto
yum install xmlto
//参考 http://blog.csdn.net/sonnet123/article/details/9188429

wget http://www.rabbitmq.com/releases/rabbitmq-server/v3.4.3/rabbitmq-server-3.4.3-1.noarch.rpm  
//不同版本自己可以修改下就可以了

rpm -ivh  --nodeps  rabbitmq-server-3.4.3-1.noarch.rpm
//这样就安装成功了

//使用 -detached 参数运行各节点

rabbitmqctl stop
rabbitmq-server -detached

//启动web监控功能
rabbitmq-plugins enable rabbitmq_management  

//重启MQ

//访问 IP:15672
//登录如果要是用默认的guest  (远程不能使用需要设置)

//修改安装目录下面ebin下的rabbit.app文件  {loopback_users,[<<guest>>]} 吧guest去了 重启MQ就可以了

//******************************************项目管理***************************************
653363623
Redmine
JIRA
todolist
project(适合小团队)
xmind freemind mindmanager（思维导图软件）
Trac(适合小团队)
禅道(bug管理)

//***************************************运维、监控类*******************************************
Hyperic HQ//监控
zabbix//监控
Nagios//是一款开源的免费网络监视工具
Keepalived//Keepalived的作用是检测web服务器的状态
drbd+heartbeat//
squid  //前端缓存框架

//******************************************工具类***************************************
teamcCity//持续集成工具
upsource//svn 代码仓库浏览器和代码审查工具
SonarQube//代码质量管理平台

gitblit//git web管理工具
SmartGit//git 版本控制管理工具

//************************************报表*******************************************
//前端
http://www.hcharts.cn/index.php //Highcharts
functioncharts //不开源 有收费 支持一些不收费

//****************************************分布式架构***********************************************
snappy//google公司内部广泛使用的一种压缩技术 google开源
hessian//一种更加高效的序列化和反序列化技术

//****************************************大数据架构***********************************************
Cloudera Manager
CDH5
Ansible
//CDH5的Ansible配置
https://github.com/mcsrainbow/ansible-playbooks-cdh5

//hadoop2.x项目组相关
HDFS MapReduce yarn Hive Pig Mathout Hbase Zookeeper Sqoop Flume Oozie impala hue Sentry 

//hbase tool
apache phoenix drill

//Hue 配置
http://gethue.com/how-to-configure-hue-in-your-hadoop-cluster/
http://cloudera.github.io/hue/docs-3.6.0/manual.html#_the_hue_database

//cdh下载
http://archive.cloudera.com/cm5/installer/
http://archive.cloudera.com/cm5/redhat/6/x86_64/cm/

//hadoop安装部署 工具
//开源的
HDP,
CDH // http://archive.cloudera.com/cdh5/cdh/5/
Apche Knox Gateway //hadoop安全
apache accumulo


//******************************************框架类***************************************
Apache Avro 与 Thrift //基于二进制的高性能的通讯中间件. 它们都提供了数据序列化的功能和RPC服务
rabbitmq //分布式系统消息中间件
Disruptor//是一个高性能的异步处理框架，或者可以认为是最快的消息框架(轻量的JMS)
Kafka//分布式消息队列
CuratorFramework //一个队zookeeper封装client与server通信框架
Mule//是一个企业服务总线(ESB)消息框架.它的主要特性包括:

Cobar介绍及配置//alibaba mysql集群工具
TProfiler//alibaba  TProfiler是一个可以在生产环境长期使用的性能分析工具
Akka //编写高并发框架
Disruptor//
Jactors//

//***********************************好用的第三方jar***************************************
//时间插件
joda-time

//***********************************JAVA 并发***************************************
JActor  //Actor模式的Java实现 
Kilim //是一个Java的actor框架

//***********************************加密算法***************************************
MD5/SHA1/SHA256，或者MD5withRSA、SHA1withRSA、SHA256withRSA


//***********************************IM***************************************
Tigase XMPP

Comet4J

SELECT
	t.id,
	t.store_name,
	t.logo_url,
	t.store_address,
	t.store_phone,
	t.x_point AS lon,
	t.y_point AS lat,
	sqrt(((
				(104.071127- t.x_point) * PI() * 12656 * cos(
					((30.577438 + t.y_point) / 2) * PI() / 180
				) / 180
			) * (
				(104.071127 - t.x_point) * PI() * 12656 * cos(
					((30.577438 + t.y_point) / 2) * PI() / 180
				) / 180
			)
		) + (
			(
				(30.577438 - t.y_point) * PI() * 12656 / 180
			) * (
				(30.577438 - t.y_point) * PI() * 12656 / 180
			)
		)
	) AS distance
FROM
	t_store AS t
GROUP BY distance 
HAVING distance <= 3
ORDER BY distance ASC 
LIMIT 20




public List<Map<String, Object>> getNearStore(String lon, String lat, String scope,Integer count) {
		ArrayList<Object> params = Lists.newArrayList();
		StringBuffer sql = new StringBuffer();
//		sql.append(" select t.id,t.store_name,t.logo_url,t.store_address,t.store_phone,t.x_point AS lon,t.y_point AS lat, ");
//		sql.append(" (POWER(MOD (ABS(t.x_point - " + lon + "), 360),2) +");
//		sql.append(" POWER(ABS(t.y_point - " + lat + "), 2");
//		sql.append(" )) as distance");
//		sql.append(" from t_store as t");
//		sql.append(" GROUP BY distance HAVING distance <= " + scope + "");
//		sql.append(" ORDER BY distance ASC LIMIT " + count);
		sql.append("SELECT");
		sql.append(" t.id,t.store_name,t.logo_url,t.store_address,t.store_phone,");
		sql.append(" t.x_point AS lon,t.y_point AS lat,");
		sql.append(" sqrt( ");
		sql.append(" (");
		sql.append(" ( ("+lon+" - t.x_point) * PI() * 12656 * cos(");
		sql.append(" ( ("+lat+" + t.y_point) / 2) * PI() / 180");
		sql.append(" ) / 180 )");
		sql.append(" *");
		sql.append(" (("+lon+" - t.x_point) * PI() * 12656 * cos(");
		sql.append(" (("+lat+" + t.y_point) / 2) * PI() / 180");
		sql.append(" ) / 180)");
		sql.append(" )");
		sql.append(" + ");
		sql.append(" (");
		sql.append(" (("+lat+" - t.y_point) * PI() * 12656 / 180 ) ");
		sql.append(" *");
		sql.append(" (("+lat+" - t.y_point) * PI() * 12656 / 180 )");
		sql.append(" )");
		sql.append(" ) AS distance");
		sql.append(" FROM");
		sql.append(" t_store AS t");
		sql.append(" GROUP BY distance ");
		sql.append(" HAVING distance <= "+scope+"");
		sql.append(" ORDER BY distance ASC ");
		sql.append(" LIMIT "+count+"");
		LogUtils.logInfo("查询附近店铺SQL:" + sql.toString());
		return findByJDBCSql(sql.toString(), params);
	}

### This file is an example authorization file for svnserve.
### Its format is identical to that of mod_authz_svn authorization
### files.
### As shown below each section defines authorizations for the path and
### (optional) repository specified by the section name.
### The authorizations follow. An authorization line can refer to:
###  - a single user,
###  - a group of users defined in a special [groups] section,
###  - an alias defined in a special [aliases] section,
###  - all authenticated users, using the '$authenticated' token,
###  - only anonymous users, using the '$anonymous' token,
###  - anyone, using the '*' wildcard.
###
### A match can be inverted by prefixing the rule with '~'. Rules can
### grant read ('r') access, read-write ('rw') access, or no access
### ('').

[aliases]

[groups]
admin_worker = sung,caogw,yangt,xuqs,jinx
android_worker = yangck,zhouq
ios_worker = lim,yuch
design_worker = hetx

#SVN根目录的权限
[/]
@android_worker = rw
@admin_worker = rw
@ios_worker = rw
@design_worker = rw
xtt = rw
* = r

[tiger:/]
@android_worker = rw
@admin_worker = rw
@ios_worker = rw
@design_worker = rw
xtt = rw
* = r

[tiger:/web]
@admin_worker = rw
* = 
[tiger:/web/code]
@admin_worker = rw
* = 

[tiger:/web/store]
@admin_worker = rw
xtt = rw
* = 

[tiger:/android/code]
@android_worker = rw
@admin_worker = rw
* = 

[tiger:/ios/code]
@ios_worker = rw
@admin_worker = rw
* = 

[tiger:/design]
@admin_worker = rw
@android_worker = rw
@ios_worker = rw
@design_worker = rw
* = r

[tiger:/doc]
@admin_worker = rw
@android_worker = rw
@ios_worker = rw
@design_worker = rw
* = r

[tiger:/temp]
* = rw

[tiger:/sport]
@admin_worker = rw
@android_worker = rw
@ios_worker = rw
@design_worker = rw
* = r

public static void main(String[] args) {
		LogUtils.logInfo("start dbMidddleware project...");
		try {
			LogBackConfigLoader.load("conf/logback.xml");
		} catch (Exception e) {
			e.printStackTrace();
		}
}




package com.gukq.dbMidddleware;

import java.io.File;
import java.io.IOException;

import org.slf4j.LoggerFactory;

import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.joran.JoranConfigurator;
import ch.qos.logback.core.joran.spi.JoranException;
import ch.qos.logback.core.util.StatusPrinter;

public class LogBackConfigLoader {
	public static void load(String externalConfigFileLocation)
			throws IOException, JoranException {
		LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();

		File externalConfigFile = new File(externalConfigFileLocation);
		if (!externalConfigFile.exists()) {
			throw new IOException(
					"Logback External Config File Parameter does not reference a file that exists");
		} else {
			if (!externalConfigFile.isFile()) {
				throw new IOException(
						"Logback External Config File Parameter exists, but does not reference a file");
			} else {
				if (!externalConfigFile.canRead()) {
					throw new IOException(
							"Logback External Config File exists and is a file, but cannot be read.");
				} else {
					JoranConfigurator configurator = new JoranConfigurator();
					configurator.setContext(lc);
					lc.reset();
					configurator.doConfigure(externalConfigFileLocation);
					StatusPrinter.printInCaseOfErrorsOrWarnings(lc);
				}
			}
		}
	}
}

package effective.study1.constructor.build;

public class Person {
	
	private final String name;
	private final int age;
	private final int sex;
	private final String iphone;
	private final String address;
	
	
	public Person(Builder builder) {
		this.name = builder.name;
		this.age = builder.age;
		this.sex = builder.sex;
		this.iphone = builder.iphone;
		this.address = builder.address;
	}




	public static class Builder{
		private final String name;
		private final int age;
		private final int sex;

		//default
		private String iphone = "13076061657";
		private String address = "成都市";
		
		public Builder(String name,int age,int sex){
			this.name = name;
			this.age = age;
			this.sex = sex;
		}
		
		public Builder iphone(String val){
			iphone = val;
			return this;
		}
		public Builder address(String val){
			address = val;
			return this;
		}
		
		public Person build(){
			return new Person(this);
		}
	}
	
	
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	public int getSex() {
		return sex;
	}
	public String getIphone() {
		return iphone;
	}
	public String getAddress() {
		return address;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", sex=" + sex
				+ ", iphone=" + iphone + ", address=" + address + "]";
	}
}




//使用
package effective.study1.constructor.build;

import effective.study1.constructor.build.Person.Builder;

public class Main {
	
	public static void main(String[] args) {
		Person p = new Person.Builder("孙刚",22,1).iphone("188888888888").build();
		System.out.println(p.toString());
	}
}



//=========================第二种方式=====================================
package effective.study1.constructor.build;

public interface AttributeBuilder<T> {
	
	T build();
}


//=========================实现不同bean的 builder=========================
package effective.study1.constructor.build;

public class PersonBuilder implements AttributeBuilder<Person>{
	
	public final String name;
	public final int age;
	public final int sex;

	//default
	public String iphone = "13076061657";
	public String address = "成都市";
	
	public PersonBuilder(String name,int age,int sex){
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	
	public PersonBuilder iphone(String val){
		iphone = val;
		return this;
	}
	public PersonBuilder address(String val){
		address = val;
		return this;
	}
	
	@Override
	public Person build() {
		return new Person(this);
	}
}


//TEST
package effective.study1.constructor.build;


public class Main {
	
	public static void main(String[] args) {
		Person p = new PersonBuilder("孙刚", 22, 1).iphone("1888888888").build();
		System.out.println(p.toString());
	}
}

//开始时间
private String startTime;
//结束时间
private String endTime;


/**
	 * 处理时间
	 * @throws ParseException
	 */
	private void processTime() {
		String sTime = null;
		String eTime = null;
		if (null != energyDataRecord.getDataFormatType()) {
			String dataFormatType = energyDataRecord.getDataFormatType();
			
			//小时
			if ("HH".equals(dataFormatType)) {
				sTime = this.startTime+ ":00:00";
				eTime = this.endTime+ ":59:59";
			}
			//天
			if ("DD".equals(dataFormatType)) {
				sTime = this.startTime + " 00:00:00";
				eTime = this.endTime + " 23:59:59";
			}
			//月
			if ("MM".equals(dataFormatType)) {
				sTime = this.startTime + "-01 00:00:00";
				String[] dateStrs = this.endTime.split("-");
				int month = Integer.parseInt(dateStrs[1]);
				if(month == 12){//处理12月
					eTime = endTime + "-31 23:59:59";
				}else{
					//结束时间设置为下个月的1号零点零分
					eTime = dateStrs[0] + "-" + (month + 1) + "-01 00:00:00";
				}
			}
			//年
			if ("YY".equals(dataFormatType)) {
				sTime = startTime + "-01-01 00:00:00";
				eTime = endTime + "-12-31 23:59:59";
			}
		}
		if (null != sTime && null != eTime) {
			try {
				this.energyDataRecord.setStartDate(DataUtil.SDF_DATE_DETAIL_TIME.parse(sTime));
				this.energyDataRecord.setEndDate(DataUtil.SDF_DATE_DETAIL_TIME.parse(eTime));
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}
}




/**
	 * 日期格式：yyyy-MM-dd HH:mm:ss
	 */
	public static final SimpleDateFormat SDF_DATE_DETAIL_TIME = new SimpleDateFormat( "yyyy-MM-dd H:m:s");

public interface Constants {

    /****/
    String CONTEXT_PATH = "ctx";

    /**
     * 当前请求的地址 带参数
     */
    String CURRENT_URL = "currentURL";


    /**
     * 当前请求的地址 不带参数
     */
    String NO_QUERYSTRING_CURRENT_URL = "noQueryStringCurrentURL";

    /**
     * 上个页面地址
     */
    String BACK_URL = "BackURL";

}


//8*******************Spring  拦截器类*************************
package com.sishuok.es.common.web.interceptor;

import com.sishuok.es.common.Constants;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.PathMatcher;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 设置通用数据的Interceptor
 * <p/>
 * 使用Filter时 文件上传时 getParameter时为null 所以改成Interceptor
 * <p/>
 * 1、ctx---->request.contextPath
 * 2、currentURL---->当前地址
 * <p>User: Zhang Kaitao
 * <p>Date: 13-1-22 下午4:35
 * <p>Version: 1.0
 */
public class SetCommonDataInterceptor extends HandlerInterceptorAdapter {

    private final PathMatcher pathMatcher = new AntPathMatcher();

    private static final String[] DEFAULT_EXCLUDE_PARAMETER_PATTERN = new String[]{
            "\\&\\w*page.pn=\\d+",
            "\\?\\w*page.pn=\\d+",
            "\\&\\w*page.size=\\d+"
    };

    private String[] excludeParameterPatterns = DEFAULT_EXCLUDE_PARAMETER_PATTERN;
    private String[] excludeUrlPatterns = null;

    public void setExcludeParameterPatterns(String[] excludeParameterPatterns) {
        this.excludeParameterPatterns = excludeParameterPatterns;
    }

    public void setExcludeUrlPatterns(final String[] excludeUrlPatterns) {
        this.excludeUrlPatterns = excludeUrlPatterns;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        if(isExclude(request)) {
            return true;
        }

        if (request.getAttribute(Constants.CONTEXT_PATH) == null) {
            request.setAttribute(Constants.CONTEXT_PATH, request.getContextPath());
        }
        if (request.getAttribute(Constants.CURRENT_URL) == null) {
            request.setAttribute(Constants.CURRENT_URL, extractCurrentURL(request, true));
        }
        if (request.getAttribute(Constants.NO_QUERYSTRING_CURRENT_URL) == null) {
            request.setAttribute(Constants.NO_QUERYSTRING_CURRENT_URL, extractCurrentURL(request, false));
        }
        if (request.getAttribute(Constants.BACK_URL) == null) {
            request.setAttribute(Constants.BACK_URL, extractBackURL(request));
        }

        return true;
    }

    private boolean isExclude(final HttpServletRequest request) {
        if(excludeUrlPatterns == null) {
            return false;
        }
        for(String pattern : excludeUrlPatterns) {
            if(pathMatcher.match(pattern, request.getServletPath())) {
                return true;
            }
        }
        return false;
    }


    private String extractCurrentURL(HttpServletRequest request, boolean needQueryString) {
        String url = request.getRequestURI();
        String queryString = request.getQueryString();
        if (!StringUtils.isEmpty(queryString)) {
            queryString = "?" + queryString;
            for (String pattern : excludeParameterPatterns) {
                queryString = queryString.replaceAll(pattern, "");
            }
            if (queryString.startsWith("&")) {
                queryString = "?" + queryString.substring(1);
            }
        }
        if (!StringUtils.isEmpty(queryString) && needQueryString) {
            url = url + queryString;
        }
        return getBasePath(request) + url;
    }

    /**
     * 上一次请求的地址
     * 1、先从request.parameter中查找BackURL
     * 2、获取header中的 referer
     *
     * @param request
     * @return
     */
    private String extractBackURL(HttpServletRequest request) {
        String url = request.getParameter(Constants.BACK_URL);

        //使用Filter时 文件上传时 getParameter时为null 所以改成Interceptor

        if (StringUtils.isEmpty(url)) {
            url = request.getHeader("Referer");
        }

        if(!StringUtils.isEmpty(url) && (url.startsWith("http://") || url.startsWith("https://"))) {
            return url;
        }

        if (!StringUtils.isEmpty(url) && url.startsWith(request.getContextPath())) {
            url = getBasePath(request) + url;
        }
        return url;
    }

    private String getBasePath(HttpServletRequest req) {
        StringBuffer baseUrl = new StringBuffer();
        String scheme = req.getScheme();
        int port = req.getServerPort();

        //String		servletPath = req.getServletPath ();
        //String		pathInfo = req.getPathInfo ();

        baseUrl.append(scheme);        // http, https
        baseUrl.append("://");
        baseUrl.append(req.getServerName());
        if ((scheme.equals("http") && port != 80) || (scheme.equals("https") && port != 443)) {
            baseUrl.append(':');
            baseUrl.append(req.getServerPort());
        }
        return baseUrl.toString();
    }
}


//****************Spring 拦截配置******************
 <!-- 拦截器设置 -->
    <mvc:interceptors>
        <bean class="org.springframework.web.servlet.handler.ConversionServiceExposingInterceptor">
            <constructor-arg ref="conversionService"/>
        </bean>
        <bean class="com.sishuok.es.common.web.interceptor.SetCommonDataInterceptor">
            <property name="excludeUrlPatterns">
                <value>/admin/polling </value>
            </property>
        </bean>
        <mvc:interceptor>
            <mvc:mapping path="/admin/**" />
            <mvc:mapping path="/office/**" />
            <mvc:exclude-mapping path="/admin/polling"/>
            <bean class="org.springframework.orm.jpa.support.OpenEntityManagerInViewInterceptor"/>
        </mvc:interceptor>
        <!--<mvc:interceptor>-->
        <!--<mvc:mapping path="/**"/>-->
        <!--<bean class="cn.javass.test.interceptor.TestInterceptor"/>-->
        <!--</mvc:interceptor>-->
    </mvc:interceptors>


//*******************页面使用******************

//直接可以:

${ctx}
${currentURL}

public class LoadAreaServlet extends HttpServlet{
	
	
	/**
	*/
	private static final long serialVersionUID = 1457805673123717992L;

	@Override
	public void init() throws ServletException {
		//初始化  区域数据
		CitySection.CITY_SECTION.init();
	}
}




//=====================================================


package com.supinfo.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.opensymphony.xwork2.ActionContext;
import com.supinfo.jieneng.domains.Area;
import com.supinfo.jieneng.domains.City;
import com.supinfo.jieneng.domains.County;
import com.supinfo.jieneng.services.AreaService;


public class CitySection {
	public static ApplicationContext CONTEXT = new ClassPathXmlApplicationContext(
			new String[] { "applicationContext-mybatis.xml",
					"applicationContext-services.xml" });
	
	private static AreaService areaService = CONTEXT.getBean("areaService",AreaService.class);
	
	public static final String DEFAULT_CITY_NAME = "成都";//默认城市名
	
	
	public static final CitySection CITY_SECTION = new CitySection(); 
	
	/**
	 * key:城市名，value:区域集合
	 */
	private static final Map<String, List<String>> CITY_SECTION_MAP = new HashMap<String, List<String>>();
	
	/**
	 * key:省名，value:城市Map集合
	 * 城市Map集合的key:城市名，value:区域集合
	 */
	public static final Map<String, Map<String, List<Area>>> PROVINCE_CITY_SECTION_MAP = new HashMap<String, Map<String, List<Area>>>();
	
	/**
	 * 获取所有城市名
	 * 
	 * @return
	 */
	public static List<City> findAllAreaName() {
		
		//存储城市
		List<City> cityList = new ArrayList<City>();
		//存储区域
		List<County> countyList = new ArrayList<County>();
		
		try {
			//获取所有省份
			List<Area> provinces = areaService.getAreaByPID(0l);
			if(DataUtil.checkListNullAndSize(provinces)){
				for (Area areaProvince : provinces) {
					//根据省份ID获取  所属省份下的城市
					List<Area> citys = areaService.getAreaByPID(areaProvince.getId());
					if (DataUtil.checkListNullAndSize(citys)) {
						for (Area areaCity : citys) {
							City  city = new City();
							city.setId(areaCity.getId());
							city.setTie(areaCity.getAreaName());
							city.setCode(areaCity.getCode());
							
							//根据城市ID 获取所属城市下的区县
							List<Area> countys = areaService.getAreaByPID(areaCity.getId());
							if (DataUtil.checkListNullAndSize(countys)) {
								for (Area areaCounty : countys) {
									County county = new County();
									county.setId(areaCounty.getId());
									county.setTie(areaCounty.getAreaName());
									county.setCode(areaCounty.getCode());
									
									countyList.add(county);
									
									city.setCouns(countyList);
								}
							}
							
							cityList.add(city);
						}
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return cityList;
	}
	
	/**
	 * 根据城市名获取其ID
	 * @author 
	 * @return
	 */
	public static Long findCityIdByName(String cityName) {
		
		Long cityId = null;//待查找城市的ID
		try {
			// 查询所有的省份
			List<Area> provinces = areaService.getAreaByPID(0L);
			if (DataUtil.checkListNullAndSize(provinces)) {
				for (Area areaProvince : provinces) {
					//获取城市
					List<Area> citys = areaService.getAreaByPID(areaProvince.getId());
					if (DataUtil.checkListNullAndSize(citys)) {
						for (Area areaCity : citys) {
							if (null != cityName && cityName.equals(areaCity.getAreaName())) {
								return areaCity.getId();
							}
							
							//找默认城市的ID
							if(cityId == null && DEFAULT_CITY_NAME.equals(areaCity.getAreaName())){
								
								cityId = areaCity.getId();//设置默认城市ID
							}
						}
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return cityId;
	}
	

	/**
	 * 获取某城市下的所有区域
	 * 
	 * @param cityName
	 * @return
	 */
	public static List<String> findSectionInCity(String cityName) {
		List<String> re = new ArrayList<String>();
			try {
				if (null != cityName) {
					List<Area> citys = areaService.getAreaByName(cityName);
					if (DataUtil.checkListNullAndSize(citys)) {
						List<Area> areas = areaService.getAreaByPID(citys.get(0).getId());
						if (DataUtil.checkListNullAndSize(areas)) {
							for (Area area : areas) {
								re.add(area.getAreaName());
							}
						}
					}
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
			return re;
	}
	
	/**
	 * 根据城市对象、获取某城市下的所有区域
	 * 
	 * @param cityName
	 * @return
	 */
	public static List<Area> findSectionInCity(Area area) {
		if (null != area) {
			try {
				return areaService.getAreaByPID(area.getId());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}
	
	
	/**
	 * 根据省份名获取省份对象
	 * @param provName
	 * @return
	 */
	public static Area findProvinceByProvName(String provName){
		if (provName != null) {
			try {
				List<Area> areas = areaService.getAreaByName(provName);
				if (DataUtil.checkListNullAndSize(areas)) {
					for (Area area : areas) {
						if (area.getPid() == 0) {
							return area;
						}
					}
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}
	
	/**
	 * 根据省份对象、城市名获取城市对象
	 * @return
	 */
	public static Area findCityByProvAndCityName(Area provObj, String cityName){
		if (null != cityName) {
			try {
				List<Area> areas = areaService.getAreaByName(cityName);
				if (DataUtil.checkListNullAndSize(areas)) {
					for (Area area : areas) {
						if (null != provObj) {
							if (area.getPid() == provObj.getId() ) {
								return area;
							}
						}
					}
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}
	

	/**
	 * 通过区域名获取区域id
	 * 
	 * @param sname
	 * @return
	 */
	public static Long findSectionIdByName(String cityName, String sname) {
		if (null != cityName) {
			try {
				List<Area> areas = areaService.getAreaByName(cityName);
				if (DataUtil.checkListNullAndSize(areas)) {
					for (Area area : areas) {
						List<Area> citys = areaService.getAreaByPID(area.getId());
						if (DataUtil.checkListNullAndSize(citys)) {
							for (Area area2 : citys) {
								if (null != sname) {
									if (sname.equals(area2.getAreaName())) {
										return area2.getId();
									}
								}
							}
						}
					}
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}
	
	/**
	 * 通过城市id获取城市名
	 * 
	 * @param id
	 * @return
	 */
	public static String findCityNameById(Long cityid) {
		if (cityid != null) {
			try {
				return areaService.findObjectById(cityid).getAreaName();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}
	
	
	
	/**
	 * 通过城市名获取区域集合
	 * 
	 * @param cityName
	 * @return
	 */
	public List<String> get(String cityName) {
		
		initCitySectionMap();
		
		return CITY_SECTION_MAP.get(cityName);
	}
	
	/**
	 * 获取城市名集合
	 * 
	 * @return
	 */
	public void init() {

		initCitySectionMap();

		//return PROVINCE_CITY_SECTION_MAP;
	}
	
	
	
	/**
	 * 为PROVINCE_CITY_SECTION_MAP集合设置值
	 */
	private static void initCitySectionMap() {
		if(PROVINCE_CITY_SECTION_MAP.size() > 0){
			
			PROVINCE_CITY_SECTION_MAP.clear();
		}
		
		try {
			//获取所有省份
			List<Area> provinces = areaService.getAreaByPID(0l);
			if (DataUtil.checkListNullAndSize(provinces)) {
				for (Area areaProvince : provinces) {
					//根据省份ID获取  所属省份下的城市
					List<Area> citys = areaService.getAreaByPID(areaProvince.getId());
					//创建城市、区域集合
					Map<String, List<Area>> citySectionMap = new HashMap<String, List<Area>>();
					if (DataUtil.checkListNullAndSize(citys)) {
						for (Area areaCity : citys) {
							String cityName = areaCity.getAreaName();
							//根据城市ID 获取所属城市下的区县
							List<Area> countys = areaService.getAreaByPID(areaCity.getId());
							// 将城市名(键)与区域集合(值)加入map
							citySectionMap.put(cityName, countys);
						}
					}
					// 将省份名(键)与城市区域集合(值)加入map
					PROVINCE_CITY_SECTION_MAP.put(areaProvince.getAreaName(), citySectionMap);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 获取当前选中城市如果没有则取默认城市
	 * @return
	 */
	public static String getCurrentCity(){
		
		String city  = (String)ActionContext.getContext().getSession().get("city");
		
		if(DataUtil.isNotNullAndEmpty(city)){
			return city;
		}
		
		return DEFAULT_CITY_NAME;
	}
	
	
	public static Map<String, Map<String, List<Area>>> getAreaDataMap(){
		if (null != PROVINCE_CITY_SECTION_MAP && PROVINCE_CITY_SECTION_MAP.size() > 0) {
			return PROVINCE_CITY_SECTION_MAP;
		}
		
		CitySection.CITY_SECTION.initSecond();
		
		return PROVINCE_CITY_SECTION_MAP;
	}
	/**
	 * 
	* 描述  : 第二次初始化
	* 方法名: initSecond
	* 创建人：孙刚   
	* 创建时间：2014-2-24 下午05:01:56  
	* @return ：void
	 */
	private Map<String, Map<String, List<Area>>> initSecond() {

		initCitySectionMap();

		return PROVINCE_CITY_SECTION_MAP;
	}
}

//=======================

package com.supinfo.jieneng.domains;

import java.io.Serializable;

import com.supinfo.core.base.BaseDomain;
/**
* @Description:TODO(行政区域实体) 
* 项目名称：jnschool   
* 类名称：Area   
* 创建人：孙刚   
* 创建时间：2013-12-9 上午09:24:00   
* 修改人1：xxx     
* 修改时间1：xxxx-xx-xx 
* 修改备注：   
* @version  1.0
 */
@SuppressWarnings("serial")
public class Area extends BaseDomain implements Serializable {
	/**
	 * 区域名称
	 */
    private String areaName;
    /**
     * pid
     */
    private Long pid;
    /**
     * 区域编号
     */
    private String code;


    public String getAreaName() {
		return areaName;
	}

	public void setAreaName(String areaName) {
		this.areaName = areaName;
	}

	public Long getPid() {
        return pid;
    }

    public void setPid(Long pid) {
        this.pid = pid;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}


//=====================================
package com.supinfo.jieneng.domains;

import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.annotations.XStreamAsAttribute;

/**
 * 区域
 * @author 
 *
 */
@XStreamAlias("coun")
public class County {
	
	@XStreamAsAttribute
    @XStreamAlias("id")
	private Long id;
	
	@XStreamAsAttribute
    @XStreamAlias("tie")
	private String tie;
	
	@XStreamAsAttribute
    @XStreamAlias("code")
	private String code;
	
	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getTie() {
		return tie;
	}

	public void setTie(String tie) {
		this.tie = tie;
	}

	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}
	
	
	
}
//================================
package com.supinfo.jieneng.domains;

import java.util.List;

import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
import com.thoughtworks.xstream.annotations.XStreamImplicit;

@XStreamAlias("city")
public class City {

	@XStreamAsAttribute
    @XStreamAlias("id")
	private Long id;
	
	@XStreamAsAttribute
    @XStreamAlias("tie")
	private String tie;
	@XStreamAsAttribute
    @XStreamAlias("code")
	private String code;
	
	@XStreamImplicit
	private List<County> couns;
	
	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getTie() {
		return tie;
	}

	public void setTie(String tie) {
		this.tie = tie;
	}

	public List<County> getCouns() {
		return couns;
	}

	public void setCouns(List<County> couns) {
		this.couns = couns;
	}

	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}
	
}

http://my.oschina.net/feichexia/blog/201907


//======================InvocationHandler =======================

package org.sung.java.custom.dynamicProxy;

import java.lang.reflect.Method;

public interface InvocationHandler {
	
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
	
}


//======================Proxy =======================

package org.sung.java.custom.dynamicProxy;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.WeakHashMap;

import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

public class Proxy implements Serializable {
	
	private final static Class[] constructorParams = { InvocationHandler.class };
	private static Map<Class<?>, Void> proxyClasses = Collections.synchronizedMap(new WeakHashMap<Class<?>, Void>());
	
	public static Object newProxyInstance(ClassLoader loader, Class<?> inface,
			InvocationHandler handler) throws IllegalArgumentException {

		if (null == handler) {
			throw new NullPointerException("handler is not null...");
		}
		// 获取代理对象
		Class<?> $proxyClass = getProxyClass(inface, loader);
		try {
			final Constructor<?> cons = $proxyClass.getConstructor(constructorParams);
			final InvocationHandler ih = handler;
			return newInstance(cons, ih);
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}
		return null;

	}

	private static Class<?> getProxyClass(Class<?> inface, ClassLoader loader) {
		String methodStr = "";
		String rt = "\r\n";
		// 过去接口中 所有的方法
		Method[] methods = inface.getMethods();
		// 判断接口中 是否有方法
		if (null != methods) {
			// 遍历所有方法
			for (Method method : methods) {
				// 获取方法所有的的参数类型
				Class<?>[] paramTypes = method.getParameterTypes();
				// 获取方法的返回类型
				Class<?> returnType = method.getReturnType();
				methodStr += "	public " + returnType.getSimpleName() + " " + method.getName();
				// 判断参数类型
				if (paramTypes.length > 0) {
					//保存临时参数
					String tempParamNames = "";
					//保存临时的参数类型
					String tempParamTypes = "";
					String tempparamName ="";
					// 遍历 参数类型
					for (int i = 0; i < paramTypes.length; i++) {
						// 获取参数类型名
						String paramTypeSimpleName = paramTypes[i].getSimpleName();
						// 制定一个 参数名 
						String paramName = "param"+(i+1);
						tempparamName += paramName + ",";
						tempParamNames += paramTypeSimpleName + " " + paramName + ",";
						tempParamTypes += paramTypeSimpleName + ".class" + ",";
					}
					
					tempParamNames = tempParamNames.substring(0,tempParamNames.length()-1) ;
					tempParamTypes = tempParamTypes.substring(0,tempParamTypes.length()-1);
					tempparamName = tempparamName.substring(0, tempparamName.length()-1);
					
					methodStr += "("+tempParamNames+"){" + rt
							+ "		try{" +  rt
							+ "			Method m = " + inface.getName()+".class.getMethod(\"" + method.getName() + "\",new Class[]{"+tempParamTypes+"});" + rt
							+ "			handler.invoke(this,m,new Object[]{"+tempparamName+"});" + rt
							+ "		}catch(Exception e) {" + rt 
							+ "			e.printStackTrace();" + rt
							+ "		}catch(Throwable e){" + rt
							+ "			e.printStackTrace();" + rt
							+ "		}" + rt
							+ "	}" + rt + "" + rt;
					
				} else {
					methodStr += "(){" + rt 
							+ "		try{" + rt 
							+ "			Method m = " + inface.getName() + ".class.getMethod(\"" + method.getName() + "\");" + rt 
							+ "			return (" + returnType.getSimpleName() + ")handler.invoke(this,m,new Object[]{});" + rt
							+ "		}catch(Exception e) {" + rt
							+ "			e.printStackTrace();" + rt 
							+ "		}catch(Throwable e){" + rt
							+ "			e.printStackTrace();" + rt 
							+ "		}" + rt
							+ "			return null;" + rt 
							+ "	}" + rt + "" + rt;
				}
			}
		} else {
			// 没有方法
		}
		
		
		// 获取当前接口的包名
		Package pack = inface.getPackage();
		String packageName = pack.getName();

		String score = "package " + packageName + ";" + rt + "" + rt
				+ "import java.lang.reflect.Method;" + rt + "" + rt
				+ "public class $ProxyClass implements "
				+ inface.getSimpleName() + " { " + rt + "" + rt + "	"
				+ packageName + ".InvocationHandler handler;" + rt + "" + rt
				+ "	public $ProxyClass(InvocationHandler handler) {" + rt
				+ "		this.handler = handler;" + rt + "	}" + rt + "" + rt +
				methodStr + rt +
				"}";
		
		
		//System.out.println(score);
		// 写入内存中

		Class<?> $proxyClass = writeClassToLoad(inface, score, packageName);

		return $proxyClass;
	}

	private static Class<?> writeClassToLoad(Class<?> inface, String score,
			String packageName) {

		String fileSeparator = File.separator;

		// 生成 源代码 目录
		String fileName = System.getProperty("user.dir") + fileSeparator
				+ "src" + fileSeparator + "main" + fileSeparator + "java"
				+ fileSeparator + packageName.replace(".", fileSeparator);

		// 生成到 本地
		File parentFile = new File(fileName);
		if (!parentFile.exists()) {
			parentFile.mkdir();
		}

		FileWriter fileWriter;
		try {
			fileWriter = new FileWriter(new File(parentFile, fileSeparator + "$ProxyClass.java"));
			fileWriter.write(score);
			fileWriter.flush();
			fileWriter.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

		// 编译 本地 JAVA文件
		Class<?> $proxyClass = compilerClassToLoad(fileName, fileSeparator,packageName);
		
		
		return $proxyClass;
	}

	@SuppressWarnings("restriction")
	private static Class<?> compilerClassToLoad(String fileName,String fileSeparator,String packageName) {
		// 编译 compile

		// 1，拿到 API 编译器
		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

		// System.out.println("compiler : " + compiler);

		// 2，获取 JAVA file 管理器
		// 参数 null 意味都是用 默认的
		StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);

		// 3，根据文件名字，获取一系列 JAVAFileObject 可使用多个
		// 通过 fileManager找到 fileName
		Iterable untis = fileManager.getJavaFileObjects(fileName + fileSeparator + ".$ProxyClass.java");

		// 4，获取编译任务
		CompilationTask task = compiler.getTask(null, fileManager, null, null,null, untis);

		// 5，实行任务
		task.call();

		try {
			// 6，关掉
			fileManager.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

		// load 到 内存 和 生成新对象
		try {
			URL[] urls = new URL[] { new URL("file:" + fileSeparator + System.getProperty("user.dir") + fileSeparator + "src"
					+ fileSeparator + "main" + fileSeparator + "java") };

			URLClassLoader classLoader = new URLClassLoader(urls);
			Class<?> clazz = classLoader.loadClass(packageName + ".$ProxyClass");

			return clazz;
			
		} catch (MalformedURLException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	
	
    public static boolean isProxyClass(Class<?> cl) {
        if (cl == null) {
            throw new NullPointerException();
        }
        return proxyClasses.containsKey(cl);
    }
    
    
    private static Object newInstance(Constructor<?> cons, InvocationHandler h) {
    	 try {
			return cons.newInstance(new Object[] {h} );
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
    	 
    	 return null;
    }
}


//======================User =======================

package org.sung.java.custom.dynamicProxy;

public class User {
	
	private int id;
	private String name;
	private String pwd;
	
	
	public User() {
		super();
	}

	public User(int id, String name, String pwd) {
		super();
		this.id = id;
		this.name = name;
		this.pwd = pwd;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPwd() {
		return pwd;
	}

	public void setPwd(String pwd) {
		this.pwd = pwd;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", pwd=" + pwd + "]";
	}
}


//======================HelloWord =======================
package org.sung.java.custom.dynamicProxy;

public interface HelloWord {
	void setMsg(String msg,String name);
	String getMsg();
	
	void setUser(User user);
	
	User getUser();
}

//======================HelloWordImpl =======================
package org.sung.java.custom.dynamicProxy;

public class HelloWordImpl implements HelloWord{

	public void setMsg(String msg,String name) {
		System.out.println(msg + ": " + name);
	}

	public String getMsg() {
		return "hello : sungang";
	}

	public void setUser(User user) {
		System.out.println(user.toString());
	}

	public User getUser() {
		User user = new User(1, "sungang", "12346");
		return user;
	}
}	

//======================LogHandler =======================

package org.sung.java.custom.dynamicProxy;

import java.lang.reflect.Method;

public class LogHandler implements InvocationHandler{
	
	private Object target;
	
	
	public LogHandler(Object target) {
		super();
		this.target = target;
	}

	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("log start ............");
		return method.invoke(target, args);
	}

}


//======================Client =======================
package org.sung.java.custom.dynamicProxy;

import java.io.IOException;

public class Client {

	public static void main(String[] args) throws IOException {

		HelloWord iHelloWord = new HelloWordImpl();
		LogHandler handler = new LogHandler(iHelloWord);
		HelloWord helloWord = (HelloWord) Proxy.newProxyInstance(null,
				HelloWord.class, handler);

		helloWord.setMsg("hello ", "sungang");

		String msg = helloWord.getMsg();
		System.out.println(msg);
		
		helloWord.setUser(new User(1, "sungang", "123465"));
		
		User user = helloWord.getUser();
		System.out.println(user.toString());
	}
}

//======================运行结果 =======================
//log start ............
//hello : sungang
//log start ............
//hello : sungang
//log start ............
//User [id=1, name=sungang, pwd=123465]
//log start ............
//User [id=1, name=sungang, pwd=12346]

//1,Bootstrap树样式 
http://runjs.cn/detail/jspmxwka


//2,悬浮支持小图标菜单 
http://runjs.cn/detail/5igdlhhz


//3,image hover
http://runjs.cn/detail/0fk8dwbt

//4,仿天猫轮播 
http://runjs.cn/detail/tvqxftuj

//5,Bootstrap做的登录界面。 
http://runjs.cn/detail/f42nfs3g

//6,可拖动布局
http://runjs.cn/detail/dje5kzar

//7,多轴highcharts了。放在runjs感觉还不错 
http://runjs.cn/detail/pld0o7um

//8,jQuery KeyBoard 键盘
http://runjs.cn/detail/ncxf7e1u

//9,多皮肤悬浮QQ在线客服jQuery插件
http://runjs.cn/detail/kgawqf8s

//10，消息发送动画 
http://runjs.cn/detail/sqekys02

//11，2012大记事
http://runjs.cn/detail/2gkexwbq

//12，打飞机 1.0 Javascript版
http://runjs.cn/detail/6cpmot1v

//13,仿优酷视频图片轮转效果
http://runjs.cn/detail/3avdokbi

//14,3D动态玫瑰 
http://runjs.cn/detail/u1wj1jux

//15,FlexJS 丑陋的原生代码开发时钟效果
http://runjs.cn/detail/ofttquye

//16,TAGS 球形旋转
http://runjs.cn/detail/fkkvhvun

package cn.net.sung.test.java.moniAOP;

public interface PersonService {
	
	void save(String name);
	void update(String name,Integer personId);
	String getPersonName(Integer personId);
}

//======================================================
package cn.net.sung.test.java.moniAOP;

public class PersonServiceBean implements PersonService{

	private String user = null;
	
	public PersonServiceBean() {
		super();
	}
	
	public PersonServiceBean(String user) {
		super();
		this.user = user;
	}

	@Override
	public void save(String name) {
		 System.out.println("我是save()方法");
	}

	@Override
	public void update(String name, Integer personId) {
		System.out.println("我是update()方法");
	}

	@Override
	public String getPersonName(Integer personId) {
		System.out.println("我是getPersonName()方法");
        return "get";
	}

	public String getUser() {
		return user;
	}

	public void setUser(String user) {
		this.user = user;
	}
}

//======================================================
package cn.net.sung.test.java.moniAOP;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JDKProxyFactory implements InvocationHandler {

	// 要代理的原始对象
	private Object targer;

	public Object createProxyInstance(Object targer) {
		this.targer = targer;
		return Proxy.newProxyInstance(this.targer.getClass().getClassLoader(),
				this.targer.getClass().getInterfaces(), this);
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object result = null;
		PersonServiceBean bean = (PersonServiceBean) this.targer;

		if (bean.getUser() != null) {
			// 前置通知
			doBefore();
			try {
				result = method.invoke(targer, args);
				// 后置通知
				doAfter();
			} catch (Exception e) {
				// 例外通知
				doException();
			} finally {
				// 最终通知
				doFinally();
			}
		}
		return result;
	}

	private void doBefore() {
		System.out.println("我是前置通知");
	}

	private void doAfter() {
		System.out.println("我是后置通知");
	}

	private void doException() {
		System.out.println("我是例外通知");
	}

	private void doFinally() {
		System.out.println("我是最终通知");
	}

}

//======================================================
package cn.net.sung.test.java.moniAOP;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CGlibProxyFactory implements MethodInterceptor {

	private Object target;

	public Object createProxyInstance(Object target) {
		this.target = target;
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(this.target.getClass());// 非final
		enhancer.setCallback(this);
		return enhancer.create();
	}

	@Override
	public Object intercept(Object proxy, Method methodProxy, Object[] args,
			MethodProxy arg3) throws Throwable {

		Object result = null;
		PersonServiceBean bean = (PersonServiceBean) this.target;
		if (bean.getUser() != null) {
			// 前置通知
			doBefore();
			try {
				result = methodProxy.invoke(target, args);
				// 后置通知
				doAfter();
			} catch (Exception e) {
				// 例外通知
				doException();
			} finally {
				// 最终通知
				doFinally();
			}
		}
		return result;
	}

	private void doBefore() {
		System.out.println("我是前置通知");
	}

	private void doAfter() {
		System.out.println("我是后置通知");
	}

	private void doException() {
		System.out.println("我是例外通知");
	}

	private void doFinally() {
		System.out.println("我是最终通知");
	}

}

//======================================================
package cn.net.sung.test.java.moniAOP;

public class AopTest {
	public static void main(String[] args) {
		//porxyTest1();
		porxyTest2();
	}
	
	private static void porxyTest1(){
		JDKProxyFactory jdkProxyFactory = new JDKProxyFactory();
		PersonService personService = (PersonService)jdkProxyFactory.createProxyInstance(new PersonServiceBean("孙刚"));
		personService.getPersonName(1);
	}
	
	private static void porxyTest2(){
		CGlibProxyFactory cGlibProxyFactory = new CGlibProxyFactory();
		PersonServiceBean personServiceBean = (PersonServiceBean)cGlibProxyFactory.createProxyInstance(new PersonServiceBean("孙刚2"));
		personServiceBean.getPersonName(2);
			
	}
}

//======================================================

http://www.cnblogs.com/linjiqin/archive/2011/04/17/2019074.html

package com.ptn.utils;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

import org.apache.log4j.Logger;


/**
* 文件工具类
*
* @author jiqinlin
*
*/
public class FileTool {
private static final Logger log = Logger.getLogger(FileTool.class);

/**
* 创建目录
*
* @param dir 目录
*/
public static void mkdir(String dir) {
try {
String dirTemp = dir;
File dirPath = new File(dirTemp);
if (!dirPath.exists()) {
dirPath.mkdir();
}
} catch (Exception e) {
log.error("创建目录操作出错: "+e.getMessage());
e.printStackTrace();
}
}


/**
* 新建文件
*
* @param fileName
* String 包含路径的文件名 如:E:\phsftp\src\123.txt
* @param content
* String 文件内容
*
*/
public static void createNewFile(String fileName, String content) {
try {
String fileNameTemp = fileName;
File filePath = new File(fileNameTemp);
if (!filePath.exists()) {
filePath.createNewFile();
}
FileWriter fw = new FileWriter(filePath);
PrintWriter pw = new PrintWriter(fw);
String strContent = content;
pw.println(strContent);
pw.flush();
pw.close();
fw.close();
} catch (Exception e) {
log.error("新建文件操作出错: "+e.getMessage());
e.printStackTrace();
}

}

/**
* 删除文件
*
* @param fileName 包含路径的文件名
*/
public static void delFile(String fileName) {
try {
String filePath = fileName;
java.io.File delFile = new java.io.File(filePath);
delFile.delete();
} catch (Exception e) {
log.error("删除文件操作出错: "+e.getMessage());
e.printStackTrace();
}
}


/**
* 删除文件夹
*
* @param folderPath 文件夹路径
*/
public static void delFolder(String folderPath) {
try {
// 删除文件夹里面所有内容
delAllFile(folderPath);
String filePath = folderPath;
java.io.File myFilePath = new java.io.File(filePath);
// 删除空文件夹
myFilePath.delete();
} catch (Exception e) {
log.error("删除文件夹操作出错"+e.getMessage());
e.printStackTrace();
}
}


/**
* 删除文件夹里面的所有文件
*
* @param path 文件夹路径
*/
public static void delAllFile(String path) {
File file = new File(path);
if (!file.exists()) {
return;
}
if (!file.isDirectory()) {
return;
}
String[] childFiles = file.list();
File temp = null;
for (int i = 0; i < childFiles.length; i++) {
//File.separator与系统有关的默认名称分隔符
//在UNIX系统上，此字段的值为'/'；在Microsoft Windows系统上，它为 '\'。
if (path.endsWith(File.separator)) {
temp = new File(path + childFiles[i]);
} else {
temp = new File(path + File.separator + childFiles[i]);
}
if (temp.isFile()) {
temp.delete();
}
if (temp.isDirectory()) {
delAllFile(path + "/" + childFiles[i]);// 先删除文件夹里面的文件
delFolder(path + "/" + childFiles[i]);// 再删除空文件夹
}
}
}


/**
* 复制单个文件
*
* @param srcFile
* 包含路径的源文件 如：E:/phsftp/src/abc.txt
* @param dirDest
* 目标文件目录；若文件目录不存在则自动创建 如：E:/phsftp/dest
* @throws IOException
*/
public static void copyFile(String srcFile, String dirDest) {
try {
FileInputStream in = new FileInputStream(srcFile);
mkdir(dirDest);
FileOutputStream out = new FileOutputStream(dirDest+"/"+new File(srcFile).getName());
int len;
byte buffer[] = new byte[1024];
while ((len = in.read(buffer)) != -1) {
out.write(buffer, 0, len);
}
out.flush();
out.close();
in.close();
} catch (Exception e) {
log.error("复制文件操作出错:"+e.getMessage());
e.printStackTrace();
}
}

/**
* 复制文件夹
*
* @param oldPath
* String 源文件夹路径 如：E:/phsftp/src
* @param newPath
* String 目标文件夹路径 如：E:/phsftp/dest
* @return boolean
*/
public static void copyFolder(String oldPath, String newPath) {
try {
// 如果文件夹不存在 则新建文件夹
mkdir(newPath);
File file = new File(oldPath);
String[] files = file.list();
File temp = null;
for (int i = 0; i < files.length; i++) {
if (oldPath.endsWith(File.separator)) {
temp = new File(oldPath + files[i]);
} else {
temp = new File(oldPath + File.separator + files[i]);
}

if (temp.isFile()) {
FileInputStream input = new FileInputStream(temp);
FileOutputStream output = new FileOutputStream(newPath
+ "/" + (temp.getName()).toString());
byte[] buffer = new byte[1024 * 2];
int len;
while ((len = input.read(buffer)) != -1) {
output.write(buffer, 0, len);
}
output.flush();
output.close();
input.close();
}
if (temp.isDirectory()) {// 如果是子文件夹
copyFolder(oldPath + "/" + files[i], newPath + "/" + files[i]);
}
}
} catch (Exception e) {
log.error("复制文件夹操作出错:"+e.getMessage());
e.printStackTrace();
}
}

/**
* 移动文件到指定目录
*
* @param oldPath 包含路径的文件名 如：E:/phsftp/src/ljq.txt
* @param newPath 目标文件目录 如：E:/phsftp/dest
*/
public static void moveFile(String oldPath, String newPath) {
copyFile(oldPath, newPath);
delFile(oldPath);
}

/**
* 移动文件到指定目录，不会删除文件夹
*
* @param oldPath 源文件目录 如：E:/phsftp/src
* @param newPath 目标文件目录 如：E:/phsftp/dest
*/
public static void moveFiles(String oldPath, String newPath) {
copyFolder(oldPath, newPath);
delAllFile(oldPath);
}

/**
* 移动文件到指定目录，会删除文件夹
*
* @param oldPath 源文件目录 如：E:/phsftp/src
* @param newPath 目标文件目录 如：E:/phsftp/dest
*/
public static void moveFolder(String oldPath, String newPath) {
copyFolder(oldPath, newPath);
delFolder(oldPath);
}

/**
* 解压zip文件
*
* @param srcDir
* 解压前存放的目录
* @param destDir
* 解压后存放的目录
* @throws Exception
*/
public static void jieYaZip(String srcDir, String destDir) throws Exception {
int leng = 0;
byte[] b = new byte[1024*2];
/** 获取zip格式的文件 **/
File[] zipFiles = new FileFilterByExtension("zip").getFiles(srcDir);
if(zipFiles!=null && !"".equals(zipFiles)){
for (int i = 0; i < zipFiles.length; i++) {
File file = zipFiles[i];
/** 解压的输入流 * */
ZipInputStream zis = new ZipInputStream(new FileInputStream(file));
ZipEntry entry=null;
while ((entry=zis.getNextEntry())!=null) {
File destFile =null;
if(destDir.endsWith(File.separator)){
destFile = new File(destDir + entry.getName());
}else {
destFile = new File(destDir + "/" + entry.getName());
}
/** 把解压包中的文件拷贝到目标目录 * */
FileOutputStream fos = new FileOutputStream(destFile);
while ((leng = zis.read(b)) != -1) {
fos.write(b, 0, leng);
}
fos.close();
}
zis.close();
}
}
}

/**
* 压缩文件
*
* @param srcDir
* 压缩前存放的目录
* @param destDir
* 压缩后存放的目录
* @throws Exception
*/
public static void yaSuoZip(String srcDir, String destDir) throws Exception {
String tempFileName=null;
byte[] buf = new byte[1024*2];
int len;
//获取要压缩的文件
File[] files = new File(srcDir).listFiles();
if(files!=null){
for (File file : files) {
if(file.isFile()){
FileInputStream fis = new FileInputStream(file);
BufferedInputStream bis = new BufferedInputStream(fis);
if (destDir.endsWith(File.separator)) {
tempFileName = destDir + file.getName() + ".zip";
} else {
tempFileName = destDir + "/" + file.getName() + ".zip";
}
FileOutputStream fos = new FileOutputStream(tempFileName);
BufferedOutputStream bos = new BufferedOutputStream(fos);
ZipOutputStream zos = new ZipOutputStream(bos);// 压缩包

ZipEntry ze = new ZipEntry(file.getName());// 压缩包文件名
zos.putNextEntry(ze);// 写入新的ZIP文件条目并将流定位到条目数据的开始处

while ((len = bis.read(buf)) != -1) {
zos.write(buf, 0, len);
zos.flush();
}
bis.close();
zos.close();

}
}
}
}


/**
* 读取数据
*
* @param inSream
* @param charsetName
* @return
* @throws Exception
*/
public static String readData(InputStream inSream, String charsetName) throws Exception{
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len = -1;
while( (len = inSream.read(buffer)) != -1 ){
outStream.write(buffer, 0, len);
}
byte[] data = outStream.toByteArray();
outStream.close();
inSream.close();
return new String(data, charsetName);
}

/**
* 一行一行读取文件，适合字符读取，若读取中文字符时会出现乱码
*
* @param path
* @return
* @throws Exception
*/
public static Set<String> readFile(String path) throws Exception{
Set<String> datas=new HashSet<String>();
FileReader fr=new FileReader(path);
BufferedReader br=new BufferedReader(fr);
String line=null;
while ((line=br.readLine())!=null) {
datas.add(line);
}
br.close();
fr.close();
return datas;
}
}

//=======================测试========================

package juint.test;

import java.io.File;
import java.io.InputStream;
import java.util.Set;

import org.apache.log4j.Logger;
import org.junit.Test;

import com.ptn.utils.FileFilterByExtension;
import com.ptn.utils.FileTool;
import com.ptn.utils.UrlTool;

public class FileToolTest {
private static final Logger log = Logger.getLogger(FileToolTest.class);

/**
* 创建目录
*/
@Test
public void mkdir(){
FileTool.mkdir("e:/ljq");
}

/**
* 新建文件
*/
@Test
public void createNewFile(){
try {
InputStream inStream=FileToolTest.class.getClassLoader().getResourceAsStream("903_13_5990_1001220007.xml");
String data=FileTool.readData(inStream, "UTF-8");
FileTool.createNewFile("e:/ljq.xml", data);
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 删除文件
*
*/
@Test
public void delFile() {
FileTool.delFile(UrlTool.readUrl("dirSrc")+"/123.txt");
}

/**
* 删除文件夹
*
*/
@Test
public void delFolder() {
FileTool.delFolder(UrlTool.readUrl("dirDest"));
}

/**
* 删除文件夹里面的所有文件
*
*/
@Test
public void delAllFile() {
FileTool.delAllFile(UrlTool.readUrl("dirDest"));
}

/**
* 复制文件
*/
@Test
public void copyFile() {
// 获取文件源目录
String dirSrc = UrlTool.readUrl("dirSrc");
// 获取文件目标目录
String dirDest = UrlTool.readUrl("dirDest");
if (dirSrc == null || "".equals(dirSrc)) {
log.error("dirSrc目录不存在");
return;
}
File[] files = new FileFilterByExtension("").getFiles(dirSrc);
if(files!=null){
for(File file:files){
FileTool.copyFile(file.getAbsolutePath(), dirDest);
}
}
}


@Test
public void copyFolder(){
// 获取文件源目录
String dirSrc = UrlTool.readUrl("dirSrc");
// 获取文件目标目录
String dirDest = UrlTool.readUrl("dirDest");
FileTool.copyFolder(dirSrc, dirDest);
}

/**
* 移动文件到指定目录
*/
@Test
public void moveFile(){
FileTool.moveFile(UrlTool.readUrl("dirSrc")+"/abc.txt",
UrlTool.readUrl("dirDest"));
}

/**
* 移动文件到指定目录
*/
@Test
public void moveFolder(){
FileTool.moveFolder(UrlTool.readUrl("dirSrc"), UrlTool.readUrl("dirDest"));
}

/**
* 移动文件到指定目录
*/
@Test
public void moveFiles(){
FileTool.moveFiles(UrlTool.readUrl("dirSrc"), UrlTool.readUrl("dirDest"));
}

/**
* 解压
*/
@Test
public void jieYaZip(){
try {
FileTool.jieYaZip(UrlTool.readUrl("dirSrc"), UrlTool.readUrl("dirDest"));
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 压缩
*/
@Test
public void yaSuoZip(){
try {
FileTool.yaSuoZip(UrlTool.readUrl("dirSrc"), UrlTool.readUrl("dirDest"));
} catch (Exception e) {
e.printStackTrace();
}
}


@Test
public void readFile() throws Exception{
Set<String> datas=FileTool.readFile("E:\\phsftp\\sql\\ycxk_srm_901_13_R_1103040036_20110419142544.txt");
for(String data:datas){
System.out.println(data);
}
}
}文件操作工具类

package cn.net.sung.test.java.gongjulei;

import org.apache.commons.lang.RandomStringUtils;

public class RandomStringUtilsTest {
	
	public static void main(String[] args) {
		//产生5位长度的随机字符串，中文环境下是乱码
		String r1 = RandomStringUtils.random(5);
		System.out.println(r1);
		
		//使用指定的字符生成5位长度的随机字符串
		String r2 = RandomStringUtils.random(5, new char[]{'a','b','c','d','e','f', '1', '2', '3'});
		System.out.println(r2);//313af
		

		//生成指定长度的字母和数字的随机组合字符串
		String r3 = RandomStringUtils.randomAlphanumeric(16);
		System.out.println(r3);//XAdAHrDZIYT5Pex6
		
		//生成随机数字字符串
		String r4 = RandomStringUtils.randomNumeric(5);
		System.out.println(r4);//65445
		
		//生成随机[a-z]字符串，包含大小写
		String r5 = RandomStringUtils.randomAlphabetic(5);
		System.out.println(r5);//zOMqg
		
		//生成从ASCII 32到126组成的随机字符串 
		String r6 = RandomStringUtils.randomAscii(4);
		System.out.println(r6);//r['_
	}
}

String s = "上面各位兄弟说的都对，我这里就总结一下，站在巨人的肩膀上啦，嘿嘿";
		Map<String, Integer> map = new HashMap<String, Integer>();
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			String tempKey = String.valueOf(c);
			if (map.containsKey(tempKey)) {
				Integer tempValue =map.get(tempKey);
				map.put(tempKey, tempValue+1);
			}else {
				map.put(tempKey, 1);
			}
		}
		//第一种
		for (String key : map.keySet()) {
			System.out.println(key + " : " + map.get(key) );
		}

package cn.cd.sg.test.proxy;

public interface DynamicProxyFactory {
	/**
	* 描述  : 生成动态代理,并且在调用代理执行函数的时候使用拦截器
	* 方法名: createProxy
	* 创建人：孙刚   
	* 创建时间：2014-5-29 下午01:53:21
	* @param <T>
	* @param target 实现此接口的类  
	* @param interceptor 拦截器  
	* @return ：T
	 */
	public <T> T createProxy(T target,Interceptor interceptor);
}

//===================================================================================================


package cn.cd.sg.test.proxy;


public class DynamicProxyFactoryImpl implements DynamicProxyFactory {

	/**
	 * 生成动态代理,并且在调用代理执行函数的时候使用拦截器 Title: createProxy
	 * 
	 * @param target
	 *            需要代理的实例
	 * @param interceptor
	 *            拦截器实现,就是我们希望代理类执行函数的前后, 抛出异常,finally的时候去做写什么
	 * @return
	 */
	@SuppressWarnings("unchecked")
	@Override
	public <T> T createProxy(T target, Interceptor interceptor) {
		// 当前对象的类加载器
		ClassLoader classLoader = target.getClass().getClassLoader();
		// 获取此对象实现的所有接
		Class<?>[] interfaces = target.getClass().getInterfaces();
		DynamicProxyInvocationHandler handler = new DynamicProxyInvocationHandler(
				target, interceptor);
		return (T) handler.getProxy();
	}

}


//==================================================================================================package cn.cd.sg.test.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/*
 * 动态代理的调用处理器 
 */
public class DynamicProxyInvocationHandler implements InvocationHandler {

	private Object target;
	private Interceptor interceptor;

	/*
	 * target: 需要代理的实例 interceptor:拦截器
	 */
	public DynamicProxyInvocationHandler(Object target, Interceptor interceptor) {
		this.target = target;
		this.interceptor = interceptor;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object result = null;

		try {
			// 在执行method之前调用interceptor去做什么事
			this.interceptor.before(method, args);
			// 在这里我们调用原始实例的method
			result = method.invoke(target, args);
			// 在执行method之后调用interceptor去做什么事
			this.interceptor.after(method, args);

		} catch (Exception e) {
			// 在发生异常之后调用interceptor去做什么事
			this.interceptor.afterThrowing(method, args, e);
		} finally {
			// 在finally之后调用interceptor去做什么事
			this.interceptor.afterFinally(method, args);
		}
		return result;
	}

	/**
	 * 获取目标对象的代理对象
	 * 
	 * @return 代理对象
	 */
	public Object getProxy() {
		return Proxy.newProxyInstance(Thread.currentThread()
				.getContextClassLoader(), target.getClass().getInterfaces(),
				this);
	}
}

//=============================================================================================
package cn.cd.sg.test.proxy;

import java.lang.reflect.Method;

public interface Interceptor {

	void before(Method method, Object[] args);

	void after(Method method, Object[] args);

	void afterThrowing(Method method, Object[] args, Throwable throwable);

	void afterFinally(Method method, Object[] args);
}



//=============================================================================================
package cn.cd.sg.test.proxy;

import java.lang.reflect.Method;

public class InterceptorImpl implements Interceptor{

	@Override
	public void after(Method method, Object[] args) {
		System.out.println("after invoking method: " + method.getName());   
	}

	@Override
	public void afterFinally(Method method, Object[] args) {
		System.out.println("afterFinally invoking method: " + method.getName());   
	}

	@Override
	public void afterThrowing(Method method, Object[] args, Throwable throwable) {
		System.out.println("afterThrowing invoking method: " + method.getName());   
	}

	@Override
	public void before(Method method, Object[] args) {
		System.out.println("before invoking method: " + method.getName()); 
	}

}


//=============================================================================================
package cn.cd.sg.test.proxy;

public interface Service {
	 public String greet(String name);   
}


//=============================================================================================

package cn.cd.sg.test.proxy;

public class ServiceImpl implements Service{

	@Override
	public String greet(String name) {
		String result = "Hello, " + name;   
		System.out.println(result);   
		return result;   
	}
}	

//=============================================================================================
package cn.cd.sg.test.proxy;

public class TestDynamicProxy {
	
	public TestDynamicProxy(){
		DynamicProxyFactory dynamicProxyFactory = new DynamicProxyFactoryImpl();
		Interceptor interceptor = new InterceptorImpl();
		Service service = new ServiceImpl();
		
		Service service2 = dynamicProxyFactory.createProxy(service, interceptor);
		
		service2.greet("孙刚");
	}
	
	public static void main(String[] args) {
		new TestDynamicProxy();
	}
}

package apache.commons.lang.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;

import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.CharSet;
import org.apache.commons.lang3.CharSetUtils;
import org.apache.commons.lang3.ClassUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.SerializationUtils;
import org.apache.commons.lang3.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.SystemUtils;
import org.apache.commons.lang3.Validate;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.commons.lang3.text.WordUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.apache.commons.lang3.time.StopWatch;

public class LangDemoTest {
	
	
	public void charSetDemo(){
		System.out.println(StringUtils.center(" charSetDemo ", 40, "="));
		CharSet charSet = CharSet.getInstance("aeiou");
		String demoStr = "The quick brown fox jumps over the lazy dog.";
		int count = 0;
		for (int i = 0, len = demoStr.length(); i < len; i++) {
            if (charSet.contains (demoStr.charAt (i) ) ) {
                count++;
            }
        }
		System.out.println("count : " + count);
	}
	
	public void charSetUtilsDemo(){
		System.out.println(StringUtils.center(" charSetUtilsDemo ", 40 , "="));
		System.out.println("计算字符串中包含某字符数");
		System.out.println(CharSetUtils.count(
				"The quick brown fox jumps over the lazy dog.", "aeiou"));
		System.out.println ("删除字符串中某字符.");
		System.out.println (CharSetUtils.delete (
                "The quick brown fox jumps over the lazy dog.", "aeiou") );
		System.out.println ("保留字符串中某字符.");
		System.out.println(CharSetUtils.keep (
				"The quick brown fox jumps over the lazy dog.", "aeiou"));
		System.out.println ("合并重复的字符.");
        System.out.println (CharSetUtils.squeeze ("a  bbbbbb     c dd", "b d") );
        
	}
	
	public void objectUtilsDemo(){
		System.out.println(StringUtils.center(" objectUtilsDemo ", 40,"="));
		System.out.println ("Object为null时，默认打印某字符.");
		Object object = null;
		System.out.println(ObjectUtils.defaultIfNull(object,"object is null "));
		
		System.out.println ("验证两个引用是否指向的Object是否相等,取决于Object的equals()方法.");
		Object a = new Object();
		Object b = a;
		Object c = new Object();
		System.out.println(ObjectUtils.equals(a, b));
		System.out.println(ObjectUtils.equals(a, c));
		
		System.out.println ("用父类Object的toString()方法返回对象信息.");
		Date date = new Date();
		System.out.println(ObjectUtils.identityToString(date));
		System.out.println(date);
		
		System.out.println ("返回类本身的toString()方法结果,对象为null时，返回0长度字符串.");
		System.out.println (ObjectUtils.toString (date) );
		System.out.println (ObjectUtils.toString (null) );
		System.out.println (date);
	}
	
	public void serializationUtilsDemo(){
		System.out.println(StringUtils.center(" serializationUtilsDemo ", 40, "="));
		Date date = new Date();
		byte[] bytes = SerializationUtils.serialize(date);
		System.out.println(ArrayUtils.toString(bytes));
		System.out.println (date);
		
		Date reDate = (Date)SerializationUtils.deserialize(bytes);
		System.out.println(reDate);
		System.out.println(ObjectUtils.equals(date, reDate));
		System.out.println(date == reDate);
		
		FileOutputStream fos = null;
		FileInputStream fis = null;
		
		try {
			fos = new FileOutputStream(new File("D:" + File.separator + "test.txt"));
			fis = new FileInputStream(new File("D:" + File.separator + "test.txt"));
			SerializationUtils.serialize(date,fos);
			Date reDate2 = (Date)SerializationUtils.deserialize(fis);
			System.out.println(date.equals(reDate2));
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				fos.close();
				fis.close();
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
	}
	
	public void randomStringUtilsDemo(){
		System.out.println(StringUtils.center(" randomStringUtilsDemo ", 40, "="));
		System.out.println("生成指定长度的随机字符串,好像没什么用");
		System.out.println(RandomStringUtils.random(500));
		
		System.out.println ("在指定字符串中生成长度为n的随机字符串.");
		System.out.println(RandomStringUtils.random(5, "reafgaby"));
		
		System.out.println ("指定从字符或数字中生成随机字符串.");
		System.out.println(RandomStringUtils.random(5,true,false));
		System.out.println(RandomStringUtils.random(5,false,true));
	}
	
	public void stringUtilsDemo(){
		System.out.println(StringUtils.center(" stringUtilsDemo ", 40, "="));
		System.out.println ("将字符串重复n次，将文字按某宽度居中，将字符串数组用某字符串连接.");
		String[] header = new String[3];
		header[0] = StringUtils.repeat("*", 50);
		header[1] = StringUtils.center(" StringUtils ", 50,"^o^");
		header[2] = header[0] ;
		String head = StringUtils.join(header,"\n");
		System.out.println(head);
		
		System.out.println ("缩短到某长度,用...结尾.");
		System.out.println (StringUtils.abbreviate (
                "The quick brown fox jumps over the lazy dog.", 10) );
		
		System.out.println ("返回两字符串不同处索引号.");
        System.out.println (StringUtils.indexOfDifference ("aaabc", "aaacc") );
        
        System.out.println ("返回两字符串不同处开始至结束.");
        System.out.println (StringUtils.difference ("aaabcde", "aaaccde") );
        
        System.out.println ("截去字符串为以指定字符串结尾的部分.");
        System.out.println (StringUtils.chomp ("aaabcde", "de") );
        
        System.out.println ("检查一字符串是否为另一字符串的子集.");
        System.out.println (StringUtils.containsOnly ("aad", "aadd") );
        
        System.out.println ("检查一字符串是否包含另一字符串.");
        System.out.println (StringUtils.contains ("defg", "ef") );
        System.out.println (StringUtils.containsOnly ("ef", "defg") );
        
        System.out.println ("返回可以处理null的toString().");
        System.out.println (StringUtils.defaultString ("aaaa") );
        System.out.println ("?" + StringUtils.defaultString (null) + "!");
        
        System.out.println ("去除字符中的空格.");
        System.out.println (StringUtils.deleteWhitespace ("aa  bb  cc") );
        
        System.out.println ("分隔符处理成数组.");
        String[] strArray = StringUtils.split ("a,b,,c,d,null,e", ",");
        System.out.println (strArray.length);
        System.out.println (strArray.toString() );
        
        System.out.println ("判断是否是某类字符.");
        System.out.println (StringUtils.isAlpha ("ab") );
        System.out.println (StringUtils.isAlphanumeric ("12") );
        System.out.println (StringUtils.isBlank ("") );
        System.out.println (StringUtils.isNumeric ("123") );
	}
	
	
	public void systemUtilsDemo(){
		System.out.println(StringUtils.center(" systemUtilsDemo ", 40, "="));
		System.out.println ("获得系统文件分隔符.");
		System.out.println(SystemUtils.FILE_SEPARATOR);
		
		System.out.println ("获得源文件编码.");
		System.out.println(SystemUtils.FILE_ENCODING);
		
        System.out.println ("获得ext目录.");
        System.out.println(SystemUtils.JAVA_EXT_DIRS);
        
        System.out.println ("获得java版本.");
        System.out.println (SystemUtils.JAVA_VM_VERSION);
        
        System.out.println ("获得java厂商.");
        System.out.println (SystemUtils.JAVA_VENDOR);
        
        
	}
	
	public void classUtilsDemo(){
		System.out.println(StringUtils.center(" classUtilsDemo ", 40, "="));
		System.out.println ("获取类实现的所有接口.");
		System.out.println(ClassUtils.getAllInterfaces(Date.class));
		
		System.out.println ("获取类所有父类.");
		System.out.println(ClassUtils.getAllSuperclasses(Date.class));
		
		System.out.println ("获取简单类名.");
		System.out.println(ClassUtils.getSimpleName(Date.class));
		
		System.out.println ("获取包名.");
		System.out.println(ClassUtils.getPackageName(Date.class));
		
		System.out.println ("判断是否可以转型.");
		System.out.println(ClassUtils.isAssignable(Date.class, Object.class));
		System.out.println(ClassUtils.isAssignable(Object.class, Date.class));
	}
	
	public void stringEscapeUtilsDemo(){
		System.out.println(StringUtils.center(" stringEscapeUtilsDemo ", 40,"="));
		System.out.println("转换特殊字符.");
		System.out.println("html : " + StringEscapeUtils.escapeHtml3(" "));
		System.out.println("html : " + StringEscapeUtils.escapeHtml4(" "));
		System.out.println("html : " + StringEscapeUtils.unescapeHtml3("<p>"));
		System.out.println("html : " + StringEscapeUtils.unescapeHtml4("<p>"));
		
	}
	
	
	private final class BuildDemo{
		String name;
		int age;
		
		public BuildDemo (String name, int age) {
            this.name = name;
            this.age = age;
        }
		 public String toString() {
	            ToStringBuilder tsb = new ToStringBuilder (this, ToStringStyle.MULTI_LINE_STYLE);
	            tsb.append ("Name", name);
	            tsb.append ("Age", age);
	            return tsb.toString();
	        }
	 
	        public int hashCode() {
	            HashCodeBuilder hcb = new HashCodeBuilder();
	            hcb.append (name);
	            hcb.append (age);
	            return hcb.hashCode();
	        }
	 
	        public boolean equals (Object obj) {
	            if (! (obj instanceof BuildDemo) ) {
	                return false;
	            }
	            BuildDemo bd = (BuildDemo) obj;
	            EqualsBuilder eb = new EqualsBuilder();
	            eb.append (name, bd.name);
	            eb.append (age, bd.age);
	            return eb.isEquals();
	        }
	}
	
	public void builderDemo(){
		System.out.println(StringUtils.center(" builderDemo ", 40, "="));
		
		BuildDemo buildDemo = new BuildDemo("a", 1);
		BuildDemo buildDemo2 = new BuildDemo("b", 2);
		BuildDemo buildDemo3 = new BuildDemo("a", 1);
		
		System.out.println(" toString() ");
		System.out.println(buildDemo);
		System.out.println(buildDemo2);
		System.out.println(buildDemo3);
		
		System.out.println ("hashCode()");
		System.out.println (buildDemo.hashCode() );
		System.out.println (buildDemo2.hashCode() );
		System.out.println (buildDemo3.hashCode() );
		
		System.out.println ("equals()");
		System.out.println (buildDemo.equals (buildDemo2) );
		System.out.println (buildDemo.equals (buildDemo3) );
	}
	
	public void numberUtils(){
		System.out.println(StringUtils.center(" numberUtils  ", 40, "="));
		System.out.println ("字符串转为数字(不知道有什么用).");
		System.out.println(NumberUtils.toInt("ba",33));
		
		System.out.println ("从数组中选出最大值.");
		System.out.println (NumberUtils.max (new int[] { 1, 2, 3, 4 }) );
		
		System.out.println ("判断字符串是否全是整数.");
		System.out.println (NumberUtils.isDigits ("123.1") );
		System.out.println (NumberUtils.isDigits ("123") );
		
		System.out.println ("判断字符串是否是有效数字.");
		System.out.println (NumberUtils.isNumber ("0123.1") );
		System.out.println (NumberUtils.isNumber ("123.1") );
	}
	
	public void dateFormatUtilsDemo(){
		System.out.println(StringUtils.center(" dateFormatUtilsDemo ", 40, "="));
		System.out.println ("格式化日期输出.");
		//System.out.println (DateFormatUtils.format (System.currentTimeMillis(), "yyyy-MM-dd HH:mm:ss") );
		
		System.out.println ("秒表.");
        StopWatch sw = new StopWatch();
        sw.start();
        
        for (Iterator iterator = DateUtils.iterator (new Date(), DateUtils.RANGE_WEEK_CENTER); iterator.hasNext();) {
            Calendar cal = (Calendar) iterator.next();
            System.out.println (DateFormatUtils.format (cal.getTime(),
                                "yy-MM-dd HH:mm") );
        }
 
        sw.stop();
        System.out.println ("秒表计时:" + sw.getTime() );
	}
	
	private void validateDemo() {
        String[] strarray = {"a", "b", "c"};
        System.out.println ("验证功能");
        System.out.println (Validate.notEmpty (strarray) );
    }

	 private void wordUtilsDemo() {
		 System.out.println(StringUtils.center(" wordUtilsDemo ", 40, "="));
		 System.out.println ("单词处理功能");
		 String str1 = "wOrD";
		 String str2 = "ghj\nui\tpo";
		 
		 System.out.println (WordUtils.capitalize (str1) ); //首字母大写
		 System.out.println (WordUtils.capitalizeFully (str1) ); //首字母大写其它字母小写
		 
		 char[] ctrg = {'.'};
		 System.out.println (WordUtils.capitalizeFully ("i aM.fine", ctrg) ); //在规则地方转换
		 System.out.println (WordUtils.initials (str1) ); //获取首字母
		 System.out.println (WordUtils.initials ("Ben John Lee", null) ); //取每个单词的首字母
		
		 char[] ctr = {' ', '.'};
		 System.out.println (WordUtils.initials ("Ben J.Lee", ctr) ); //按指定规则获取首字母
		 System.out.println (WordUtils.swapCase (str1) ); //大小写逆转
		 System.out.println (WordUtils.wrap (str2, 1) ); //解析\n和\t等字符
	 }
	
	public static void main(String[] args) {
		LangDemoTest langDemo = new LangDemoTest();
		
		//langDemo.charSetDemo();
		//langDemo.charSetUtilsDemo();
		//langDemo.objectUtilsDemo();
		//langDemo.serializationUtilsDemo();
		//langDemo.randomStringUtilsDemo();
		//langDemo.stringUtilsDemo();
		//langDemo.systemUtilsDemo();
		//langDemo.classUtilsDemo();
		//langDemo.stringEscapeUtilsDemo();
		//langDemo.builderDemo();
		//langDemo.numberUtils();
		//langDemo.dateFormatUtilsDemo();
		//langDemo.validateDemo();
		langDemo.wordUtilsDemo();
	}
}

package cn.cd.sg.sort;

import java.util.TreeMap;
import java.util.Map.Entry;

public class TestTreeMap {
	public static void main(String[] args) {
		TreeMap<Person, String> treeMap = new TreeMap<Person, String>();
		treeMap.put(new Person("zhangsan",21), "90");  
		treeMap.put(new Person("lisi",33), "10");  
		treeMap.put(new Person("wangwu",22), "30");  
		treeMap.put(new Person("zhaoliu",55), "50"); 
		
		 //使用entrySet遍历map  
		for (Entry<Person, String> entry : treeMap.entrySet()) {  
		    Person person = entry.getKey();  
		    System.out.println(person);  
		}
	}
}




package cn.cd.sg.sort;

public class Person implements Comparable<Person>{

	private String name;  
    private int age;
    	
    
    
    
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}


	@Override
	public int compareTo(Person o) {
		if (this.age > o.age) {
			return -1;
		}else if (this.age == o.age) {
			return 0;
		}else {
			return 1;
		}
		
//		if (this.name.equals(o.name)) {
//			return 0;
//		}else if (!this.name.equals(o.name)) {
//			return -1;
//		}else {
//			return 1;
//		}
	}


	@Override
	public String toString() {
		return "Person [age=" + age + ", name=" + name + "]";
	}


	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}




package cn.cd.sg.sort;

import java.util.Comparator;
import java.util.TreeMap;

public class TestTreeMap2 {
	
	public static void main(String[] args) {
		
		TreeMap<Person2, String> map2 = new TreeMap<Person2, String>(new Comparator<Person2>() {
			
			@Override
			public int compare(Person2 o1, Person2 o2) {
				if (o1.getAge()>o2.getAge()) {  
					return -1;  
				}else if (o1.getAge()<o2.getAge()) {  
					return 1;  
				}  
				return 0;  
			}
		});
		 map2.put(new Person2("aaa",21), "90");  
		 map2.put(new Person2("bbb",33), "10");  
		 map2.put(new Person2("ccc",22), "30");  
		 map2.put(new Person2("ddd",55), "50");  
		 //通过keySet遍历map 如果只要获取值直接通过map2.values  
		 for(Person2 key : map2.keySet()){  
		     System.out.println(key.getName()+" "+key.getAge());  
		 }  
	}
	
}



package cn.cd.sg.sort;

public class Person2 {
	private String name;
	private int age;

	public Person2(String name, int age) {
		this.age = age;
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}



package cn.cd.sg.sort;

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

public class TestTreeMap3 {
	
	
	@SuppressWarnings("unchecked")
	public static Map.Entry<String,Integer>[] getSortedHashtableByValue(Map map){
		Set set = map.entrySet();
		Map.Entry<String, Integer>[] entries =  (Entry<String, Integer>[]) set.toArray(new Map.Entry[set.size()]);
		Arrays.sort(entries,new Comparator() {
			@Override
			public int compare(Object arg0, Object arg1) {
				Long key1 = Long.valueOf(((Map.Entry) arg0).getValue().toString());  
				Long key2 = Long.valueOf(((Map.Entry) arg1).getValue().toString());  
				return key1.compareTo(key2);
			}  
	    });
		
		return entries; 
	}
	
	
	public static void main(String[] args) {
	    Map<String, Integer> score = new HashMap<String, Integer>();  
	    score.put("yzq", 21);  
	    score.put("yzh", 23);  
	    score.put("yhf", 11);  
	    score.put("ysq", 45);  
	    Map.Entry<String, Integer>[] entries = getSortedHashtableByValue(score);  
	    for (Entry<String, Integer> entry : entries) {  
	        String key = entry.getKey();  
	        Integer value = entry.getValue();  
	        System.out.println(key+":"+value);  
	    }  
	}
}

package com.supinfo.core.web;

import java.util.HashMap;

/**
* 描述：用于MyBatis参数  传递封转  Map
* 项目名称：jnschool2   
* 类名称：Parameter   
* 创建人：孙刚   
* 创建时间：2014-2-25 上午10:21:03   
* 修改人1：xxx     
* 修改时间1：xxxx-xx-xx 
* 修改备注：   
* @version  1.0
 */
public class Parameter extends HashMap<String, Object>{

	private static final long serialVersionUID = -2912662164421350185L;
		
	/**
	* 描述  : 创建参数
	* 方法名: createParameter
	* 创建人：孙刚   
	* 创建时间：2014-2-25 上午10:24:09
	* @param key
	* @param value
	* @return ：Parameter
	 */
	public static Parameter createParameter(String key,Object value){
		return new Parameter().addParameter(key, value);
	}
	
	/**
	 * 
	* 描述  : 用来封装多个参数, 并实现连接操作 
	* 方法名: addParameter
	* 创建人：孙刚   
	* 创建时间：2014-2-25 上午10:25:34
	* @param key
	* @param value
	* @return  
	* @return ：Parameter
	 */
	public Parameter addParameter(String key,Object value){
		this.put(key, value);
		return this;
	}
}

//创建 SVN windows服务自动开启

binpath是你SVN服务端 安装位置

-r 是指你资源库指定目录

sc create MySVNServer binpath= "D:/svnService/Subversion/bin/svnserve.exe --service -r D:/svnService/svnRepoRoot/jieneng"  
displayname= "SVNService" depend= Tcpip start= auto

package cn.cd.sg.test.qita2;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

public class BackupMysql {
	
	/*
	 * 数据库用户名
	 */
	private String username;
	private String password;// 数据库密码
	private String dbname;// 需要备份的数据库名
	private String ip = "localhost"; //主机IP 
	private String charset = "utf-8";//编码格式
	private String backupPath; // 存放备份文件的路径
	private String mysqlpath; //mysql安装位置

	private String stmt;
	
	
	public BackupMysql(String username, String password, String dbname,
			String ip, String charset,String mysqlpath,String backupPath) {
		
		this.username = username;
		this.password = password;
		this.dbname = dbname;
		if (ip == null || ip.equals("")){
			this.ip = "localhost";
		}else{
			this.ip = ip;
		}
		if (charset == null || charset.equals("")){
			this.charset = " "; 
		}else{
			this.charset = " --default-character-set=" + charset;
		}
		this.mysqlpath = mysqlpath;
		this.backupPath = this.getRandomFileName(backupPath);
		
		this.stmt = mysqlpath + "\\mysqldump " + this.dbname+ " -h "
				+ this.ip + " -u" + this.username + " -p" + this.password
				+ this.charset + " --result-file=" + this.backupPath;
	}

	
	
	public boolean run() {
		boolean run_result = false;
		try {
			Runtime.getRuntime().exec(this.stmt);
			run_result = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return run_result;
	}
	
	
	public String getRandomFileName(String backupPath){
		Date now = new Date();
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		String random = format.format(now);
		String dbName = random + ".sql";
		File file = new File(backupPath);
		if (!file.exists()) {
			file.mkdirs();
		}
		dbName = backupPath + File.separator + dbName;
		return dbName;
	}
	
	
	
	 public static void main(String[] args){
		 	BackupMysql backup=new BackupMysql("root","root","jnschool",null,"utf8","C:\\Program Files\\MySQL\\MySQL Server 5.5\\bin","d:\\db\\dbBack");
	        boolean result = backup.run();
	        if(result)
	            System.out.println("备份成功");        

	    }
}

package cn.cd.sg.zip.utils;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Date;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;

import org.apache.log4j.Logger;

/**
* @Description:文件 压缩、解压工具(主要是 使用的java.util.zip.*工具)
* 项目名称：utils   
* 类名称：ZipUtils2   
* 创建人：孙刚   
* 创建时间： 
* 修改人1：xxx     
* 修改时间1：xxxx-xx-xx 
* 修改备注：   
* @version  1.0
 */
public class ZipUtils2 {
	
	private static final int BUFFER = 2048;

	private final static Logger logger = Logger.getLogger(ZipUtils2.class);
	/**
	* @Description: 把一个zip文件解压在一个指定的目录中
	* 注意：该解压后的目录，已经去掉了zip包的根目录
	* 方法名: zipToFolder
	* @param ： @param zFile
	* @param ： @param folder
	* @return void 
	* @throws
	 */
	public static void zipToFolder(File zFile, String folder) throws Exception{
		
		String baseDir = folder;
		ZipFile zfile = new ZipFile(zFile);
		Enumeration<?> zList = zfile.entries();
		ZipEntry ze = null;
		OutputStream os = null;
		InputStream is = null;
		try {
			while (zList.hasMoreElements()){
				ze = (ZipEntry) zList.nextElement();
				if (ze.isDirectory()) {
					logger.debug("Dir: " + ze.getName() + " skipped..");
					continue;
				}
				os =  new BufferedOutputStream(new FileOutputStream(getRealFileName(baseDir,ze.getName())));
				is = new BufferedInputStream(zfile.getInputStream(ze));
				int readLen = 0;
				int buffSize = 1024;
				byte[] buf = new byte[buffSize];
				while ((readLen = is.read(buf, 0, BUFFER)) != -1){
					os.write(buf, 0, readLen);
				}	
			}
		} catch (Exception e) {
			
		}finally{
			if (is != null)
			{
				is.close();
			}
			if (os != null)
			{
				os.close();
			}
		}
	}
	/**
	* @Description: 将文件夹filesFolder的内容打包到zipFilePath路径,绝对路径
	* 方法名: getCompressToZip</p>
	* @param ：filesFolder  要打包的
	* @param ：zipFilePath  打包到哪里
	* @param ：zipFileName  打包名字
	* @return File    返回类型
	* @throws
	 */
	public static File getCompressToZip(String filesFolder,String zipFilePath,String zipFileName){
		
		File baseFolder = new File(filesFolder);
		ZipOutputStream zos = null;
		String _zipFileName = zipFileName + ".zip";
		File zipFile = new File(zipFilePath, _zipFileName);
		try {
			if (!zipFile.exists()) {
				File parentfolder = zipFile.getParentFile();
				if (!parentfolder.exists()){
					parentfolder.mkdirs();
				}
				zipFile.createNewFile();
			}
			zos = new ZipOutputStream(new FileOutputStream(zipFile));
			// 将文件夹压缩为的zip文件, 去掉第一层目录
			File[] listFiles = baseFolder.listFiles();
			int listFilesSize = listFiles.length;
			for (int i = 0; i < listFilesSize; i++) {
				zipFiles(zos, listFiles[i], "");
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if (zos != null) {
				try {
					zos.flush();
					zos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return zipFile;
	}
	
	/**
	* @Description: 定义压缩文件及目录为zip文件的方法
	* 方法名: zipFiles
	* @param ：zos
	* @param ：file
	* @return void   
	* @throws
	 */
	public static void zipFiles(ZipOutputStream zos, File file, String baseDir) {
		FileInputStream in = null;
		String fileName = file.getName();
		
		try {
			// 判断File是否为目录
			if (file.isDirectory()) {
				// 获取file目录下所有文件及目录,作为一个File数组返回
				File[] files = file.listFiles();
				baseDir =  baseDir.length() == 0 ? "" : baseDir;
				String entryName = baseDir + fileName + "/";
				zos.putNextEntry(new ZipEntry(entryName));
				int subFileSize = files.length;
				for (int i = 0; i < subFileSize; i++) {
					zipFiles(zos, files[i], entryName);
				}
			}else {
				zos.putNextEntry(new ZipEntry(baseDir + fileName));
				in = new FileInputStream(file);
				int lenth = 0;
				int buffSize = 1024;
				byte[] buff = new byte[buffSize];
				while ((lenth = in.read(buff, 0, buffSize)) != -1) {
					zos.write(buff, 0, lenth);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if (in != null){
				try {
					in.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	/**
	* @Description:给定根目录，返回一个相对路径所对应的实际文件名. 注意：该解压后的目录，已经去掉了其根目录
	* 方法名: getRealFileName
	* @param ：baseDir 指定根目录
	* @param ：absFileName  相对路径名，来自于ZipEntry中的name
	* @return File 
	* @throws
	 */
	public static File getRealFileName(String baseDir, String absFileName){
		String[] dirs = absFileName.split("/");
		File ret = new File(baseDir);
		
		if (dirs.length > 1) {
			for (int i = 0; i < dirs.length; i++) {
				ret = new File(ret, dirs[i]);
			}
		}
		if (!ret.exists()) {
			ret.mkdirs();
		}
		
		ret = new File(ret, dirs[dirs.length - 1]);
		
		return ret;
	}
	
	
	public static void main(String[] args) {
		Date d1 = new Date();
		try {
			getCompressToZip("D:\\test1", "E:\\test2", "aaa");
			
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		Date d2 = new Date();
		System.out.println(d2.getTime() - d1.getTime() / 1000 + "s");
	}
}

package cn.cd.sg.zip.utils;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Enumeration;
import java.util.zip.CRC32;
import java.util.zip.CheckedOutputStream;

import org.apache.tools.zip.ZipEntry;
import org.apache.tools.zip.ZipFile;
import org.apache.tools.zip.ZipOutputStream;

/**
* @Description:文件 压缩、解压工具(主要是 使用的org.apache.tools.zip.*工具)
* 项目名称：utils   
* 类名称：ZipUtils   
* 创建人：孙刚   
* 创建时间：
* 修改人1：xxx     
* 修改时间1：xxxx-xx-xx 
* 修改备注：   
* @version  1.0
 */
public class ZipUtils {
	
	public static final String FILE_SEPARATOR = System.getProperty("file.separator");
	
	
	/**
	* @Description: 压缩一个文件
	* 方法名: zipFile
	* @param ：filePath  文件路径，  
	* @param ：zipPath  压缩到的指定位置
	* @return boolean
	 */
	public static boolean zipFile(String filePath,String zipPath){
		
		BufferedReader in = null;
		ZipOutputStream out = null;
		
		try {
			File file = new File(filePath);
			in = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"UTF-8"));
			FileOutputStream f =new FileOutputStream(zipPath);
			CheckedOutputStream checkedOutputStream = new CheckedOutputStream(f, new CRC32());
			out = new ZipOutputStream(new BufferedOutputStream(checkedOutputStream));
			
			int c ;
			
			out.putNextEntry(new ZipEntry(file.getName()));
			
			while ((c = in.read()) != -1) {
				out.write(c);
			}
		} catch (Exception e) {
			 e.printStackTrace();
             return false;
		}finally{
			try {
				 if(in!=null) in.close();				      
				 if(out!=null)  out.close();
			} catch (IOException e) {				
				e.printStackTrace();				
			}  
		}
		return true;
	}
	
	/**
	* @Description:  将指定的文件解压缩到指定的文件夹，解压后的文件夹目录和给定的压缩文件名相同.
	* 方法名: unZipFile
	* @param ：zipFilePath 压缩文件全路径
	* @param ： unZipDirectory   指定解压位置路径
	* @return boolean  
	 */
	public static boolean unZipFile(String zipFilePath, String unZipDirectory)throws IOException {
		
		ZipFile zipFile = new ZipFile(zipFilePath);
		Enumeration<?> entries = zipFile.getEntries();
		if (null == entries) {
			return false;
		}
		while (entries.hasMoreElements()) {
			ZipEntry zipEntry = (ZipEntry)entries.nextElement();
			File file = new File(unZipDirectory + FILE_SEPARATOR + zipEntry.getName());
			if (zipEntry.isDirectory()) {
				if (!file.exists() && !file.mkdirs())
					throw new IOException("Couldn't create directory: " + file);
			}else {
				BufferedInputStream is = null;
				BufferedOutputStream os = null;
				
				try {
					is = new BufferedInputStream(zipFile.getInputStream(zipEntry));
					
					File destDir = file.getParentFile();
					if (!destDir.exists() && !destDir.mkdirs()) {
						throw new IOException("Couldn't create dir " + destDir);
					}
					
					os = new BufferedOutputStream(new FileOutputStream(file));
					
					int b = -1;
					while ((b = is.read()) != -1) {
						os.write(b);
					}
					
				} catch (Exception e) {
					e.printStackTrace();
				}finally{
					if (is != null)
						is.close();
					if (os != null)
						os.close();
				}
			}
		}
		zipFile.close();
		return true;
	}
	
	/**
	* @Description:压缩一个  目录
	* 方法名: zipDirectory
	* @param ：dir  压缩的目录
	* @param ：zipPath  压缩到的指定位置
	* @return boolean  
	* @throws
	 */
	public static boolean zipDirectory(String dir,String zipPath ){
		
		ZipOutputStream out = null;
		try {
			File dirFile = new File(dir);
			if(!dirFile.isDirectory()){
				return false;	
			}
			FileOutputStream f = new FileOutputStream(zipPath);
			CheckedOutputStream ch = new CheckedOutputStream(f,new CRC32());
			out = new ZipOutputStream(new BufferedOutputStream(ch));
			
			zip(out, dirFile, "");
			
		} catch (Exception e) {
			 e.printStackTrace();
             return false;
		}finally{
			 try {						      
				 if(out!=null)  out.close();				 
			} catch (IOException e) {				
				e.printStackTrace();				
			}   
		}
		return true;
	}
	
	
	private static void zip(ZipOutputStream out,File f,String base)throws Exception{
		System.out.println("Zipping  "+f.getName());
		BufferedInputStream in = null;
		try {
			if (f.isDirectory()) {
				File[] fl = f.listFiles();
				out.putNextEntry(new ZipEntry(base + "/"));
				base = base.length() == 0 ? "" : base + "/";
				for (int i = 0;i < fl.length ;i++ )	{
					zip(out,fl[i],base+fl[i].getName());
				}
			}else {
				out.putNextEntry(new org.apache.tools.zip.ZipEntry(base));
				FileInputStream is = new FileInputStream(f);
				//修改BUG!二进制输出采用buffered
				in = new BufferedInputStream(is);
				int b;
				while ((b=in.read()) != -1){
					out.write(b);
				}
			}
		} catch (Exception e) {
			
		}finally{
			if (null != in) {
				in.close();
			}
		}
	}
	
	 public static void main(String[] args){
	     //	boolean f = zipFile("d:/计量设备.xls","d:/计量设备.zip");
	         //boolean f = zipDirectory("D:/","d:/计量设备.zip");
	        
	         //System.out.println(f);
			 try {
				 unZipFile("d:/计量设备.zip", "D:\\");
				//zipDirectory("F:\\list","F:\\list.zip");
			} catch (Exception e) {			
				e.printStackTrace();			
			}
	         
		 }
}

package cn.cd.sg.validate.utils;

import java.util.Collection;
import java.util.Map;

import org.apache.log4j.Logger;

import cn.cd.sg.collection.utils.CollectionUtils;
import cn.cd.sg.object.utils.ObjectUtils;
import cn.cd.sg.string.utils.StringUtils;
public class Validate {
	
	/**
	 * log4j DEBUG输出级别
	 */
	public static final int DEBUG = 1;

	/**
	 * log4j INFO输出级别
	 */
	public static final int INFO = 2;

	/**
	 * log4j ERROR输出级别
	 */
	public static final int ERROR = 3;

	/**
	 * log4j WARN输出级别
	 */
	public static final int WARN = 4;

	
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: isTrue
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:03:31
	* @param expression
	* @param message  
	* @return ：void
	 */
	public static void isTrue(boolean expression, String message) {
		if (!expression) {
			throw new IllegalArgumentException(message);
		}
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: isTrue
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:03:36
	* @param expression  
	* @return ：void
	 */
	public static void isTrue(boolean expression) {
		isTrue(expression, "[Assertion failed] - this expression must be true");
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: isNull
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:03:40
	* @param object
	* @param message  
	* @return ：void
	 */
	public static void isNull(Object object, String message) {
		if (object != null) {
			throw new IllegalArgumentException(message);
		}
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: isNull
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:03:44
	* @param object  
	* @return ：void
	 */
	public static void isNull(Object object) {
		isNull(object, "[Assertion failed] - the object argument must be null");
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: notNull
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:03:50
	* @param object
	* @param message  
	* @return ：void
	 */
	public static void notNull(Object object, String message) {
		if (object == null) {
			throw new IllegalArgumentException(message);
		}
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: notNull
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:03:56
	* @param object  
	* @return ：void
	 */
	public static void notNull(Object object) {
		notNull(object, "[Assertion failed] - this argument is required; it must not be null");
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: hasLength
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:04:00
	* @param text
	* @param message  
	* @return ：void
	 */
	public static void hasLength(String text, String message) {
		if (!StringUtils.hasLength(text)) {
			throw new IllegalArgumentException(message);
		}
	}
	/**
	 * 
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: hasLength
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:04:07
	* @param text  
	* @return ：void
	 */
	public static void hasLength(String text) {
		hasLength(text,"[Assertion failed] - this String argument must have length; it must not be null or empty");
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: hasText
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:04:15
	* @param text
	* @param message  
	* @return ：void
	 */
	public static void hasText(String text, String message) {
		if (!StringUtils.hasText(text)) {
			throw new IllegalArgumentException(message);
		}
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: hasText
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:04:19
	* @param text  
	* @return ：void
	 */
	public static void hasText(String text) {
		hasText(text,"[Assertion failed] - this String argument must have text; it must not be null, empty, or blank");
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: doesNotContain
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:04:25
	* @param textToSearch
	* @param substring
	* @param message  
	* @return ：void
	 */
	public static void doesNotContain(String textToSearch, String substring, String message) {
		if (StringUtils.hasLength(textToSearch) && StringUtils.hasLength(substring) &&
				textToSearch.indexOf(substring) != -1) {
			throw new IllegalArgumentException(message);
		}
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: doesNotContain
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:04:34
	* @param textToSearch
	* @param substring  
	* @return ：void
	 */
	public static void doesNotContain(String textToSearch, String substring) {
		doesNotContain(textToSearch, substring,"[Assertion failed] - this String argument must not contain the substring [" + substring + "]");
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: notEmpty
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:04:40
	* @param array
	* @param message  
	* @return ：void
	 */
	public static void notEmpty(Object[] array, String message) {
		if (ObjectUtils.isEmpty(array)) {
			throw new IllegalArgumentException(message);
		}
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: notEmpty
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:04:44
	* @param array  
	* @return ：void
	 */
	public static void notEmpty(Object[] array) {
		notEmpty(array, "[Assertion failed] - this array must not be empty: it must contain at least 1 element");
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: noNullElements
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:04:48
	* @param array
	* @param message  
	* @return ：void
	 */
	public static void noNullElements(Object[] array, String message) {
		if (array != null) {
			for (int i = 0; i < array.length; i++) {
				if (array[i] == null) {
					throw new IllegalArgumentException(message);
				}
			}
		}
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: noNullElements
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:04:53
	* @param array  
	* @return ：void
	 */
	public static void noNullElements(Object[] array) {
		noNullElements(array, "[Assertion failed] - this array must not contain any null elements");
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: notEmpty
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:04:58
	* @param collection
	* @param message  
	* @return ：void
	 */
	@SuppressWarnings("unchecked")
	public static void notEmpty(Collection collection, String message) {
		if (CollectionUtils.isEmpty(collection)) {
			throw new IllegalArgumentException(message);
		}
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: notEmpty
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:05:03
	* @param collection  
	* @return ：void
	 */
	@SuppressWarnings("unchecked")
	public static void notEmpty(Collection collection) {
		notEmpty(collection,
				"[Assertion failed] - this collection must not be empty: it must contain at least 1 element");
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: notEmpty
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:05:09
	* @param map
	* @param message  
	* @return ：void
	 */
	@SuppressWarnings("unchecked")
	public static void notEmpty(Map map, String message) {
		if (CollectionUtils.isEmpty(map)) {
			throw new IllegalArgumentException(message);
		}
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: notEmpty
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:05:14
	* @param map  
	* @return ：void
	 */
	@SuppressWarnings("unchecked")
	public static void notEmpty(Map map) {
		notEmpty(map, "[Assertion failed] - this map must not be empty; it must contain at least one entry");
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: isInstanceOf
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:05:19
	* @param clazz
	* @param obj  
	* @return ：void
	 */
	@SuppressWarnings("unchecked")
	public static void isInstanceOf(Class clazz, Object obj) {
		isInstanceOf(clazz, obj, "");
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: isInstanceOf
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:05:23
	* @param type
	* @param obj
	* @param message  
	* @return ：void
	 */
	@SuppressWarnings("unchecked")
	public static void isInstanceOf(Class type, Object obj, String message) {
		notNull(type, "Type to check against must not be null");
		if (!type.isInstance(obj)) {
			throw new IllegalArgumentException(message +
					"Object of class [" + (obj != null ? obj.getClass().getName() : "null") +
					"] must be an instance of " + type);
		}
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: isAssignable
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:05:28
	* @param superType
	* @param subType  
	* @return ：void
	 */
	@SuppressWarnings("unchecked")
	public static void isAssignable(Class superType, Class subType) {
		isAssignable(superType, subType, "");
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: isAssignable
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:05:33
	* @param superType
	* @param subType
	* @param message  
	* @return ：void
	 */
	@SuppressWarnings("unchecked")
	public static void isAssignable(Class superType, Class subType, String message) {
		notNull(superType, "Type to check against must not be null");
		if (subType == null || !superType.isAssignableFrom(subType)) {
			throw new IllegalArgumentException(message + subType + " is not assignable to " + superType);
		}
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: state
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:05:37
	* @param expression
	* @param message  
	* @return ：void
	 */
	public static void state(boolean expression, String message) {
		if (!expression) {
			throw new IllegalStateException(message);
		}
	}
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: state
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:05:42
	* @param expression  
	* @return ：void
	 */
	public static void state(boolean expression) {
		state(expression, "[Assertion failed] - this state invariant must be true");
	}
	
	/**
	* 描述  : (这里用一句话描述这个方法的作用)
	* 方法名: log4j
	* 创建人：孙刚   
	* 创建时间：2014-1-21 下午05:05:46
	* @param className
	* @param category
	* @param msg  
	* @return ：void
	 */
	public static <T> void log4j(String className, int category, String msg) {
		Logger log = Logger.getLogger(className);
		switch (category) {
		case DEBUG:
			log.debug(msg);
			break;

		case INFO:

			log.info(msg);
			break;

		case ERROR:
			log.error(msg);
			break;

		case WARN:
			log.warn(msg);
			break;

		default:
			log.debug(msg);
		}
	}
}