今天有时间挨个找关于影响grails的问题，执行命令grails -v就报java.lang.SecurityException:Prohibited package name:java.lang，原来是我在设置CLASSPATH时填写太详细，把所有jdk的lib下的jar包都加入，现在一个一个检查，发现是rt.jar包影响，删除之后grails -v就正常

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

在VM argsuments增加以下配置就可解决
-Dorg.mortbay.jetty.webapp.parentLoaderPriority=true

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

    JDK6 已经发布了，而对于JDK5 的新特性还来不及使用，虽然在项目中还没有使用，但可以写一些Demo体验一下Tiger的魅力，现在的时代就是体验的时代，事事都要亲历亲为才能有发言权，怎么有点毛主席“实事求是”的感觉。

JDK5中的一个亮点就是将Doug Lea 的并发库 引入到Java标准库中。Doug Lea确实是一个牛人，能教书，能出书，能编码，不过这在国外还是比较普遍的，而国内的教授们就相差太远了。

一般的服务器都需要线程池，比如Web、FTP等服务器，不过它们一般都自己实现了线程池，比如以前介绍过的Tomcat 、Resin和Jetty等，现在有了JDK5，我们就没有必要重复造车轮了，直接使用就可以，何况使用也很方便，性能也非常高。

package concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestThreadPool {
  public static void main(String args[]) throws InterruptedException {
    // only two threads
    ExecutorService exec = Executors.newFixedThreadPool(2);
    for(int index = 0; index < 100; index++) {
      Runnable run = new Runnable() {
        public void run() {
          long time = (long) (Math.random() * 1000);
          System.out.println("Sleeping " + time + "ms");
            try {
              Thread.sleep(time);
            } catch (InterruptedException e) {
            }
        }
      };
      exec.execute(run);
    }
    // must shutdown
    exec.shutdown();
  }
}

    上面是一个简单的例子，使用了2个大小的线程池来处理100个线程。但有一个问题：在for循环的过程中，会等待线程池有空闲的线程，所以 主线程会阻塞的。 为了解决这个问题，一般启动一个线程来做for循环，就是为了避免由于线程池满了造成主线程阻塞。不过在这里我没有这样处理。[重要修正：经过测试，即使 线程池大小小于实际线程数大小，线程池也不会阻塞的，这与Tomcat的线程池不同，它将Runnable实例放到一个“无限”的 BlockingQueue中，所以就不用一个线程启动for循环，Doug Lea果然厉害]

另外它使用了Executors的静态函数生成一个固定的线程池，顾名思义，线程池的线程是不会释放的，即使它是Idle。这就会产生性能问题，比 如如果线 程池的大小为200，当全部使用完毕后，所有的线程会继续留在池中，相应的内存和线程切换（while(true)+sleep循环）都会增加。如果要避 免这个问题，就必须直接使用ThreadPoolExecutor()来构造。可以像Tomcat的线程池一样设置“最大线程数”、“最小线程数”和“空 闲线程keepAlive的时间”。通过这些可以基本上替换Tomcat的线程池实现方案。

需要注意的是线程池必须使用shutdown来显式关闭，否则主线程就无法退出。shutdown也不会阻塞主线程。

许 多 长时间运行的应用有时候需要定时运行任务完成一些诸如统计、优化等工作，比如在电信行业中处理用户话单时，需要每隔1分钟处理话单；网站每天凌晨统计用户 访问量、用户数；大型超时凌晨3点统计当天销售额、以及最热卖的商品；每周日进行数据库备份；公司每个月的10号计算工资并进行转帐等，这些都是定时任 务。通过 java的并发库concurrent 可以轻松的完成这些任务，而且非常的简单。

package concurrent;
import static java.util.concurrent.TimeUnit.SECONDS;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
public class TestScheduledThread {
  public static void main(String[] args) {
    final ScheduledExecutorService scheduler = Executors
        .newScheduledThreadPool(2);
    final Runnable beeper = new Runnable() {
      int count = 0;
      public void run() {
        System.out.println(new Date() + " beep " + (++count));
      }
    };
    // 1秒钟后运行，并每隔2秒运行一次
    final ScheduledFuture<?> beeperHandle = scheduler.scheduleAtFixedRate(
        beeper, 1, 2, SECONDS);
    // 2秒钟后运行，并每次在上次任务运行完后等待5秒后重新运行
    final ScheduledFuture<?> beeperHandle2 = scheduler
        .scheduleWithFixedDelay(beeper, 2, 5, SECONDS);
    // 30秒后结束关闭任务，并且关闭Scheduler
    scheduler.schedule(new Runnable() {
      public void run() {
        beeperHandle.cancel(true);
        beeperHandle2.cancel(true);
        scheduler.shutdown();
      }
    }, 30, SECONDS);
  }
}

为了退出进程，上面的代码中加入了关闭Scheduler的操作。而对于24小时运行的应用而言，是没有必要关闭Scheduler的。

    在 实际应用中，有时候需要多个线程同时工作以完成同一件事情，而且在完成过程中，往往会等待其他线程都完成某一阶段后再执行，等所有线程都到达某一个阶段后再统一执行。

    比如有几个旅行团需要途经深圳、广州、韶关、长沙最后到达武汉。旅行团中有自驾游的，有徒步的，有乘坐旅游大巴的；这些旅行团同时出发，并且每到一个目的地，都要等待其他旅行团到达此地后再同时出发，直到都到达终点站武汉。

这时候CyclicBarrier 就可以派上用场。CyclicBarrier最重要的属性就是参与者个数，另外最要方法是await()。当所有线程都调用了await()后，就表示这些线程都可以继续执行，否则就会等待。

package concurrent;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestCyclicBarrier {
  // 徒步需要的时间: Shenzhen, Guangzhou, Shaoguan, Changsha, Wuhan
  private static int[] timeWalk = { 5, 8, 15, 15, 10 };
  // 自驾游
  private static int[] timeSelf = { 1, 3, 4, 4, 5 };
  // 旅游大巴
  private static int[] timeBus = { 2, 4, 6, 6, 7 };
  
  static String now() {
    SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
    return sdf.format(new Date()) + ": ";
  }

  static class Tour implements Runnable {
    private int[] times;
    private CyclicBarrier barrier;
    private String tourName;
    public Tour(CyclicBarrier barrier, String tourName, int[] times) {
      this.times = times;
      this.tourName = tourName;
      this.barrier = barrier;
    }
    public void run() {
      try {
        Thread.sleep(times[0] * 1000);
        System.out.println(now() + tourName + " Reached Shenzhen");
        barrier.await();
        Thread.sleep(times[1] * 1000);
        System.out.println(now() + tourName + " Reached Guangzhou");
        barrier.await();
        Thread.sleep(times[2] * 1000);
        System.out.println(now() + tourName + " Reached Shaoguan");
        barrier.await();
        Thread.sleep(times[3] * 1000);
        System.out.println(now() + tourName + " Reached Changsha");
        barrier.await();
        Thread.sleep(times[4] * 1000);
        System.out.println(now() + tourName + " Reached Wuhan");
        barrier.await();
      } catch (InterruptedException e) {
      } catch (BrokenBarrierException e) {
      }
    }
  }

  public static void main(String[] args) {
    // 三个旅行团
    CyclicBarrier barrier = new CyclicBarrier(3);
    ExecutorService exec = Executors.newFixedThreadPool(3);
    exec.submit(new Tour(barrier, "WalkTour", timeWalk));
    exec.submit(new Tour(barrier, "SelfTour", timeSelf));
    exec.submit(new Tour(barrier, "BusTour", timeBus));
    exec.shutdown();
  }
}

运行结果：
00:02:25: SelfTour Reached Shenzhen
00:02:25: BusTour Reached Shenzhen
00:02:27: WalkTour Reached Shenzhen
00:02:30: SelfTour Reached Guangzhou
00:02:31: BusTour Reached Guangzhou
00:02:35: WalkTour Reached Guangzhou
00:02:39: SelfTour Reached Shaoguan
00:02:41: BusTour Reached Shaoguan

    并 发库中的BlockingQueue 是一个比较好玩的类，顾名思义，就是阻塞队列。该类主要提供了两个方法put()和take()，前者将一个对象放到队列中，如果队列已经满了，就等待直到有空闲节点；后者从head取一个对象，如果没有对象，就等待直到有可取的对象。

下 面的例子比较简单，一个读线程，用于将要处理的文件对象添加到阻塞队列中，另外四个写线程用于取出文件对象，为了模拟写操作耗时长的特点，特让线程睡眠一 段随机长度的时间。另外，该Demo也使用到了线程池和原子整型（AtomicInteger），AtomicInteger可以在并发情况下达到原子化 更新，避免使用了synchronized，而且性能非常高。由于阻塞队列的put和take操作会阻塞，为了使线程退出，特在队列中添加了一个“标 识”，算法中也叫“哨兵”，当发现这个哨兵后，写线程就退出。

当然线程池也要显式退出了。

package concurrent;
import java.io.File;
import java.io.FileFilter;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

public class TestBlockingQueue {
  static long randomTime() {
    return (long) (Math.random() * 1000);
  }

  public static void main(String[] args) {
    // 能容纳100个文件
    final BlockingQueue<File> queue = new LinkedBlockingQueue<File>(100);
    // 线程池
    final ExecutorService exec = Executors.newFixedThreadPool(5);
    final File root = new File("F:\\JavaLib");
    // 完成标志
    final File exitFile = new File("");
    // 读个数
    final AtomicInteger rc = new AtomicInteger();
    // 写个数
    final AtomicInteger wc = new AtomicInteger();
    // 读线程
    Runnable read = new Runnable() {
      public void run() {
        scanFile(root);
        scanFile(exitFile);
      }

      public void scanFile(File file) {
        if (file.isDirectory()) {
          File[] files = file.listFiles(new FileFilter() {
            public boolean accept(File pathname) {
              return pathname.isDirectory()
                  || pathname.getPath().endsWith(".java");
            }
          });
          for (File one : files)
            scanFile(one);
        } else {
          try {
            int index = rc.incrementAndGet();
            System.out.println("Read0: " + index + " "
                + file.getPath());
            queue.put(file);
          } catch (InterruptedException e) {
          }
        }
      }
    };
    exec.submit(read);
    // 四个写线程
    for (int index = 0; index < 4; index++) {
      // write thread
      final int NO = index;
      Runnable write = new Runnable() {
        String threadName = "Write" + NO;
        public void run() {
          while (true) {
            try {
              Thread.sleep(randomTime());
              int index = wc.incrementAndGet();
              File file = queue.take();
              // 队列已经无对象
              if (file == exitFile) {
                // 再次添加"标志"，以让其他线程正常退出
                queue.put(exitFile);
                break;
              }
              System.out.println(threadName + ": " + index + " "
                  + file.getPath());
            } catch (InterruptedException e) {
            }
          }
        }
      };
      exec.submit(write);
    }
    exec.shutdown();
  }
}

从 名字可以看出，CountDownLatch 是一个倒数计数的锁，当倒数到0时触发事件，也就是开锁，其他人就可以进入了。在一些应用场合中，需要等待某个条件达到要求后才能做后面的事情；同时当线程都完成后也会触发事件，以便进行后面的操作。

CountDownLatch最重要的方法是countDown()和await()，前者主要是倒数一次，后者是等待倒数到0，如果没有到达0，就只有阻塞等待了。

一个CountDouwnLatch实例是不能重复使用的，也就是说它是一次性的，锁一经被打开就不能再关闭使用了，如果想重复使用，请考虑使用CyclicBarrier 。

下面的例子简单的说明了CountDownLatch的使用方法，模拟了100米赛跑，10名选手已经准备就绪，只等裁判一声令下。当所有人都到达终点时，比赛结束。

同样，线程池需要显式shutdown。

package concurrent;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestCountDownLatch {
  public static void main(String[] args) throws InterruptedException {
    // 开始的倒数锁
    final CountDownLatch begin = new CountDownLatch(1);
    // 结束的倒数锁
    final CountDownLatch end = new CountDownLatch(10);
    // 十名选手
    final ExecutorService exec = Executors.newFixedThreadPool(10);
    for(int index = 0; index < 10; index++) {
      final int NO = index + 1;
      Runnable run = new Runnable(){
        public void run() {
          try {
            begin.await();
            Thread.sleep((long) (Math.random() * 10000));
            System.out.println("No." + NO + " arrived");
          } catch (InterruptedException e) {
          } finally {
            end.countDown();
          }
        }
      };
      exec.submit(run);
    }
    System.out.println("Game Start");
    begin.countDown();
    end.await();
    System.out.println("Game Over");
    exec.shutdown();
  }
}

运行结果:
Game Start
No.4 arrived
No.1 arrived
No.7 arrived
No.9 arrived
No.3 arrived
No.2 arrived
No.8 arrived
No.10 arrived
No.6 arrived
No.5 arrived
Game Over

有 时 候在实际应用中，某些操作很耗时，但又不是不可或缺的步骤。比如用网页浏览器浏览新闻时，最重要的是要显示文字内容，至于与新闻相匹配的图片就没有那么重 要的，所以此时首先保证文字信息先显示，而图片信息会后显示，但又不能不显示，由于下载图片是一个耗时的操作，所以必须一开始就得下载。

Java的并发库 的Future 类 就可以满足这个要求。Future的重要方法包括get()和cancel()，get()获取数据对象，如果数据没有加载，就会阻塞直到取到数据，而 cancel()是取消数据加载。另外一个get(timeout)操作，表示如果在timeout时间内没有取到就失败返回，而不再阻塞。

下面的Demo简单的说明了Future的使用方法：一个非常耗时的操作必须一开始启动，但又不能一直等待；其他重要的事情又必须做，等完成后，就可以做不重要的事情。

package concurrent;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestFutureTask {
  public static void main(String[] args)throws InterruptedException,
      ExecutionException {
    final ExecutorService exec = Executors.newFixedThreadPool(5);
    Callable<String> call = new Callable<String>() {
      public String call() throws Exception {
        Thread.sleep(1000 * 5);
        return "Other less important but longtime things.";
      }
    };
    Future<String> task = exec.submit(call);
    // 重要的事情
    Thread.sleep(1000 * 3);
    System.out.println("Let's do important things.");
    // 其他不重要的事情
    String obj = task.get();
    System.out.println(obj);
    // 关闭线程池
    exec.shutdown();
  }
}

运行结果：
Let's do important things.
Other less important but longtime things.

考 虑以下场景：浏览网页时，浏览器了5个线程下载网页中的图片文件，由于图片大小、网站访问速度等诸多因素的影响，完成图片下载的时间就会有很大的不同。如果先下载完成的图片就会被先显示到界面上，反之，后下载的图片就后显示。

Java的并发库 的CompletionService 可 以满足这种场景要求。该接口有两个重要方法：submit()和take()。submit用于提交一个runnable或者callable，一般会提 交给一个线程池处理；而take就是取出已经执行完毕runnable或者callable实例的Future对象，如果没有满足要求的，就等待了。 CompletionService还有一个对应的方法poll，该方法与take类似，只是不会等待，如果没有满足要求，就返回null对象。

package concurrent;

import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestCompletionService {
  public static void main(String[] args) throws InterruptedException,
      ExecutionException {
    ExecutorService exec = Executors.newFixedThreadPool(10);
    CompletionService<String> serv = 
      new ExecutorCompletionService<String>(exec);

    for (int index = 0; index < 5; index++) {
      final int NO = index;
      Callable<String> downImg = new Callable<String>() {
        public String call() throws Exception {
          Thread.sleep((long) (Math.random() * 10000));
          return "Downloaded Image " + NO;
        }
      };
      serv.submit(downImg);
    }

    Thread.sleep(1000 * 2);
    System.out.println("Show web content");
    for (int index = 0; index < 5; index++) {
      Future<String> task = serv.take();
      String img = task.get();
      System.out.println(img);
    }
    System.out.println("End");
    // 关闭线程池
    exec.shutdown();
  }
}

运行结果:
Show web content
Downloaded Image 1
Downloaded Image 2
Downloaded Image 4
Downloaded Image 0
Downloaded Image 3
End

操作系统的信号量是个很重要的概念，在进程控制方面都有应用。 Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，acquire()获取一个许可，如果没有就等待，而release()释放一个许可。比如在Windows下可以设置共享文件的最大客户端访问个数。

Semaphore维护了当前访问的个数，提供同步机制，控制同时访问的个数。在数据结构中链表可以保存“无限”的节点，用Semaphore可以实现有限大小的链表。另外重入锁ReentrantLock也可以实现该功能，但实现上要负责些，代码也要复杂些。

下面的Demo中申明了一个只有5个许可的Semaphore，而有20个线程要访问这个资源，通过acquire()和release()获取和释放访问许可。

package concurrent;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class TestSemaphore {
  public static void main(String[] args) {
    // 线程池
    ExecutorService exec = Executors.newCachedThreadPool();
    // 只能5个线程同时访问
    final Semaphore semp = new Semaphore(5);
    // 模拟20个客户端访问
    for (int index = 0; index < 20; index++) {
      final int NO = index;
      Runnable run = new Runnable() {
        public void run() {
          try {
            // 获取许可
            semp.acquire();
            System.out.println("Accessing: " + NO);
            Thread.sleep((long) (Math.random() * 10000));
            // 访问完后，释放
            semp.release();
          } catch (InterruptedException e) {
          }
        }
      };
      exec.execute(run);
    }
    // 退出线程池
    exec.shutdown();
  }
}

 运行结果：
Accessing: 0
Accessing: 1
Accessing: 2
Accessing: 3
Accessing: 4
Accessing: 5
Accessing: 6
Accessing: 7
Accessing: 8
Accessing: 9
Accessing: 10
Accessing: 11
Accessing: 12
Accessing: 13
Accessing: 14
Accessing: 15
Accessing: 16
Accessing: 17
Accessing: 18
Accessing: 19

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

我在使用urlrewrite过程中，觉得很强大，但对.htaccess支持得不好好。

由于urlrewrite.xml还是强重量，而且喜欢apache，所以选择用.htaccess。当把modRewriteConf值设置为true，就启用.htaccess，目前只支持RewriteLogLevel，RewriteLog，RewriteRule，也算基本够用吧。

<init-param>
       <param-name>modRewriteConf</param-name>
        <param-value>true</param-value>
</init-param>

但是一配置htaccess就启动不了，报org.tuckey.web.filters.urlrewrite.UrlRewriteFilter ERROR: Conf failed to load，后来是Conf构造方法把docProcessed设置为true就可以，目前暂时不发现有什么影响。

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

很酷的房子建造，估计现在这些在石头上的房子应该也没人住了，可以放粮食，保存些东西，以防止火灾之类的迫害，很有特点。

http://www.545300.cn/blog/article/view/69.jhtml?domain=biaowen

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

干我们这一行的，熬夜是家常便饭。
其实，熬夜是百害而无一利的。为什么这么说呢？看看下面就知道了：
一、晚上9-11点为免疫系统（淋巴）排毒时间，此段时间应安静或听音乐 。
二、晚间11-凌晨1点，肝的排毒，需在熟睡中进行。
三、凌晨1-3点，胆的排毒，亦同。
四、凌晨3-5点，肺的排毒。此即为何咳嗽的人在这段时间咳得最剧烈，因排毒动作已走到肺；不应用止咳药，以免抑制废积物的排除。
五、凌晨5-7点，大肠的排毒，应上厕所排便。
六、凌晨7-9点，小肠大量吸收营养的时段，应吃早餐。疗病者最好早吃，在６点半前，养生者在７点半前，不吃早餐者应改变习惯，即使拖到９、10点吃都比不吃好。
七、半夜至凌晨４点为脊椎造血时段，必须熟睡，不宜熬夜。
朋友，你还会熬夜吗？

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.TimeUnit;
 
class Athlete implements Runnable {
    private boolean start = false;
    private final int id;
 
    public Athlete(int id) {
       this.id = id;
    }
 
    public boolean equals(Object o) {
       if (!(o instanceof Athlete))
           return false;
       Athlete athlete = (Athlete) o;
       return id == athlete.id;
    }
 
    public String toString() {
       return "Athlete<" + id + ">";
    }
 
    public int hashCode() {
       return new Integer(id).hashCode();
    }
 
    public synchronized void prepare() throws InterruptedException {
       System.out.println(this + " ready!");
       while (start == false)
           wait();
       if (start == true)
           System.out.println(this + " go!");
    }
 
    public synchronized void go() {
       start = true;
       notifyAll();
    }
 
    public void run() {
       try {
           prepare();
       } catch (InterruptedException e) {
           //maybe should notify the referee
           System.out.println(this+" quit the game");
       }
    }
}
 
class Referee implements Runnable {
    private Set<Athlete> players = new HashSet<Athlete>();
 
    public void addPlayer(Athlete one) {
       players.add(one);
    }
 
    public void removePlayer(Athlete one) {
       players.remove(one);
    }
 
    public void ready() {
       Iterator<Athlete> iter = players.iterator();
       while (iter.hasNext())
           new Thread(iter.next()).start();
    }
 
    public void action() {
       Iterator<Athlete> iter = players.iterator();
       while (iter.hasNext())
           iter.next().go();
    }
 
    public void run() {
       ready();
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       action();
    }
}
 
public class Game {
    public static void main(String[] args) {
       Referee referee = new Referee();
       for (int i = 0; i < 10; i++)
           referee.addPlayer(new Athlete(i));
       new Thread(referee).start();
    }
}

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

网址是http://www.qubei.com ,专门记录北京奥运.

这个网站是用ruby on rails开发,不加美工,一天就能完成.开发效率真快.

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

在我们的努力些，融水互动 发布了β1.6，主要是修复一些已发布的BUG，还增加了数字效验。

但还存在很多问题，在下个版本站我们会做一些功能的增强，以前引入图片图片安全保护和版权问题。

技术问题暂时不公开，不过离不开javaeyec的帮助，在这我学习到更多技术。

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

http://www.groovyland.net/groovylive/shell

可以按照提示一边学习一边看效果,非常方便.

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

     在我们的网站建设中，时常会遇到需要网页重定向的情况：象网站调整，如改变网页目录结构，网页被移到一个新地址，再或者，网页扩展名改变，如因应用需要把.jsp改成.html或.shtml，在这种情况下，如果不做重定向，则用户收藏夹或搜索引擎数据库中旧地址只能让访问客户还会得到一个404页面错误信息，访问流量白白丧失；再如某些注册了多个域名的网站，也需要通过重定向让访问这些域名的用户自动跳转到主站点，等等。

　　页面永久性移走（301重定向）是一种非常重要的“自动转向”技术。

　　301重定向可促进搜索引擎优化效果

　　从搜索引擎优化角度出发，301重定向是网址重定向最为可行的一种办法。当网站的域名发生变更后，搜索引擎只对新网址进行索引，同时又会把旧地址下原有的外部链接如数转移到新地址下，从而不会让网站的排名因为网址变更而收到丝毫影响。同样，在使用301永久性重定向命令让多个域名指向网站主域时，亦不会对网站的排名产生任何负面影响。

　　302重定向可影响搜索引擎优化效果

　　迄今为止，能够对302重定向具备优异处理能力的只有Google。也就是说，在网站使用302重定向命令将其它域名指向主域时，只有Google会把其它域名的链接成绩计入主域，而其它搜索引擎只会把链接成绩向多个域名分摊，从而削弱主站的链接总量。既然作为网站排名关键因素之一的外链数量受到了影响，网站排名降低也是很自然的事情了。

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

这次可以发布图片，文章，音乐，和申请圈子以及加入朋友的圈子了。

网址是:www.545300.cn 融水互动

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

       def pagination_links_each(paginator, options)  
         options = DEFAULT_OPTIONS.merge(options)  
         link_to_current_page = options[:link_to_current_page]  
         always_show_anchors = options[:always_show_anchors]  
         current_page = paginator.current_page  
         window_pages = current_page.window(options[:window_size]).pages  
         return if window_pages.length <= 1 unless link_to_current_page  
         first, last = paginator.first, paginator.last  
         html = ''  
         if always_show_anchors and not (wp_first = window_pages[0]).first?  
           html << yield(first.number)  
           html << ' ... ' if wp_first.number - first.number > 1  
           html << ' '  
         end  
         window_pages.each do |page|  
           if current_page == page && !link_to_current_page  
             html << page.number.to_s  
           else  
             html << yield(page.number)  
           end  
           html << ' '  
         end  
         if always_show_anchors and not (wp_last = window_pages[-1]).last?   
           html << ' ... ' if last.number - wp_last.number > 1  
           html << yield(last.number)  
         end  
         html  
       end 

这会产生一个比较好看的视觉，至少我觉得，现在想做个JAVA版的，主要是怎么生成html，请各人搞手给个思路，谢谢！

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师