公司的项目中用到了这个新消息提示的效果，主要用于提示用户有新消息。具体实现代码如下：

调用显示新消息提示：newMessageRemind.show();

调用取消新消息提示：newMessageRemind.clear();

查看demo：http://www.css88.com/demo/newMessageRemind/

另：单纯的这个代码会出现这么一个问题：
就是当你打开一个站点很多张页面的时候，如过有新消息，那么所有页面都会不停的闪，当你查看消息后其他页面仍会提示。

我们公司是通过使用Cookie的方式解决的，当查看新消息后所有标题闪动的页面将全部取消提示。

声明: 本文采用 BY-NC-SA 协议进行授权 | WEB前端开发
转载请注明转自《标题栏新消息提示效果》

今天一个刚学js的朋友给了我一段代码问为什么方法不执行，代码如下：

其实不是不执行，只是朋友的意思这里alert出来的应该是“0”，而不是function (){return x;}。
不是脚本写错了，只是没搞懂return，从当前函数退出，并从那个函数返回一个值。如果返回的是一个函数，那么返回的也是函数本身。
可以这样修改上面的代码,就是alert(makefunc(0)())：

如果要返回函数执行的结果那么首先要让这个函数执行，例如：

这里有一个匿名函数，

在第一个括号内是匿名函数，第二个括号用于调用该匿名函数，您可以在第二个括号中传入所需的参数。例如：

声明: 本文采用 BY-NC-SA 协议进行授权 | WEB前端开发
转载请注明转自《return闭包函数》

哇，居然页面倒过来了，页头和页脚翻了一个根头，其实我以前还在想，背景图片是不是可以这样呢，今天至少在页面上看到了。

真好奇，立即启动火狐看了一下，哈哈，找到原因了，马上在试了一下IE，搞定，也OK，哈哈，如果不知道的同学们，我想你们也想知道这是怎么回事吧。

其实就是这个东东在做怪。。。

-moz-transform: rotate(180deg);

-webkit-transform: rotate(180deg);

filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=2);

三行代码，分别用来支持moz，webkit和IE的内核的浏览器。

我们看看克军是怎么做的呢，他使用了JS，让代码立即执行的方式。。给页面增加一个<sytle>和相应的样式，并且为body增加相应的class.下面我将他的js代码贴出来。嘿嘿！

;(function(){
var d = document, n = d.createElement('style'), r='.flip { -moz-transform: rotate(180deg);-webkit-transform: rotate(180deg);filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=2); }';
n.type = 'text/css';
if(n.styleSheet)
{
 n.styleSheet.cssText = r;
}
else
{
 n.appendChild(d.createTextNode(r))
}
d.getElementsByTagName('head')[0].appendChild(n);
d.body.className += ' flip';
}

为了使用document方便，他把document传给了变量d,建立了一个style标签为变量n，把样式的内容传给
了变量r，克军的命名都很简洁。
在为这个n其实就是style标签了type这个属性。
下面是进行判断页面中style有不有属性，如果没有，直接将r，也就是样式的内容放入n中。
如果有，就得使用建立文本并且追加的方式。
我不知道我的解释对不对哈，反正大概意思就是这样的，欢迎指正。
一切准备就绪以后，就将n添加到head中去，在将class增加到body上，这样页面一加载。。。。你的页面就会被旋转180度，当然你可以旋转90度，10度，数字是可以调整的哟。

2010.09.30  今天在使用过程中，最后发现，原来ie只支持4个值，分别旋转值可以是1，2，3或4。这些数字分别代表90，180，270，或360度旋转。

通过许多实际项目，个人认为一个完备的前端产品开发团队，必须拥有如下的人才配备，也希望大家补充：

• 团队全体成员达到所有技能中的a级标准
• 团队全体成员必须掌握两项技能中的b级标准，并保证所有的b级标准在该团队中有50%以上成员能达到
• 团队全体成员必须掌握一项技能中的c级标准，并保证所有的c级标准在该团队中有25%以上成员能达到

具体技能描述：

• 【必备】UserInterface
• 1. PhotoShop/Fireworks Design
     a – 配合美工将草图形成具体的符合WebPage的设计
     b – 有快速制作分层高品质PSD、PNG的能力
     c – 能迅速将PSD、PNG的内容构思成div+css或者table等HTML代码
  2. Flash Design
     a – 基本动画效果
     b – 复杂的交互体系设计，了解第三方swf辅助设计软件
     c – 复杂的交互体系设计以及较强的对各类外埠资源（PNG、JPG、MP3、WAV等）的整合能力。精通部分第三方辅助设计软件（AE、SwishMax、Swift3D等）
• 【必备】Browser-side (Web Application)
• 1. XHTML/CSS
     a – 基本的layout实现
     b – 严格跨平台的layout实现以
     c – 优雅的HTML code，尽可能符合标准并有SEO的考虑因素。在任何平台、浏览器下基本保持一致。不要求了解各种CSS的hacks，但要求知道遇到问题应该如何查阅资料以在第一时间内解决。能够为JavaScript开发人员提供最好操作的DOM结构，让JS开发人员在开发的时候认为”一切都已经准备就绪了”，而不是”捉襟见肘”。
  2. JavaScript/Ajax/DOM
     a – 基本的DOM操作，了解AJAX，可以实现数据通信
     b – 基本的DOM操作，能写高效率的OOP代码，以降低维护成本
     c – 基于需求，进行不同的开发，选择合适的框架，做到代码效率最高，用户体验最好，代码下载量最小，并且可以在单独甚至更多产品线中最大限度重用代码
  3. Flash Developement
     a – 基于Timeline的ActionScript操作，能实现简单交互
     b – 掌握a外，能实现数据层通信（与服务器以及本地SharedObject）
     c – 精通AS1-3，能根据需求进行各类RIA开发。无论是要求支持FlashPlayer8的，还是FlashPlayer9的，都能做到开发效率最高、灵活性最大（比如对HTML层的接口设计，等等）。
• 【必备】Client-side (Desktop Application)
  1. Apollo
     a – 产品级的封装，基本技术了解（如何打包、如何加入HTML和JavaScript等）
     b – 掌握a的同时，能利用Apollo的API独立设计、开发OS的文件I/O功能。
     c – 掌握基本技能的同时，对”3D概念体系”有所认知。这里”3D”即：Design（设计）、Development（开发）、Deploy（产品部署）。能用Apollo
  2. Windows Presentation Foundation、WPF/E（Silverlight）
     （待定，欢迎补充）
• 【增补】Server-side （修改：经考虑，这个技能不参与评级）
  本来列举了”1、Server端简单的技术、脚本”和”2、MediaServer（Red5）接口”作为”Web前端工程师技能列表“的一种（服务器、数据逻辑层技能的）评判标准。但似乎很多朋友对于前端工程师是否应该掌握Server端技能的必要性表示怀疑。确实，要掌握好上述的展现层技能不是意见容易的事情，而且前端工程师的确非常辛苦。但是，站在另一方面来说，辛苦的原因是什么，我不知道在你日夜奋战div+CSS的时候思考过没有。就我的经验，前端的辛苦在于以下几个方面：

   

  1. 重复劳动多，大量的div+css都是重复的，即便可以复制粘贴，但几千行的div海洋中去寻找一个入口恐怕都非常痛苦
  2. 需求变更多，往往你折腾几个小时终于把跨平台问题解决好了，而且在IE6、7和Firefox下面都能显示同样的效果了，甚至连JavaScript交互都已经快搞定了。突然上面说需求要变。这无疑是莫大的痛苦。

  也许表面上看，这跟Server端技能无关，但我觉得有好的Server端的意识，一定会有所帮助（当然不可能解决所有的问题）。毕竟信息结构和数据库是密切相关的，而Server是连接数据库的唯一渠道（至少大多数B/S应用是如此）。掌握Server端的基本技能，对于同逻辑层开发人员设计接口是非常重要的。而且HTML表现层在开发时与数据的分离，也与Server端的各种模板技术有关。例如PHP中的Smarty模板（我曾经用的）、jsp的model2概念等等。HTML结构如何设计，如何让HTML重用，甚至在HTML层进行OOP的开发（我现在在新产品线中设计的前端开发流程），都需要Server端的支持。最起码，你要告诉php程序员你需要什么。如果你完全对PHP一无所知的话，那也无从谈起了。
  此外，对于创业团队，往往人手非常有限。为了让运营成本降到最低，所有的技术人员都有义务对Server端技术有所了解。如果为了修改一个网页的标题还要跑去喊PHP程序员连接Remote Server的话，那实在是增加了整个公司的运营成本。
  总结：我认为，可以不了解技术细节，但应该知道原理，最好能掌握一两套设计思想（毕竟数据逻辑都在这里走，光看HTML和JavaScript，对人的见识还是有局限的，这种局限限制了我自己很久的时间），那将是一比宝贵的财富。

• 【增补】Mobile-side（不参与评级）
  1. Flashlite
     （待定，欢迎补充）
  2. Java？
     （待定，欢迎补充）

看到很多朋友留言说前端工程师没前途，我在想，同时掌握移动设备的技能是否也是拓展前途的一个必要性？这里再多说几句，关于技术人员的前途，目前在国内确实得用”惨淡”来形容。浮躁的氛围让技术人才往往过早放弃了自己的技术生涯，而尔虞我诈的整体道德水平也让单纯的技术人员痛不欲生（我身边太多了，恩，不说具体细节了，呵呵）。

作为一个技术人员，开发人员，在保持纯粹地敬业心态（这是前提，这么没有，啥也别谈）外，更要学会如何保护自己，如何壮大自身，社会不会同情你，只有你自己才能保护你自己。

本文来自：http://www.awflasher.com/blog/archives/906

<a href="http://www.cookseo.com?keepThis=true&TB_iframe=true&height=500&width=820" title="ThickBox 3.1:调用框架，固定宽度和高度，超出显示滚动条" class="thickbox">OECSPACE</a>

<a href="boxs.html?keepThis=true&TB_iframe=true&height=100&width=220&modal=true" title="ThickBox 3.1:modal=true表示禁用title，去掉即可显示title及可自动关闭" class="thickbox">Open iFrame Modal</a>

<a href="box.html?height=350&width=350&modal=true" title="ThickBox 3.1:Ajax载入，页面无法查看源代码" class="thickbox">Example</a>

<a href="#TB_inline?height=200&width=300&inlineId=hiddenModalContent&modal=true" title="ThickBox 3.1:链接显示隐藏层" class="thickbox">Show hidden modal content</a>

<div id="hiddenModalContent" style="display:none">
<p>ThickBox hidden modal content. Click to hide.</p>
<p style="text-align:center"><input type="submit" value=" O K " onclick="tb_remove()" /></p>
</div>

<input alt="#TB_inline?height=150&width=400&inlineId=myOnPageContent " title="ThickBox 3.1:按钮显示隐藏层" class="thickbox" type="button" value="Show" />

<div id="myOnPageContent" style="display:none">
<p>ThickBox hidden modal content.Auto Hide.</p>
</div>

<a href="images/plant1.jpg" title="plant" class="thickbox"><img src="images/plant1_t.jpg" alt="ThickBox 3.1" /></a>

<a href="images/plant1.jpg" title="plant1" class="thickbox" rel="gallery-plants"><img src="images/plant1_t.jpg" alt="ThickBox 3.1 1" /></a>
<a href="images/plant2.jpg" title="plant2" class="thickbox" rel="gallery-plants"><img src="images/plant2_t.jpg" alt="ThickBox 3.1 2" /></a>
<a href="images/plant3.jpg" title="plant3" class="thickbox" rel="gallery-plants"><img src="images/plant3_t.jpg" alt="ThickBox 3.1 3" /></a>

$("#TB_window").append("<a href='' id='TB_ImageOff' title='Close'><img id='TB_Image' src='"+url+"' width='"+imageWidth+"' height='"+imageHeight+"' alt='"+caption+"'/></a>" + "<div id='TB_caption'>"+caption+"<div id='TB_secondLine'>" + TB_imageCount + TB_PrevHTML + TB_NextHTML + "</div></div><div id='TB_closeWindow'><a href='#' id='TB_closeWindowButton' title='Close'>close</a> or Esc Key</div>");     


$("#TB_window").append("<img id='TB_Image' src='"+url+"' width='"+imageWidth+"' height='"+imageHeight+"' alt='"+caption+"'/>" + "<div id='TB_caption'>"+caption+"<div id='TB_secondLine'>" + TB_imageCount + TB_PrevHTML + TB_NextHTML + "</div></div><div id='TB_closeWindow'><a href='#' id='TB_closeWindowButton' title='Close'>close</a> or Esc Key</div>");     


    //最基本的做法

    private int prime1(int num) {
        int i = 0, s = 0;
        label1: for (int n = 2; n <= num; n++) {
            for (int m = 2; m * m <= n; m++) {
                if (n % m == 0)
                    continue label1;
            }
            s++;
            i++;
            //System.out.println("第" + i + "个素数是：" + n);
        }
        return s;
    }

    //6N±1法

    private int prime2(int num){
        int i = 0, s = 0;
        for(int n = 2; n <=3; n ++){
            s++;
            i++;
            //System.out.println("第" + i + "个素数是：" + n);
        }
        label1: for(int n = 1; ; n++) {
            label2: for (int m = 0; m <= 1; m++) {
                int tmp = 2 * (3 * n + m) - 1;
                if (tmp > num)
                    break label1;
                for(int k = 2; k * k <= tmp; k++)
                    if (tmp % k == 0)
                        if (m == 0)
                            continue label2;
                        else
                            continue label1;
                s++;
                i++;
                //System.out.println("第" + i + "个素数是：" + tmp);
            }
        }
        return s;
    }

    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        long start = System.currentTimeMillis();
        int sum = new Prime().prime1(num);
        long end = System.currentTimeMillis();
        System.out.println("方法一共" + sum + "个素数");
        System.out.println("用时：" + (end - start));
        start = System.currentTimeMillis();
        sum = new Prime().prime2(num);
        end = System.currentTimeMillis();
        System.out.println("方法二共" + sum + "个素数");
        System.out.println("用时：" + (end - start));
       
    }
}

输入：1000000

运行结果：

方法一共78498个素数
用时：3434
方法二共78498个素数
用时：3453

（看来基本方法比6N±1法还要更快些，奇怪了，我的程序写的没什么问题阿）

【1】求10000以内的所有素数。
素数是除了1和它本身之外再不能被其他数整除的自然数。由于找不到一个通项公式来表示所有的素数，所以对于数学家来说， 素数一直是一个未解之谜。像著名的 哥德巴赫猜想、孪生素数猜想，几百年来不知吸引了世界上多少优秀的数学家。尽管他们苦心钻研，呕心沥血，但至今仍然未见分晓。
自从有了计算机之后，人们借助于计算机的威力，已经找到了2²¹⁶⁰⁹¹以内的所有素数。
求素数的方法有很多种，最简单的方法是根据素数的定义来求。对于一个自然数N，用大于1小于N的各个自然数都去除一下N，如果都除不尽，则N为素数，否则N为合数。
但是，如果用素数定义的方法来编制计算机程序，它的效率一定是非常低的，其中有许多地方都值得改进。
第一，对于一个自然数N，只要能被一个非1非自身的数整除，它就肯定不是素数，所以不
必再用其他的数去除。
第二，对于N来说，只需用小于N的素数去除就可以了。例如，如果N能被15整除，实际
上就能被3和5整除，如果N不能被3和5整除，那么N也决不会被15整除。
第三，对于N来说，不必用从2到N一1的所有素数去除，只需用小于等于√N(根号N)的所有素数去除就可以了。这一点可以用反证法来证明：
如果N是合数，则一定存在大于1小于N的整数d1和d2，使得N=d1×d2。
如果d1和d2均大于√N，则有：N＝d1×d2>√N×√N＝N。
而这是不可能的，所以，d1和d2中必有一个小于或等于√N。
基于上述分析，设计算法如下：
(1)用2，3，5，7逐个试除N的方法求出100以内的所有素数。
(2)用100以内的所有素数逐个试除的方法求出10000以内的素数。
首先，将2，3，5，7分别存放在a[1]、a[2]、a[3]、a[4]中，以后每求出一个素数，只要不大于100，就依次存放在A数组中的一个单元 中。当我们求100—10000之间的素数时，可依次用a[1]－a[2]的素数去试除N，这个范围内的素数可以不保存，直接打印。

【2】用筛法求素数。
简单介绍一下厄拉多塞筛法。厄拉多塞是一位古希腊数学家，他在寻找素数时，采用了一种与众不同的方法：先将2－N的各数写在纸上：

在2的上面画一个圆圈，然后划去2的其他倍数；第一个既未画圈又没有被划去的数是3，将它画圈，再划去3的其他倍数；现在既未画圈又没有被划去的第一个数 是5，将它画圈，并划去5的其他倍数……依次类推，一直到所有小于或等于N的各数都画了圈或划去为止。这时，表中画了圈的以及未划去的那些数正好就是小于 N的素数。

这很像一面筛子，把满足条件的数留下来，把不满足条件的数筛掉。由于这种方法是厄拉多塞首先发明的，所以，后人就把这种方法称作厄拉多塞筛法。
在计算机中，筛法可以用给数组单元置零的方法来实现。具体来说就是：首先开一个数组：a[i]，i=1，2，3，…，同时，令所有的数组元素都等于下标 值，即a[i]=i，当i不是素数时，令a[i]=0 。当输出结果时，只要判断a[i]是否等于零即可，如果a[i]=0，则令i=i+1，检查下一个a[i]。
筛法是计算机程序设计中常用的算法之一。

【3】用6N±1法求素数。
任何一个自然数，总可以表示成为如下的形式之一：
6N，6N+1，6N+2，6N+3，6N+4，6N+5 (N=0，1，2，…)
显然，当N≥1时，6N，6N+2，6N+3，6N+4都不是素数，只有形如6N+1和6N+5的自然数有可能是素数。所以，除了2和3之外，所有的素数都可以表示成6N±1的形式(N为自然数)。
根据上述分析，我们可以构造另一面筛子，只对形如6 N±1的自然数进行筛选，这样就可以大大减少筛选的次数，从而进一步提高程序的运行效率和速度。

在程序上，我们可以用一个二重循环实现这一点，外循环i按3的倍数递增，内循环j为0－1的循环，则2(i+j)-1恰好就是形如6N±1的自然数。

http://www.blogjava.net/renyangok/archive/2006/11/20/82278.html

     第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。

     第四，&和&&的区别。

     第五，HashMap和Hashtable的区别。

     第六，Collection 和 Collections的区别。

     第七，什么时候用assert。

     第八，GC是什么? 为什么要有GC?

     第九，String s = new String("xyz");创建了几个String Object?

     第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

     第十一，short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

     第十二，sleep() 和 wait() 有什么区别?

     第十三，Java有没有goto?

     第十四，数组有没有length()这个方法? String有没有length()这个方法?

     第十五，Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

     第十六，Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

     第十七，给我一个你最常见到的runtime exception。

     第十八，error和exception有什么区别?

     第十九，List, Set, Map是否继承自Collection接口?

     第二十，abstract class和interface有什么区别?

     第二十一，abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?

     第二十二，接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

     第二十三，启动一个线程是用run()还是start()?

     第二十四，构造器Constructor是否可被override?

     第二十五，是否可以继承String类?

     第二十六，当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

     第二十七，try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

     第二十八，编程题: 用最有效率的方法算出2乘以8等於几?

     第二十九，两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?

     第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

     第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

     第三十二，编程题: 写一个Singleton出来。

以下是答案

第一，谈谈final, finally, finalize的区别。
final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。
finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

     第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?
匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

     第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。
Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。具体可见http: //www.frontfree.net/articles/services/view.asp?id=704&page=1
注： 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

     第四，&和&&的区别。
&是位运算符。&&是布尔逻辑运算符。

     第五，HashMap和Hashtable的区别。
都属于Map接口的类，实现了将惟一键映射到特定的值上。
HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。
Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。

     第六，Collection 和 Collections的区别。
Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。
Collection是个java.util下的接口，它是各种集合结构的父接口。

第七，什么时候用assert。
断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true。如果表达式计算为 false，那么系统会报告一个 AssertionError。它用于调试目的：
  assert(a > 0); // throws an AssertionError if a < = 0
断言可以有两种形式：    
  assert Expression1 ;
  assert Expression1 : Expression2 ;
Expression1 应该总是产生一个布尔值。
Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。
断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记： 
  javac -source 1.4 Test.java
要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。
要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。
要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。
可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

    
第八，GC是什么? 为什么要有GC? (基础)。
GC是垃圾收集器。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：
  System.gc()
  Runtime.getRuntime().gc()

     第九，String s = new String("xyz");创建了几个String Object?
两个对象，一个是“xyx”,一个是指向“xyx”的引用对象s。

     第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
Math.round(11.5)返回（long）12，Math.round(-11.5)返回（long）-11;

     第十一，short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
short s1 = 1; s1 = s1 + 1;有错，s1是short型，s1+1是int型,不能显式转化为short型。可修改为s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正确。

     第十二，sleep() 和 wait() 有什么区别? 搞线程的最爱
sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后，线程不一定立即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非(a)“醒来”的线程具有更高的优先级
(b)正在运行的线程因为其它原因而阻塞。
wait()是线程交互时，如果线程对一个同步对象x 发出一个wait()调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。

     第十三，Java有没有goto?
Goto—java中的保留字，现在没有在java中使用。

     第十四，数组有没有length()这个方法? String有没有length()这个方法？
数组没有length()这个方法，有length的属性。
String有有length()这个方法。

     第十五，Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

     第十六，Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?
Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。
equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

     第十七，给我一个你最常见到的runtime exception。
ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, ConcurrentModificationException, DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException,
ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFormatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException

     第十八，error和exception有什么区别?
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

第十九，List, Set, Map是否继承自Collection接口?
List，Set是

     Map不是

     第二十，abstract class和interface有什么区别?
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

第二十一，abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
都不能

     第二十二，接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?
接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。

     第二十三，启动一个线程是用run()还是start()?
启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

    第二十四，构造器Constructor是否可被override?
构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

     第二十五，是否可以继承String类?
String类是final类故不可以继承。

     第二十六，当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
不能，一个对象的一个synchronized方法只能由一个线程访问。

     第二十七，try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
会执行，在return前执行。

    
第二十八，编程题: 用最有效率的方法算出2乘以8等於几?
有C背景的程序员特别喜欢问这种问题。

     2 <<  3

     第二十九，两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
不对，有相同的hash code。

     第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

    
第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?
switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。

     第三十二，编程题: 写一个Singleton出来。
     Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
public class Singleton {
private Singleton(){}
//在自己内部定义自己一个实例，是不是很奇怪？
//注意这是private 只供内部调用
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}
第二种形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次
//使用时生成实例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance; }
}
其他形式:
定义一个类，它的构造函数为private的，所有方法为static的。
一般认为第一种形式要更加安全些
第三十三 Hashtable和HashMap
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现

     HashMap允许将null作为一个entry的key或者value，而Hashtable不允许

     还有就是，HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。

     最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在
多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap
就必须为之提供外同步。

     Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

它是用于进行两个对象的比较的，是对象内容的比 较，当然也能用于进行对象参阅值的比较。什么是对象参阅值的比较？就是两个参阅变量的值得比较，我们 都知道参阅变量的值其实就是一个数字，这个数字可以看成是鉴别不同对象的代号。两个对象参阅值的比较，就是两个数字的比较，两个代号的比较。这种比较是默 认的对象比较方式，在Object这个对象中，这种方式就已经设计好了。所以你也不用自己来重写，浪费不必要的时间。

• 对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
• 反射性：x.equals(x)必须返回是“true”。
• 类推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
• 还有一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
• 任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。

• 如果x.equals(y)返回“true”，那么x和y的hashCode()必须相等。
• 如果x.equals(y)返回“false”，那么x和y的hashCode()有可能相等，也有可能不等。

为 什么这两个规则是这样的，原因其实很简单，拿HashSet来说吧，HashSet可以拥有一个或更多的箱子，在同一个箱子中可以有一个 或更多的独特元对象（HashSet所容纳的必须是独特的元对象）。这个例子说明一个元对象可以和其他不同的元对象拥有相同的hashCode。但是一个 元对象只能和拥有同样内容的元对象相等。所以这两个规则必须成立。

设计这两个函数所要注意到的：
如果你设计的对象类型并不使用于收集性对象，那么没有必要自己再设计这两个函数的处理方式。这是正确的面向对象设计方法，任何用户一时用不到的功能，就先不要设计，以免给日后功能扩展带来麻烦。

如果你在设计时想别出心裁，不遵守以上的两套规则，那么劝你还是不要做这样想入非非的事。我还没有遇到过哪一个开发者和我说设计这两个函数要违背前面说的两个规则，我碰到这些违反规则的情况时，都是作为设计错误处理。

当 一个对象类型作为收集型对象的元对象时，这个对象应该拥有自己处理equals()，和/或处理hashCode()的设计，而且要遵守前面所说 的两种原则。equals()先要查null和是否是同一类型。查同一类型是为了避免出现ClassCastException这样的异常给丢出来。查 null是为了避免出现NullPointerException这样的异常给丢出来。

摘要

　　Java Web应用程序框架是企业Java得以成功的重要原因之一。人们怀疑如果没有Apache Struts框架Java EE是否能够如此成功。虽然底层编程语言很重要，但通常是框架使编程语言成为引人注目的中心的。如果您经常访问讨论论坛，就会注意到Ruby语言和Ruby On Rails框架之间也是这种情况。Ruby已经出现十多年了，然而只是在Ruby On Rails框架流行之后，开发人员才开始注意到Ruby语言。

　　诸如Ruby、PHP和Python之类的脚本语言最近几年越来越流行，因此，需要开发一个Java脚本备选语言和类似Rails的针对Java环境的框架。Groovy就是这个脚本语言，而Grails就是这个框架。

　　在本文中我将讨论Groovy的Web开发功能，然后继续讨论Grails框架。我将开发一个示例Grails Web应用程序，并讨论此框架的各种特性。

Groovy是什么？

　　Groovy是一种语言，其语法类似于Java，但比Java更简单。它通常被视为脚本/灵活/动态的语言，但是我不喜欢这类形容词，因为我认为它们只会令人困惑。如果说Java是一位明智的中年男子，那么Groovy就是他十几岁的儿子。Groovy具有父亲的许多特点，但是更为狂野且更为有趣。他们也可以很好地合作。

　　Groovy的规则比Java少得多。例如，要在Java中获得标准的"Hello World"输出，您需要编写一个类、一个具有合适参数的主方法，等等。但是在Groovy中，如果不想编写所有样板代码，您可以抛开类定义和主方法，仅编写一行代码即可打印出"Hello World"。

　　以下是打印Hello World的文件 Hello.groovy 的内容：

println "Hello World" 

　　Java平台仅关心使字节码得到执行。同样，此平台不强迫您使用Java语言。只要提供了字节码，工作就会进行。Groovy代码会被编译为字节码，而对于Java平台来说，字节码是从Java代码还是Groovy代码生成的并没有任何区别。

　　以下是一个Groovy例子，它显示了Groovy对清单、映射和范围的内置支持，并证明了Groovy的简单性及其利用Java的强大功能的能力：

// Print Date
def mydate = new java.util.Date()
println mydate
//Iterate through a map
def numbersMAP = ['1':'ONE', '2':'TWO']
for (entry in numbersMAP) {
println "${entry.key} = ${entry.value}"
}
//Introducing the range
def range = 'a'..'d'
//Lists
def numberlist = [1, 2, 3, 4, 5, 6, 7, 8]
println numberlist;
println "Maximum value: ${numberlist.max()}"

　　请注意以上代码直接使用java.util.Date ，对收集的内置支持减少了使用清单、映射和范围所需的代码。还有许多其他有趣的Groovy特性，例如闭包和简化的XML处理。您可以在groovy.codehaus.org上找到详细清单。

　　现在让我们来讨论如何将Groovy用于Web开发。

使用Groovy进行Web开发

　　大多数Java EE教程都从一个基本servlet例子开始。对于Groovy Web开发来说，您将从groovlet（在groovy中servlet的对应概念）开始。如果您在servlet中摆脱了类和doXX() 方法声明，那么剩下的内容就与groovlet很像了。以下是一个名为 Login.groovy 的groovlet例子，您需要将它置于Web应用程序的最高级目录：

def username= request.getParameter("username")
def password= request.getParameter("password")
if (username == "java" && password == "developer") {
response.sendRedirect("home.jsp")
session = request.getSession(true);
session.setAttribute("name", username)
}
else {
println """
<h1>Login Invalid</h1>
<p>Your IP has been logged > ${request.remoteHost}</p>
"""
paramMap = request.getParameterMap()
println "<p>You Submitted:</p>"
for (entry in paramMap) {
println "${entry.key} = ${entry.value}<br/>"
}
}

　　您可以仅创建一个简单的HTML表单，然后将此表单的行为属性发送到 action="Login.groovy"。然后将以下标签添加到web.xml：

<servlet>
<servlet-name>Groovy</servlet-name>
<servlet-class>groovy.servlet.GroovyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Groovy</servlet-name>
<url-pattern>*.groovy</url-pattern>
</servlet-mapping>

　　现在只需将要求的Groovy jar 文件添加到WEB-INF/lib 目录，您的Groovy Web应用程序就准备好在任意Java EE应用服务器上运行了。

　　您应该已经注意到代码中没有分号，而且使用了隐式变量如request和response。其他隐式变量有context、application、session、out、sout和 html。

　　GSP是JSP在groovy中的对应概念。您无需使用println生成HTML；只需将Groovy代码嵌入HTML页面。本文中的例子将在提到Grails时使用GSP。

　　请注意，因为所有代码最终都要转换为字节码，所以groovlet和GSP能够与servlet和JSP轻松协作。因此您无需区分groovlet和GSP或者servlet和JSP。

　　现在让我们讨论前途无量的Grails框架。如果成功的话，Grails能够极大地改变开发Java Web应用程序的方式。Ruby on Rails对Ruby的影响，Grails也能够对Groovy实现。

Grails特性和架构

　　Grails试图使用Ruby On Rails的“规约编程”（coding by convention）范例来降低对配置文件和其他样板代码的需求。使用“规约编程” ，如果文件的名称本身就能说明此文件的用途，那么您就不需要在配置文件中再次声明这些内容了。此框架会查看文件名，并自己弄清文件用途。通过使用“规约编程” ，Grails还将自动生成Web应用程序中需要的许多内容。通过使用Grails，您将能够在很短的时间内、以最小的复杂性使Web应用程序就绪。请看以下例子。

　　Grails基于开源技术，例如Spring、Hibernate和SiteMesh。如果您已经擅长这些技术，那么这是件好事；但是如果您由于某种原因不喜欢这些技术，或者您认为不仅需要学习Grails，还需要学习其他三种框架，那么这就不是件好事了。虽然这些技术能够帮助Grails执行得更好，但是学习四种框架对于大多数人来说是一个很高的门槛。Grails文档目前主要关注它与Spring、Hibernate和其他程序的集成，然而我认为它需要采用相反的方法，将Grails推行为一个简单快速的Web应用程序开发框架。开发人员无需担心或考虑底层发生了什么。

　　幸运的是，一旦您开始使用Grails，您将发现Grails隐藏了这些框架的大多数底层复杂性。如果您忘掉在底层运行的是Spring、Hibernate和其他程序，那么事情就会变得简单。

　　Grails应用程序的三个层是：

1. 由视图和控制器组成的Web层
2. 由域类和服务组成的业务逻辑层
3. 由域类和数据源组成的持久层

　　大多数框架都有数十种特性，其中只有很少几种得到了广泛使用。对于Grails来说，这种关键特性是指“规则编程”（coding by convention）范例和构件的自动生成。

　　Grails的其他特性包括对Ajax、验证、单元测试和功能测试的内置支持。它使用免费的开源Canoo WebTest项目来实现Web应用程序的功能测试。Grails还提供与Quartz Scheduler的集成。

　　现在是时候安装Grails框架并且编写您的第一个应用程序了。

Grails安装

　　安装过程非常简单。以下是Grails下载页面：http://grails.org/Download。您可以从http://dist.codehaus.org/grails/grails-bin-0.2.1.zip下载version 0.2.1。请注意Grails源代码和文档作为单独的下载提供。下载zip文件之后，只需将其内容解压缩到一个目录即可，在我的案例中此目录是 C:\groovy\grails-0.2.1\。

　　创建一个名为GRAILS_HOME 的新环境变量，并将其值设为 C:\groovy\grails-0.2.1\。接下来将GRAILS_HOME\bin 添加到PATH 环境变量。这样安装就完成了。通过在命令提示符界面中运行grails 命令您可以检查安装是否成功。您应该获得此命令的使用信息。

　　既然您有了一个运行中的Grails安装，那么您已经为创建Grails Web应用程序做好了准备。

开发Grails应用程序：应用程序结构

　　多年来我一直计划开发一个可以帮助我管理衣服的应用程序——这个应用程序应该能够告诉我我最喜欢的T恤衫放在哪里、是否洗过、是否熨过，等等。总有一天我会靠销售这个应用程序挣上几百万，但是现在我将把它用作Grails例子。

　　第一步是创建一个Grails项目目录结构。在这一步我将在C:\groovy\grailsapps 创建一个新目录，并在此级别打开一个命令提示符窗口。在此窗口中，执行命令grails create-app。要求您输入应用程序名称。输入 ClothesMgt。Grails将显示它为您创建的全部目录和文件。图1显示了最后得到的命令结构。

　　图1：Grails项目目录结构

　　此命令将创建约800 KB大小的文件和目录。这里的想法是此框架遵循已经建立的Web应用程序开发惯例，因此它创建的文件和目录在大多数Web应用程序中是有用的。虽然有些人可能不喜欢这种强制使用某种结构的想法，但是这种基于惯例的自动生成正是Grails的RAD特性的基础。

　　如果更仔细地看一下这些目录，您就会发现存在用于诸如控制器、视图、测试、配置文件和标签库之类东西的目录。您还会发现存在一些基本JavaScript和CSS文件。那么现在应用程序的基本结构已经有了。您只需做些填空，应用程序即可就绪。

　　请注意自动生成目录和文件的命令是可选的。您可以手动创建全部文件和目录。如果熟悉Apache Ant，那么您甚至可以打开GRAILS_HOME 目录中的\src\grails\build.xml 文件，来仔细查看每个Grails命令的用途。

数据库

　　在此例中我将使用一个 运行于localhost的名为Clothes_Grails的MySQL数据库。Grails内置一个HSQL数据库，这对测试简单的应用程序或仅试用Grails非常有用。如果您使用HSQL DB，那么无需执行以下几步。我将使用MySQL来证明您能够非常轻松地使用HSQL之外的数据库。

　　从http://www.mysql.com/products/connector/j/ 下载MySQL驱动器，并将mysql-connector-java-<version number>-stable-bin.jar 文件放置在ClothesMgt\lib 目录中。接下来您需要编辑 ClothesMgt\grails-app\conf\ApplicationDataSource.groovy文件。

　　现在此文件的内容应该类似以下内容：

class ApplicationDataSource {
boolean pooling = true
String dbCreate = "create-drop"
String url = "jdbc:mysql://localhost/Clothes_Grails"
String driverClassName = "com.mysql.jdbc.Driver"
String username = "grails"
String password = "groovy"
}

　　现在让我们看一下如何使用此数据库和对象关系映射。

域类

　　Grails的对象关系映射(GORM)功能在内部使用Hibernate 3，但是您无需了解或更改任何Hibernate设置。Grails具有称为“域类”的东西，这些域类的对象被映射到数据库。您可以使用关系来链接域类，它们也提供用于CRUD（创建/读取/更新/删除）操作的功能非常强大的动态方法。

　　在此例中，我们将创建三个域类，其名称分别是Shirt、Trouser和Cabinet。要创建域类，只需运行命令 grails create-domain-class。请记住在您的项目目录（而不是它的上级目录）内运行此命令。这是一个常见错误，虽然我已经提醒了您，您还是会犯至少一次这样的错误。

　　您必须提供给create-domain-class 命令的唯一输入是类的名称。运行此命令三次，将Shirt、Trouser和Cabinet作为三个域类的名称。Grails现在将在目录 grails-app/domain/中创建这些域类。它们将仅具有两个属性id 和 version。我将为这些类添加属性，以便使它们更能代表衬衫、裤子和衣橱。

　　清单1：Cabinet.groovy

class Cabinet {
Long id
Long version
String name
String location
def relatesToMany = [ shirts : Shirt, trousers : Trouser ]
Set shirts = new HashSet()
Set trousers = new HashSet()
String toString() { "${this.class.name} :  $id" }
boolean equals(other) {
if(other?.is(this))return true
if(!(other instanceof Cabinet)) return false
if(!id || !other?.id || id!=other?.id) return false
return true
}
int hashCode() {
int hashCode = 0
hashCode = 29 * (hashCode + ( !id ? 0 : id ^ (id >>> 32)) )
}
}

　　清单2： Trouser.groovy

class Trouser {
Long id
Long version
String name
String color
Cabinet cabinet
def belongsTo = Cabinet
String toString() { "${this.class.name} :  $id" }
boolean equals(other) {
if(other?.is(this))return true
if(!(other instanceof Trouser)) return false
if(!id || !other?.id || id!=other?.id) return false
return true
}
int hashCode() {
int hashCode = 0
hashCode = 29 * (hashCode + ( !id ? 0 : id ^ (id >>> 32) ) )
}
}

　　清单3： Shirt.groovy

class Shirt {
Long id
Long version
String name
String color
Cabinet cabinet
def belongsTo = Cabinet
String toString() { "${this.class.name} :  $id" }
boolean equals(other) {
if(other?.is(this))return true
if(!(other instanceof Shirt)) return false
if(!id || !other?.id || id!=other?.id) return false
return true
}
int hashCode() {
int hashCode = 0
hashCode = 29 * (hashCode + ( !id ? 0 : id ^ (id >>> 32)))
}
}

　　我添加的仅有的几行声明了字段名称和颜色，然后声明了Cabinet、Shirt和Trouser之间的关系。每个Shirt和Trouser都属于Cabinet，而Cabinet具有shirt和trouser的集合。belongsTo 属性在此案例中是可选的，因为在一对多关系中，Grails会将“一”这一方视为所有者。因此您就无需显式声明了。在这里我进行显式声明只是为了使这种关系更明显。

　　接下来我们将讨论Grails应用程序的控制器和视图部分。

控制器和视图

　　既然域类已经就绪，让我们使用generate-all命令自动生成基本CRUD Web应用程序。运行grails generate-all 命令三次，当被询问时提供域类名称。generate-all 命令的目的是生成每个域类的控制器和视图，但是由于bug-245，Grails 0.2.1不能生成控制器。您必须手动生成控制器，其方法是对每个域类使用generate-controller 命令。

　　现在您应该在grails-app\controllers 目录中看到三个控制器。这些控制器负责处理Web应用程序中针对特定域类的请求。因此ShirtController.groovy 将处理Web应用程序中与Shirt域类相关的CRUD请求，等等。现在控制器具有多个闭包，每个闭包映射到一个URI。闭包是Groovy语言很好的一个特性，然而要习惯它还是需要一些时间的。清单4显示了Shirtcontroller.groovy的一段摘录。

　　清单4：ShirtController.groovy 摘录

class ShirtController {
def index = { redirect(action:list,params:params) }
def list = {
[ shirtList: Shirt.list( params ) ]
}
def show = {
[ shirt : Shirt.get( params.id ) ]
}
def delete = {
def shirt = Shirt.get( params.id )
if(shirt) {
shirt.delete()
flash.message = "Shirt ${params.id} deleted."
redirect(action:list)
}
else {
flash.message = "Shirt not found with id ${params.id}"
redirect(action:list)
}
}
// ...
}

　　在此例中，ShirtController 中的list闭包将处理URI是/shirt/list的请求，等等。您可在控制器中使用您习惯在Java Web应用程序中使用的东西，例如请求、会话和servletContext。

　　请注意：闭包也将值作为显式返回语句返回，或者作为闭包体中的最后一个语句的值返回。不要因为Grails生成的代码中没有return 而困惑。

　　一旦控制器完成了对请求的处理，它必须委托给合适的视图。Grails使用惯例机制实现此操作。因此ShirtController 中的list闭包将委托给视图 /grails-app/views/shirt/list.gsp 或 /grails-app/views/shirt/list.jsp。 尽管您在使用Grails，全部视图可以是JSP文件而不是GSP。我几乎没有编写任何代码，但是我已经准备好了一个Web应用程序。

　　让我们尝试部署和运行我们的应用程序。

在Java EE Server上部署和运行Grails

　　Grails具有一个内置Resin服务器，您可使用grails run-app 命令运行应用程序。此命令会将应用程序部署到Resin服务器并启动服务器。因此您现在可以在http://localhost:8080/ClothesMgt 访问此应用程序。您还可以同样轻松地将应用程序部署到任意JavaEE服务器。我尝试将它部署到Tomcat。要实现此操作，我所需要做的是运行grails war 命令，将生成的war文件复制到Tomcat中的webapps目录！

　　在此案例中生成的war文件的名称为 ClothesMgt.war。一旦部署到Tomcat，您就应该能够在http://localhost:8080/ClothesMgt/ 上访问它，并看到如图2所示的屏幕。

　　图2：Grails 应用程序

　　通过此应用程序，能够获得Shirt、Trouser和Cabinet的全部CRUD功能。可以显示衣橱的全部数据、向衣橱添加新衬衫和裤子、编辑它们的值和删除记录——实现这些操作都无需编写任何业务逻辑、视图或数据访问代码。仅在几分钟内您就在JavaEE服务器上部署好了一个合适的Web应用程序。很酷吧？！

　　让我们更进一步来定制Grails。

创建自定义控制器

　　我现在将把新功能和页面添加到Web应用程序，同时重用已经存在的域类。shirt/list 和 trouser/list 会分别显示衬衫和裤子的清单，现在让我们添加一个新的显示，来同时显示衬衫和裤子的清单。要创建一个新的显示，您需要一个新的控制器和视图。

　　使用 generate-controller 和 generate-views 命令，可以轻松实现使用域类自动生成视图和控制器。然而，在此案例中我希望创建一个与域类不直接关联的控制器。因此我将使用grails create-controller命令。当被提示输入控制器名称时，声明Display。Grails将在grails-app/controllers/ 目录创建一个名为DisplayController.groovy 的控制器，在grails-tests 目录创建一个测试套件。如清单5所示编辑控制器。

　　清单5：DisplayController.groovy

class DisplayController {
def index = {redirect(action:list,params:params)}
def list = {
params['max'] = 10
return [ shirtList: Shirt.list( params ),
trouserList: Trouser.list( params )]
}
}

　　index 闭包将请求重定向到清单。在list 闭包中我将最大参数设为10，然后使用动态方法Shirt.list 和 Trouser.list。然后返回Groovy Map，它有两个清单——衬衫清单和裤子清单。

　　作为Java开发人员，当看到Shirt.list()时会自然认为是在Shirt域类中的list 方法。然而，如果打开Shirt.groovy，会发现并没有此方法。对于Java开发人员来说，不了解Groovy的特性就使用Grails不仅是令人困惑的，而且是死胡同。动态方法是Grails的特殊特性，它是构建于Groovy语言的一个非常特殊的特性元对象协议 (MOP)之上的。如此证明可以使用动态方法查询域类。因此，在控制器中，您将注意到在域类上调用的方法似乎在域类中不存在。您可以在这里阅读关于使用动态方法查询的更多信息。可以在这里找到对Grails控制器和域类中可用的动态方法的参考资料。

　　既然控制器能够处理请求、获取清单并转发到视图，我需要创建相应视图。

创建自定义视图

　　当创建控制器时，Grails还在grails-app\views 目录创建了一个新的显示目录，并将以下映射添加到web.xml 文件中。

<servlet-mapping>
<servlet-name>grails</servlet-name>
<url-pattern>/display/*</url-pattern>
</servlet-mapping>

　　目前Grails有一个generate-views 命令，此命令能够生成基于域类的视图，然而没有能够自动生成视图的create-view 命令。请看图3中的例子。

　　图3：一个显示Trousers的默认视图

　　因为我希望创建一个独立于域类的视图，所以让我们手动创建视图文件。在目录grails-app\views\display\中，创建一个名为 list.gsp的文件，如清单6所示。

　　清单6：list.gsp

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<title>Display Shirt And Trouser List</title>
<link rel="stylesheet" href="${createLinkTo(dir:'css',file:'main.css')}"></link>
</head>
<body>
<div class="nav">
<span class="menuButton"><a href="${createLinkTo(dir:'')}">Home</a></span>
</div>
<div class="body">
<h1>Shirt List</h1>
<table>
<tr>
<th>Id</th><th>Cabinet</th> <th>Color</th><th>Name</th>
</tr>
<g:each in="${shirtList}">
<tr>
<td>${it.id}</td> <td>${it.cabinet.name}</td>
<td>${it.color}</td> <td>${it.name}</td>
</tr>
</g:each>
</table>
<h1>Trouser List</h1>
<table>
<tr>
<th>Id</th> <th>Cabinet</th>
<th>Color</th> <th>Name</th>
</tr>
<g:each in="${trouserList}">
<tr>
<td>${it.id}</td> <td>${it.cabinet.name}</td>
<td>${it.color}</td> <td>${it.name}</td>
</tr>
</g:each>
</table>
</div>
</body>
</html>

　　与我之前使用的方式类似，您现在也可以使用run-app 命令运行应用程序，或者创建一个war文件并将其部署到Tomcat。您应该在http://localhost:8080/ClothesMgt/display/下看到新的视图，如图4所示。

　　图4：新创建的列出衬衫和裤子清单的视图

　　现在让我们快速讨论一下Grails服务。

服务

　　如果您想知道如何分开业务逻辑以及放置业务逻辑的位置，答案在Grails 服务中。服务以SomeNameService.groovy 格式命名，且被置于 /grails-app/services/目录。服务可利用依赖注入特性，您能够轻松地从控制器内部调用这些服务。

　　让我们来看一个使用服务的例子。首先，使用create-service 命令创建新服务。运行此命令并命名服务Order。Grails将创建两个文件——grails-app/services/OrderService.groovy 和 grails-tests/OrderTests.groovy。

　　现在编辑OrderService.groovy，如清单7所示。当引入新的orderGoods() 方法时会自动生成serviceMethod() 。

　　清单7：OrderService.groovy

class OrderService {
boolean transactional = true
def serviceMethod() {
// TODO
}
def orderGoods() {
return "Order Placed - New shirts and trousers \
will be sent shortly."
}
}

　　现在编辑DisplayController，如清单8所示。引入使用OrderService的重排闭包。请注意服务将由Groovy注入。

　　清单8：DisplayController.groovy

class DisplayController {
OrderService orderService
def index = {redirect(action:list,params:params)}
def list = {
params['max'] = 10
return [ shirtList: Shirt.list( params )
, trouserList: Trouser.list( params )]
}
def reorder = {
render(orderService.orderGoods())
}
}

　　现在当您访问URL http://localhost:8080/ClothesMgt/display/reorder时，重排闭包将调用 OrderService，响应会被发回到浏览器。您能够以类似方式将全部业务逻辑移入服务，然后使用Grails的注入功能非常轻松地使用它们。

动态方法和属性

　　正如之前提到的，域类没有能够从数据库获取数据或更新/删除现有数据的任何方法，例如find()、 findAll() 或 save() 。在控制器中您也没有编写诸如 redirect() 或 render() 之类的方法。但是域类和控制器有它们的计划目的，且允许所有要求的操作。原因是Grails中动态方法和属性的存在。动态方法被动态添加到类，就好像功能是在程序中编译的一样。

　　这些是可用的方法和属性，无需编写。这些动态方法涵盖了大多数Web应用程序开发中会碰到的常见情况。对于域类来说，存在诸如find()、findAll()、list()、executeQuery()、save()和 delete()之类的动态方法。控制器具有诸如session、request和response之类的动态属性，以及诸如chain()、render()和 redirect()之类的方法。要真正利用Grails的强大功能，您需要了解所有这些动态方法和属性的功能。

顺便介绍一下：自动重载和@Property

　　Grails的一个重要特性是能够在开发过程中进行了更改时自动重载文件。因此只需编辑和保存gsp文件，就会自动重载新文件。然而这里创建的类似OrderService 的事务服务不会被重载。您会在服务器控制台看到以下消息"[groovy] Cannot reload class [class OrderService] reloading of transactional service classes is not currently possible. Set class to non-transactional first. "。

　　Grails的自动重载功能会为您节省许多时间，您就无需浪费时间来重启服务器了。我碰到过一些Grails不能自动重载的案例，例如将一个jsp文件重命名到gsp。然而，Grails的这项功能有望在未来版本中得到进一步改进。

　　在Groovy JSR 06 的之前版本中，您必须使用@Property 来定义Groovy中的新属性。因此您会在线看到许多使用@Property的旧的Groovy例子。然而请注意，@Property已经从Groovy JSR 06中移除，在Grails 0.2和之后的版本中也不会再需要它。请参阅@Property 建议来获得更多细节。

结束语

　　在本文中，我介绍了Grails框架的基本特性，并使用Grails创建了一个应用程序。Groovy和Grails最大的好处是一切都运行在优秀的旧Java和Java EE上——因此您能够使用Groovy和Grails的RAD特性快速开发应用程序，然后将应用程序部署到可靠的Java EE服务器上。考虑到关于Ruby和Rails的宣传噪音，显然需要一个Java备选方案。Groovy和Grails看起来非常适合这个角色。

下载

　　下载本文中的代码：

• 本文中的代码 (zip)。
• 最新版本的SVN快照。

参考资料

• Grails主页
• Groovy主页
• Grails Wiki
• Grails Mailing 清单
• Groovy, Java's New Scripting Language (ONJava, 2004)
• Getting to Know Groovy (Sun, 2005)
• Groovy bridges the scripting and the enterprise Java worlds (IndicThreads, 2006)

substr 方法
返回一个从指定位置开始的指定长度的子字符串。

stringvar.substr(start [, length ])

参数
stringvar

必选项。要提取子字符串的字符串文字或 String 对象。

start

必选项。所需的子字符串的起始位置。字符串中的第一个字符的索引为 0。

length

可选项。在返回的子字符串中应包括的字符个数。

说明
如果 length 为 0 或负数，将返回一个空字符串。如果没有指定该参数，则子字符串将延续到 stringvar 的最后。

示例
下面的示例演示了substr 方法的用法。

function SubstrDemo(){
   var s, ss;                // 声明变量。
   var s = "The rain in Spain falls mainly in the plain.";
   ss = s.substr(12, 5);  // 获取子字符串。
   return(ss);               // 返回 "Spain"。
}

substring 方法
返回位于 String 对象中指定位置的子字符串。

strVariable.substring(start, end)
"String Literal".substring(start, end)

参数
start

指明子字符串的起始位置，该索引从 0 开始起算。

end

指明子字符串的结束位置，该索引从 0 开始起算。

说明
substring 方法将返回一个包含从 start 到最后（不包含 end ）的子字符串的字符串。

substring 方法使用 start 和 end 两者中的较小值作为子字符串的起始点。例如， strvar.substring(0, 3) 和 strvar.substring(3, 0) 将返回相同的子字符串。

如果 start 或 end 为 NaN 或者负数，那么将其替换为0。

子字符串的长度等于 start 和 end 之差的绝对值。例如，在 strvar.substring(0, 3) 和 strvar.substring(3, 0) 返回的子字符串的的长度是 3。

示例
下面的示例演示了 substring 方法的用法。

function SubstringDemo(){
   var ss;                         // 声明变量。
   var s = "The rain in Spain falls mainly in the plain..";
   ss = s.substring(12, 17);   // 取子字符串。
   return(ss);                     // 返回子字符串。
}

1.    在Apache下为SVN建立多个库。上篇中虽然也建立了一个SVN的库在Apache下，但是我们不可能一个SVN服务器上只有一个项目，或者所有项目共用一个SVN库进行开发，在Apache上为SVN建立多个库可以通过建立多个虚拟目录的方式实现。下面我们就来讲讲具体的步骤（注意，此篇中的配置和上篇中的配置方式有很大区别）
   
   
   1. 到F盘建立我们的SVN代码存放位置目录：SubversionFiles，并在其中建立一个conf目录，将会把对Apache对SVN的配置文件都放在这里
      
   2. 再在F:\SubversionFiles下目录Test1和Test2，并将它们变成SVN库（用svnadmin create命令或者用TortoiseSVN来创建都可以）
      
   3. 在httpd.conf的最后添加如下代码
      
      #
      # SVN 项目配置文件，格式：Include 配置文件名
      #为每个虚拟目录设置一个配置文件，用Include命令加载
      #
      Include F:/SubversionFiles/conf/*.project
      
      即把F:/SubversionFiles/conf/目录下的所有*.project文件都包到httpd.conf中来
      
      
      
   4. 在F:/SubversionFiles/conf/创建Test1.project和Test2.project文件，Test1内容如下，Test2可以做相应的修改
      
      #SVN项目名
      
           DAV svn
      
          #SVN项目的路径
           SVNPath F:\SubversionFiles\Test1
      
          #SVN项目的路径权限授权文件存放路径
          AuthzSVNAccessFile F:\SubversionFiles\conf\Test1.access
      
      #对于所有用户都需要身份验证
          Satisfy Any
           Require valid-user
      
      #验证方式
          AuthType Basic
      
          #项目的名称
           AuthName "My Test1"
      
          #用户信息
           AuthUserFile  F:\SubversionFiles\conf\user
      
      
      
      
      以上配置含义是在Apache下建立了一个叫作Test1的SVN虚拟目录，指向F:\SubversionFiles\Test1，授权配置文件是F:\SubversionFiles\conf\Test1.access，用户信息和密码文件是F:\SubversionFiles\conf\user
      
      
      
   5.  通过以上配置，我们就在Apache上建立了Test1和Test2两个虚拟目录，也就是两个独立的SVN库，我们还需要两个文件访问权限配置的.access和包含登录用户的user。 在F:\SubversionFiles\conf目录中创建用户列表文件user，方法在上篇中已经说过，也就是htpasswd命令，我们需要创建Xrinehart, X-Killer, Guest三个用户。
      
      
   6. 接下来，我们为Test1库创建它的访问权限文件F:\SubversionFiles\conf\Test1.access。在上篇文章中我们是采用对每个用户分别赋予对应权限的方式，如果用户比较多，管理起来就会比较麻烦，这时我们需要用用户组来对用户进行管理。下面我们就来尝试用用户组配置访问权限。Test1.access文件内容如下：
      
      
      [groups]
      AdminGroup = Xrinehart
      GuestGroup = guest
      
      [/]
      @AdminGroup = rw
      @GuestGroup = r
      
      X-Killer = rw
      
      
              在上面的配置中，通过[groups]节定义了两个用户组：AdminGroup和GuestGroup，并将Xrinehart用户归入AdminGroup用户组，guest用户归入GuestGroup。再在下面的[/]定义了他们对Test1库的根目录的操作权限：AdminGroup组有读写权限，GuestGroup组只有读权限，X-Killer用户拥有读写权限。这里需要注意的是定义权限的时候，用户组需要在前面加@符号来标示。
      
      
   7. 为了测试效果，我们可以将Test2.access文件写为：
      
      [groups]
      AdminGroup = Xrinehart, X-Killer
      GuestGroup = guest
      
      [/]
      @AdminGroup = r
      @GuestGroup = rw
      
      
      
   8. 保存好上面的所有配置文件之后，重新启动Apache服务器。此时我们就可以在IE里面通过http://localhost:8080/Test1 和http://localhost:8080/Test2 来访问Test1和Test2库了，你可以测试一下，用户权限是否符合下面这个列表所示？做到这里，SVN在Apache上建立多个库的配置也就算完成了。
      
      
                                                       Test1                                            Test2
      
      Xrinehart                                    rw                                                  r
      X-Killer                                       rw                                                  r
      guest                                          r                                                    rw
      

1. 准备工作：
   
   
   1. 下载软件：
      1. SVN服务器端程序。到官方网站 的下载二进制安装文件，来到二进制包下载部分  ，找到 Windows NT, 2000, XP and 2003部分，然后选择"this directory"，这样我们可以看到许多下载的内容，目前可以下载 svn-1.2.3-setup.exe。
         
         
      2. TortoiseSVN，客户端程序。TortoiseSVN是扩展Windows Shell的一套工具，可以看作Windows资源管理器的插件，安装之后Windows就可以识别Subversion的工作目录。
         官方网站是TortoiseSVN，下载方式和前面的svn服务器类似，在Download页面的我们选择Official version for Win2k/XP or higher的版本，然后在sourceforge的下载页面选择目前的最高稳定版本的安装文件TortoiseSVN-1.2.5.4719-svn-1.2.3.msi。（注意：TortoiseSVN有一个特殊对VS.Net运行时一个BUG修正的版本，在下载页面有选择：Special version for Win2k/XP or higher: (We provide NO support for this!) uses _svn folders instead of .svn to work around the VS.NET bug with web projects. If you don't use web projects then please use the official version. ）
         
         
      3. TortoiseSVN的中文语言包，注意这个需要下和客户端程序版本相同的。可以在Download页面内的Language Packs选择下载。
         
         
      4. Apache服务器程序。可以到Apache官方网站下载最新版本的Apache，并且SVN必须运行在Apache2以上版本，在下载页面选择Windows的安装包文件apache_2.0.55-win32-x86-no_ssl.msi
         
         
      5. AnkhSVN，可选安装VS.Net的SVN插件。有0.5和0.6版本选择，0.6版支持VS2005 Beta2，下载页面。
         
         
   2. 停止IIS，因为Apache默认安装为80端口，需要关闭IIS避免端口冲突。可以在安装好之后再调整端口。
      
      
      
2. 开始安装：
   
   
   1. 先安装Apache服务器。在到填写ServerInfo的时候，若机器已经启用了AD，安装程序会自动填写，否则自己手动填写。安装完成之后到安装目录下找到conf目录下的httpd.config文件，搜索Listen，并将Listen后面的80改为8080（或者你希望的端口），然后重新启动Apache服务器，这时可以用http://localhost:8080 来测试是否安装正确。
      
      
   2. 再安装SVN服务器，没有什么好说的，一路回车就可以了。（安装SVN时，请确保Apache服务器正在运行状态，安装过程中可能会将Apache关闭，重新启动属于正常现象）
      
      
3. 配置Apache服务器与SVN集成：
   
   
   
   1. 首先将Subversion安装目录bin\下面的两个文件：mod_authz_svn.so和mod_dav_svn.so复制到Apache安装目录modules\目录下。
      
   2. 有些文章说需要再修改httpd.conf，并做如下修改：
      找到Apache安装目录下的conf目录，用文本编辑器打开httpd.conf，找到一下两行：
      
      #LoadModule dav_module modules/mod_dav.so
      #LoadModule dav_fs_module modules/mod_dav_fs.so
      
      将每行前面的注释符“#”去掉。再在所有LoadModule语句的最后添加一下几行：
      
      #SVN
      LoadModule dav_svn_module modules/mod_dav_svn.so
      LoadModule authz_svn_module modules/mod_authz_svn.so
      
      但是我安装完之后发现这个文件已经被做了那些修改，大概是新版的SVN安装程序做了一些优化吧。其实在成功安装SVN之后，Apache服务器已经和SVN初步集成。如图：
      
      
      
      注意下面的状态栏已经是Apache/2.0.55 SVN1.2.3 DAV/2
      
      
   3. 建立一个SVN存放文件的目录，我在F盘下创建一个文件夹：F:/SubversionFiles
   4. 接下来我们必须告诉Apache我们的资源库所在的路径，可以通过Location指令来完成这个设置。因为不希望为每个单独的项目都进行单独的设置，所以我们把所有项目都存放在统一的资源库目录，那么可以使用SVNParentPath指令来指定存放所有项目的路径。在httpd.conf文件最后添加下面配置：
      
      #SVN
      
      <Location /svn>
          DAV svn
          SVNParentPath "F:/SubversionFiles"
      </Location>
      
      

   这样我们就可以通过http://myhost:8080/svn/<项目名> 来访问存放于资源库F:/SubversionFiles中的指定项目。当然有可能你并不希望某个项目提供这样一种访问方式，这时候你可以使用SVNPath为每个项目进行单独的设置，SVNPath的使用方法如下：
   
       DAV svn
       SVNPath "F:/SubversionFiles/project1"
   

   同样把这段配置放在httpd.conf最后，重启Apache HTTP服务即可通过http://myhost:8080/svn/project1 来访问project1项目的资源库。

   1. 下面作一个测试：

      1. 到F:\SubversionFiles下建立一个子目录Test，然后到Aapche下的Bin目录下执行svnadmin create F:\SubversionFiles\Test

      2. 打开浏览器输入网址：http://localhost:8080/svn/Test ，应该可以正确访问，但当前该项目下还没有加入任何内容，所以显示为空的

      3. 有一点需要提示的是，现在的访问是完全匿名的，任何人都可以对SVN进行操作。所以我们接下来利用Apache的权限管理功能来对SVN进行用户验证集成

   2. 加入用户身份验证：
      
      在确定对访问用户的权限控制之前，你必须规划好是对整个资源库中的所有项目还是单独的某一个项目进行统一的身份验证， 也就是我们前面讲到的是使用SVNParentPath还是SVNPath的问题。
      
      最简单的身份验证方式是使用Basic HTTP Authentication机制，该方式通过用户名和口令对访问用户进行身份验证。我们可以直接通过Apache提供的支持进行设置。Apache提供一个htpasswd工具来管理用户名和口令。接下来我们利用这个工具来添加两个用户。
      
      在命令行窗口中转到Apache所在的目录，执行下列命令
      
      说明：创建用户Xrinehart
      输入：htpasswd –c F:\SubversionFiles\svn_auth_passwd Xrinehart
      说明：使用-c参数来创建一个passwd文件
      输出：
      New password: *****
      Re-type new password: *****
      Adding password for user Xrinehart
      
      再创建用户的时候就不用-c参数，而是用-m参数，因为文件svn_auth_passwd 已经创建。
      
      

      打开svn_auth_passwd文件，密码使用MD5加密过了，而且同样的密码加密出来的内容却不相同
      
      接下来我们必须告诉Apache服务器如何使用这个passwd文件，打开httpd.conf找到刚才我们添加的Location配置的位置，修改如下：
      
      #
      # SVN
      #
      
        DAV svn
        SVNParentPath "F:/SubversionFiles"
      
      # how to authenticate a user
       AuthType Basic
       AuthName "Subversion repository"
       AuthUserFile "F:/SubversionFiles/svn_auth_passwd"
       
        # only authenticated users may access the repository
      Require valid-user
      
      
      重新启动Apache HTTP服务器，使用浏览器打开 http://localhost:8080/svn/Test 你将会看到要求登录的对话框，输入你刚设置的用户名和口令即可。
      
      这样Apache和SVN的集成就基本告成了