在国内各大知名网站都在抢先报导开幕式的盛况和我们大家彼此谈论和分享看点时,知道各大国际网站对此的报导吗?

去BBC、泰晤士报、New York Times、economist、CNN等逛了逛,心情突然没那么好了.

在他们的网站上,盛况只是了了带过,他们更关注的问题(也是主体报导)却是其他问题:

首当其冲的是安全(security)问题,他们记者报导是北京的气氛比较紧张,各种小事件又更加加重了这种气氛,比如当天抓了三名抗议、支持藏独 的美国人,还有日本飞机返回东京(说接到的邮件中声称到北京上空会遭到爆炸),加之前面藏独闹事和新疆的各种恐怖活动.也难怪他们这样想!在他们的报导 中,也可以看出政府压力真的很大(为了安全问题,北京天安门附近戒严的很厉害,各种安检也更严格,生怕出事).不管怎样,希望这个奥运会能圆满成功吧,在 这不平凡的一年里,中国人民确实需要这次成功! 闹事分子,去你的吧!

其次问题就是空气污染问题了,按理来说北京空气应该不错啊,官方有人解释是天气问题,不过他们总认为北京空气向来如此,这也难怪前两天美国自行车运动员进机场时带着口罩了.难道国外空气质量真的特别好吗,以至于他们说这样的空气会威胁他们的健康(汗一个).

然后就是人权问题,这个东西,不好评论.

其他问题就是开幕式现场问题了,烟花放的过了(呛鼻子)、中国人好客(对和自己友好的国家热情,对反对自己的国家冷淡).虽然有些鸡蛋里挑骨头了,但也是一些我们没想到的问题.

看了这么多报导,到底是他们因为中国威胁论而不够宽容还是我们需要更加努力呢?

而无论如何,我相信更多的人是在欣赏这次盛会.我也更期待这次奥运会的圆满成功并让世人见证.

• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！

      终于等到了这一天，终于数着各个不认识的国家的名字等到了奥运会的主题曲。不过却没有激情，没有惊喜，只有失望。主题曲是《我和你》？太平淡的一首歌了，和《亚洲雄风》比起来就不是一个级别的，都不能和《北京欢迎你》比，《北京欢迎你》多朗朗上口啊，旋律歌词都很棒！甚至都不如《拥抱爱的梦想》！就连《点燃激情，传递梦想》、《we are ready》都比这首歌好！

      历经几届选曲，最终选出这样一首歌，个人觉得有点有失水准！再加上歌手在唱歌的时候还有解说员的解说，烟火声，更是淡化了歌声，失望了。  引用网友一句话：“谁脑壳有包，选了这么首烂歌，肯定，本届主题歌将是开幕式最大败笔 ”。

     不过这个开幕式换算不错，只是有些地方觉得有点罗嗦。 展现四大发明的那幅画卷和最后的点火都挺好！

• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！

1. 继承java.lang.Thread，并重写它的run()方法，将线程的执行主体放入其中。
2. 实现java.lang.Runnable接口，实现它的run()方法，并将线程的执行主体放入其中。

public class ThreadTest extends Thread {
	public void run() {
		// 在这里编写线程执行的主体
		// do something
	}
}

public class RunnableTest implements Runnable {
	public void run() {
		// 在这里编写线程执行的主体
		// do something
	}
}

public class ThreadStartTest {
	public static void main(String[] args) {
		// 创建一个线程实例
		ThreadTest tt = new ThreadTest();
		// 启动线程
		tt.start();
	}
}

public class RunnableStartTest {
	public static void main(String[] args) {
		// 创建一个线程实例
		Thread t = new Thread(new RunnableTest());
		// 启动线程
		t.start();
	}
}

public void run() {
	if (target != null) {
		target.run();
	}
}

1. NEW（新建状态、初始化状态）：线程对象已经被创建，但是还没有被启动时的状态。这段时间就是在我们调用new命令之后，调用start()方法之前。
2. RUNNABLE（可运行状态、就绪状态）：在我们调用了线程的start()方法之后线程所处的状态。处于RUNNABLE状态的线程在JAVA虚拟机（JVM）上是运行着的，但是它可能还正在等待操作系统分配给它相应的运行资源以得以运行。
3. BLOCKED（阻塞状态、被中断运行）：线程正在等待其它的线程释放同步锁，以进入一个同步块或者同步方法继续运行；或者它已经进入了某个同步块或同步方法，在运行的过程中它调用了某个对象继承自java.lang.Object的wait()方法，正在等待重新返回这个同步块或同步方法。
4. WAITING（等待状态）：当前线程调用了java.lang.Object.wait()、java.lang.Thread.join()或者java.util.concurrent.locks.LockSupport.park()三个中的任意一个方法，正在等待另外一个线程执行某个操作。比如一个线程调用了某个对象的wait()方法，正在等待其它线程调用这个对象的notify()或者notifyAll()（这两个方法同样是继承自Object类）方法来唤醒它；或者一个线程调用了另一个线程的join()（这个方法属于Thread类）方法，正在等待这个方法运行结束。
5. TIMED_WAITING（定时等待状态）：当前线程调用了java.lang.Object.wait(long timeout)、java.lang.Thread.join(long millis)、java.util.concurrent.locks.LockSupport.packNanos(long nanos)、java.util.concurrent.locks.LockSupport.packUntil(long deadline)四个方法中的任意一个，进入等待状态，但是与WAITING状态不同的是，它有一个最大等待时间，即使等待的条件仍然没有满足，只要到了这个时间它就会自动醒来。
6. TERMINATED（死亡状态、终止状态）：线程完成执行后的状态。线程执行完run()方法中的全部代码，从该方法中退出，进入TERMINATED状态。还有一种情况是run()在运行过程中抛出了一个异常，而这个异常没有被程序捕获，导致这个线程异常终止进入TERMINATED状态。

public enum State {
	NEW,
	RUNNABLE,
	BLOCKED,
	WAITING,
	TIMED_WAITING,
	TERMINATED;
}

public static native void sleep(long millis) throws InterruptedException;

public static void sleep(long millis, int nanos) throws InterruptedException {
	//other code
}

public class InterruptTest {
	public static void main(String[] args) {
		Thread t = new Thread() {
			public void run() {
				try {
					System.out.println("我被执行了-在sleep()方法前");
					// 停止运行10分钟
					Thread.sleep(1000 * 60 * 60 * 10);
					System.out.println("我被执行了-在sleep()方法后");
				} catch (InterruptedException e) {
					System.out.println("我被执行了-在catch语句块中");
				}
				System.out.println("我被执行了-在try{}语句块后");
			}
		};
		// 启动线程
		t.start();
		// 在sleep()结束前中断它
		t.interrupt();
	}
}

1. 我被执行了-在sleep()方法前
2. 我被执行了-在catch语句块中
3. 我被执行了-在try{}语句块后

public final void wait() throws InterruptedException {
	//do something
}

public final native void wait(long timeout) throws InterruptedException;

public final void wait(long timeout, int nanos) throws InterruptedException {
	//do something
}

public synchronized void aMethod() {
	// do something
}

public static synchronized void anotherMethod() {
	// do something
}

public void test() {
	// 同步锁
	String lock = "LOCK";

	// 同步块
	synchronized (lock) {
		// do something
	}

	int i = 0;
	// ...
}

private Lock lock = new ReentrantLock();

public void testLock() {
	// 锁定对象
	lock.lock();
	try {
		// do something
	} finally {
		// 释放对对象的锁定
		lock.unlock();
	}
}

1. 互斥（Mutual exclusion）：线程所使用的资源中至少有一个是不能共享的，它在同一时刻只能由一个线程使用。
2. 持有与等待（Hold and wait）：至少有一个线程已经持有了资源，并且正在等待获取其他的线程所持有的资源。
3. 非抢占式（No pre-emption）：如果一个线程已经持有了某个资源，那么在这个线程释放这个资源之前，别的线程不能把它抢夺过去使用。
4. 循环等待（Circular wait）：假设有N个线程在运行，第一个线程持有了一个资源，并且正在等待获取第二个线程持有的资源，而第二个线程正在等待获取第三个线程持有的资源，依此类推……第N个线程正在等待获取第一个线程持有的资源，由此形成一个循环等待。

1. Task（任务）：这是个代表任务的抽象类，其中定义了一个deal()方法，继承Task抽象类的子类需要实现这个方法，并把这个任务需要完成的具体工作在deal()方法编码实现。线程池中的线程之所以被创建，就是为了执行各种各样数量繁多的任务的，为了方便线程对任务的处理，我们需要用Task抽象类来保证任务的具体工作统一放在deal()方法里来完成，这样也使代码更加规范。

Task的定义如下：


public abstract class Task {
	public enum State {
		/* 新建 */NEW, /* 执行中 */RUNNING, /* 已完成 */FINISHED
	}

	// 任务状态
	private State state = State.NEW;

	public void setState(State state) {
		this.state = state;
	}

	public State getState() {
		return state;
	}

	public abstract void deal();
}

2. TaskQueue（任务队列）：在同一时刻，可能有很多任务需要执行，而程序在同一时刻只能执行一定数量的任务，当需要执行的任务数超过了程序所能承受的任务数时怎么办呢？这就有了先执行哪些任务，后执行哪些任务的规则。TaskQueue类就定义了这些规则中的一种，它采用的是FIFO（先进先出，英文名是First In First Out）的方式，也就是按照任务到达的先后顺序执行。

TaskQueue类的定义如下：


import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class TaskQueue {
	private List<Task> queue = new LinkedList<Task>();

	// 添加一项任务
	public synchronized void addTask(Task task) {
		if (task != null) {
			queue.add(task);
		}
	}

	// 完成任务后将它从任务队列中删除
	public synchronized void finishTask(Task task) {
		if (task != null) {
			task.setState(Task.State.FINISHED);
			queue.remove(task);
		}
	}

	// 取得一项待执行任务
	public synchronized Task getTask() {
		Iterator<Task> it = queue.iterator();
		Task task;
		while (it.hasNext()) {
			task = it.next();
			// 寻找一个新建的任务
			if (Task.State.NEW.equals(task.getState())) {
				// 把任务状态置为运行中
				task.setState(Task.State.RUNNING);
				return task;
			}
		}
		return null;
	}
}


addTask(Task task)方法用于当一个新的任务到达时，将它添加到任务队列中。这里使用了LinkedList类来保存任务到达的先后顺序。finishTask(Task task)方法用于任务被执行完毕时，将它从任务队列中清除出去。getTask()方法用于取得当前要执行的任务。
3. TaskThread（执行任务的线程）：它继承自Thread类，专门用于执行任务队列中的待执行任务。

public class TaskThread extends Thread {
	// 该线程所属的线程池
	private ThreadPoolService service;

	public TaskThread(ThreadPoolService tps) {
		service = tps;
	}

	public void run() {
		// 在线程池运行的状态下执行任务队列中的任务
		while (service.isRunning()) {
			TaskQueue queue = service.getTaskQueue();
			Task task = queue.getTask();
			if (task != null) {
				task.deal();
			}
			queue.finishTask(task);
		}
	}
}

4. ThreadPoolService（线程池服务类）：这是线程池最核心的一个类。它在被创建了时候就创建了几个线程对象，但是这些线程并没有启动运行，但调用了start()方法启动线程池服务时，它们才真正运行。stop()方法可以停止线程池服务，同时停止池中所有线程的运行。而runTask(Task task)方法是将一个新的待执行任务交与线程池来运行。

ThreadPoolService类的定义如下：


import java.util.ArrayList;
import java.util.List;

public class ThreadPoolService {
	// 线程数
	public static final int THREAD_COUNT = 5;

	// 线程池状态
	private Status status = Status.NEW;

	private TaskQueue queue = new TaskQueue();

	public enum Status {
		/* 新建 */NEW, /* 提供服务中 */RUNNING, /* 停止服务 */TERMINATED,
	}

	private List<Thread> threads = new ArrayList<Thread>();

	public ThreadPoolService() {
		for (int i = 0; i < THREAD_COUNT; i++) {
			Thread t = new TaskThread(this);
			threads.add(t);
		}
	}

	// 启动服务
	public void start() {
		this.status = Status.RUNNING;
		for (int i = 0; i < THREAD_COUNT; i++) {
			threads.get(i).start();
		}
	}

	// 停止服务
	public void stop() {
		this.status = Status.TERMINATED;
	}

	// 是否正在运行
	public boolean isRunning() {
		return status == Status.RUNNING;
	}

	// 执行任务
	public void runTask(Task task) {
		queue.addTask(task);
	}

	protected TaskQueue getTaskQueue() {
		return queue;
	}
}

public class SimpleTaskTest extends Task {
	@Override
	public void deal() {
		// do something
	}

	public static void main(String[] args) throws InterruptedException {
		ThreadPoolService service = new ThreadPoolService();
		service.start();
		// 执行十次任务
		for (int i = 0; i < 10; i++) {
			service.runTask(new SimpleTaskTest());
		}
		// 睡眠1秒钟，等待所有任务执行完毕
		Thread.sleep(1000);
		service.stop();
	}
}

• 调整任务队列的规则，给任务设置优先级，级别高的任务优先执行。
• 动态维护线程池，当待执行任务数量较多时，增加线程的数量，加快任务的执行速度；当任务较少时，回收一部分长期闲置的线程，减少对系统资源的消耗。

public static ExecutorService newCachedThreadPool() {
	// other code
}

public static ExecutorService newFixedThreadPool(int nThreads) {
	// other code
}

public static ExecutorService newSingleThreadExecutor() {
	// other code
}

1. Runnable接口：继承Runnable接口的类要实现它的run()方法，并将执行任务的代码放入其中，run()方法没有返回值。适合于只做某种操作，不关心运行结果的情况。
2. Callable接口：继承Callable接口的类要实现它的call()方法，并将执行任务的代码放入其中，call()将任务的执行结果作为返回值。适合于执行某种操作后，需要知道执行结果的情况。

import java.util.concurrent.*;

public class ExecutorTest {
	public static void main(String[] args) throws InterruptedException,
			ExecutionException {
		ExecutorService es = Executors.newSingleThreadExecutor();
		Future fr = es.submit(new RunnableTest());// 提交任务

		Future fc = es.submit(new CallableTest());// 提交任务
		// 取得返回值并输出
		System.out.println((String) fc.get());

		// 检查任务是否执行完毕
		if (fr.isDone()) {
			System.out.println("执行完毕-RunnableTest.run()");
		} else {
			System.out.println("未执行完-RunnableTest.run()");
		}

		// 检查任务是否执行完毕
		if (fc.isDone()) {
			System.out.println("执行完毕-CallableTest.run()");
		} else {
			System.out.println("未执行完-CallableTest.run()");
		}

		// 停止线程池服务
		es.shutdown();
	}
}

class RunnableTest implements Runnable {
	public void run() {
		System.out.println("已经执行-RunnableTest.run()");
	}
}

class CallableTest implements Callable {
	public Object call() {
		System.out.println("已经执行-CallableTest.call()");
		return "返回值-CallableTest.call()";
	}
}

1. 已经执行-RunnableTest.run()
2. 已经执行-CallableTest.call()
3. 返回值-CallableTest.call()
4. 执行完毕-RunnableTest.run()
5. 执行完毕-CallableTest.run()

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！
• 搜狐网站诚聘Java、PHP和C++工程师

• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public class recursion1{
	
	int fib(int n){   
	    if(n == 0)        return 0;   
	    else if(n == 1)   return 1;  
	    else             
		System.out.print("  "+n);
		int a = fib(n-1);
		int b = fib(n-2);
		int c = a+b;
		System.out.print(" a="+a+" b="+b+" a+b= "+c+"\\ ");
		System.out.println();	
		return fib(n-1) + fib(n-2);  
	
}
 
	public static void main(String args[]){
			
 		dgClass1 dg = new dgClass1();
		System.out.println(" 6="+dg.fib(6));  //return 8



	}

}

• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！
• 北京: 千橡集团暨校内网诚聘软件研发工程师

       Lucene索引的建立需要两种基础的结构支持，它们分别是Document和Field，这两个概念不能从字面意思上理解。其实Document是Field的集合，它其实主要是用来管理Field的，而Field是一种数据源，也就是要索引的东西。每个Field都有几个重要的属性，它们分别是：

     1 name:它是这个Field的名字。它主要是以后要搜索的时候用的，也就是要按照此名字来对此Field来检索。

     2 value：它是Field的具体的内容。

     3 store：它表明此Field是否需要存储，如果通过名字检索此Field后，要显示完整的Field的内容，那么就要将起属性设置为YES。

     4 index：它表明此Field是否需要索引。它可以有四种不同的值。分别是不索引，索引并且分词，索引不分词，以及不使用分析器来索引。

      搞清楚了Document和Field具体是什么后，就可以了解Lucene索引建立的具体过程了。索引的建立主要是有类IndexWriter来实现的，而实际上索引建立的工作是由DocumentWriter来完成的，IndexWriter主要是将索引中加入已经建立好的Document.通过DocumentWriter建立索引后，建立了如下的文件：segments,deletable,.f, .fdt,.fdx,.fnm,.frq,.prx,.tii,.tis。

    1  segments文件主要记录了索引中有多少个segment，以及每个segment有多少个Document等信息。

    2. fdt文件主要保存了Field的内容，并且它只保存Field属性被设置为YES的Field。

    3 .fdx文件则记录了Document在.fdt文件中的位置。

    4  .fnm文件记录了此segment中所有Document的所有Field的名字。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！

• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！
• 搜狐网站诚聘Java、PHP和C++工程师

1 Perl基础学习总结

1.1 Perl的安装和环境变量
在装Linux系统时，Perl会自动被安装到你的系统中（默认）, 而我为了学习，不得不把自带的Perl安装程序卸载, 再从官方下载相关的源码安装，安装虽说简单，但我还是把安装遇到的问题跟大家分享一下:
下载源码包后，将其解压, 大概操作如下:
    # Tar –Zxvf Perl-Xxx.Tar.Gz
    # Cd Perl-Xxx
       ./Configure
       Make
       Make Install
   在Configure后面有很多的参数，如果不想安装在指定的路径下，可用-D加上Profix=/You/Path/
其他参数的说明可用--Help参数查看. 具体的详细安装就要看README. 安装后要验证，用Perl –V命令，如果没有出错的话，就会显示在当前系统的Perl版本信息. 如果说未找到此命令,就要配置环境变量了，
在/Etc/Profile文件的最后一行加上PATH=/You/Path/Bin:$PATH, 用Source 或重启系统就行了.

1.2 Perl标量总结
   在Perl 里面，标量其实就是数字，字符串，简称为基本数据类型 , 其中数字又分为整型，浮点型；而字符串则是由单引号或双引号组成的. 对于这些整型和浮点型及字符串它们之间的操作，我这里就不多讲，举个很简单的例子给大家看看，把一个整数变成一个浮点点只需要乘以1或除以1，因为乘法或除法就是一种浮点操作。把数字变成字符串就更简单了。Printf ‘%D/%D/%D’,2008,07,27; 这个打印语句会显示
2008-7-27 上面用%后加字母D，就叫数字格式化。具体请查相关文档.

1.3 Perl 操作符简单学习
Perl的操作符相当之多，我把学习中遇到的一些常用的操作符跟大家分享。

    赋值操作符         =
    算术操作符         +   -  *  /   **  %
    字符串操作符       . X #点是连接操作符, X是复制操作符
    逻辑操作符          AND OR NOT && || !
    组合赋值操作符    +=  -=  *=  /=  **=  %=  ||=  &&=  X=  .=
    递增和递减操作符 ++   --
    比较操作符          ==  !=  >  <  <=  >=  <=>  eq  ne  gt  lt   le  ge   cmp

上面除了<=> Cmp外，其他全返回Ture 或Flase . <=>和Cmp 返回三个值 1/0/-1
   绑定操作符 =~ !~
   关系操作符 => # 在Hash中常用到
   范围操作符 .. # 1..10 代表 1 2 3 4 5 6 7 8 9 10
   三元操作符 ? :
上面就是一些常用到的操作符，当然这只是Perl当中的一小部分，还有很多的操作符由于缺乏经验，所以我也不知道。

2 Perl 数组和Hash的总结

    数组其实就是列表的组合,而列表其实就是数据的集合, 如何定义数组，我用例子来说，大家看的会更明白一点. 首先数组用@来做前缀的，例如: @Array=(1,2,3,4,5);
    用括号括起来 的就是一个列表，然后把它赋值给@Array这个数组, 可以通过数组下标来取数组元素，数组下标从0开始, 下面是一些操作数组的常用函数:

         push 是往数组尾部添加一个元素，
         pop是往数组尾部删除一个元素，
         shift 是往数组首部添加一个元素，
         unshift是往数组首部删除一个元素。
         splice函数是删除数组多个元素
         undef 是删除数组所有元素。还可以利用Reverse 和Sort对数组反转和排序.

   另外，获得数组的元素大小也有好几种方法: $Size=@Array $#Array+1 Scalar(@Array) , 这里要解释一下$#Array+1 ，$#是取得当前数组最后一个元素的下标，所以要加1. 对数组的了解我就这么多，下面说说hash:
定义hash要用%做前缀, hash是由键值组合的,在Perl 里面用”=>”操作符来区分hash的键和值, 操作hash是一个很复杂的过程，我这里写一些比较简单的,hash操作函数:

     keys 是取hash中的key, 而values 函数是取hash中的value，在hash中，key必须是唯一的。
     each函数是返回hash中的key/value对，每次只返回一个键值对.
     exists函数 判断hash是否存在某个键或值是否存在, 一般是判断key是否存在
     undef 函数是删除一个键对应的值，而这个键会一直保存在hash中.
     delete函数是整个删除key和value.
   也可以使用前面提到的reverse函数把整个hash反转. 总之对hash要想深入了解，必须要多实践，看懂不代表会做，对hash我暂且也只了解这么一点。

3. Perl 正则表达式
正则表达式是Perl的特征之一，也相当复杂，我把学会的跟大家分享：
   首先要说三个符号: $ @ \
这三个字符如果转义的话，就会马上触发文本的插值操作. 还有一些特殊的字符，但由于比较多，就说几个常见的 \r \n \t 分别是回车，换行，制表符.

   要应用正则一般用//作为分隔符，当然还可以使用其他自己喜欢的字符做为分隔符, 使用绑定操作符”=~”可以拿左边的字符串和右边的模式匹配，正则表达式的操作符如下：
     m//     匹配操作符
     s//     替换操作符

     修饰符如下:
     /i     忽略大小写
     /g     匹配全局

     还有在匹配模式中的一些常用特殊符号:
     ?       匹配零个或一个
     *       匹配零个或多个
     +       匹配一个或多个
对于正则表达式我就说这么多，因为内容实在太多了，我也只学了一点皮毛。

• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！

     转到Architecture Team后接手了公司的Framework, 单点登录也就落到我头上了.

     公司最开始使用的策略是基于Tomcat 的Realm SSO, 这种策略的缺点是所有应用都必须放在同一个Tomcat下面, 放到不同Tomcat下都必须再做一次登录.

     非常不利于HA.

     (一)转到Architecture Team后我就向SDC的头提议了CAS的SSO策略.

1)      The user choose to visit AMS

2)      When the user arrived, AMS will first check to see if the user is authenticated by trying to locate a service ticket. if not, the framework on which the AMS built will redirect the user to the login page

3)      Then Framework will ask the user to enter username and password which can identify herself/himself

4)      If authentication passed, the user will be redirected back to AMS

5)      The user is granted to visit AMS

6)      If at some time during the same session the user serfs the BMS’ page with a ticket

7)      BMS will first check to see if the user is authenticated by trying to locate a service ticket. And it found one, but it doesn’t know whether it’s valid, so it ask CAS to check it out

8)      Validation pass

9)      BMS is granted to visit.

    检验一种方法的好坏是看它是否满足实际需要, 这种策略扩展性很好, 但是却需要独立部署一个中央认证系统. 公司非常不希望增加一个潜在的单点故障. 所以这个策略没被采纳.

   (二) 不知什么原因, 后来SSO被外包公司负责. 他们提供了另外一种方案, 还是基于Tomcat, 利用Domain Cookie, 修改自己的Realm Authenticator, 可以提供真正的SSO体验. 最大的缺点是不同的Web Container要实现一整套不同的实现.

   (三) 我自然对方案(二)很不满意. 吸取(二)的优点, 提出了以下方案. 基于Spring Security 2.0, 提供自己的SSOTicketFilter和SSOAuthenticationFilter. SSOAuthenticationFilter负责本地用户认证, SSOTicketFilter负责跨系统用户认证. SSOAuthenticationFilter在用户通过验证后保存Ticket. 跨系统时另一个系统由于也是采用Framework, 它也就会用同样的SSOTicketFilter实现来检验用户提供的Ticket. 经过验证, 方案(三)能够提供真正的SSO体验, 公司最终采取了这个方案.

  以下样例配置:

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/security"
	xmlns:beans="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
                        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.1.xsd">
                        
                        
	<beans:bean id="springSecurityFilterChain"
		class="org.springframework.security.util.FilterChainProxy">
		<beans:property name="filterChainMap">
			<beans:map>
				<beans:entry key="/**">
					<beans:list>
						<beans:ref local="httpSessionContextIntegrationFilter" />
						<beans:ref local="logoutFilter" />
						<beans:ref local="ssoTicketProcessingFilter" />
						<beans:ref local="ssoAuthenticationProcessingFilter" />
						<beans:ref local="exceptionTranslationFilter" />
						<beans:ref local="filterSecurityInterceptor" />
					</beans:list>
				</beans:entry>
			</beans:map>
		</beans:property>
	</beans:bean>
	<beans:bean id="httpSessionContextIntegrationFilter"
		class="org.springframework.security.context.HttpSessionContextIntegrationFilter">
	</beans:bean>
	<beans:bean id="exceptionTranslationFilter"
		class="org.springframework.security.ui.ExceptionTranslationFilter">
		<beans:property name="authenticationEntryPoint"
			ref="authenticationProcessingFilterEntryPoint">
		</beans:property>
	</beans:bean>
	<beans:bean id="ssoAuthenticationProcessingFilter"
		class="sso.SsoAuthenticationProcessingFilter">
		<beans:property name="authenticationManager" ref="authenticationManager"></beans:property>
		<beans:property name="defaultTargetUrl" value="/index.jsp"></beans:property>
		<beans:property name="authenticationFailureUrl" value="/login.jsp"></beans:property>
		<beans:property name="invalidateSessionOnSuccessfulAuthentication">
			<beans:value>true</beans:value>
		</beans:property>
	</beans:bean>
	<beans:bean id="authenticationProcessingFilterEntryPoint"
		class="org.springframework.security.ui.webapp.AuthenticationProcessingFilterEntryPoint">
		<beans:property name="loginFormUrl" value="/login.jsp"></beans:property>
	</beans:bean>
	<beans:bean id="filterSecurityInterceptor"
		class="org.springframework.security.intercept.web.FilterSecurityInterceptor">
		<beans:property name="authenticationManager" ref="authenticationManager" />
		<beans:property name="accessDecisionManager" ref="accessDecisionManager"></beans:property>
		<beans:property name="objectDefinitionSource">
			<!-- <filter-invocation-definition-source>
				<intercept-url pattern="/secure/super/**" access="ROLE_WE_DONT_HAVE" />
				<intercept-url pattern="/secure/**"
					access="ROLE_SUPERVISOR,ROLE_TELLER" />
			</filter-invocation-definition-source>
			 -->
			<beans:value>
		        CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
                PATTERN_TYPE_APACHE_ANT
                /auth/login.action=ROLE_ANONYMOUS,ROLE_SUPERVISOR,ROLE_TELLER
                /**/*.action=ROLE_SUPERVISOR,ROLE_TELLER
                /**=ROLE_ANONYMOUS,ROLE_SUPERVISOR,ROLE_TELLER
		    </beans:value>
		</beans:property>
	</beans:bean>
	<beans:bean id="accessDecisionManager"
		class="org.springframework.security.vote.AffirmativeBased">
		<beans:property name="decisionVoters">
			<beans:list>
				<beans:ref local="voter"></beans:ref>
				<beans:bean class="org.springframework.security.vote.AuthenticatedVoter" />
			</beans:list>
		</beans:property>
	</beans:bean>
	<beans:bean id="voter" class="org.springframework.security.vote.RoleVoter">
	</beans:bean>
	<beans:bean id="ssoTicketProcessingFilter" class="sso.SsoTicketProcessingFilter">
		<custom-filter after="CAS_PROCESSING_FILTER" />
		<beans:property name="authenticationManager" ref="authenticationManager" />
		<beans:property name="defaultTargetUrl" value="/index.jsp"></beans:property>
		<beans:property name="authenticationFailureUrl" value="/j_spring_security_check"></beans:property>
		<beans:property name="invalidateSessionOnSuccessfulAuthentication">
			<beans:value>true</beans:value>
		</beans:property>
	</beans:bean>
	<beans:bean id="logoutFilter"
		class="org.springframework.security.ui.logout.LogoutFilter">
		<beans:constructor-arg>
			<beans:value>/login.jsp</beans:value>
		</beans:constructor-arg>
		<beans:constructor-arg>
			<beans:list>
				<beans:bean
					class="org.springframework.security.ui.logout.SecurityContextLogoutHandler"></beans:bean>
				<beans:bean class="sso.CleanTicketLogoutHandler"></beans:bean>
			</beans:list>
		</beans:constructor-arg>
	</beans:bean>
	<authentication-manager alias="authenticationManager" />
	<beans:bean id="casAuthenticationProvider" class="sso.SsoAuthenticationProvider">
		<custom-authentication-provider />
		<beans:property name="userDetailsService" ref="userDetailsService" />
	</beans:bean>
	<user-service id="userDetailsService">
		<user name="rod" password="rod"
			authorities="ROLE_SUPERVISOR, ROLE_USER, ROLE_TELLER" />
		<user name="dianne" password="dianne" authorities="ROLE_USER,ROLE_TELLER" />
		<user name="scott" password="scott" authorities="ROLE_USER" />
		<user name="peter" password="peter" authorities="ROLE_USER" />
	</user-service>
</beans:beans>

• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye图灵杯第2届问答大赛开始了！8月4日至8月17日，奖品丰厚！

public class MessagePoster<REQ_OBJ, RESP_OBJ> {
	private String url = "http://localhost:8080/HttpChat/Server";

	private String propLoc = "com/cxz/httpchat/util/class.properties";

	// The XStream instance is thread-safe.
	public XStream xstream = null;

	public MessagePoster() {
		initXStream();
	}

	public void setUrl(String url) {
		this.url = url;
	}

	private void initXStream() {
		xstream = new XStream();
		Properties properties = new Properties();
		try {
			properties.load(MessagePoster.class.getClassLoader()
					.getResourceAsStream(propLoc));
			Set keys = properties.keySet();
			for (Object key : keys) {
				xstream.alias((String) key, Class.forName((String) properties
						.get(key)));
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public RESP_OBJ postXML(REQ_OBJ requestObj) throws HttpException,
			IOException {
		RESP_OBJ responseObj = null;
		PostMethod method = null;
		try {
			String xml = xstream.toXML(requestObj);
			HttpClient client = new HttpClient();
			method = new PostMethod(url);
			RequestEntity entity;
			entity = new StringRequestEntity(xml, "text/xml", "utf-8");
			method.setRequestEntity(entity);
			client.executeMethod(method);
			responseObj = (RESP_OBJ) xstream.fromXML(method
					.getResponseBodyAsStream());
		} catch(StreamException e){
			e.printStackTrace();
		} finally {
			method.releaseConnection();
		}
		return responseObj;
	}

}

HeartBeatRequest=com.cxz.httpchat.message.HeartBeatRequest
HeartBeatResponse=com.cxz.httpchat.message.HeartBeatResponse
UploadRequest=com.cxz.httpchat.message.UploadRequest
UploadResponse=com.cxz.httpchat.message.UploadResponse
Message=com.cxz.httpchat.message.Message

public class TimedQueue implements Queue<Message> {

	private long lastAccess;

	private int cycleSeconds;
	
	private static final int UNIT_CONVERSION = 1000;

	private Queue<Message> queue = new ConcurrentLinkedQueue<Message>();
	
	public List<Message> toList(){
		resetLastAccess();
		List<Message> messages = new ArrayList<Message>();
		while(!queue.isEmpty()){
			messages.add(queue.remove());
		}
		return messages;
	}

	public boolean isOutOfDate(){
		System.out.println(System.currentTimeMillis() - lastAccess);
		return System.currentTimeMillis() >= lastAccess + cycleSeconds * UNIT_CONVERSION;
	}

	public boolean add(Message e) {
		resetLastAccess();
		queue.add(e);
		return true;
	}

	public Message poll() {
		resetLastAccess();
		return queue.poll();
	}

package com.cxz.httpchat.util;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import com.cxz.httpchat.message.Message;
import com.cxz.httpchat.util.TimedQueue;

public class SelfCleaner implements Runnable{

	private Map<Integer, TimedQueue> map = new ConcurrentHashMap<Integer, TimedQueue>();
	
	private Thread gcThread;
	
	private static SelfCleaner instance;
	
	private static final int POLL_SECONDS = 60;
	
	private boolean runFlag = true;
	
	private static final int UNIT_CONVERSION = 1000;
	
	public static synchronized SelfCleaner getInstance() {
		if (instance == null) {
			instance = new SelfCleaner();
		}
		return instance;
	}
	
	private SelfCleaner(){
		
	}
	
	public void stopGc(){
		runFlag = false;
		gcThread.interrupt();
	}
	
	public void forceGc() {
		//Interrupted the sleeping gc Thread
		gcThread.interrupt();
	}
	
	public boolean isStopped() {
		return runFlag;
	}
	
	public void start() {
		gcThread = new Thread(this, "gcThread");
		gcThread.start();
	}
	
	public void run() {
		cleanTheHashMap();
		while(runFlag){
			try {
				Thread.sleep(POLL_SECONDS * UNIT_CONVERSION);
			} catch (InterruptedException e) {
				// This thread has been woken up by a interruption.
				System.out.println("Hey, man, get up from the bed and gc.");
			}
		}
		
	}
	
	public void remove(Integer id) {
		map.remove(id);
	}
	
	public List<Message> getMessage(Integer id){
		if(map.get(id) == null){
			List<Message> list = new ArrayList<Message>();
			return list;
		} else {
			return map.get(id).toList();
		}
	}
	
	public void add(Integer id, Message message) {
		TimedQueue queue = map.get(id);
		if (queue == null) {// If the user does not exists in the queue
			TimedQueue temp = new TimedQueue();
			temp.add(message);
			map.put(id, temp);
		} else {
			queue.add(message);
		}
	}

	private void cleanTheHashMap() {
		Set<Integer> set = map.keySet();
		for (Integer id : set) {
			TimedQueue tq = map.get(id);
			if (tq.isOutOfDate()) {
				map.remove(id);
			}
		}
	}

}

package com.cxz.httpchat.server;

import java.io.IOException;
import java.util.List;

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

import com.cxz.httpchat.message.HeartBeatRequest;
import com.cxz.httpchat.message.HeartBeatResponse;
import com.cxz.httpchat.message.Message;
import com.cxz.httpchat.message.UploadRequest;
import com.cxz.httpchat.message.UploadResponse;
import com.cxz.httpchat.util.MessagePoster;
import com.cxz.httpchat.util.SelfCleaner;
import com.thoughtworks.xstream.XStream;

/**
 * Servlet implementation class for Servlet: Server
 *
 */
public class Server extends javax.servlet.http.HttpServlet implements
		javax.servlet.Servlet {
	/* (non-Java-doc)
	 * @see javax.servlet.http.HttpServlet#HttpServlet()
	 */
	private XStream xstream = new MessagePoster().xstream;
	
	SelfCleaner map = SelfCleaner.getInstance();

	public Server() {
		super();
		map.start();
	}

	
	/* (non-Java-doc)
	 * @see javax.servlet.http.HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
	}

	/* (non-Java-doc)
	 * @see javax.servlet.http.HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		Object req = xstream.fromXML(request.getInputStream());
		Object resp = processRequest(req);
		if(resp != null){
			xstream.toXML(resp, response.getOutputStream());
		} else {// Check the null
			
		}
	}
	
	private Object processRequest(Object req){
		if(req.getClass() == UploadRequest.class){
			UploadRequest upload = (UploadRequest)req;
			return processUpload(upload);
		} else if (req.getClass() == HeartBeatRequest.class) {
			HeartBeatRequest heartBeat = (HeartBeatRequest)req;
			return processHeartBeat(heartBeat);
		} else {
			return null;
		}
	}

	/**
	 * Just for fun
	 * @param upload
	 * @return
	 */
	private UploadResponse processUpload(UploadRequest upload) {
		//Just for tracking the message flow
		Message message = new Message();
		message.setFrom(upload.getId());
		message.setDate(upload.getDate());
		message.setContent(upload.getContent());
		map.add(upload.getTo(), message);
		UploadResponse resp = null;
		if(true/*upload.getId().equals(new Integer(1))&&upload.getPwd().equals("19841230")*/){
			resp = new UploadResponse(); 
			resp.set