又虚度了一年,没啥成就,庆幸的是体重增长了3斤,,目标很近啦.

    得赶紧找个女朋友了,这一年一年,一个人过的太不像样子了

    一个人过也好,两个人一起生活也好,这日子总要过的开开心心的:

          以粗荼淡饭养胃,清新空气洗洗肺,找群朋友喝个醉,像猫咪那样睡一睡!

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

上周问题:

      日志分析在hadoop-hdfs/hadoop-local这2个不同的环境测试中得到的结果数据不一样

原因:

      经过多方面的测试,发现LogStorage implements ReversibleLoadStoreFunc这个类在计算vid和uid结果时丢失了部分数据,而pv数据没丢失,有2点:

      1.LogStorage这个自定义类有2个功能,一是字段分割,二是过滤少于23个字段,而内置的PigStorage()只作分割用,在pig中的每个自定义方法只能有一个功能?这里最值得怀疑

      1.pig脚本中,vid.pig比pv.pig多几个"FILTER"内置方法,其他部分大同小异

目前解决方法:

      1.不使用自定义分割方法,使用内置的PigStorage("分割符")

      2.FILTER A BY ARITY(*) == 23;使用此方法先把不满足23个字段条件的过滤掉,回头拿几天的数据测试一下每天

!=23的日志有多少条,占多少比重,如果这个数值比较小的话,可以忽略不计

贴出LogStorage类的2个主要方法,觉得有问题的请指正:

	int temp = 0;
	public Tuple getNext() throws IOException {
		if (is == null || is.getPosition() > end) {
			return null;
		}
		String line;
		if ((line = is.readLine(UTF8, delimiter)) == null) {
			return null;
		} else {
			Hashtable ht = Split.split(line, "|");
			
			if (ht.size() != 23) {
				temp++;
				return null;
			}
			StringBuilder sb = new StringBuilder();
			for(int i=0;i<ht.size();i++){
				sb.append(ht.get(i));
				sb.append("\t");
			}
			return new Tuple(sb.substring(0, sb.length() - 1), fieldDel);
		}
	}

	private String customParser(Matcher matcher) {
		StringBuilder sb = new StringBuilder();
		int last = matcher.groupCount();
		for (int i = 1; i <= last; i++) {
			sb.append(matcher.group(i));
			sb.append("\t");
		}
		return sb.substring(0, sb.length() - 1);
	}

 下一个急需要解决的问题是如何优化hadoop的MapReduce性能.

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

1. 本周接上周的工作,完成将pig生成的文件计算结果存入数据库的应用
2. 测试pig过程中发现日志文件中有异常日志记录(不满21个属性),写了个自定义的LogStorage implements ReversibleLoadStoreFunc方法过滤异常日志,每天的异常日志记录不超过1000条,应该可忽略

3. 发现日志分析在hadoop-hdfs/hadoop-local这2个不同的环境测试中得到的结果数据不一样,出现hadoop-hdfs数据丢失的情况,而且2个测试结果均少于CMS系统分析出来的结果,目前原因不明,待进一步分析

简单说明:

        hadoop-hdfs:单独启动hadoop,命令指向hadoop的conf文件夹(hadoop-site.xml文件),并将日志copyFromLocal到hdfs中,使用如下命令执行pig脚本

                                java -cp pig.jar:/home/quan/opt/hadoop/conf org.apache.pig.Main uid.pig

        hadoop-local:不单独启动hadoop,由pig直接调用hadoop17.jar中的相关方法,使用如下命令执行pig脚本

                                java -cp pig.jar org.apache.pig.Main -x local uid.pig

例:求每天的pv,ipsum,vid,uid,以 2008-07-17日志测试

       hadoop-local的结果是:6185568(pv),562160(ipsum),904271(vid),796874(uid)

       hadoop-hdfs的结果是 :6185518(pv),562160(ipsum),875835(vid),772799(uid)

下面是计算uid count,vid计算相同

--uid count

REGISTER udfs.jar;
A = LOAD '2008-07-17' using quan.pig.udfs.LogStorage() AS (null,ip,time,checkpoint,refer,appname,language,os,repeatip,vrepeatip,rtime,uid);
B = FILTER A BY uid neq '' and time neq '';
BB = FILTER B BY quan.pig.udfs.NonInt(uid);
generateUid = FOREACH BB GENERATE uid,time;
groupUid = GROUP generateUid by uid;
uid = FOREACH groupUid GENERATE $0,COUNT($1) as cont;
ssss = ORDER uid BY cont;
STORE ssss INTO 'res/uid-hdfs.txt';

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

       本周工作仍是研究pig,对pig源码包里的部分测试用例在本机运行测试,从中学习pig脚本与udfs接合使用技巧,以深入学习pig
       在根据现有analyze CMS系统中的某些需求(如:按天查询用户PV/查询时间段内单个用户PV数/每个用户在网站上的平均停留时间等),编写pig+udfs例子进行测试
       目前来看,使用pig来直接分析日志,在很多需求下,pig只能得到一个接近结果的中间值或文本文件,需要我们再编写少量的代码来分析并计算这个中间文件,从而得到期望结果.
       根据现在的使用情况来看,在使用pig编写脚本时,需要注意在获取log文件中的某些字段值进行分析之前,一定要先把该字段的空值或类型不匹配的记录过滤掉才能使用,这样计算出来的结果可能与实际值有误差(貌似较小);

       下面是一个计算一天中每个用户在网站的停留时间的简单pig脚本:

REGISTER udfs.jar;
A = LOAD 'LOGFILE' using PigStorage('|') AS (null,ip,time,checkpoint,refer,appname,language,os,repeatip,vrepeatip,rtime,uid,first_refer,vid,showp,afid,ucode,zzz,znh,sendshow,current_refer,browser_info);
B = filter A by ip neq '' and time neq '' and vid neq '' and vid neq '0';
BB = FILTER B BY quan.pig.udfs.NonInt(vid);
C = FOREACH BB GENERATE ip,time,vid;
D = GROUP C BY vid;
E = FOREACH D GENERATE $0,COUNT($1),$1.$1;
MAX_F = FOREACH E GENERATE $0,$1,quan.pig.udfs.MaxtimeFuc($2);
MIN_F = FOREACH E GENERATE $0,$1,quan.pig.udfs.MintimeFuc($2);
G = GOGROUP MAX_F BY $0,MIN_F BY $0;
H = FOREACH G GENERATE $0,$1.$2-$2.$2;
--dump H;
STORE H INTO 'H.txt';

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

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

Yahoo Pig 是一个运行在Hadoop（Doug Cutting 在06年3月份加入了Yahoo ）上的并行处理架构，有了Pig 使得普通的程序员具有了分析处理gigantic数据集的能力。
Pig目前还是apache的一个孵化器项目,
Pig 主页:http://incubator.apache.org/pig/
Pig wiki:http://wiki.apache.org/pig/
Yahoo Pig 有如下特点：
1、专注于于大量数据集分析（ad-hoc analysis ， ad-hoc 代表：a solution that has been custom designed for a specific problem ）；
2、运行在集群的计算架构上，Yahoo Pig 提供了多层抽象，简化并行计算让普通用户使用；这些抽象完成自动把用户请求queries翻译成有效的并行评估计划，然后在物理集群上执行这些计划；
3、提供类似 SQL 的操作语法；
4、开放源代码；

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

hadoop已经发布0.17.1版本,只是修复0.17.0的一些bug
hbase也经过一个多月的改进,也发布了0.1.3版本,这个版本在上一个0.1.2的基础上修复了20个bug,还提高了一些性能方面的改进,官方建议升级到最新,但遗憾的是,hbase0.1.3目前还只是支持hadoop0.16.3版本,期待

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

我们来简单了解如何操作hbase,hbase与我们常用的数据库最大的差别就是列存储和无数据类型,所有数据都以string类型存储,再有如果hbase table里有5个字段,但实际只有4个字段有值,那么为null的那个字段是不占用空间的,这点比较好,可以跟我们常用的数据库比较下
首先还是创建一个表,暂不使用mapreduce:

/**
 * 定义几个常量
 */
public static HBaseConfiguration conf = new HBaseConfiguration();
static HTable table = null;
/**
 * 创建hbase table
 * @param table
 * @throws IOException
 */
public static void creatTable(String tablename) throws IOException {
	HBaseAdmin admin = new HBaseAdmin(conf);
	if (!admin.tableExists(new Text(tablename))) {
		HTableDescriptor tableDesc = new HTableDescriptor(tablename);
		tableDesc.addFamily(new HColumnDescriptor("ip:"));
		tableDesc.addFamily(new HColumnDescriptor("time:"));
		tableDesc.addFamily(new HColumnDescriptor("type:"));
		tableDesc.addFamily(new HColumnDescriptor("cookie:"));
		//注意这个C列,下面我会简单以此列来说明列存储
		tableDesc.addFamily(new HColumnDescriptor("c:"));
		admin.createTable(tableDesc);
		System.out.println("table create ok!!!");
	} else {
		System.out.println("table Already exists");
	}
}

 将hadoop/hbase都启动再运行,在hql中使用"desc tablename"就可以看出这个表有5个字段,下面我们再来往这个表里录入点数据,上面说过值为空的字段是不占用空间的,这里还要注意点,经过我的测试,如果发现这个字段无值,就不要往hbase里面写null值,当然你要真往这个字段存null值是不会有任何问题的,但你查询这个有null值的字段时,会有点毛病,当然这个我也不知道怎么描述,有兴趣的可以试试看,所以我下面有判断,再者,hbase table里面的每一行数据集都必须有一个唯一row关键字,这个row你可以随便定义,方便准确找到你需要的数据

/**
 * 录入数据
 * @throws Exception
 */
public static void insertData() throws Exception{
	//读取日志文件
	BufferedReader reader = new BufferedReader(new FileReader("log file name"));
	if(table==null)
		table = new HTable(conf, new Text(tablename));
	String line;
	while((line = reader.readLine()) != null){
		//这里我就不说了,先前有说明
		LogAccess log = new LogAccess(line);
		//这里我使用time+cookie为row关键字,确保不重复,如果cookie记录有重复,将区别对待,这里暂不多做说明
		String row = createRow(log.getTime(),log.getCookie());
		
		long lockid = table.startUpdate(new Text(row));
		if(!log.getIp().equals("") && log.getIp()!=null)
			table.put(lockid, new Text("ip:"), log.getIp().getBytes());
		if(!log.getTime().equals("") && log.getTime()!=null)
			table.put(lockid, new Text("time:"), log.getTime().getBytes());
		if(!log.getType().equals("") && log.getType()!=null)
			table.put(lockid, new Text("type:"), log.getType().getBytes());
		if(!log.getCookie().equals("") && log.getCookie()!=null)
			table.put(lockid, new Text("cookie:"), log.getCookie().getBytes());
		//这里要注意,我是往c列中写入了5个字段,你可以想象,我在c列中存入了一个map
		if(!log.getRegmark().equals("") && log.getRegmark()!=null)
			table.put(lockid, new Text("c:_regmark"), log.getRegmark().getBytes());
		if(!log.getRegmark2().equals("") && log.getRegmark2()!=null)
			table.put(lockid, new Text("c:_regmark2"), log.getRegmark2().getBytes());
		if(!log.getSendshow().equals("") && log.getSendshow()!=null)
			table.put(lockid, new Text("c:_sendshow"), log.getSendshow().getBytes());
		if(!log.getCurrenturl().equals("") && log.getCurrenturl()!=null)
			table.put(lockid, new Text("c:_currenturl"), log.getCurrenturl().getBytes());
		if(!log.getAgent().equals("") && log.getAgent()!=null)
			table.put(lockid, new Text("c:_agent"), log.getAgent().getBytes());
		//存入数据
		table.commit(lockid);
	}
}

O了,测试下吧

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

hadoop都到0.17了，hbase还只是支持0.16.3，这点比较郁闷

首先hbase是必须运行在hadoop的dfs之上，可以看看这篇翻译文章 ，英语好的话可直接看wiki
如果你了解Google的分布式文件系统，那么就应该知道hbase就是java版的bigtable开源实现，这里有介绍bigtable的论文翻译 ，我们可以从这篇文章大概了解一下hbase的数据结构，我们可以把hbase理解为一个多维的排序的map,想深入了解hbase的数据结构，可以研究这篇文章：Understanding HBase and BigTable ，具体的就不说了，其实我也没太懂：)
启动hbase：<HADOOP_HOME>/contrib/hbase/bin/start-hbase.sh（记得先启动hadoop阿）
进入hql：<HADOOP_HOME>/contrib/hbase/bin/hbase shell
有关hql的操作，wiki有简单的说明（http://wiki.apache.org/hadoop/HRDF/HQL），具体的还需要我们在实际应用中去发现。如果经常使用mysql的话，应该对hql不陌生，有些语句是跟mysql是一样的：show tables/desc tablename等等
我们还可以通过Web方式来访问hbase－http://360quan-1:60010,能正常打开的话，点击第一个“HQL”链接,就可以写hql语句了。

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

在 Eclipse 环境下可以方便地进行 Hadoop 并行程序的开发和调试。推荐使用 IBM MapReduce Tools for Eclipse, 使用这个 Eclipse plugin 可以简化开发和部署 Hadoop 并行程序的过程。
具体说明这里有篇文章：
http://www.ibm.com/developerworks/cn/opensource/os-cn-hadoop2/index.html
关于hadoop自带的WordCount示例程序的分析，上面这个篇文章有很详细的说明，
这里以我们的实际需求：分析日志来简单测试一下,网站apache产生的日志文件经过解析，每条记录会生成以‘｜’符号分割的21个字段，如：｜1｜2｜3｜4｜5｜6｜......21｜这个形式的日志文件，而WordCount是以空格来区隔每个单词来计算的，所以我们要修改map方法中的StringTokenizer,让其以‘｜’分割计算：

public static class StringTokenizers extends StringTokenizer{
	public StringTokenizers(String str) {
		super(str, "[|]\n\r\f", false);
	}
}

这样就ok了

但这个例子会把这21个字段都进行统计，实际工作只需要统计某些列就行了，假如第13列表示唯一cookie数字值，只要用户访问了网站哪个页面，都会记录下来，这里要求计算这个用户每小时/每天/每月访问网站的url次数，我们进一步修改，首先建立一个logbean，这个bean有21个属性，分别代表日志文件中的21个字段，构造函数分别给这些属性赋值：

public class logbean {
	private String ip;
	private String time;
	private String type;
	private String cookie;
	//...
	public logbean(String line) throws Exception{
		Hashtable ret = null;
		if(line != null){
			ret = Split.split(line, "|");
			this.ip = ret.get(1).toString();
			this.time = ret.get(2).toString();
			this.type = ret.get(3).toString();
			this.cookie = ret.get(13).toString();
			//...
		}
	}
	//other get set
}
/**
 *按照‘｜’分割字符串
 */
public static Hashtable split(String fieldsru, String tag){  
	Hashtable returnarray = new Hashtable();  
	char dot = tag.charAt(0);  
	String field;  
	field = fieldsru + dot;  
	int num = 0;  
	int field_len = field.length();  
	for (int i = 0; i < field_len; i++)  
	{  
		if (field.charAt(i) == dot)  
		{  
			num++;  
		}  
	} 
	int begin = 0;  
	int end;  
	for (int j = 0; j < num; j++)  
	{  	
		end = field.indexOf(dot, begin);  
		returnarray.put(new Integer(j), field.substring(begin, end));  
		begin = end + 1;  
	}  
	return returnarray;  
}	
/**我们再修改WordCount中的map方法
   * value 是文本文件中的一行，利用 StringTokenizer 将这个字符串拆成单词，
   * 然后将输出结果 <单词,1> 写入到 org.apache.hadoop.mapred.OutputCollector 中
   */
public void map(LongWritable key, Text value,
		OutputCollector<Text, IntWritable> output, Reporter reporter)
		throws IOException {
	String line = value.toString();
	String l = "";
	String regEx = "\\d+";
	if (line != null) {
		try{					
			LogAccess log = new LogAccess(line);
			if(!log.getCookie().equals("") && log.getCookie() != null 
					&& Pattern.matches(regEx,log.getCookie()))
				l = log.getCookie().toString();
			
		}catch(Exception e){
			//e.printStackTrace();
		}
		StringTokenizer itr = new StringTokenizer(l);
		while (itr.hasMoreTokens()) {
			word.set(itr.nextToken());
			output.collect(word, one);
		}
	}

}

 好了，在运行WordCount时，别忘了添加2个参数：/temp/in(要统计的文件存放目录)   /temp/out(输出结果目录)

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

最近研究hadoop，由于hbase0.12的lib包里面包含的是hadoop0.16.3，如果没打算研究hbase的话，建议下载hadoop0.17版本，相对稳定些。故我们就使用hadoop0.16.3版本来安装学习。网上有几篇文章讲解如何安装，但都有这样那样的问题，下面就以我们的安装步骤来说明
1、硬件环境
    我们采用了3台机器来构建,都安装的是Ubuntu8.04系统，并且都有一个名为“quan“的帐号，如下：
           主机名称：360quan-1    ip:192.168.0.37        功能：NameNode,JobTracker
           主机名称：360quan-2    ip:192.168.0.43        功能：DataNode,TaskTracker
           主机名称：360quan-3    ip:192.168.0.53        功能：DataNode,TaskTracker
    重点：修改3台机器的/etc/hosts,让彼此的主机名称和ip都能顺利解析
          127.0.0.1       localhost
          192.168.0.37    360quan-1
          192.168.0.43    360quan-2
          192.168.0.53    360quan-3
2、每台机器都要安装java环境，我们的路径统一为“/opt/jdk1.6.0_03“,并添加到系统环境变量 sudo gedit /etc/profile

       JAVA_HOME=/opt/jdk1.6.0_03
	CLASSPATH=$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:.
	PATH=$JAVA_HOME/bin:$PATH
	export JAVA_HOME
	export CLASSPATH
	export PATH

 3、下载hadoop0.16.3，hbase0.12版本到"360quan-1"，将hadoop解压到/home/quan/opt/hadoop,hbase解压到hadoop/contrib/hbase。建议最好也将hadoop的目录添加到环境变量里面去:

       HADOOP_HOME=/home/quan/opt/hadoop	＃这是hadoop的主目录
	export HADOOP_HOME
	HADOOP_CONF_DIR=$HADOOP_HOME/conf	＃这是hadoop的配置文件目录
	export HADOOP_CONF_DIR
	HADOOP_LOG_DIR=/home/quan/hadoop/log	＃存放运行日志目录
	export HADOOP_LOG_DIR
	HADOOP_SSH_OPTS="-p 22"			＃SSH的端口号，其实默认就是22
	export HADOOP_SSH_OPTS	

 4、安装ssh,这里注意ubuntu8.04下面是ssh2，如果是ssh1的话，请升级,安装完后，建立ssh通道，使用空密码（生产环境可不能使用空密码啊），这里使用“360quan-1”这台机器为例说明:

       sudo apt-get install ssh
	ssh-keygen -t dsa -P '' -f ~/.ssh/id_dsa 
	cat ~/.ssh/id_dsa.pub >> ~/.ssh/authorized_keys

      以上配置完成后，执行一下ssh localhsot,确认你的每台机器都可以使用ssh（不需要密码）连接，连接成功后会输出以下信息：

       Linux zhangqiaohui-desktop 2.6.24-19-generic #1 SMP Wed Jun 4 16:35:01 UTC 2008 i686
	The programs included with the Ubuntu system are free software;
	the exact distribution terms for each program are described in the
	individual files in /usr/share/doc/*/copyright.
	Ubuntu comes with ABSOLUTELY NO WARRANTY, to the extent permitted by
	applicable law.
	To access official Ubuntu documentation, please visit:
	http://help.ubuntu.com/
	Last login: Thu Jun 12 10:40:50 2008 from localhost

     ok后，我们将“360quan-1”机器上产生的这个空密钥拷贝到另外2台机器上，作为公共密钥，让namenode也可以不需要密码访问2台datanode:

       sudo scp authorized_keys 360quan-2:/home/quan/.ssh/ 
	sudo scp authorized_keys 360quan-3:/home/quan/.ssh/ 
	ssh 360quan-2
	ssh 360quan-3

 5、接下来，我们要修改hadoop的相关设定了。修改"360quan-1"上面的hadoop的[conf/masters]、[conf/slaves]这2个文件：

       Master设置(<HADOOP_HOME>/conf/masters) :360quan-1
       Slave设置(<HADOOP_HOME>/conf/slaves) L：360quan-2 360quan-3
6、修改［conf/hadoop-env.sh］：

       export JAVA_HOME=/opt/jdk1.6.0_03

7、修改［conf/hadoop-site.xml],这里只是几个常用的属性配置，有关hadoop的性能优化调整，需要研究hadoop-default.xml:

<configuration>
		<property>
			<name>fs.default.name</name>
			<value>360quan-1:9000</value>
			<description>指定NameNode的IP地址和端口号,缺省值是file:///, 表示使用本地文件系统, 用于单机非分布式模式</description>
		</property>
		<property>
			<name>mapred.job.tracker</name>
			<value>360quan-1:9001</value>
			<description>指定 JobTracker的IP地址和端口号。缺省值是local, 表示在本地同一Java进程内执行JobTracker和TaskTracker, 用于单机非分布式模式</description>
		</property>
		<property>
			<name>dfs.replication</name>
			<value>1</value>
			<description>指定HDFS中每Block被复制的次数，起数据冗余备份的作用。在典型的生产系统中，这个数常常设置为3。</description>
		</property>
		<property>
			<name>hadoop.tmp.dir</name>
			<value>/home/quan/opt/hadoop/tmp/</value>
		</property>
	</configuration>

 8、修改hbase的[hbase-evn.sh]:
        export JAVA_HOME=/opt/jdk1.6.0_03
9、修改hbase的［hbase-site.xml］:

<configuration>
		<property>
			<name>hbase.master</name>
			<value>360quan-1:60000</value>
		</property>
		<property>
			<name>hbase.rootdir</name>
			<value>hdfs://360quan-1:9000/hbase</value>
		</property>
</configuration>

 10、然后将hadoop的整体环境拷贝到360quan-2、360quan-3上面去
          scp -r /home/quan/hadoop 360quan-2:/home/hdp/
          scp -r /home/quan/hadoop 360quan-3:/home/hdp/
11、在360quan-1这个namenode上面格式化一个新的分布式文件系统HDFS，就是hadoop-site.xml文件中指定的hadoop.tmp.dir路径
         <HADOOP_HOME>/bin/hadoop namenode -format
    
到此大致上就完成了属于你自己的Cloud Computing环境了
        启动hadoop：<HADOOP_HOME>/bin/start-all.sh
        启动hbase：<HADOOP_HOME>/contrib/hbase/bin/start-hbase.sh
        停止hbase：<HADOOP_HOME>/contrib/hbase/bin/stop-hbase.sh
        停止hadoop：<HADOOP_HOME>/bin/stop-all.sh
说明：
    (1) 执行 $ bin/start-all.sh启动Hadoop进程后，会启动5个java进程,同时会在/tmp目录下创建五个pid文件记录这些进程ID号。通过这五个文件，可以得知namenode,datanode,secondary namenode,jobtracker,tasktracker 分别对应于哪一个Java进程。当你觉得 Hadoop 工作不正常时，可以首先查看这5个java进程是否在正常运行,运行jps命令也可以查看。
    (2) 访问 http://360quan-1:50030 可以查看JobTracker的运行状态。访问 http://360quan-1:50060可以查看 TaskTracker的运行状态。访问 http://360quan-1:50070可以查看NameNode以及整个分布式文件系统的状态，浏览分布式文件系统中的文件以及log等。
    (3) 查看 ${HADOOP_HOME}/logs目录下的log文件，namenode,datanode,secondary namenode,jobtracker, tasktracker各有一个对应的log文件，每一次运行的计算任务也有对应用log文件。分析这些log文件有助于找到故障原因。

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

split方法不能按照“｜”符号分割？汗，今天才知道，笨呀
没办法，只能想想办法了

public static Hashtable split(String fieldsru, String tag)  
{  
	Hashtable returnarray = new Hashtable();  
	char dot = tag.charAt(0);  
	String field;  
	field = fieldsru + dot;  
	int num = 0;  
	int field_len = field.length();  
	for (int i = 0; i < field_len; i++)  
	{  
		if (field.charAt(i) == dot)  
		{  
			num++;  
		}  
	}  
	int begin = 0;  
	int end;  
	for (int j = 0; j < num; j++)  
	{  	
		end = field.indexOf(dot, begin);  
		returnarray.put(new Integer(j), field.substring(begin, end));  
		begin = end + 1;  
	}  

	return returnarray;  
}

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

摘自10658000手机尾号8666的信息

活着真好，莫在意钱多钱少，汶川的震波，分不清你是乞丐还是富豪；
活着真好，莫计较权大权小，汶川的楼板，不认识你头顶着几尺官帽；
活着真好，莫为身外之物、世态炎凉烦恼，汶川的废墟，掩埋了多少豪情壮志、俗事纷扰；
活着真好，请记住这汶川的分分秒秒，幸存的生命，再次演绎了爱的伟大、情的崇高；
请记住我在时时刻刻为你祈祷，珍惜这份情、这份爱，你会活的更好！

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

1.http://my.donews.com/eraera/2006/09/26/swogzstwtqdnwlfrzgsljctkjsbrtuiumxzj/

2.http://my.donews.com/eraera/2006/09/27/gvzwfjvzagmxymaynvemdgwgfjgzicnxnwps/

3.http://my.donews.com/eraera/2006/09/28/feahrnvxnoquabudxnkxuvbbvdbkkflvfftt/

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

Hadoop HDFS结构与设计的翻译文档，见附件

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

org.apache.hadoop.conf      定义了系统参数的配置文件处理 API 。

org.apache.hadoop.fs           定义了抽象的文件系统 API 。

org.apache.hadoop.dfs        Hadoop 分布式文件系统（ HDFS ）模块的实现。

org.apache.hadoop.io          定义了通用的 I/O API ，用于针对网络，数据库，文件等数据对象做读写操作。

org.apache.hadoop.ipc        用于网络服务端和客户端的工具，封装了网络异步 I/O 的基础模块。

org.apache.hadoop.mapred          Hadoop 分布式计算系统（ MapReduce ）模块的实现，包括任务的分发调度等。

org.apache.hadoop.metrics         定义了用于性能统计信息的 API ，主要用于 mapred 和 dfs 模块。

org.apache.hadoop.record           定义了针对记录的 I/O API 类以及一个记录描述语言翻译器，用于简化将记录序列化成语言中性的格式（ language-neutral manner ）。

org.apache.hadoop.tools     定义了一些通用的工具。

org.apache.hadoop.util        定义了一些公用的 API 。

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

Hadoop是什么
Hadoop是一个用于运行应用程序在大型集群的廉价硬件设备上的框架。Hadoop为应用程序透明的提供了一组稳定/可靠的接口和数据运动。在Hadoop中实现了Google的MapReduce算法，它能够把应用程序分割成许多很小的工作单元，每个单元可以在任何集群节点上执行或重复执行。此外，Hadoop还提供一个分布式文件系统用来在各个计算节点上存储数据，并提供了对数据读写的高吞吐率。由于应用了map/reduce和分布式文件系统使得Hadoop框架具有高容错性，它会自动处理失败节点。已经在具有600个节点的集群测试过Hadoop框架。
目前Hadoop受到Yahoo的支持，有Yahoo员工长期工作在项目上，而且Yahoo内部也准备使用Hadoop代替原来的基于FreeBSD的系统。
Hadoop实现了HDFS文件系统和MapRecue。目前版本是0.16。还不成熟，但是已经可以在2000个节点上运行。用户只要继承MapReduceBase，提供分别实现Map和Reduce的两个类，并注册Job即可自动分布式运行。
HDFS把节点分成两类：NameNode和DataNode。NameNode是唯一的，程序与之通信，然后从DataNode上存取文件。这些操作是透明的，与普通的文件系统API没有区别。
项目主页：
            http://hadoop.apache.org
            http://ydn.krugle.com/kse/files?query=hadoop#3
文档主页：
            http://www.handandaily.com/hadoop/docs/
Hadoop学习安装部署 ：
            http://www.cnblogs.com/wayne1017/archive/2007/03/20/678724.html
            http://blog.chinajavaworld.com/entry/4424/0/
hadoop学习FileSystem类：
            http://www.cnweblog.com/nm1504/archive/2007/08/27/249592.html
Hadoop Learning and Inside学习：
            http://blog.csdn.net/ycl111/archive/2006/09/04/1176124.aspx
Hadoop-- 开源海量文件分布式计算处理方案：
            http://hi.baidu.com/ge_geshuai/blog/item/e8fc7a2ca02a93ed8b139942.html
Yahoo's Hadoop Support：
            http://developer.yahoo.net/blog/archives/2007/07/yahoo-hadoop.html

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

获取当前日期所在星期的7个日期，记下来，以后用得着：

Date date = new Date();
SimpleDateFormat dateformat = new SimpleDateFormat("yyyyMMdd");
Calendar c = new GregorianCalendar();
c.setFirstDayOfWeek(Calendar.MONDAY-1);
c.setTime(date);
String[] d = new String[7];
for(int i=0;i<7;i++){        	
      c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()+i);
      d[i] = dateformat.format(c.getTime());
      System.out.println(d[i]);
}

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

    今天离职了,一切都是那么顺利,手续办完的那一刻,我知道我是时候该休息休息了.

    总是把工作当成一种谋生的渠道，任何一场经历，无非是学习,应用,工作的一个循环而已，行业如何，职务如何，报酬如何，环境如何，一切的一切，到最后用算盘珠子拨上一拨，吃饱了，还过的不错，是我要的生活，O了。可能朋友们都说我太天真了,没错,我心里就是这么想的,可是一个男人怎么能只顾自己吃饱喝足呢?还有很多事情压在我的头上,等待我去解决,不过,休息的时候还是好好歇歇吧,干嘛去想那些烦心事呢!任何事情都会有解决办法的.

    我是快乐的

    因为我自由了

    我是快乐的

    因为我脱离了电脑

    我是快乐的

    因为接下来就是我的假期

    我是快乐的

    可我为什么快乐不起来呢???

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

Aptana studio 1.1 pro是收费的,下载后可以免费使用30天,下面这个破解方法很好用:)

下载地址:http://www.aptana.com   (建议下载exe安装文件,避免出现不可预知的异常)

支持中文的方法 ：在Windows 菜单 → Preferences → General → Content Types，选择 Text ，在下方指定默认编码为UTF-8后update，并在File associations下面添加文件类型，如 *.js.如果文档的编码不是UTF-8 就指定成相应的编码。不过还是建议使用 UTF-8 编码。

Aptana studio pro 破解方法:使用附件中的2个class文件替换掉plugins\com.aptana.ide.core_1.1.0.007007.jar(后面的版本号可能会有所不一样,不用管它,只要找到com.aptana.ide.core_开头就行了),这个文件可以用WINRAR打开.在RAR的 com.aptana.ide.core_1.1.0.007007.jar\com\aptana\ide\core\licensing路径下

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

号外,号外:

       本人J2EE方向开发已经2年半了,最近因为某些原因,想换一个工作环境,如果有能让我给其公司奉献2年以上或更久时间的合适职位, 请各位朋友帮忙推荐一下.十分感谢!

工作地点:北京(主要),上海,杭州,深圳

联系方式:

    MSN:zqh.xl@msn.com

    QQ:77427691

    EMAIL:qiaohui.zhang@gmail.com

哪位朋友能帮忙推荐的话,烦请通过以上联系方式联系我,我将呈上我的个人简历.

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

最近项目中使用Spring+iBatis,其中用到的公共dao记录在此 

/**

 * 数据库Dao必须继承的接口，该接口定义了DaoTemplate的Set和Get方法

 * 其他dao继承IBaseDao后自动获得CRUD等功能 

 */

public interface IBaseDao {

	public void setDaoTemplate(IBatisDaoTemplate template);

	public IBatisDaoTemplate getDaoTemplate();

	/**

	 * 更新数据

	 * @param statementName

	 * @param paramMap

	 */

	public int update(String statementName,Map paramMap);

	/**

	 * 添加数据

	 * @param statementName

	 * @param paramMap

	 * @return

	 */

	public Object save(String statementName,Map paramMap);

	/**

	 * 根据条件查询一条数据

	 * @param statementName

	 * @param paramMap

	 * @return

	 */

	public Object load(String statementName,Map paramMap);

	/**

	 * 根据条件查询数据

	 * @param statementName

	 * @param paramMap

	 * @return

	 */

	public List searchAll(String statementName,Map paramMap);

	/**

	 * 根据条件分页查询数据

	 * @param statementName

	 * @param paramMap

	 * @param pageNum

	 * @param recoderNum

	 * @return

	 */

	public List searchPage(String statementName,Map paramMap,int pageNum,int recoderNum);

	/**

	 * 删除符合条件的记录

	 * @param statementName

	 * @param paramMap

	 * @return

	 */

	public int delete(String statementName,Map paramMap);

}

/** 

 * IBaseDao的实现 

 * 

 */  

public class BaseDaoImpl implements IBaseDao {

	private IBatisDaoTemplate template;

	public IBatisDaoTemplate getDaoTemplate() {

		return this.template;

	}

	public void setDaoTemplate(IBatisDaoTemplate template) {

		this.template=template;

	}

	/**

	 * 更新数据

	 * @param statementName

	 * @param paramMap

	 */

	public int update(String statementName,Map paramMap){

		return this.template.update(statementName, paramMap);

	}

	/**

	 * 添加数据

	 * @param statementName

	 * @param paramMap

	 * @return

	 */

	public Object save(String statementName,Map paramMap){

		return this.template.save(statementName, paramMap);

	}

	/**

	 * 根据条件查询一条数据

	 * @param statementName

	 * @param paramMap

	 * @return

	 */

	public Object load(String statementName,Map paramMap){

		return this.template.load(statementName, paramMap);

	}

	/**

	 * 根据条件查询数据

	 * @param statementName

	 * @param paramMap

	 * @return

	 */

	public List searchAll(String statementName,Map paramMap){

		return this.template.searchAll(statementName, paramMap);

	}

	/**

	 * 根据条件分页查询数据

	 * @param statementName

	 * @param paramMap

	 * @param pageNum

	 * @param recoderNum

	 * @return

	 */

	public List searchPage(String statementName,Map paramMap,int pageNum,int recoderNum){

		return this.template.searchPage(statementName, paramMap, pageNum,recoderNum);

	}

	/**

	 * 删除符合条件的记录

	 * @param statementName

	 * @param paramMap

	 * @return

	 */

	public int delete(String statementName,Map paramMap){

		return this.template.delete(statementName, paramMap);

	}

}

/**

 * 利用IBatis操作数据库实现的模版类，Dao通过注入进行调用

 *

 */

public class IBatisDaoTemplate extends SqlMapClientDaoSupport {

	/**

	 * 更新数据

	 * @param statementName

	 * @param paramMap

	 */

	public int update(String statementName,Map paramMap){

		return this.getSqlMapClientTemplate().update(statementName, paramMap);

	}

	/**

	 * 添加数据

	 * @param statementName

	 * @param paramMap

	 * @return

	 */

	public Object save(String statementName,Map paramMap){

		return getSqlMapClientTemplate().insert(statementName, paramMap);

	}

	/**

	 * 根据条件查询一条数据

	 * @param statementName

	 * @param paramMap

	 * @return

	 */

	public Object load(String statementName,Map paramMap){

		return getSqlMapClientTemplate().queryForObject(statementName, paramMap);

	}

	/**

	 * 根据条件查询数据

	 * @param statementName

	 * @param paramMap

	 * @return

	 */

	public List searchAll(String statementName,Map paramMap){

		return this.getSqlMapClientTemplate().queryForList(statementName, paramMap);

	}

	/**

	 * 根据条件分页查询数据

	 * @param statementName

	 * @param paramMap

	 * @param pageNum

	 * @param recoderNum

	 * @return

	 */

	public List searchPage(String statementName,Map paramMap,int pageNum,int recoderNum){

		return this.getSqlMapClientTemplate().queryForList(statementName, pageNum, pageNum*recoderNum,(pageNum+1)*recoderNum);

	}

	/**

	 * 删除符合条件的记录

	 * @param statementName

	 * @param paramMap

	 * @return

	 */

	public int delete(String statementName,Map paramMap){

		return this.getSqlMapClientTemplate().delete(statementName, paramMap);

	}

}

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

接上篇------>设计模式学习之复合模式(1)

我们为什么不将创建鸭子的程序集中在一个地方呢?换句话说,让我们将创建和装饰的部分包装起来,这看起来像是什么模式?
10.我们需要一些质量控制来确保鸭子一定是被包装起来的,需要建造一个工厂创建装饰过的鸭子.此工厂应该生产各种不同类型的鸭子的产品家族,使用我们使用抽象工厂模式.

//定义一个抽象工厂,它的子类会创建不同的家族
public abstract class AbstractDuckFactory {
	//每个方法创建一种鸭子
	public abstract Quackable createMallardDuck();
	public abstract Quackable createRedheadDuck();
	public abstract Quackable createDuckCall();
	public abstract Quackable createRubberDuck();
}
//创建一个工厂,此工厂创建没有装饰者的鸭子
public class DuckFactory extends AbstractDuckFactory {
	//每个方法创建一个产品,一种特定种类的Quackable.
	//模拟器并不知道实际的产品是什么,只知道它实现了Quackable接口
	public Quackable createMallardDuck() {
		return new MallardDuck();
	}
	public Quackable createRedheadDuck() {
		return new RedheadDuck();
	}
	public Quackable createDuckCall() {
		return new DuckCall();
	}
	public Quackable createRubberDuck() {
		return new RubberDuck();
	}
}
//现在,要创建我们真正需要的工厂
public class CountingDuckFactory extends AbstractDuckFactory {
	//每个方法都会先用叫声计数装饰者将Quackable包装进来.模拟器并不知道有何不同,
	//只知道它实现了Quackable接口,所有的叫声都会被计算进去
	public Quackable createMallardDuck() {
		return new QuackCounter(new MallardDuck());
	}
	public Quackable createRedheadDuck() {
		return new QuackCounter(new RedheadDuck());
	}
	public Quackable createDuckCall() {
		return new QuackCounter(new DuckCall());
	}
	public Quackable createRubberDuck() {
		return new QuackCounter(new RubberDuck());
	}
}

11.我们修改模拟器来使用这个工厂

public class DuckSimulator {
	public static void main(String[] args) {
		DuckSimulator simulator = new DuckSimulator();
		//首先我们创建工厂,准备把它传入simulate方法
		AbstractDuckFactory duckFactory = new CountingDuckFactory();
		simulator.simulate(duckFactory);
	}
	//simulate需要一个AbstractDuckFactory参数,利用它来创建鸭子,而不是直接实例化鸭子
	void simulate(AbstractDuckFactory duckFactory) {
		Quackable redheadDuck = duckFactory.createMallardDuck();
		Quackable redheadDuck = duckFactory.createRedheadDuck();
		Quackable duckCall = duckFactory.createDuckCall();
		Quackable rubberDuck = duckFactory.createRubberDuck();
		Quackable gooseDuck = new GooseAdapter(new Goose());
		//这里不改动
		simulate(mallardDuck);
		simulate(redheadDuck);
		simulate(duckCall);
		simulate(rubberDuck);
		simulate(gooseDuck);
		System.out.println("The ducks quacked "+QuackCounter.getQuacks()+" times");
	}
	void simulate(Quackable duck) {
		duck.quack();
	}
}

测试...
看到这里,你不觉得分别管理这些不同的鸭子变得有些困难吗?有什么办法帮我们作为一个整体来管理这些鸭子,甚至让我们管理几个想持续追踪的鸭子家族吗?下一次命令就能够让整个集合的鸭子听命行事,什么模式可以帮我们?
还记得吗,组合模式允许我们像对待单个对象一样对待对象集合.
12.让我们创建一群鸭子,实际上是一群Quackable

//别忘了,组合需要和叶节点元素一样实现相同的接口,这里的叶节点就是'Quackable'
public class Flock implements Quackable {
	//在每个flock内,我们使用ArrayList记录属于这个flock的Quackable对象
	ArrayList quackers = new ArrayList();
	//用add方法新增Quackable对象到flock
	public void add(Quackable quacker) {
		quackers.add(quacker);
	}
	//注意到了吗,这里我们其实还使用了迭代器模式
	public void quack() {
		Iterator iterator = quackers.iterator();
		while (iterator.hasNext()) {
			Quackable quacker = (Quackable)iterator.next();
			//毕竟flock也是Quackable,所以也要具备quack方法,此方法会对整群产生作用
			//我们遍历ArrayList调用每个元素上的quack方法
			quacker.quack();
		}
	}
}

13.我们的组合已经准备好了,我们需要一些让鸭子能进入组合的代码,再来修改模拟器

public class DuckSimulator {
	public static void main(String[] args) {
		DuckSimulator simulator = new DuckSimulator();
		//首先我们创建工厂,准备把它传入simulate方法
		AbstractDuckFactory duckFactory = new CountingDuckFactory();
		simulator.simulate(duckFactory);
	}
	//simulate需要一个AbstractDuckFactory参数,利用它来创建鸭子,而不是直接实例化鸭子
	void simulate(AbstractDuckFactory duckFactory) {
		Quackable redheadDuck = duckFactory.createRedheadDuck();
		Quackable duckCall = duckFactory.createDuckCall();
		Quackable rubberDuck = duckFactory.createRubberDuck();
		Quackable gooseDuck = new GooseAdapter(new Goose());
		
		//我们先创建一个flock,然后把许多Quackable塞给它,这个flock是主群
		Flock flockOfDucks = new Flock();
		flockOfDucks.add(redheadDuck);
		flockOfDucks.add(duckCall);
		flockOfDucks.add(rubberDuck);
		flockOfDucks.add(gooseDuck);
		//然后创建一个新的绿头鸭群
		Flock flockOfMallards = new Flock();
		//创建绿头小家族
		Quackable mallardOne = duckFactory.createMallardDuck();
		Quackable mallardTwo = duckFactory.createMallardDuck();
		Quackable mallardThree = duckFactory.createMallardDuck();
		Quackable mallardFour = duckFactory.createMallardDuck();
		//将刚创建的绿头小家族加入绿头鸭群
		flockOfMallards.add(mallardOne);
		flockOfMallards.add(mallardTwo);
		flockOfMallards.add(mallardThree);
		flockOfMallards.add(mallardFour);
		//将绿头鸭群加入主群
		flockOfDucks.add(flockOfMallards);
		//测试整群
		simulate(flockOfDucks);
		//只测试绿头鸭群
		simulate(flockOfMallards);
		//最后显示呱呱叫次数
		System.out.println("\nThe ducks quacked " + 
		                   QuackCounter.getQuacks() + 
		                   " times");
	}
	//这里不需要修改,因为flock也是Quackable
	void simulate(Quackable duck) {
		duck.quack();
	}
}

14.既然我们有办法管理整群鸭子,我们也应该有办法来追踪个别的鸭子及其实时呱呱叫行为,我想到起了有个模式可以观察对象的行为:观察者模式
首先我们需要一个Observable接口,所谓Observable就是被观察的对象,Observable需要注册和通知观察者的方法.

//如何想被观察的Quackable都必须实现QuackObservable接口
public interface QuackObservable {
	//注册观察者,任何实现了Observer接口的对象都可以监听呱呱叫
	public void registerObserver(Observer observer);
	//通知观察者
	public void notifyObservers();
}
//现在我们需要确定所有的Quackable都实现此接口,所以干脆我们让Quackable扩展此接口
public interface Quackable extends QuackObservable {
	public void quack();
}

15.现在我们必须确定所有实现Quackable的具体类都能够扮演QuackObservable的角色.每一个类中都需要实现注册和通知,使用另外的做法:我们要在另一个Observalbe的类中封装注册和通知,然后将它和QuackObservable组合在一起,这样,我们只需要一份代码即可,QuackObservable所有的调用都委托给Observable辅助类

//Observable必须实现QuackObservable,因为他们具有一组相同的方法,
//QuackObservable会将这些方法的调用转给Observable的方法
public class Observable implements QuackObservable {
	ArrayList observers = new ArrayList();
	QuackObservable duck;
	//在次构造器中我们传进了QuackObservable.看看notifyObservers方法,
	//你会发现当通知发生时,观察者把次对象传进去.好让观察者知道是哪个对象在呱呱叫
	public Observable(QuackObservable duck) {
		this.duck = duck;
	}
	//注册
	public void registerObserver(Observer observer) {
		observers.add(observer);
	}
	//通知
	public void notifyObservers() {
		Iterator iterator = observers.iterator();
		while (iterator.hasNext()) {
			Observer observer = (Observer)iterator.next();
			observer.update(duck);
		}
	}
	public Iterator getObservers() {
		return observers.iterator();
	}
}

16.整合Observable辅助类和Quackable类

public class MallardDuck implements Quackable {
	//每个Quackable都有一个Observable实例变量,在构造器中传入一个MallardDuck对象的引用
	Observable observable;
	public MallardDuck() {
		observable = new Observable(this);
	}
	public void quack() {
		System.out.println("Quack");
		//当呱呱叫时,需要让观察者知道
		notifyObservers();
	}
	//这是两个QuackObservable方法,注意我们只是委托给辅助类进行
	public void registerObserver(Observer observer) {
		observable.registerObserver(observer);
	}
	public void notifyObservers() {
		observable.notifyObservers();
	}
}

17.我们已经实现了Observable所需要的一切,现在需要一些观察者Observer

//Observer只有一个update方法,他需要传入一个正在呱呱叫的对象QuackObservable
public interface Observer {
	public void update(QuackObservable duck);
}
//我们需要实现Observer,否则无法以QuackObservable注册
public class Quackologist implements Observer {
	//打印出正在呱呱叫的Quackable对象
	public void update(QuackObservable duck) {
		System.out.println("Quackologist: " + duck + " just quacked.");
	}
}

18.我们准备开始观察了,让我们更新模拟器,了解这一切是如何工作的

public class DuckSimulator {
	public static void main(String[] args) {
		DuckSimulator simulator = new DuckSimulator();
		AbstractDuckFactory duckFactory = new CountingDuckFactory();
		simulator.simulate(duckFactory);
	}
	void simulate(AbstractDuckFactory duckFactory) {
		//other 创建鸭子工厂和鸭子
		//other 创建群

		//我们在这里所需要做的就是创建一个Quackologist,把它注册成为一个群的观察者
		Quackologist quackologist = new Quackologist();
		flockOfDucks.registerObserver(quackologist);
		
		simulate(flockOfDucks);

		System.out.println("\nThe ducks quacked " + 
		                   QuackCounter.getQuacks() + 
		                   " times");
	}
	void simulate(Quackable duck) {
		duck.quack();
	}
}

如果想观察整个群呢?有什么办法?考虑试写一下

未完待续...

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

使用模式最棒的方式,就是把他们从家里找出来同其他模式展开交互.你越多的使用模式就越容易发现他们一同现身在你的设计中,对于这些在设计中携手合作征服许多问题的模式,我们给了一个特别的名字:复合模式.但是我们将某些模式结合使用,并不代表这些模式就够资格称为复合模式.复合模式必须够一般性,适合解决许多问题才行.
我们将再次使用鸭子的例子来说明并学习,下一章我们会拜访一个真正的复合模式--MVC,没错,就是MVC.

1.首先,我们将创建一个Quackable接口

public interface Quackable {
	//只做一件事:呱呱叫
	public void quack();
}

2.现在,某些鸭子实现了Quackable接口

public class MallardDuck implements Quackable {
	//绿头鸭子
	public void quack() {
		System.out.println("Quack");
	}
}
public class RedheadDuck implements Quackable {
	//红头鸭子
	public void quack() {
		System.out.println("Quack");
	}
}
public class DuckCall implements Quackable {
	//如果我们没有加入别的种类的鸭子,就不大好玩了
	//鸭鸣器也会呱呱叫,虽然不十分像
	public void quack() {
		System.out.println("Kwak");
	}
}
public class RubberDuck implements Quackable {
	//橡皮鸭,声音其实是吱吱叫
	public void quack() {
		System.out.println("Squeak");
	}
}

3.好了,我们有了鸭子,还需要一个模拟器,制造一个会产生鸭子,还要确认鸭子呱呱叫的模拟器

public class DuckSimulator {
	public static void main(String[] args) {
		//创建一个模拟器,调用simulate方法
		DuckSimulator simulator = new DuckSimulator();
		simulator.simulate();
	}
	void simulate() {
		//每一种会呱呱叫的鸭子都有一份实例
		Quackable mallardDuck = new MallardDuck();
		Quackable redheadDuck = new RedheadDuck();
		Quackable duckCall = new DuckCall();
		Quackable rubberDuck = new RubberDuck();
		//模拟每种鸭子
		simulate(mallardDuck);
		simulate(redheadDuck);
		simulate(duckCall);
		simulate(rubberDuck);
	}
	void simulate(Quackable duck) {
		//重载了simulate方法来模拟一种鸭子,剩下的事让多态发挥它的魔法
		duck.quack();
	}
}

4.只要有水塘的地方,就大概会有鸭子和鹅,我们为这个模拟器设计一个鹅类

public class Goose {
	//鹅的叫声是咯咯
	public void honk() {
		System.out.println("Honk");
	}
}

5.我们需要鹅适配器,既然鹅不会呱呱叫,那么我们可以利用适配器将鹅适配成鸭子

public class GooseAdapter implements Quackable {
	Goose goose;
	//传入要适配的对象
	public GooseAdapter(Goose goose) {
		this.goose = goose;
	}
	//当调用quack时,会被委托到鹅的honk方法
	public void quack() {
		goose.honk();
	}
}

6.现在,模拟器中也应该可以使用鹅了,我们需要做的就是创建goose对象,将它包装进适配器

public class DuckSimulator {
	public static void main(String[] args) {
		//创建一个模拟器,调用simulate方法
		DuckSimulator simulator = new DuckSimulator();
		simulator.simulate();
	}
	void simulate() {
		//每一种会呱呱叫的鸭子都有一份实例
		Quackable mallardDuck = new MallardDuck();
		Quackable redheadDuck = new RedheadDuck();
		Quackable duckCall = new DuckCall();
		Quackable rubberDuck = new RubberDuck();
		//通过把goose包装进gooseAdapter,我们就可以让鹅像鸭子一样
		Quackable gooseDuck = new GooseAdapter(new Goose());
		//模拟每种鸭子
		simulate(mallardDuck);
		simulate(redheadDuck);
		simulate(duckCall);
		simulate(rubberDuck);
		//一旦鹅被包装进来,我们就可以把它当做其他鸭子的Quackable对象
		simulate(gooseDuck);

	}
	void simulate(Quackable duck) {
		//重载了simulate方法来模拟一种鸭子,剩下的事让多态发挥它的魔法
		duck.quack();
	}
}

7.测试一下上面的DuckSimulator,你会发现,鹅和其他鸭子一起叫.现在我们考虑一下,我们如何在不变化鸭子类的情况下,计算呱呱叫的次数呢?有什么模式可以解决这个问题?
8.让我们创建一个装饰者,通过把鸭子包装进装饰者对象,给鸭子一些新行为(计算次数),我们不必修改鸭子的代码

//QuackCounter是一个装饰者,像适配器一样实现Quackable
public class QuackCounter implements Quackable {
	//我们用一个实例变量来记录被装饰的呱呱叫对象
	Quackable duck;
	//用静态变量跟踪所有呱呱叫次数
	static int numberOfQuacks;
	public QuackCounter(Quackable duck) {
		this.duck = duck;
	}
	//当quack被调用时,我们就把调用委托给正在装饰的Quackable对象,然后把叫声的次数加一
	public void quack() {
		duck.quack();
		numberOfQuacks++;
	}
	//给装饰者加入一个静态方法,以便返回在所有Quackable中发生的叫声次数
	public static int getQuacks() {
		return numberOfQuacks;
	}
}

 9.现在我们必须包装在QuackCounter装饰折中被实例化的每个Quackable对象,如果不这么做,鸭子会到处乱跑而使得我们无法统计叫声次数,我们需要更新模拟器,以便创建被装饰的鸭子

public class DuckSimulator {
	public static void main(String[] args) {
		DuckSimulator simulator = new DuckSimulator();
		simulator.simulate();
	}
	void simulate() {
		//每次我们创建一个Quackable,就用一个新的装饰者包装它
		Quackable mallardDuck = new QuackCounter(new MallardDuck());
		Quackable redheadDuck = new QuackCounter(new RedheadDuck());
		Quackable duckCall = new QuackCounter(new DuckDuck());
		Quackable rubberDuck = new QuackCounter(new RubberDuck());
		//鹅不是呱呱叫,所以不用包装
		Quackable gooseDuck = new DooseAdapter(new Goose());
		//模拟每种鸭子
		simulate(mallardDuck);
		simulate(redheadDuck);
		simulate(duckCall);
		simulate(rubberDuck);
		simulate(gooseDuck);
		//就是在这里,我们收集呱呱叫行为
		System.out.println("The ducks quacked "+QuackCounter.getQuacks()+" times");
	}
	void simulate(Quackable duck) {
		duck.quack();
	}
}

未完待续......

-------------->设计模式学习之复合模式(2)

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

原来还不知道iBatis也有像Hibernate类似的自动化代码生成工具,今天找到Abator这工具也挺不错的,在ecelipse上面小试了一把:

1.获得Abator
      http://ibatis.apache.org/abator.html
      Eclipse可以自动的进行Update获取此Plugin，具体见官方的安装步骤
2.安装好后将在New菜单中看到一个新的文件类型Abator for iBATIS Configuration File，此是Abator的配置文件，配置文件的详细说明见http://ibatis.apache.org/docs/tools/abator/,文件名默认是abatorConfig.xml,根据自己的实际需求进行修改,我这里使用mysql测试,内容是:

<abatorConfiguration>
  <abatorContext>    <!-- TODO: Add Database Connection Information -->
    <!--这里大家应该都明白是什么意思-->
    <jdbcConnection driverClass="com.mysql.jdbc.Driver"
        connectionURL="jdbc:mysql://localhost:3306/lunjian"
        userId="root"
        password="admin">
      <!--mysql驱动jar-->
      <classPathEntry location="D:\Tomcat5\webapps\MoloonMarket\WEB-INF\lib\mysql-connector-java-5.0.4-bin.jar" />
    </jdbcConnection>
    <!--targetPackage指定一个包名存放model bean,targetProject是工程名-->
    <javaModelGenerator targetPackage="com.itatis.domain" targetProject="MJTserver" />
    <!--sqlMapGenerator 指定一个包名存放sqlMap.xml-->
    <sqlMapGenerator targetPackage="com.itatis.persistence.xml" targetProject="MJTserver" />
    <!--daoGenerator 指定一个包名存放dao以及daoImpl-->
    <daoGenerator type="IBATIS" targetPackage="com.itatis.persistence.sqlmapdao" targetProject="MJTserver" />
    <!--表名,可以多个,默认不写columnOverride的话生成所有字段-->
    <table tableName="users">
         <!--  <columnOverride column="???" property="???" /> -->
    </table>

  </abatorContext>
</abatorConfiguration>

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