BlogJava-Junky's IT Notebook-随笔分类-webhttp://www.blogjava.net/junky/category/11396.htmlzh-cnFri, 06 Jul 2007 17:33:15 GMTFri, 06 Jul 2007 17:33:15 GMT60spring+JAX-RPC(Axis) 构建webservicehttp://www.blogjava.net/junky/archive/2007/07/06/128590.htmljunkyjunkyFri, 06 Jul 2007 07:07:00 GMThttp://www.blogjava.net/junky/archive/2007/07/06/128590.htmlhttp://www.blogjava.net/junky/comments/128590.htmlhttp://www.blogjava.net/junky/archive/2007/07/06/128590.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/128590.htmlhttp://www.blogjava.net/junky/services/trackbacks/128590.html阅读全文

junky 2007-07-06 15:07 发表评论
]]>WebWork2教程（中文版）（1）http://www.blogjava.net/junky/archive/2007/06/28/126726.htmljunkyjunkyThu, 28 Jun 2007 01:42:00 GMThttp://www.blogjava.net/junky/archive/2007/06/28/126726.htmlhttp://www.blogjava.net/junky/comments/126726.htmlhttp://www.blogjava.net/junky/archive/2007/06/28/126726.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/126726.htmlhttp://www.blogjava.net/junky/services/trackbacks/126726.html1、下载和安装WW2

（1）本教程基于WebWork 2.1版本，在webwork.dev.java.net网站上下载webwork-2.1.zip；

（2）将压缩包解压，使用WebWork所需要的lib包括webwork-2.1.jar和lib/core文件夹中的jar文件



junky 2007-06-28 09:42 发表评论
]]>WebWork2教程（中文版）(3)http://www.blogjava.net/junky/archive/2007/06/28/126724.htmljunkyjunkyThu, 28 Jun 2007 01:41:00 GMThttp://www.blogjava.net/junky/archive/2007/06/28/126724.htmlhttp://www.blogjava.net/junky/comments/126724.htmlhttp://www.blogjava.net/junky/archive/2007/06/28/126724.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/126724.htmlhttp://www.blogjava.net/junky/services/trackbacks/126724.html3、Actions和Results

Actions是基本执行单元，在WebWork配置中注册，用来响应特定的请求。在MVC中，Actions是控制部分。下面是在WebWork中创建Action的基本步骤：

l         创建调用Action的JSP页；

l         创建Action类；

l         创建处理Action返回结果的JSP页；

l         在xwork.xml中注册Action；

（1）Hello WebWorld的例子

l         xwork.xml文件内容如下：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN"
"http://www.opensymphony.com/xwork/xwork-1.0.dtd">
 
<xwork>
       <!-- Include webwork defaults (from WebWork-2.1 JAR). -->
       <include file="webwork-default.xml" />
       
       <!-- Configuration for the default package. -->
       <package name="default" extends="webwork-default">
              <!-- Default interceptor stack. --> 
              <default-interceptor-ref name="defaultStack" /> 
         
              <!-- Action: Lesson 03: HelloWebWorldAction. --> 
              <action name="helloWebWorld" class="lesson03.HelloWebWorldAction"> 
                <result name="success" type="dispatcher">ex01-success.jsp</result> 
              </action> 
       </package>
</xwork>

配置文件告诉WebWork，有一个叫helloWebWorld的Action，由lesson03.HelloWebWorldAction实现；同时定义了一个叫success的结果，指向ex01-success.jsp页面；

l         调用Action的页面ex01-index.jsp：

<html>
<head>
<title>WebWork Tutorial - Lesson 3 - Example 1</title>
</head>
 
<body>
 
<p>Click the button below to activate HelloWebWorldAction.</p>
 
<form action="helloWebWorld.action" method="post">
<p><input type="submit" value="Hello!" /></p>
</form>
 
</body>
</html>

当点击页面的按钮时，浏览器提交表单数据给helloWebWorld.action；既然URL匹配映射*.action，Servlet容器激活WebWork的ServletDispatcher；ServletDispatcher读取xwork.xml，查找名为helloWebWorld的Action，如果找到就创建Action类的一个新实例，调用execute()方法

l         Action类：HelloWebWorldAction.java

package lesson03; 
 
import com.opensymphony.xwork.ActionSupport; 
 
public class HelloWebWorldAction extends ActionSupport { 
       String hello; 
       public String getHello() { 
              return hello; 
       }
       public String execute() throws Exception { 
              hello = "Hello, WebWorld!"; 
              return SUCCESS; 
       } 
}

Action类继承com.opensymphony.xwork.ActionSupport，并实现execute()方法；execute()方法的返回值SUCCESS和success（<result>的name属性值）对应；ServletDispatcher查找名字相匹配的result，转移到指定的JSP页ex01-success.jsp

l         结果显示JSP页ex01-success.jsp：

<%@ taglib uri="webwork" prefix="ww" %> 
<html> 
<head> 
<title>WebWork Tutorial - Lesson 3 - Example 1</title> 
</head> 
<body> 
 
<ww:property value="hello" /> 
 
</body> 
</html>

<ww:property value="hello" />在Action类中查找hello属性，调用hello属性的setter方法获得属性值（在execute()中已经设置），显示Hello, WebWorld!

（2）向Action提供数据的例子

xwork.xml：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN"
"http://www.opensymphony.com/xwork/xwork-1.0.dtd">
 
<xwork>
       <!-- Include webwork defaults (from WebWork-2.1 JAR). -->
       <include file="webwork-default.xml" />
       
       <!-- Configuration for the default package. -->
       <package name="default" extends="webwork-default">
              <!-- Default interceptor stack. --> 
              <default-interceptor-ref name="defaultStack" /> 
         
              <!-- Action: Lesson 03: HelloAction. -->
              <action name="hello" class="lesson03.HelloAction">
                <result name="error" type="dispatcher">ex02-index.jsp</result>
                <result name="success" type="dispatcher">ex02-success.jsp</result>
              </action>
       </package>
</xwork>

HelloAction.java：

package lesson03;
 
import com.opensymphony.xwork.ActionSupport;
 
public class HelloAction extends ActionSupport {
       String person;
       public String getPerson() {
              return person;
       }
       public void setPerson(String person) {
              this.person = person;
       }
       public String execute() throws Exception {
              if ((person == null) || (person.length() == 0)) return ERROR;
              else return SUCCESS;
       }
}

ex02-index.jsp：

<html>
<head>
<title>WebWork Tutorial - Lesson 3 - Example 2</title>
</head>
 
<body>
 
<p>What's your name?</p>
 
<form action="hello.action" method="post">
<p><input type="text" name="person" /><input type="submit" /></p>
</form>
 
</body>
</html>

ex02-success.jsp：

<%@ taglib uri="webwork" prefix="ww" %>
<html>
<head>
<title>WebWork Tutorial - Lesson 3 - Example 2</title>
</head>
<body>
 
Hello, <ww:property value="person" />
 
</body>
</html>

这个例子使用POST方法向Action发送表单数据（使用person名），在HelloAction的实例创建以后，ServletDispatcher调用setter方法用数据设置Action的对应属性（person）；因此，在执行execute()之前，person属性已经设置了

（3）result的类型

上面的例子中使用的result类型是dispatcher，而WebWork的result类型已经在webwork-default.xml中配置：

l         dispatcher (com.opensymphony.webwork.dispatcher.ServletDispatcherResult)： forwards 结果到指定位置URL

l         redirect (com.opensymphony.webwork.dispatcher.ServletRedirectResult)： redirects结果到指定位置URL ；与dispatcher不同的是不会发送表单数据

l         velocity (com.opensymphony.webwork.dispatcher.VelocityResult：使用 Velocity 模版作为结果，需要在web.xml中配置 VelocityServlet，这是一种很好的方法

l         chain (com.opensymphony.xwork.ActionChainResult): Action链，将结果传送给另外一个Action

l         xslt (com.opensymphony.webwork.views.xslt.XSLTResult): 使用XSLT式样格式化结果



junky 2007-06-28 09:41 发表评论
]]>WebWork2教程（中文版）（2）http://www.blogjava.net/junky/archive/2007/06/28/126725.htmljunkyjunkyThu, 28 Jun 2007 01:41:00 GMThttp://www.blogjava.net/junky/archive/2007/06/28/126725.htmlhttp://www.blogjava.net/junky/comments/126725.htmlhttp://www.blogjava.net/junky/archive/2007/06/28/126725.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/126725.htmlhttp://www.blogjava.net/junky/services/trackbacks/126725.html2、建立Web应用程序

（1）这里假设你安装了Servlet容器，并知道如何创建一个Web应用程序；如果你不知道，建议学习Apache Tomcat（Apache Jakarta项目中的一个免费Servlet容器）；

（2）复制需要的运行库（webwork-2.1.jar和lib/core/*.jar）到Web应用程序的WEB-INF/lib文件夹中；

（3）如下配置web.xml、xwork.xml和validators.xml文件；

（4）web.xml看起来象下面的样子：

<?xml version="1.0"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
 
<web-app>
       <display-name>My WebWork Application</display-name>
       <servlet>
              <servlet-name>webwork</servlet-name>
              <servlet-class>com.opensymphony.webwork.dispatcher.ServletDispatcher</servlet-class>
              <load-on-startup>1</load-on-startup>
       </servlet>
       <servlet-mapping>
              <servlet-name>webwork</servlet-name>
              <url-pattern>*.action</url-pattern>
       </servlet-mapping>
       <taglib>
              <taglib-uri>webwork</taglib-uri>
              <taglib-location>/WEB-INF/lib/webwork-2.1.jar</taglib-location>
       </taglib>
</web-app>

为了使用WebWork，必须注册ServletDispatcher，并映射到*.action；作为可选，如果要使用WebWork的tags，要声明WebWork的taglib描述；

（5）在WEB-INF/classes目录下创建WebWork的配置文件xwork.xml，下面是一个配置框架（会在教程的后面增加内容）：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" 
"http://www.opensymphony.com/xwork/xwork-1.0.dtd">
 
<xwork>
       <!-- Include webwork defaults (from WebWork-2.1 JAR). -->
       <include file="webwork-default.xml" />
       
       <!-- Configuration for the default package. -->
       <package name="default" extends="webwork-default">
       </package>
</xwork>

这做两件事：

l         导入webwork-default.xml（位于webwork-2.1.jar中）的配置信息，包含WebWork应用程序的缺省配置；

l         定义名为default的package，用于actions、 results和interceptors的注册；这个package继承webwork-default，以继承其中定义的配置；

（6）在WEB-INF/classes目录下创建validators.xml。包括以下内容：

<!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator
1.0//EN" "http://www.opensymphony.com/xwork/xwork-validator-1.0.dtd"> 
 
<validators> 
       <validator name="required"
              class="com.opensymphony.xwork.validator.validators.RequiredFieldValidator"/> 
       <validator name="requiredstring"
              class="com.opensymphony.xwork.validator.validators.RequiredStringValidator"/> 
       <validator name="int"
              class="com.opensymphony.xwork.validator.validators.IntRangeFieldValidator"/> 
       <validator name="date"
              class="com.opensymphony.xwork.validator.validators.DateRangeFieldValidator"/> 
       <validator name="expression"
              class="com.opensymphony.xwork.validator.validators.ExpressionValidator"/> 
       <validator name="fieldexpression"
              class="com.opensymphony.xwork.validator.validators.FieldExpressionValidator"/> 
       <validator name="email"
              class="com.opensymphony.xwork.validator.validators.EmailValidator"/> 
       <validator name="url"
              class="com.opensymphony.xwork.validator.validators.URLValidator"/> 
       <validator name="visitor"
              class="com.opensymphony.xwork.validator.validators.VisitorFieldValidator"/> 
       <validator name="conversion"
              class="com.opensymphony.xwork.validator.validators.ConversionErrorFieldValidator"/> 
</validators>

这个文件定义可以使用的有效Validators。



junky 2007-06-28 09:41 发表评论
]]>WebWork2教程（中文版）(4.1.1) http://www.blogjava.net/junky/archive/2007/06/28/126721.htmljunkyjunkyThu, 28 Jun 2007 01:40:00 GMThttp://www.blogjava.net/junky/archive/2007/06/28/126721.htmlhttp://www.blogjava.net/junky/comments/126721.htmlhttp://www.blogjava.net/junky/archive/2007/06/28/126721.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/126721.htmlhttp://www.blogjava.net/junky/services/trackbacks/126721.html阅读全文

junky 2007-06-28 09:40 发表评论
]]>WebWork2教程（中文版）(4.1) http://www.blogjava.net/junky/archive/2007/06/28/126722.htmljunkyjunkyThu, 28 Jun 2007 01:40:00 GMThttp://www.blogjava.net/junky/archive/2007/06/28/126722.htmlhttp://www.blogjava.net/junky/comments/126722.htmlhttp://www.blogjava.net/junky/archive/2007/06/28/126722.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/126722.htmlhttp://www.blogjava.net/junky/services/trackbacks/126722.html4、视图

有几种作为视图的技术可以使用：

l         JSP：这是Java Web开发者熟悉的技术，可以作为通用选择；本教程介绍在JSP中使用WebWork的标记库

l         Velocity：一种基于Java的模板引擎，提供简单而强大的模板语言VTL来替代JSP，将Java代码从Web页面中分离

l         Freemaker：对于MVC模式设计，另外一种可以替代JSP的基于Java的模板引擎，但兼容JSP标记

4.1、使用JSP作为视图

使用JSP呈现视图，可以使用Scriptlets或WebWork标记来访问Action的数据。推荐使用WebWork标记库。

（1）使用Scriptlets访问Acition的数据

在Scriptlets中是使用Value Stack对象访问Action的数据的，下面是使用Scriptlets实现上节中第二个例子的结果输出页面：

<%@ page import="com.opensymphony.xwork.util.OgnlValueStack" %>
<html>
<head>
<title>WebWork Tutorial - Lesson 4.1 - Lesson 3's example modified</title>
</head>
<body>
<%
OgnlValueStack stack = (OgnlValueStack)request.getAttribute("webwork.valueStack");
out.write("Hello, " + stack.findValue("person"));
%>
</body>
</html>

然而，推荐使用WebWork标记，就象上节中第二个例子使用<ww:property />做的那样，具有清晰的语法，并能在Value Stack对象不存在时处理。

（2）使用WebWork标记库

WebWork标记库可以分为7类：

l         通用标记：最常用的基本标记；

l         组件标记：在视图中生成组件；

l         流程控制标记：控制JSP中的流程；

l         Iteration标记：遍历访问元素或操作可遍历对象；

l         UI标记：生成HTML表单域和控制；

l         VUI标记：（需要志愿者来编写）；

l         国际化标记：使视图具有国际化；

（1）通用标记

<ww:property />

获得结果属性值；如果值不存在，返回Value Stack 中最顶上的值

<ww:push />

将值推入Value Stack

<ww:param />

设置父标记的参数（属性）值；该标记只能在其它标记内部使用

<ww:set />

设置Value Stack 中具有指定范围（page, stack, application, session）的对象值；如果没有指定值，使用Value Stack 中最顶上的值

<ww:url />

创建编码的URL

（2）组件标记

<ww:action />

在taglib的上下文中执行一个Action ，标记体用来显示Action 的响应结果

<ww:bean />

在ActionContext 中创建一个JavaBean，实例化它的属性，以便以后使用

<ww:include />

包含另外一个页面或Action

（3）流程控制标记

<ww:if />

如果条件标记的布尔表达式为true ，计算标记体的内容

<ww:else />

如果前面条件标记的布尔表达式为false，计算标记体的内容

<ww:elseif />

如果前面条件标记的布尔表达式为false，而本条件标记的布尔表达式为true，计算标记体的内容

（4）Iteration标记

<ww:iterator />

遍历一个集合

<ww:generator />

生成遍历对象

<ww:append />

追加遍历对象

<ww:subset />

获得遍历对象的子集

<ww:merge />

合并几个遍历对象为一个.

（5）UI标记

生成HTML表单控件的UI标记和WebWork核心紧密集成，标记被设计为最小化编译代码逻辑的数量和使用模板系统呈现HTML的代表。UI标记覆盖了大部分常用标记，而且提供了一个组件标记，用来创建定制组件。UI标记还提供了显示内联错误信息的内建支持。有关UI标记的详细介绍，在下一节中讲述。

（6）VUI标记

需要志愿者来编写。

（7）国际化标记

<ww:text />

打印出国际化字符串

<ww:i18n />

将一个资源包放到Value Stack中, 以便<ww:text />标记使用



junky 2007-06-28 09:40 发表评论
]]>WebWork2教程（中文版）(4.2)http://www.blogjava.net/junky/archive/2007/06/28/126719.htmljunkyjunkyThu, 28 Jun 2007 01:39:00 GMThttp://www.blogjava.net/junky/archive/2007/06/28/126719.htmlhttp://www.blogjava.net/junky/comments/126719.htmlhttp://www.blogjava.net/junky/archive/2007/06/28/126719.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/126719.htmlhttp://www.blogjava.net/junky/services/trackbacks/126719.html4.2、在WebWork中使用Velocity

使用Velocity作为视图，有两种方法：

l         使用velocity结果类型来呈现Velocity模板

l         在web.xml中注册WebWorkVelocityServlet，直接请求Velocity模板文件来呈现；这种方法要在web.xml中为WebWorkVelocityServlet添加一个Servlet映射，如下：

<servlet> 
       <servlet-name>velocity</servlet-name> 
       <servlet-class>com.opensymphony.webwork.views.velocity.WebWorkVelocityServlet</servlet-class> 
       <load-on-startup>1</load-on-startup> 
</servlet> 
<servlet-mapping> 
       <servlet-name>velocity</servlet-name> 
       <url-pattern>*.vm</url-pattern> 
</servlet-mapping>

使用velocity结果类型意味着Velocity模板是通过Action来呈现。如果访问.vm文件，不会呈现该文件，而是返回文本文件。因此，Velocity模板文件应该放在WEB-INF目录下，使其无法直接访问。

使用WebWorkVelocityServlet意味着可以通过请求.vm文件来呈现Velocity模板，这可能需要在模板中实现安全检查。

无论使用哪种方法，在写模板时，Velocity的所有特性都是有效的，并且有一些WebWork的特定功能可以使用。这里假设你对Velocity很熟悉，重点放在WebWork的特定功能上。

（1）WebWork的特定功能

WebWork在Value Stack中提供了一些可以访问的对象，包括：

l         当前的HttpServletRequest

l         当前的HttpServletResponse

l         当前的OgnlValueStack

l         OgnlTool实例

l         当前Action类的所有属性

要访问Value Stack中的对象，需要在模板中正确使用Velocity引用：

l         $req=HttpServletRequest

l         $res=HttpServletResponse

l         $stack=OgnlValueStack

l         $ognl=OgnlTool

l         $name-of-property=当前Action类的属性

（2）使用velocity结果类型

下面的例子是使用Velocity模板作为结果，来实现前面的Hello例子，注意<property value="person" />标记被$person引用所替代：

xwork.xml：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" 
"http://www.opensymphony.com/xwork/xwork-1.0.dtd">
<xwork>
       <!-- Include webwork defaults (from WebWork-2.1 JAR). -->
       <include file="webwork-default.xml" />
       <!-- Configuration for the default package. -->
       <package name="default" extends="webwork-default">
              <!-- Default interceptor stack. --> 
              <default-interceptor-ref name="defaultStack" /> 
              <!-- Action: Lesson 4.2: HelloAction using Velocity as result. -->
              <action name="helloVelocity" class="lesson03.HelloAction">
                <result name="error" type="dispatcher">ex01-index.jsp</result>
                <result name="success" type="velocity">ex01-success.vm</result>
              </action>
       </package>
</xwork>

HelloAction.java：（同前面的例子）

ex01-index.jsp：（同前面的例子）

ex01-success.vm：

<html> 
<head> 
<title>WebWork Tutorial - Lesson 4.2 - Example 1</title> 
</head> 
<body> 
Hello, $person 
</body> 
</html>

（3）在Velocity中使用WebWork标记

使用Velocity模板替代JSP标记，会失去使用JSP标记的能力。然而，WebWork的Velocity Servlet提供了一种在Velocity模板中使用JSP标记的方法：使用#tag、#bodytag和#param Velocimacros。下面是通用语法：

#tag (name-of-tag list-of-attributes)

或：

#bodytag (name-of-tag list-of-attributes)
       #param (key value)
       #param (key value)
...
#end

下面的例子使用Velocity实现4.1.1节中示范UI标记用法的例子：

xwork.xml：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" 
"http://www.opensymphony.com/xwork/xwork-1.0.dtd">
<xwork>
       <!-- Include webwork defaults (from WebWork-2.1 JAR). -->
       <include file="webwork-default.xml" />
       <!-- Configuration for the default package. -->
       <package name="default" extends="webwork-default">
              <!-- Default interceptor stack. --> 
              <default-interceptor-ref name="defaultStack" /> 
              <!-- Actions: Lesson 4.2: FormProcessingAction using Velocity. --> 
              <action name="formProcessingVelocityIndex" class="lesson04_02.FormProcessingIndexAction">
                <result name="success" type="velocity">ex02-index.vm</result>
              </action>
              <action name="formProcessingVelocity" class="lesson04_01_01.FormProcessingAction"> 
                <result name="input" type="velocity">ex02-index.vm</result> 
                <result name="success" type="velocity">ex02-success.vm</result> 
                <interceptor-ref name="validationWorkflowStack" /> 
              </action> 
       </package>
</xwork>

ex02-index.vm：

<html> 
<head> 
<title>WebWork Tutorial - Lesson 4.2 - Example 2</title> 
<style type="text/css"> 
  .errorMessage { color: red; } 
</style>   
</head> 
<body> 
<p>UI Form Tags Example using Velocity:</p> 
#bodytag (Form "action='formProcessingVelocity.action'" "method='post'") 
       #tag (Checkbox "name='checkbox'" "label='A checkbox'" "fieldValue='checkbox_value'") 
       #tag (File "name='file'" "label='A file field'") 
       #tag (Hidden "name='hidden'" "value='hidden_value'") 
       #tag (Label "label='A label'") 
       #tag (Password "name='password'" "label='A password field'") 
       #tag (Radio "name='radio'" "label='Radio buttons'" "list={'One', 'Two', 'Three'}") 
       #tag (Select "name='select'" "label='A select list'" "list={'One', 'Two', 'Three'}" 
              "emptyOption=true") 
       #tag (Textarea "name='textarea'" "label='A text area'" "rows='3'" "cols='40'") 
       #tag (TextField "name='textfield'" "label='A text field'") 
       #tag (Submit "value='Send Form'") 
#end 
</body> 
</html>

ex02-success.vm：

<html> 
<head> 
<title>WebWork Tutorial Lesson 4.2 - Example 2</title> 
</head> 
<body> 
<p>UI Form Tags Example result using Velocity:</p> 
<ul> 
       <li>checkbox: $!checkbox</li> 
       <li>file: $!file</li> 
       <li>hidden: $!hidden</li> 
       <li>password: $!password</li> 
       <li>radio: $!radio</li> 
       <li>select: $!select</li> 
       <li>textarea: $!textarea</li> 
       <li>textfield: $!textfield</li> 
</ul> 
</body> 
</html>

FormProcessingAction.java：（同4.1.1节的例子）

FormProcessingAction-validation.xml：（同4.1.1节的例子）

下面的例子使用Velocity实现4.1.1节中自定义组件的例子，注意#param的用法：

ex03.vm：

<html> 
<head> 
<title>WebWork Tutorial - Lesson 4.2 - Example 3</title> 
</head> 
<body> 
<p>Custom Component Example:</p> 
<p> 
#bodytag (Component "template=/files/templates/components/datefield.vm") 
       #param ("label" "Date") 
       #param ("name" "mydatefield") 
       #param ("size" "3") 
#end 
</p> 
</body> 
</html>

/files/templates/components/datefield.vm：（同4.1.1节的例子）

 

4.3、在WebWork中使用Freemaker（略）



junky 2007-06-28 09:39 发表评论
]]>WebWork2教程（中文版）(5)(完）http://www.blogjava.net/junky/archive/2007/06/28/126718.htmljunkyjunkyThu, 28 Jun 2007 01:38:00 GMThttp://www.blogjava.net/junky/archive/2007/06/28/126718.htmlhttp://www.blogjava.net/junky/comments/126718.htmlhttp://www.blogjava.net/junky/archive/2007/06/28/126718.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/126718.htmlhttp://www.blogjava.net/junky/services/trackbacks/126718.html5、Interceptors

Interceptors允许在调用堆栈中包含任意在Action处理之前和/或处理之后执行的代码。这是你的代码简单，更能重用。Xwork和WebWork的大部分特性都是Interceptors实现的。你可以通过外部配置，按照你定义的顺序，对指定的Action应用你自己的Interceptors。

当你访问.action URL时，WebWork的ServletDispatcher启动Action对象，在Action被执行之前，启动允许被其它的对象中断，这就称Interceptor。在指定的Action之前（或之后）执行Interceptor，只要在xwork.xml中配置属性。下面是4.1.1节中展示UI标记用法的例子的Interceptor配置：

<action name="formProcessing" class="lesson04_01_01.FormProcessingAction"> 
       <result name="input" type="dispatcher">ex01-index.jsp</result> 
       <result name="success" type="dispatcher">ex01-success.jsp</result> 
       <interceptor-ref name="validationWorkflowStack" /> 
</action>

FormProcessingAction使用了validationWorkflowStack。这是一个Interceptor堆，组织一组按顺序执行的Interceptors。ValidationWorkflowStack在webwork-default.xml中配置，所以我们只要使用<interceptor-ref />在Action配置中，或使用<default-interceptor-ref />在package配置中使用它。下面是HelloWebWorld例子的Interceptor配置：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" 
"http://www.opensymphony.com/xwork/xwork-1.0.dtd">
<xwork>
       <!-- Include webwork defaults (from WebWork-2.1 JAR). -->
       <include file="webwork-default.xml" />
       <!-- Configuration for the default package. -->
       <package name="default" extends="webwork-default">
              <!-- Default interceptor stack. --> 
              <default-interceptor-ref name="defaultStack" /> 
              <!-- Action: Lesson 03: HelloWebWorldAction. --> 
              <action name="helloWebWorld" class="lesson03.HelloWebWorldAction"> 
                <result name="success" type="dispatcher">ex01-success.jsp</result> 
              </action> 
       </package>
</xwork>

看一下Interceptor如何工作的

l         创建Interceptor类，需要扩展com.opensymphony.xwork.interceptor.Interceptor接口（包含在xwork-1.0.jar）；

l         在xwork.xml文件中，使用<interceptors />内嵌的<interceptor />声明Interceptor类；

l         使用<interceptor-stack />创建Interceptor堆（可选）；

l         使用<interceptor-ref /> 或<default-interceptor-ref />哪些Interceptor由哪个Action使用；前者由指定Action使用，后者为所有Action使用

（1）webwork-default.xml

让我们看一下webwork-default.xml的内容：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" 
"http://www.opensymphony.com/xwork/xwork-1.0.dtd">
<xwork>
       <package name="webwork-default">
              <result-types>
                <result-type name="dispatcher" default="true"
                       class="com.opensymphony.webwork.dispatcher.ServletDispatcherResult"/>
                <result-type name="redirect" 
                       class="com.opensymphony.webwork.dispatcher.ServletRedirectResult"/>
                <result-type name="velocity" 
                       class="com.opensymphony.webwork.dispatcher.VelocityResult"/>
                <result-type name="chain" 
                       class="com.opensymphony.xwork.ActionChainResult"/>
                <result-type name="xslt" 
                       class="com.opensymphony.webwork.views.xslt.XSLTResult"/>
              </result-types>
              <interceptors>
                <interceptor name="timer" 
                       class="com.opensymphony.xwork.interceptor.TimerInterceptor"/>
                <interceptor name="logger" 
                       class="com.opensymphony.xwork.interceptor.LoggingInterceptor"/>
                <interceptor name="chain" 
                       class="com.opensymphony.xwork.interceptor.ChainingInterceptor"/>
                <interceptor name="static-params" 
                       class="com.opensymphony.xwork.interceptor.StaticParametersInterceptor"/>
                <interceptor name="params" 
                       class="com.opensymphony.xwork.interceptor.ParametersInterceptor"/>
                <interceptor name="model-driven" 
                       class="com.opensymphony.xwork.interceptor.ModelDrivenInterceptor"/>
                <interceptor name="component" 
                       class="com.opensymphony.xwork.interceptor.component.ComponentInterceptor"/>
                <interceptor name="token" 
                       class="com.opensymphony.webwork.interceptor.TokenInterceptor"/>
                <interceptor name="token-session" 
                       class="com.opensymphony.webwork.interceptor.TokenSessionStoreInterceptor"/>
                <interceptor name="validation" 
                       class="com.opensymphony.xwork.validator.ValidationInterceptor"/>
                <interceptor name="workflow" 
                       class="com.opensymphony.xwork.interceptor.DefaultWorkflowInterceptor"/>
                <interceptor name="servlet-config" 
                       class="com.opensymphony.webwork.interceptor.ServletConfigInterceptor"/>
                <interceptor name="prepare" 
                       class="com.opensymphony.xwork.interceptor.PrepareInterceptor"/>
                <interceptor name="conversionError" 
                       class="com.opensymphony.webwork.interceptor.WebWorkConversionErrorInterceptor"/>
                <interceptor-stack name="defaultStack">
                       <interceptor-ref name="static-params"/>
                       <interceptor-ref name="params"/>
                       <interceptor-ref name="conversionError"/>
                </interceptor-stack>
                <interceptor-stack name="validationWorkflowStack">
                       <interceptor-ref name="defaultStack"/>
                       <interceptor-ref name="validation"/>
                       <interceptor-ref name="workflow"/>
                </interceptor-stack>
              </interceptors>
       </package>
</xwork>

既然在我们的xwork.xml中包含了webwork-default.xml，我们就可以在Action中使用这些Interceptor或Interceptor堆。下面是这些Interceptor做的事情：

l         timer：对Action的执行进行计时（包括嵌套的Interceptor和视图）

l         chain：使前一个Action的属性对当前的Action有效，通常创建Action链

l         static-params：设置xwork.xml中的参数到Action中（<action />内嵌的<param />）

l         params：设置请求参数（POST或GET）到Action中

l         model-driven：如果Action实现ModelDriven，将getModel()的结果推到Value Stack中

l         component：使能和注册组件，使其对Action有效

l         token：检查Action中的有效token，防止重复提交

l         token-session：同上，但是当处理到无效token时，在session中保存提交的数据

l         validation：使用在{Action}-vaildation.xml中定义的验证器进行数据验证

l         workflow：调用Action类中的validate()方法，在发生错误时，返回INPUT视图；应该和validation Interceptor一起使用

l         servlet-config：获得对HttpServletRequest和HttpServletResponse的访问（由于绑定到Servlet API，最好不要使用）

l         prepare

l         conversionError

（2）创建自己的Interceptor

如果上面的Interceptor没有适合你的，你可以创建自己的Interceptor。下面的例子假设我们需要一个Interceptor在session中根据当天时间放置一个欢迎信息：

GreetingInterceptor.java：

package lesson05;
 
import java.util.Calendar;
import com.opensymphony.xwork.interceptor.Interceptor;
import com.opensymphony.xwork.ActionInvocation;
 
public class GreetingInterceptor implements Interceptor {
       public void init() { }
       public void destroy() { }
       public String intercept(ActionInvocation invocation) throws Exception {
              Calendar calendar = Calendar.getInstance();
              int hour = calendar.get(Calendar.HOUR_OF_DAY);
              String greeting = (hour < 6) ? "Good evening" : 
                ((hour < 12) ? "Good morning": 
                ((hour < 18) ? "Good afternoon": "Good evening"));
 
              invocation.getInvocationContext().getSession().put("greeting", greeting);
 
              String result = invocation.invoke();
 
              return result;
       }
}

xwork.xml：

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" 
"http://www.opensymphony.com/xwork/xwork-1.0.dtd">
 
<xwork>
       <!-- Include webwork defaults (from WebWork-2.1 JAR). -->
       <include file="webwork-default.xml" />
       
       <!-- Configuration for the default package. -->
       <package name="default" extends="webwork-default">
              <interceptors> 
                <interceptor name="greeting" class="section02.lesson05.GreetingInterceptor" /> 
              </interceptors> 
         
              <!-- Action: Lesson 5: GreetingInterceptor. --> 
              <action name="greetingAction" class="lesson05.GreetingAction"> 
                <result name="success" type="velocity">ex01-result.vm</result> 
                <interceptor-ref name="greeting" /> 
              </action> 
       </package>
</xwork>

GreetingAction.java：

package lesson05;
 
import com.opensymphony.xwork.ActionSupport;
 
public class GreetingAction extends ActionSupport {
       public String execute() throws Exception {
              return SUCCESS;
       }
}

ex01-result.vm：

<html>
<head>
<title>WebWork Tutorial - Lesson 5 - Example 1</title>
</head>
<body>
 
#set ($ses = $req.getSession())
<p><b>${ses.getAttribute('greeting')}!</b></p>
 
</body>
</html>

Interceptor类要扩展com.opensymphony.xwork.interceptor.Interceptor接口：init()在Interceptor初始化时调用；destroy()在销毁时调用；intercept(ActionInvocation invocation)是处理的中心。

invocation.invoke()用来调用Interceptor堆中下一个Interceptor，或是Action（如果没有的话）。因此，我们完全可以绕开Action而返回结果（不执行Action）。

上面的例子是在Action执行之前调用，如果要在Action执行之后调用Interceptor，只要将执行代码放在invocation.invoke()之后。

WebWork提供一个实现这种方式的抽象类com.opensymphony.xwork.interceptor.AroundInterceptor，你只要实现它的before(ActionInvocation invocation)和 after(ActionInvocation dispatcher, String result)方法就可以了。




junky 2007-06-28 09:38 发表评论
]]>Web Services带来了什么http://www.blogjava.net/junky/archive/2007/05/22/119109.htmljunkyjunkyTue, 22 May 2007 05:43:00 GMThttp://www.blogjava.net/junky/archive/2007/05/22/119109.htmlhttp://www.blogjava.net/junky/comments/119109.htmlhttp://www.blogjava.net/junky/archive/2007/05/22/119109.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/119109.htmlhttp://www.blogjava.net/junky/services/trackbacks/119109.html作者：王昱

摘要：本文介绍了Web Services的起源和基本原理，分析了在企业应用中Web Services带来的冲击和变革，指出了Web Services的一些优缺点以及如何正确地应用Web Services.

无论是在计算机杂志还是在Internet上，目前最热门的话题莫过于“Web Services”。各个平台之间的锋争，各个新产品的发布，众多新标准的制订，大都和Web Services有关。

我的一些朋友是这样的一些人，他们总是用着最新的平台，尝试着最新的技术，他们喜欢变化，喜欢流行，用他们自己的话说，新技术创造新生活！可是，当我的一个朋友，带领他们一个部门的开发人员，花了两个月的，将他们内部的管理系统用Web Services重新设计和实现了一遍，却发现在实际使用的情况下，系统性能非常糟糕。他提出了这样一个问题：是不是Web Services现在还处于实验和市场炒作时期，根本没有进入实用的阶段？简单的回答是：Web Services不是万能的，它有它的应用范围和优势劣势。

Web Services的起源

Web应用的巨大成功和不断发展，使其渗透到商业领域和个人生活的各个方面。人们只要使用浏览器，就可以享受到各种各样的Web服务，例如网上购物，网上交易，网络游戏，预定车票，网上聊天和交友等等。与此同时，由于Web技术所带来的优势（统一的客户端和较好的维护性），使一些传统的应用纷纷转型到BS结构上。

然而，在发展中，逐步暴露了一些问题。所有这些Web页面都是为人准备的，是让人去阅读，去输入，去判断。因此各种反映视觉效果的内容占用了大量的网络带宽，例如各种图片，字体信息，文字排版样式等。而真正含有高价值的一些信息，被深深埋在这些显示信息中，很难被其他应用和程序所使用。更重要的是，各种web服务之间缺少交互和通讯的机制。

程序之间的互相通讯很重要吗？简单举一个例子。

假设你经常去国外出差，在你回国以后，第一件事就是费用报销了。而你们公司有这样的财务规定，所有的报销款，都按报销当天的外汇比价进行结算。因此在你填写报销单的时候必须先填写每一笔在各个国家的花消，然后上网查出当天的外汇比价，填写到报销单上。剩下的事情也许不用你做了，你的报销单填写工具会自动进行换算和统计。

觉得有什么不妥吗？作为IT公司的员工，也许都有一个特点，计算机能做的事情，尽量要计算机去做。外汇比价的查询可以让计算机自动去做嘛！然而，让你的程序自动去网页上查找指定的外汇比价可不是一件容易的事。因为这些网页是给人阅读的，人眼和大脑的反应速度有多快，它们可以从一整页信息中快速定位到你所要的内容，而且无论网页怎样变化和改版都不会带来太大的影响。而应用程序想要做同样的事就差得太远了。因此，现在需要的是专门为应用程序制定的Web服务。

随着应用程序之间通讯的需求越来越大，这就需要制定统一的标准和协议。HP公司是最先提出这个观点的公司，他们制定了有关“e-Speak”的标准来保证应用程序之间的交互，并声称将成为下一代Internet信息交互的标准。而随后，MicroSoft意识到此计划的美好前景，便推出了.Net战略；IBM很快就发布了Web Services Toolkit(WSTK)，和Web Services Development Environment(WSDE)，申明对Web Services的全力支持。与此同时，Oracle也开发出自己的Dynamic Services，并和Oracle 8i Release 2集成在一起。在这以后，W3C统一制定了Web Services的各种标准。而SUN公司在宣布了自己的Web Services的框架以后，将Web Services的标准溶入J2EE的环境，使Web Services有了广泛支持的基础和平台。

Web Services的基本原理

Web Services 是通过一系列标准和协议来保证程序之间的动态连接。其中最基本的协议包括：SOAP, WSDL, UDDI

  • SOAP: 是“Simple Object Access Protocol”的缩写，SOAP是消息传递的协议，它规定了Web Services之间是怎样传递信息的。简单的说，SOAP规定了：
    1.     传递信息的格式为XML。这就使Web Services能够在任何平台上，用任何语言进行实现。
    2.     远程对象方法调用的格式。规定了怎样表示被调用对象以及调用的方法名称和参数类型等。
    3.     参数类型和XML格式之间的映射。这是因为，被调用的方法有时候需要传递一个复杂的参数，例如，一个Person对象。怎样用XML来表示一个对象参数，也是SOAP所定义的范围。
    4.     异常处理以及其他的相关信息.

  • WSDL:是“Web Services Description Language”的缩写.意如其名,WSDL是Web Services的定义语言。当你实现了某种服务的时候(如,股票查询服务),为了让别的程序调用,你必须告诉大家你的服务的接口.例如,服务名称，服务所在的机器名称，监听端口号，传递参数的类型,个数和顺序,返回结果的类型等等.这样别的应用程序才能调用你的服务。WSDL协议就是规定了有关Web Services描述的标准。

  • UDDI: 是Universal Description, Discovery, and Integration的缩写。简单说，UDDI用于集中存放和查找WSDL描述文件，起着目录服务器的作用。

如上图，一个Web Services的生命周期是：

  1. 实现一个Web Services，使其能够接受和响应SOAP消息（现在有很多工具都可以帮助实现）。

  2. 撰写一个WSDL文件用于描述此Web Services。（现在有很多工具可以自动生成WSDL文件）。

  3. 将此WSDL发布到UDDI上。

  4. 其他的应用程序（客户端）从UDDI上搜索到你的WSDL。

  5. 根据你的WSDL，客户端可以编写程序（现在有很多工具可以自动生成调用程序）调用你的Web Services。

Web Services的缺点

由于是基于XML的应用，Web Services与生俱来地在拥有XML带来的一切优势的同时，不可避免地继承了XML所带来的一些限制。

  • Web Services通常需要大量的CPU资源。因为XML数据要经过多步处理才能被系统使用。首先是效验（validate），检查它的格式是否符合XML的规范，以及根据应用程序定义（DTD或Schema）检查是否符合语义上的规范；然后还要进行解析（parse），从XML文档分解出单个的元素；最后还要转换成应用程序所需要的二进制表达（例如，把“12” 转换成整型12的二进制表示）。

  • Web Services还意味着占用较多的内存资源。在进行XML解析的时候，会产生大量的临时内存对象。特别是在处理DOM对象的时候。这些大量的临时对象对于象JAVA这类自动回收内存的语言和系统其实是一种负担，大量的临时对象将会使系统每隔一段时间就会进行内存回收，从而降低系统的性能。当然，现在有的Web Services的产品（如axis）采用了SAX技术，大大减少了内存的占用量。详细信息请参考：（http://xml.apache.org/axis/index.html）。

  • 网络资源的消耗也是Web Services应用的一些限制。因为基于XML数据的传递通常数据量要比二进制的协议（如RMI/IIOP）要大的多。这种额外的消耗在网络资源比较紧张或网络传输比较频繁的应用中会产生一定的影响。

除了XML带来的限制，Web Services本身也具有一些缺点：

  • 到目前为止，Web Services还可以说是一种无状态（stateless）的服务。
    所谓stateless就意味着不保存客户端服务调用者的任何信息。这是由Web Services的本质所决定的。Web Services在本质上是要为应用程序之间提供数据通讯的标准，为企业应用之间动态地提供大颗粒度的服务，所以Web Services并不适合于非常精细的基于会话的方法调用以及复杂的事务（transaction）处理之中。
    也许有人会对我这点提出异议！因为，现在有很多Web Services的产品（如WASD），不但可以保存session的信息，使服务成为有状态（stateful）的服务，而且还实现了remote interface，可以在Web Services的会话中传递远程对象的句柄，让客户端可以操纵递远程对象（详细信息请参考：http://www.systinet.com ）。原理上说，这并不难实现，因为在XML数据中，可以互相传送任何数据，包括sessionID和transactionID，有了这些ID，从技术角度上说，实现有状态（stateful）的服务和事务处理并不复杂。但是，这样功能缺少标准的支持，当前版本的WSDL还无法表示这些复杂的服务。在企业内部，你可以任意使用这些特殊的功能，可以自己定义会话状态的交互协议，因为服务者和服务调用者之间的通讯都在你的控制之中；然而要将这些服务发布到Internet上，其他的应用程序是无法根据标准去识别这些特殊功能。

  • 数据绑定也存在一些不足。
    因为所有的数据传递都用XML格式，因此，需要在二进制数据和XML数据之间有个转换。但是，并不是所有的二进制数据都能方便地用XML来表示，并不是所有的JAVA对象都能被XML所表示。因此，经常在转换过程中会出现语义丢失的情况。

  • 技术要求高，学习曲线较长。
    每一个Web Services的产品，都有丰富的工具，能够根据Web Services的定义（如WSDL文件）方便地生成客户端的程序；能够将一般的服务程序，很容易就包装成Web Services服务。因此，各个Web Services的产品都声称自己的平台容易使用，根本不需要了解XML，也不需要了解什么WSDL，UDDI，SOAP就能使用发布Web Services。特别是一个朋友告诉我，他在什么都不了解的情况下，用.NET花了15分钟就发布了一个Web Services！
    千万不要醉心于这种简便，这对于简单的Demo也许是对的，可是对于真正意义上严肃的应用，一定要了解Web Services的各个方面，设计整体结构和解决方案，还要根据具体的应用调整性能。所有这些都需要对Web Services知识的全面掌握。

什么应用适合Web Services

Web Services这么多的缺点是不是让你很泄气？其实，已经有很多成功的Web Services的应用和越来越多的开发商的加盟，证明Web Services一定会成为新一代WEB信息通讯的主流。经过不断的发展，Web Services一定能克服自身的弱点，得到更广泛的应用。但就目前来说，Web Services比较适合用于下列形式的应用：

  • 基于WAN和Internet的应用

要在Internet上创建基于二进制协议的RMI/IIOP的应用，一般都会遇上一个大麻烦--防火墙。客户端浏览器极大可能在ISP防火墙后，大多数防火墙都只能允许和外部的HTTP连接，因此想要ISP防火墙后的客户端能和防火墙外的RMI/IIOP的应用端口进行连接的话，就要改变ISP的安全策略，让客户端能够连接除了80以外的其他端口。可是当运行RMI/IIOP的应用的服务器为了安全也在防火墙之后的DMZ中的话，那这个连接就更加复杂了，要跨越两个防火墙。
而Web Services由于使用的是HTTP协议，传递的是纯文本的XML数据，因此拥有穿透防火墙的良好性能。

  • 基于异构平台的应用

XML语言本身就是跨平台、跨语言的数据表示方法，在加上通用的HTTP等协议，使得Web Services天生就适用于基于异构平台的应用。如果你的客户端包含了各种不同的平台，例如，你希望你的服务即可以被JAVA程序所调用，又可以由VB和COM程序所调用。你有两种选择：一种是为不同的平台提供相应的API，还要为不同的语言提供API；如果提供Web Services，所有平台和语言都可以调用了！

  • 需要强安全特性的应用

很多人都认为，安全性是Web Services的弱项。其实不然，经过不断的完善和各种新的协议的出台，Web Services完全可以用于安全性很强的应用环境下。并且，由于Web Services使用HTTP协议进行传输，所以可以和容易就使用已经很成熟的基于HTTP的各种安全技术。

  • EAI（企业应用集成）
    这是目前Web Services应用最看好的方向之一。大多数企业内部都有着各种各样的应用系统，它们是在不同的领导在任期间，由不同的软件开发商开发，因此运行在不同的平台和系统上，系统的开发语言也各不相同。由于现代企业信息自动化要求的提高，各个系统之间的互动和相互通讯便提到日程上。因此，保护原有投资，重用遗留系统是当前很多中大型企业的重要任务。
    由于遗留系统的运行平台是异构环境，因此企业应用集成的代价一般来说是很高的。但如果使用Web Services作为应用集成的手段，将会大大降低集成的消耗。Web Services与平台和语言无关的特性，以及各种平台和环境下的开发工具都是企业应用集成的利器。
    另外，在开发新的应用系统的时候，仍然需要考虑和其他系统的集成，需要考虑调用其他系统的功能，和被其他系统所调用。使用Web Services作为系统与外部交流的接口，能够使新的系统和别的系统之间保持松耦合的关系，保持较高的可扩展性。

  • 行业内部B2B应用
    行业内部的应用是Web Services的另外一个方向。因为在一个行业中，商业业务是很相似的，因此在行业内部很容易形成服务的标准，使所有的业内企业共同遵守；但怎样实现服务和使用什么样的系统，决定权在于各个企业自己。例如，电信运营商之间的结算服务，银行之间的转帐服务等都可以形成行业标准，以WSDL的形式公布出来。各个企业之间可以选择不同的平台进行服务的实现。

提高Web Services的性能

要想提高Web Services应用的性能，需要对整个系统做全盘的考虑。一般来说，有以下几点需要注意：

  1. Web Services的颗粒度
    选择Web Services的颗粒度是提高Web Services应用的性能的主要手段。因为Web Services使用的传输协议为HTTP或SMTP等，这些协议都是面向无状态的连接协议，每一个请求都要建立一个新的连接。因此Web Services的调用不能象数据库JDBC（ODBC）接口一样可以进行精细而复杂的方法调用（例如，先获得Connection，再获得结果集，然后一行一行获取结果）。Web Services比较适用于大颗粒度的应用，在一个调用中便获得所有的信息（比如说银行之间的转帐，在一次调用中就将包括金额和认证等所有的信息都传输过去）。

  2. 谨慎使用XML接口
    系统之间的接口可以使用XML，这样可以增加系统的灵活性；但不要使用XML作为系统内部的接口，因为这不会带来任何好处，尽量使用二进制作为系统内部的接口，避免不必要的XML文档的解析和效验；在处理XML的时候，尽快将XML转换成内部对象，XML的传递只会增加系统的开销。

  3. 最大可能性使用CACHE
    当有些信息是只读的，或者在一段时间内保持不变，就可以使用CACHE。无论是客户端的CACHE还是服务器端的CACHE，都能大大提高系统的性能

总结

一旦Web Services得到更加广泛的应用，使得各种服务可以动态查找和定位，这样就提供了不同设备之间各种各样的信息交互方式，将会大大改变商业运做的模式和信息交流的风格。

你可以使用别人已经成熟的功能来使自己提供更好的服务，例如google，它的搜索引擎可以通过Web Services来访问。这就意味着在你的系统中可以方便的嵌入使用google的强大搜索功能，而不论你的系统是运行在什么平台上，使google的搜索引擎成为你系统的一部分，（请参考http://www.google.com/apis/）。站在别人的肩膀上，毕竟要看得远些！

面对Web Services，你现在可以不行动，但你一定要准备好！



junky 2007-05-22 13:43 发表评论
]]>采用dwr+ajax和struts开发文件上传进度条(转)http://www.blogjava.net/junky/archive/2007/04/16/111027.htmljunkyjunkyMon, 16 Apr 2007 09:31:00 GMThttp://www.blogjava.net/junky/archive/2007/04/16/111027.htmlhttp://www.blogjava.net/junky/comments/111027.htmlhttp://www.blogjava.net/junky/archive/2007/04/16/111027.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/111027.htmlhttp://www.blogjava.net/junky/services/trackbacks/111027.html编写监听器以及相关的类

不用自己写了，源码可以从

http://www.telio.be/blog/2006/01/06/ajax-upload-progress-monitor-for-commons-fileupload-example里面下载，

下载地址

http://www.telio.be/blog/wp-content/uploads/2006/01/ajax-upload-1.0.war

下载完之后，你需要解包，在命令行中：

jar xvf ajax-upload-1.0.war

源码就在\WEB-INF\src下面

将要用到的文件有resources文件夹下，\WEB-INF\下面的dwr.xml和lib下面的jar文件

上传页面

在上面解开的包里面有index.jsp这个是上传页面，upload.jsp负责上传，resources包里面包含了dwr与服务器通讯的javascript脚本，你需要把index.jsp的form中的action换成你的struts action即可，然后把form中的file名改成你actionform中的file属性名，把页面中剩余的file去掉

index.jsp上传页面示例代码：

<%@ page contentType="text/html; charset=gb2312" language="java"

    import="java.util.*" errorPage=""%>

<%

    String path=request.getContextPath();

%>

<html locale="true">

<head>

<SCRIPT language=javascript>

function check_file() {

 var strFileName=document.forms(0).file;

  if (strFileName.value==""){

    alert("请选择要上传的文件");

    return false;

 }

 startProgress();

}

function loadmessage(){ 

        <%

       if (request.getAttribute("message") != null) {

       %> 

           window.alert("<%=request.getAttribute("message")%>");

           window.returnValue="yes";

       <%}%>

}

</SCRIPT>

<title>上传</title>

       <script src='<%=path%>/resources/js/upload.js'> </script>

        <script src='<%=path%>/dwr/interface/UploadMonitor.js'> </script>

        <script src='<%=path%>/dwr/engine.js'> </script>

        <script src='<%=path%>/dwr/util.js'> </script>

        <style type="text/css">

            #progressBar { padding-top: 5px; }

            #progressBarBox { width: 350px; height: 20px; border: 1px inset; background: #eee;}

            #progressBarBoxContent { width: 0; height: 20px; border-right: 1px solid #444; background: blue; }

        </style>

       <LINK href="<%=path%>/css/style.css" type="text/css" rel="stylesheet">

 

<meta http-equiv="Content-Type" content="text/html; charset=gb2312">

</head>

<style type="text/css">

<!--

body {

    margin-left: 0px;

    margin-top: 0px;

    margin-right: 0px;

    margin-bottom: 0px;

 

}

-->

</style>

<body leftmargin="0" topmargin="0" marginwidth="0" marginheight="0" onLoad="loadmessage()">

<form name="form" method="post" action="<%=path%>/upload.do?method=upload" enctype="multipart/form-data" onSubmit="return check_file()">

 <table width="60%" border="0" cellspacing="1">

    <tr background-color=" #E7F5FE">

      <td width="30%" align="right">从文件导入：</td>

      <td width="51%"><input type="file" name="file" class="input"></td>

      <td width="27%"><input type="submit" name="files" class="button_4"

                        style="border-style:None;width:71px;" value="确定" id="uploadbutton">

      </td>

    </tr>

    <tr align="left" background-color=" #E7F5FE">

      <td colspan="3">

     <div id="progressBar" style="display: none;">

 

            <div id="theMeter">

                <div id="progressBarText"></div>

                <div id="progressBarBox">

                    <div id="progressBarBoxContent"></div>

                </div>

            </div>

        </div>

     </td>

    </tr>

 </table>

</form>

</body>

</html>

并且要修改一下\resources\js中的upload.js文件：

/* Licence:

*   Use this however/wherever you like, just don't blame me if it breaks anything.

*

* Credit:

*   If you're nice, you'll leave this bit:

*

*   Class by Pierre-Alexandre Losson -- http://www.telio.be/blog

*   email : plosson@users.sourceforge.net

*/

function refreshProgress()

{

    UploadMonitor.getUploadInfo(updateProgress);

}

 

function updateProgress(uploadInfo)

{

    if (uploadInfo.inProgress)

    {

       document.getElementById('uploadbutton').disabled = true;

        document.getElementById('file').disabled = true;

 

        var fileIndex = uploadInfo.fileIndex;

 

        var progressPercent = Math.ceil((uploadInfo.bytesRead / uploadInfo.totalSize) * 100);

 

        document.getElementById('progressBarText').innerHTML = '文件读取进度: ' + progressPercent + '%';

 

        document.getElementById('progressBarBoxContent').style.width = parseInt(progressPercent * 3.5) + 'px';

 

        window.setTimeout('refreshProgress()', 1000);

    }

    else

    {

        document.getElementById('uploadbutton').disabled = false;

        document.getElementById('file').disabled = false;

    }

 

    return true;

}

 

function startProgress()

{

    document.getElementById('progressBar').style.display = 'block';

    document.getElementById('progressBarText').innerHTML = '文件读取进度: 0%';

    document.getElementById('uploadbutton').disabled = true;

 

    // wait a little while to make sure the upload has started ..

    window.setTimeout("refreshProgress()", 1000);

    return true;

}

配置dwr.xml

放在/WEB-INF/下面

<dwr>

    <allow>

        <create creator="new" javascript="UploadMonitor">

            <param name="class" value="be.telio.mediastore.ui.upload.UploadMonitor"/>

        </create>

        <convert converter="bean" match="be.telio.mediastore.ui.upload.UploadInfo"/>

    </allow>

</dwr>

web.xml中配置dwr，省略spring，struts等的配置

<servlet>

              <servlet-name>dwr-invoker</servlet-name>

              <display-name>DWR Servlet</display-name>

              <servlet-class>uk.ltd.getahead.dwr.DWRServlet</servlet-class>

              <init-param>

                     <param-name>debug</param-name>

                     <param-value>false</param-value>

              </init-param>

              <init-param>

                     <param-name>logLevel</param-name>

                     <param-value>WARN</param-value>

              </init-param>

</servlet>

<servlet-mapping>

              <servlet-name>dwr-invoker</servlet-name>

              <url-pattern>/dwr/*</url-pattern>

</servlet-mapping>

编写struts的MultipartRequestHandler ：AjaxMultipartRequestHandler

实现 MultipartRequestHandler接口并在struts-config.xml的controller中替换默认的multipartClass

<controller>

              <set-property property="multipartClass"

                     value="org.springside.components.ajaxupload.AjaxMultipartRequestHandler" />

</controller>

其实这个类AjaxMultipartRequestHandler编写很简单，把struts的src源码中的org.apache.struts.upload.CommonsMultipartRequestHandler.java修改一下就可以了：

在public void handleRequest(HttpServletRequest request)

           throws ServletException {

方法中把定义factory之前的那几行代码注释掉然后写入

UploadListener listener = new UploadListener(request, 30);

FileItemFactory factory = new MonitoredDiskFileItemFactory(listener);

之后再注释掉

// upload.setSizeThreshold((int) getSizeThreshold(ac));

// upload.setRepositoryPath(getRepositoryPath(ac));

这个类就算写完了

编写struts上传类

就用你原来编写的struts上传类

上传方法代码段示例：

/**

     * 上传文件

     */

    public ActionForward upload(ActionMapping mapping, ActionForm form,

           HttpServletRequest request, HttpServletResponse response)

           throws Exception {

       String path = getServlet().getServletContext().getRealPath("/");

       log.info(">>>>>>>>>>>>>>>path:" + path);

       if (form == null) {

           return mapping.findForward("success");

       }

       FileUploadForm fuf = (FileUploadForm) form;

       FormFile file = fuf.getFile();

       try {

           if (file == null) {

              log.info(">>>>>>>>>>>>>>>file为空");

              return mapping.findForward("success");

           }

       } catch (Exception e) {

           e.printStackTrace();

       }

       String fname = file.getFileName();

       int t = 0;

       for (int i = 0; i < fname.length(); i++) {

           if (fname.charAt(i) == '.') {

              t = i;

           }

       }

       String filename = null;

       if (t > 0) {

           filename = fname.substring(0, t);

       }

       log.info(">>>>>>>>>>>>>>>文件名：" + filename);

       String filepath = path + "dataimport/upfiles/" + fname;

       File f = new File(path + "dataimport/upfiles/");

       log.info(">>>>>>>>>>>>>>>文件生成路径：" + filepath);

       if (!f.exists()) {

           f.mkdirs();

       } else {

           log.info(">>>>>>>>>>>>>>>路径存在");

       }

       InputStream stream = file.getInputStream();

       OutputStream os = new FileOutputStream(path + "dataimport/upfiles/"

              + fname);

       int readBytes = 0;

       byte buffer[] = new byte[8192];

       while ((readBytes = stream.read(buffer, 0, 8192)) != -1) {

           os.write(buffer, 0, readBytes);

       }

       os.close();

       stream.close();

       file.destroy();

      

       String message = "成功！";

       request.setAttribute("message", message);

       return mapping.findForward("success");

    }

-------------------------一切ok------------------------



junky 2007-04-16 17:31 发表评论
]]>ExtremeTable 的使用(转)http://www.blogjava.net/junky/archive/2007/04/03/108188.htmljunkyjunkyTue, 03 Apr 2007 05:27:00 GMThttp://www.blogjava.net/junky/archive/2007/04/03/108188.htmlhttp://www.blogjava.net/junky/comments/108188.htmlhttp://www.blogjava.net/junky/archive/2007/04/03/108188.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/108188.htmlhttp://www.blogjava.net/junky/services/trackbacks/108188.htmlwww.javabc.com

0.概述
    Home Page:http://www.extremecomponents.org 
     Extreme Table是最功能强大而又容易配置,扩展,自定义的Table 控件。
     最紧要的功能包括排序, 分页, 导出Excel, pdf和汇总。
    基础读物: 
     1. ExtremeTable自带的文档 http://extremecomponents.org/wiki/index.php/Main_Page .
     2.Luck翻译的ExtremeTable官方文档中文版http://extremecomponents.org/wiki/index.php/Simplified_Chinese
1. 安装
1.1 安装原始版本
     1. 从http://www.extremecomponents.org 下载最新版
     2.把extremecomponents.jar 放入web-inf/lib
     3.根据minum, 导出excel 或 导出pdf的需要，把/lib下的jar copy到web-inf/lib
     4.把images里的图片放入web的任意目录
     5.把css文件放到web的任意目录
     6.在/source/org/extremecomponents/table/core目录找到extremetable.properties文件,把它复制到WEB-INF/classes里面并进行修改.
     7.修改web.xml (见2)。
 1.2 复制修改过的样式
     1.Copy 修改过的Table Head的图，查。
     2.将修改版extremecomponents.css文件放入任意目录
     3.把/src/resource/extremetable.properties 复制到对应目录
     4.把extremecomponents.tld复制到web-inf/下
1.3 使用Compact View很重要
     默认的式样不符合大家的审美，幸亏还有Compact View和css设置，让我们可以敬谢不敏它号称非常方便的HtmlView子类扩展。
    1. 在全局设置里
 
table.view.html=org.extremecomponents.table.view.CompactView
    2.把images里/table/compact/*.gif copy 到 /table
2.全局属性配置
   ExtremeTable支持在properties文件里方便的统一配置丰富的全局属性
 在/source/org/extremecomponents/table/core目录找到extremetable.properties文件,把它复制到WEB-INF/classes里面.
 在web.xml里面增加
   <context-param>
        <param-name>extremecomponentsPreferencesLocation</param-name>
        <param-value>/extremetable.properties</param-value>
   </context-param>
一般只写需要修改的文件:
table.filterable=false
table.imagePath=/images/table/*.gif
table.locale=zh_CN
table.view.html=org.extremecomponents.table.view.CompactView
row.highlightRow=true
column.format.date=yyyy-MM-dd
column.format.currency=###,###,###,###,#00.00
3.导出Excel
    注意Excel 导出的Tag已改为，且官方版不支持中文文件名。
    <ec:exportXls fileName="BookList.xls" tooltip="导出 Excel"/>
在web.xml必须加入：
    <filter>
        <filter-name>eXtremeExport</filter-name>
        <filter-class>org.extremecomponents.table.filter.ExportFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>eXtremeExport</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
     ExtremeTable导出的一项重要特性是可以根据不同的View导出不同的列.
     比如html管理界面可能只列出订单几个最重要的列，而导出excel时则需要导出所有的列。
<ec:column property="orderdate" title="订单日期"  cell="date" format="yyyy-MM-dd"  viewsDenied= "html"/>
又比如有些操作按纽的列只想在html出现,excel里不想出现：
<ec:column property="orderdate" title="订单日期" viewAllowed= "html"/>
     以上订单日期列在html view看不到，而excel,pdf view可以见到.
    而"编辑图标"，"选择Checkbox"这些管理界面上的列，也可以设置不export到pdf,excel view
4.其他要点
4.1. 使用排序功能时,如果property为嵌套属性时,需要设置alias
          因为javascript的关系.
<ec:column property="customer.name" title="客户名称" alias="customer"/>
4.2. Date Cell与NumberCell 和RowCountCell
     在全局属性定义:
 column.format.date= yyyy-MM-dd
column.format.currency= ￥###,###,#00.00
<ec:column property="totalprice" title="总金额" cell="currency" width="80" />
<ec:column property="shipdate" title="发货日期"  cell="date" width= "80"/>
<e
其中RowCountCell用于显示序号。
4.3. 汇总
在column中加入两个cac属性，就会自动在table的底端显示汇总
<ec:column property="totalprice" title="总金额" cell="number" format="###,###,##0.00" calc="total" calcTitle= "汇总:"/>
4.4 i18N
在Web.xml里面指定i18N的Properties文件
<context-param>
  <param-name>extremecomponentsMessagesLocation</param-name>
  <param-value>messages</param-value>
</context-param>
<ec:column property="name" title="book.name"/>
4.5数据库分页
 EC默认从数据库中查找所有记录然后由它来分页，如果查询结果较大，可以考虑使用数据库端分页的方案。
 此时，EC会使用Limit对象向Controller传递PageNo,PageSize,OrderBy等分页信息。而服务端将向EC返回总记录数和当前页的内容。 
4.6不显示导出excel及分页
最快的方式是设置table的showStatusBar= false
<ec:table  items= "order.orderItems"var="item" action=""   showStatusBar= "false">
    4.7ImagePath
 旧版EC包括其文档都在每个table tag里定义ImagePath, 新版已经可以自动插入ContextPath,只需在properties文件定义table.imagePath=/images/table/*.gif即可
5.自定义及扩展
   ExtremeTable比Display Tag的一个就是良好的自定义和扩展能力，不用千人一面。
   不过，人总是懒的，虽然扩展子类很容易，但能不扩展就还是不可扩展了。幸亏用Compact View再改改CSS一般就能达到要求。
 5.1. 良好的CSS定义
         ExtremeTable 的CSS定义非常严谨, 并且提供很多个层次的修改方式:
         1.直接修改css文件, 可以把table view改成任意样式
         2.修改全局属性, 改变某种元素对应的css class名
table.styleClass=tableRegion
         3.在某个页面的row,column tag中定义class
 <ec:row or styleClass=""/>
        我们这边采用 直接修改extremecomponents.css为合适的样式
5.2方便的<tr><td>属性扩展
        row与column已提供了丰富的普通属性与 javascript属性如onClick(), 如果属性仍然未够,可自行扩展<row>与<column>tag ，并通过全局属性指定新的子类名。
   为了方便大家在子类扩展属性, extreme Table提供了专门的回调函数与Util函数如
public void addColumnAttributes(Column column) {
   column.addAttribute("customAttributeOne", customAttributeOne);
}   
 
        
详细请看手册,Table, Row,Column都提供相同的扩展:
http://extremecomponents.org/wiki/index.php/Column#Extended_Attributes
如果不是Extremetable的特别支持, 普通taglib class要扩展属性的话:
        1.定义真正的Java属性,setter,getter
        2. tld文件中声明新的属性 
        3.重载输出函数将新属性打印出来
5.3 扩展HTMLView,cell 等显示组件
     Extreme Table在这些类的扩展上放便很多，但这个版本里我还没有进行尝试，就不写了。请自行参考官方文档:http://extremecomponents.org/wiki/index.php/Html_View_Tutorial .


junky 2007-04-03 13:27 发表评论
]]>J2EE平台介绍(转)http://www.blogjava.net/junky/archive/2007/03/16/104226.htmljunkyjunkyFri, 16 Mar 2007 05:32:00 GMThttp://www.blogjava.net/junky/archive/2007/03/16/104226.htmlhttp://www.blogjava.net/junky/comments/104226.htmlhttp://www.blogjava.net/junky/archive/2007/03/16/104226.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/104226.htmlhttp://www.blogjava.net/junky/services/trackbacks/104226.html

今天，越来越多的程序设计人员希望借助服务器端技术的快捷、安全以及可靠性，为他们的企业开发分布式的交易应用系统。如果你已经工作在这一领域，你将非常清楚，在今天这样一个电子商务和信息技术飞速发展、并充满需求的世界上，企业应用必须以更少的资金、更快的速度和比以往更少的资源来设计、建造和运营。

     今天，越来越多的程序设计人员希望借助服务器端技术的快捷、安全以及可靠性，为他们的企业开发分布式的交易应用系统。如果你已经工作在这一领域，你将非常清楚，在今天这样一个电子商务和信息技术飞速发展、并充满需求的世界上，企业应用必须以更少的资金、更快的速度和比以往更少的资源来设计、建造和运营。

为降低成本、快速实现企业应用的设计和开发，J2EE平台技术为企业应用的设计、开发、集成以及部署提供了一条基于组件的实现途径。J2EE平台为您提供了一个多层次分布是应用设计模式，重用组件的能力，统一的安全模式，灵活的交易控制。你不仅可以把全新的客户解决方案，用比以往都快的速度推向市场，而且平台独立、基于J2EE组件的解决方案将使你的产品不绑定在任何一个厂商的产品和API上。

本文介绍J2EE 1.3平台并同时作为J2EE教程的概述章节。J2EE教程采用基于范例的方式，描述J2EE SDK 1.3版的特点和功能。无论你是新手还是有经验的企业应用开发人员，你都将发现J2EE教程中结合了文字的范例，是你创建自己企业的解决方案时，有价值的、唾手可得知识库。

如果你是刚刚开始接触J2EE应用开发，这个介绍是一个很好的起点。在这里你将学习J2EE架构，开始熟悉重要的术语和概念，找到如何开始进行J2EE应用程序编程，集成和部署。

分布式的多层次应用

J2EE平台采用一个多层次分布式的应用模式。这意味着应用逻辑根据功能被划分成组件，组成J2EE应用的不同应用组件安装在不同的服务器上，这种划分是根据应用组件属于多层次J2EE环境中的哪一个层次来决定的。图1展示了两个多层次J2EE应用划分成在下面的表中描述的不同层次。图1中表示的J2EE应用部分代表了J2EE应用组件。

• 运行在客户机器上的客户层组件

• 运行在J2EE服务器上的Web层组件

• 运行在J2EE服务器上的业务层组件

• 运行在EIS服务器上的企业信息系统层软件

如图1所示，J2EE应用可以由三或四个层次组成，J2EE多层次应用一般被认为是三层应用，因为它们是被分布在三个不同的地点：客户端机器、J2EE服务器和数据库或后端的传统系统服务器。三层架构应用是对标准的客户端/服务器应用架构的一种扩展，即在客户端应用和后台存储之间增加一个多线程应用服务器。


图1：多层应用

J2EE应用组件

J2EE应用是由组件组成的。J2EE组件是一个自我封装的功能软件单元，它将通过相关的类、文件和与其它组件的通讯，被集成进J2EE应用。J2EE规范定义了如下J2EE组件：

• 应用（Application）客户端和小程序（applet）是客户端组件

• Java Servlet和Java Server Pages技术组件是Web组件

• Enterprise JavaBeans(EJB)组件是业务组件

J2EE组件使用Java编程语言编写的，也向任何Java编程语言程序一样编译的。使用J2EE平台的不同之处是，J2EE组件是被集成到J2EE应用中的，是经过很好格式化的并经过J2EE规范兼容性验证的，而且在部署和正式运行时，是运行在J2EE服务器上，并且是在J2EE服务器的管理下运行的。

客户端组件

一个J2EE应用可以使基于Web的或不基于Web的。对于不基于Web的J2EE应用，一个应用客户端软件将运行在客户端机器上，而对于基于Web的J2EE应用，浏览器会下载Web页面和小程序（applet）到客户端机器上。

应用客户端

运行在客户端机器上的应用客户端软件，为用户提供一个途径，处理象J2EE系统或应用管理这样的工作。它通常由一个用Swing或AWT API开发的图形用户界面，但是也可以使用命令行接口。

应用客户端软件直接访问运行在业务层的企业Bean。当然，如果J2EE应用客户端允许，一个应用客户端也可以建立HTTP连接，与运行在Web层的Servlet进行通讯。

Web浏览器

用户端的Web浏览器从Web层下载HTML/WML/XML等静态或动态Web页面。动态页面是由运行在Web层的Servlet或JSP页面生成的。

Applet

一个从Web层下载的Web页面可以包含嵌入的applet。一个applet是一个用Java编程语言编写的小客户端应用，通过安装在Web浏览器上的Java虚拟机执行。然而，applet要在Web浏览器上成功运行，客户端系统还需要Java插件（Java Plug-in）和安全策略文件。

JSP页面是推荐的创建基于Web的客户端程序的API，因为在客户端无需插件和安全策略文件。而且，JSP页面支持清晰的、多模块应用设计，因为它提供一个途径，使应用程序编程和Web页面设计分离。这意味着参与Web页面设计的人员所要做的工作，不需要了解Java编程语言的语法。

运行在基于网络的系统，例如手持设备、汽车电话等上的Applet，可以执行运行在J2EE服务器上的JSP页面或Servlet生成的WML页面。WML页面是通过无线应用协议（WAP）传送的，网络配置需要一个网关，把WAP转换成HTTP，然后在转换回来。网关把从手持设备上来的WAP请求转换成J2EE服务器的HTTP请求，再把HTTP服务器的响应和WML页面转换成一个WAP服务器响应和WML页面显示在手持设备上。

JavaBeans组件架构

客户层也由一个基于JavaBeans组件架构的组件，用于管理应用客户端或applet 与运行在J2EE服务器上的组件之间的数据流。JavaBeans组件不是在J2EE规范中的组件。

为J2EE平台而写的JavaBeans组件，包含实例变量以及为访问实例变量的读取和设置方法。以这种方式使用的JavaBeans组件一般设计和实现起来非常简单，但是要遵循JavaBeans组件架构中的命名和设计规范。

J2EE服务器通讯

图2展示了组成客户层的不同组成部分。客户端与运行在J2EE服务器上的业务层之间的通讯，可以是直接的，或者是在客户端运行浏览器的情况下，通过运行在Web层的JSP页面或Servlet完成。


图2：服务器通讯


瘦客户端

J2EE应用使用瘦客户端。一个瘦客户端是与应用连接地轻负载接口，它不处理象查询数据库、执行负载业务逻辑、或域传统系统连接等工作。象这样的重负载被转移到运行在J2EE服务器上的Web或企业Beans上，这样可以借助J2EE服务器端技术的安全性、快速、服务和可靠性。

Web组件

J2EE的Web组件可以是JSP页面，也可以是Servlet。Servlet是Java编程语言的类，能够动态处理请求并生成响应。JSP页面是基于文本的文件，包含静态内容和小段的Java编程语言代码用以生成动态内容。当JSP页面被调用时，后台Servlet执行这小短代码，并返回结果。

静态HTML页面和applet在应用集成的时候是与Web组件捆绑在一起的。但是没有被J2EE规范最为Web组件处理。服务器端应用类也可以与Web组件捆绑，象HTML一样，没有作为Web组件。

如图3展示，向客户层一样，Web层有JavaBeans对象管理用户的输入，并把输入发送到运行在业务层的企业Bean处理。


图3：Web层和J2EE应用


业务组件

业务代码，用于解决或满足特定的业务领域的问题的逻辑，例如银行、零售或者金融等等，是在业务层，由企业Beans来处理的。图4展示一个企业Beans是如何接收客户端程序的数据，处理它（如果需要的话），并把它发送到企业信息系统层进行存储。企业Bean同样接收存储的数据，处理它（如果需要的话），在发送回客户端程序。

企业Beans有三类：Session Beans、实体beans(entity beans)和消息驱动Beans。一个Session Bean代表一个与客户的临时会话。当客户结束操作时，这个Session Bean和它的数据就消失了。相反，实体Bean表示一个永久存储在数据库的表中的数据。如果客户结束操作或服务器关机，后台操作保证实体Beans的数据存储下来。

一个消息驱动的Bean结合了Session Bean和Java消息服务（JMS）消息侦听器的功能，允许业务组件以异步的方式接收JMS消息。这里介绍实体Beans和Session Beans。想了解更多的关于消息驱动Beans，参加Java Message Service教程。


图4：业务和企业信息系统（EIS）层


企业信息系统层

企业信息系统层处理企业信息系统软件，包括企业体系结构系统如企业资源规划（ERP），大型机交易处理，数据库系统，以及传统信息系统。J2EE应用组件需要访问企业信息系统，例如建立数据库连接等等。

J2EE架构

通常，瘦客户端多层次应用是很难编写的，因为它包括很多行非常难以理解的代码，以处理交易和状态管理，多线程，资源池管理，以及其他复杂的低层次细节问题。基于组件的、与平台无关的J2EE应用的开发是很容易的，因为业务逻辑被组织成可重复使用的组件，而且J2EE服务器以容器(Container)的形式为每种类型的组件提供后台支持。由于你不必自己开发这些服务，你可以专注于解决你面临的业务问题。

容器（container）和服务

组件在部署时被安装在容器之中，是组件和特定平台底层功能之间的接口支持着组件。在Web，企业Bean或者应用客户端组件能够被执行以前，它必须被组装到J2EE应用里，并且被部署到它的容器里。

组装流程包括设定J2EE应用中的每一个组件以及J2EE应用本身在容器之中的设置。容器的设置个性化了J2EE服务器对每个组件的后台支持，包括象安全性、交易管理、Java命名和目录接口查询，以及远程连接等等。这里是一些重点：

• J2EE安全模式，使你能够配置Web组件或企业Bean，使系统资源只能被授权的用户访问。

• J2EE交易模式，使你能够指定方法之间的关系，从而组成一个交易，这样交易中的所有方法将被作为一个单元对待。

• JNDI查询服务，为企业中多种命名和目录服务提供统一的接口，这样应用组件就可以访问命名和目录服务了。

• J2EE远程连接模式，管理客户端和企业Beans之间的底层通讯。在企业Bean被创建后，客户端调用它的方法，就象它在同一个虚拟机上一样。

实际上，J2EE架构提供可配置的服务，意思是在同一个J2EE应用中的应用组件可以根据他们部署的位置不同，表现不同。一个企业Bean可以通过不同的安全设置，是它在一个生产系统中获得一种层次的数据库数据访问，而在另一个生产系统中，则获得另一种数据库访问权限。

容器还管理着不可配置服务，如企业bean和Servlet的生命周期，数据库连接资源池，数据持续性（persistence），以及J2EE API中描述的访问J2EE平台的API。尽管数据持续性机制是一个不可配置服务，J2EE架构允许你在需要比缺省的容器管理的持续性机制更多的控制时，用你的企业Bean实现中的相应的代码覆盖原有的容器管理的持续机制。例如，你可以使用Bean管理的持续性机制来实现你自己的搜索方法，或创建个性化的数据库缓存。

容器类型

在部署过程之中，J2EE应用组件被安装在如下类型的J2EE容器中。本文中涉及的J2EE组件和容器参见图5。

企业JavaBeans(EJB)容器，为J2EE应用管理着所有的企业Beans。企业Bean和它们的容器运行在J2EE服务器上。

Web容器，为J2EE应用管理着所有的JSP页面和Servlet组件。Web组件和它们的容器运行在J2EE服务器上。

应用客户端容器，为J2EE应用管理着所有的应用客户端组件。应用客户端组件和它们的容器运行在客户端机器上。

applet容器，是Web浏览器和Java插件的组合，运行在客户端机器上。


图5：J2EE服务器和容器


包装

J2EE组件是单独包装的，为部署而捆绑到J2EE应用中。每个组件，其相关的文件如GIF和HTML文件，或者服务器端应用类，以及部署描述，被集成成一个模块并添加到J2EE应用中。J2EE应用是由一个或多个企业Bean，Web，或应用客户端组件模块组成的。最终企业解决方案可以使用一个J2EE应用或根据设计需要由两个或更多的J2EE应用组成。

一个J2EE应用以及它的每一个模块都有它自己的部署描述。部署描述是一个XML文本文件，带有.xml后缀，描述组件的部署设置。一个企业Bean的部署描述，例如，声明交易属性，和企业Bean的安全认证。由于部署描述的信息是可以声明的，这样它可以在无需修改Bean的源代码的情况下，进行修改。在运行时，J2EE服务器读取部署描述，并依次对组件进行操作。

J2EE应用以及相关的模块是在一个Enterprise Archive(EAR)中发送的。EAR文件是一个标准的JAR文件，以.ear后缀结尾。在GUI版的J2EE SDK应用部署工具集中，你先创建一个EAR文件，在添加JAR和WAR到EAR中。如果你使用命令行打包工具，则先创建JAR和WAR文件，然后创建EAR文件。J2EE SDK工具：

• 每个EJB JAR文件包含它的部署描述，相关文件和企业Bean的.class文件

• 每个应用客户端JAR包含它的部署描述，相关文件和应用客户端的.class文件

• 每个WAR文件包含它的部署描述，相关文件和servlet的.class文件以及JSP页面的.jsp文件

使用模块和EAR文件使使用一些相同的组件组装多个不同的J2EE应用成为可能。无需额外的编程，只是把不同的J2EE模块组装到J2EE EAR文件中。

开发的角色

可重用模块使把应用开发和部署过程分成截然不同的角色成为可能。这样不同的人或公司能够在整个过程中实施不同的部分。

最开始的两个角色包括购买和安装J2EE产品和工具。当软件采购的并且安装了， J2EE组件可以由应用组件提供商开发，由应用组装商组装，由应用部署商部署。在一个大的机构中，每一个角色由不同的个人或小组完成。这种劳动力的分割是可行的，因为每一个先前的角色输出一个可移植的文件，这个文件可以作为后续角色的输入。例如，在应用组件开发阶段，一个企业Bean软件开发商提交EJB JAR文件。在应用组装角色中，另一个开发商把这些EJB JAR文件与J2EE应用相结合，并存放在一个EAR文件中。在应用部署角色中，系统管理员在客户现场，使用EAR文件，把J2EE应用安装到一个J2EE服务器中。

不同的角色并不是总是由不同的人来执行的。如果你为一个小公司工作，或者你在构建一个测试应用，你可能要执行每一个阶段的工作。

J2EE产品供应商

J2EE产品供应商是设计和制作能够用于销售的J2EE平台、API和J2EE规范所定义的其他特性的公司。产品供应商一般是操作系统、数据库系统、应用服务器或Web服务器厂商，他们根据J2EE规范实现J2EE平台。

工具供应商

工具供应商是个人或公司，他们提供组件开发商、组装商、部署商等使用的开发、组装和包装工具。参见工具信息提供的J2EE SDK 1.3兼容的工具。

应用组件供应商

应用组件供应商是公司或个人，他们制作Web组件、企业Beans、applet或应用客户端，这些组件可用于J2EE应用。

企业Bean制作

软件开发者完成以下工作，以提供包含企业Bean的EJB JAR文件：

• 编写并编译源代码

• 定制部署描述

• 捆绑.class文件和部署描述到一个EJB JAR文件

Web组件制作

Web开发者（JSP页面）或软件开发者（servlet）完成以下工作，以提供包含Web组件的WAR文件。

• 编写并编译servlet源代码

• 编写JSP和HTML文件

• 为web组件定制部署描述

• 捆绑.class，.jsp，.html和部署描述文件到WAR文件

J2EE应用客户端制作

软件开发者完成以下工作，以提供包含J2EE应用客户端的JAR文件。

• 编写并编译源代码

• 为客户端定制部署描述

• 捆绑.class文件和部署描述文件到JAR文件

应用组装商

应用组装商是一些公司或个人，他们从组件供应商那里得到应用组件的JAR文件，并组装成J2EE应用的EAR文件。组装商和部署商可以直接编辑部署描述或者使用工具，根据交互方式的选择，正确的增加XML标签。软件开发商完成以下工作，以提供包含J2EE应用的EAR文件。

• 组装EJB JAR和前一阶段开发的Web组件（WAR）文件，生成新的J2EE应用（EAR）文件。

• 为J2EE应用定制部署描述

• 检查EAR文件的内容是否是很好格式化的并符合J2EE规范

应用部署商和管理员

部署商和管理员是公司或个人，他们配置并部署J2EE应用，管理J2EE运行的计算和网络架构，并监视运行环境。责任包括设置交易控制，安全属性，并设定与数据库地连接。

在配置过程中，部署者遵循由应用组件供应商提供的指南，解决外部依赖关系，设定安全框架，设置交易属性。在安装过程中，部署商将应用组件转移到服务器上，并生成容器专用的类和接口。

部署商/系统管理员完成以下工作，已安装并配置J2EE应用。

• 增加在前一阶段制作的J2EE应用（EAR）文件到J2EE服务器上

• 为运行环境配置J2EE应用，即修改J2EE应用的部署描述

• 检查EAR文件的内容是否是很好格式化的并符合J2EE规范

• 部署（安装）J2EE应用的EAR文件到J2EE服务器

参考实现软件

J2EE SDK是由Sun公司提供的J2EE平台和规范的非商业用途的实现，适用于示范、原形制作和教学环境。包含J2EE应用服务器、Web服务器、关系型数据库、J2EE API等，是一套完整的开发部署工具。你可以从网上下载J2EE SDK。

• 产品开发商使用J2EE SDK确定在一组给定应用条件下必须组那些实现，并且运行J2EE兼容性测试包，以检测它们的产品测试包是否完全符合J2EE规范。

• 应用组件开发商在J2EE SDK上运行他们的J2EE应用，以验证这些应用是否适用于所有J2EE产品和工具。

Web服务器

Web服务器提供一个或多个Web容器。例如，Web容器一般依赖于Web服务器提供HTTP消息管理。J2EE实现不是必须支持某个特定的Web服务器，这意味着不同的J2EE产品对Web服务器的支持是由变化的。

数据库访问

关系性数据库对应用数据提供持久的存储。J2EE实现不是必须支持某一特定类型的数据库，这意味着不同J2EE产品对数据库的支持是变化的。参见J2EE SDK下载文件中的版本说明，提供了参考实现目前支持的数据库清单。

J2EE API

Java 2平台标准版（J2SE）SDK在运行J2EE SDK时是必需的，它为编写J2EE组件提供核心API，核心开发工具，以及Java虚拟机。J2EE SDK提供下列API供J2EE应用使用。

企业JavaBeans技术 2.0

一个企业Bean是一段包含域和方法的代码体，用于实现业务逻辑的一个模块。你可以认为企业Bean是一个构建模块，可以单独使用或与其他企业Beans一起在J2EE服务器上执行业务逻辑。

由三种类型的企业Bean：Session Bean，实体Beans，和消息驱动Beans，这些在业务组件中描述过。有了实体Beans，你无需编写任何SQL代码或直接使用JDBC API执行数据库访问操作。EJB容器替你处理这些。当然，如果你不管因为任何原因，覆盖了却省的容器管理持续性机制，你将需要使用JDBC API。同样，如果你选用Session Beans访问数据库，你必须使用JDBC API。

JDBC 2.0 API

JDBC API是你可以从Java编程语言的方法中，调用SQL命令。你在覆盖了却省的容器管理持续性机制，或选用Session Beans访问数据库，则企业Bean中访问数据库必须使用JDBC API。有了容器管理持续性机制，数据库访问操作由容器来处理，你的企业Bean的实现中不包含JDBC代码或SQL命令。你也可以从servlet或JSP页面中直接使用JDBC API访问数据库，而不通过企业Bean。

JDBC API由两个部分：一个适用于应用组件访问数据库的应用驱动接口；一个是隶属于J2EE平台的服务提供接口。

Java Servlet技术2.3

Java Servlet技术为你定义HTTP专用的servlet类。一个Servlet类扩展了服务器的能力，这个服务器存放着应用，而应用是以请求-响应编程模式被访问的。尽管Servlet可以响应任意形式的请求，但是它通常被用于扩展Web服务器存放的应用。

JavaServer Pages(JSP)技术 1.2

JSP页面技术是你能够在基于文本的文件中结合小段的Java编程语言代码和静态内容。一个JSP页面是一个基于文本的文件，它包含两种类型的文本：静态模板数据，它可以表示为任何基于文本的格式，如HTML、WML和XML；JSP元素，决定这个页面如何构造动态内容。

Java Messaging Service 1.0

JMS API是一种消息标准，允许J2EE应用组件创建、发送、接受和读取消息。它是松散耦合的、可靠的，异步地进行分布式通讯。有关JMS的更多信息参见Java消息服务教程。

Java Transaction API(JTA) 1.0

JTA API为分段交易提供标准的分段接口。J2EE架构提供一个缺省的自动确认来处理交易的确认和回滚。一个自动确认意味着任何其他查询数据的应用，在每次数据库的读写操作以后，将看到最新的数据。然而，如果你的应用执行两个独立的相互依赖的数据库访问操作，你将希望使用JTA API来划分，使整个交易同时含有开始、回滚和确认。

JavaMail技术1.2

很多互联网应用需要发送邮件进行确认，所以J2EE平台包含了与JavaMail服务提供商配合使用的JavaMail API，这样，应用组件可以使用它发送邮件。JavaMail API包含两个部分：一个是应用层接口，应用组件使用它发送邮件；一个服务提供商接口。

JavaBean Activation Framework 1.0

JavaBeans激活框架被包含是因为JavaMail要使用它。它提供标准的服务，以确定专用数据的类型，对它的压缩访问，发现对它可以使用的操作，并创建相应的JavaBean组件来执行那些操作。

Java API for XML(JAXP) 1.1

XML是一种语言，用于表示和描述基于文本的数据，这样数据可以被使用XML API的程序或者工具所读取和处理。程序和工具可以生成XML文件，另一些程序和工具可以读取和处理。

例如，一个J2EE应用使用XML制作报表，不同的公司收到这个报表，可以用最符合他们需要的方式处理这些数据。一个公司可能把XML数据通过程序转换成HTML格式，这样它可以把报表放在Web上，另一个公司可能把XML数据通过工具生成市场演讲稿，再有另一个公司可能把XML数据读到J2EE应用中进行处理。

J2EE Connector API 1.0

连接器API被J2EE工具厂商和系统集成商用于创建资源适配器，使企业信息系统可以嵌入一些J2EE产品。一个资源适配器是一个软件组件，它使J2EE应用组件可以与后台资源管理器进行访问和交互。因为资源适配器是他的资源管理器专用的，所以每个类型的数据库或信息系统有它不同的资源适配器。

Java授权与认证服务（JAAS）1.0

Java授权与认证服务（JAAS）提供一个途径，使J2EE应用可以授权并认证一个用户或一个用户组使用它。JAAS是标准的嵌入式认证模块（PAM）框架的一个Java编程语言版本，使Java 2平台安全架构可以支持基于用户的授权。

工具

J2EE参考实现提供一个应用部署工具和一组脚本，用于组装、验证和部署J2EE应用并管理你的开发和生产环境。参见J2EE教程以全面了解这些工具。

应用部署工具

J2EE参考实现提供一个应用部署工具，用于组装、验证和部署J2EE应用。它由两个版本：命令行和GUI。

GUI工具包含有Wizards用于：

• 打包、配置和部署J2EE应用

• 打包、配置企业Beans

• 打包、配置Web组件

• 打包、配置应用客户端

• 打包、配置资源使配器

另外，配置信息可以在表格化的检验图框中为每一个组件和模块类型进行设置。

脚本

表1列出了J2EE参考实现中包含的脚本，你可以在命令行中执行这些操作。

脚本

描述

j2ee

启动和停止J2EE服务器

cloudscape

启动和停止缺省数据库

cloudIJ

运行交互式SQL工具，这是一个不支持的工具

j2eeadmin

为不同的资源增加JDBC驱动，JMS目标，和连接工厂

keytool

创建公开的和私有的密钥，生成X509自己签署（self-signed）的证书

realmtool

输入证书文件。为J2EE应用在认证/授权列表中，增加、删除J2EE用户

packager

包装J2EE应用组件到EAR，EJB JAR，应用客户端JAR和WAR文件中。

verifier

验证EAR、EJB JAR、应用客户端JAR和WAR文件是否是很好格式化的，以及是否遵从J2EE规范

runclient

运行J2EE应用客户端

cleanup

从J2EE服务器上清除所有部署的应用

结论

J2EE平台提供了你设计、建造、测试、部署分布式多层次应用所需要的所有内容。J2EE教程对平台特性、API和工具进行了有深度的介绍。如果你需要J2EE应用设计方面的帮助，J2EE BluePrints Digest对在J2EE平台上，开发多层次、瘦客户应用，提供了高层次的描述。

应用编程模式由技术主体和原则组成，指导J2EE应用开发人员确定最合理的实施选择、最有效的使用JSP和Servlets，在实现业务逻辑时选择好的设计、有效的把J2EE安全模型映射到企业计算环境和体系结构。

作者简介

Monica Pawlan, Java Developer Connection(JDC)的首席作家，是Essentials of the Java Programming Language: A Hands-On Guide的作者，和Advanced Programming for the Java 2 Platform的合作作者。



junky 2007-03-16 13:32 发表评论
]]>40种网站常用Javascript技巧(转)http://www.blogjava.net/junky/archive/2007/02/27/100917.htmljunkyjunkyTue, 27 Feb 2007 04:57:00 GMThttp://www.blogjava.net/junky/archive/2007/02/27/100917.htmlhttp://www.blogjava.net/junky/comments/100917.htmlhttp://www.blogjava.net/junky/archive/2007/02/27/100917.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/100917.htmlhttp://www.blogjava.net/junky/services/trackbacks/100917.html
1. oncontextmenu="window.event.returnValue=false" 将彻底屏蔽鼠标右键
<table border oncontextmenu=return(false)><td>no</table> 可用于Table

2. <body onselectstart="return false"> 取消选取、防止复制

3. onpaste="return false" 不准粘贴

4. oncopy="return false;" oncut="return false;" 防止复制

5. <link rel="Shortcut Icon" href="favicon.ico"> IE地址栏前换成自己的图标

6. <link rel="Bookmark" href="favicon.ico"> 可以在收藏夹中显示出你的图标

7. <input style="ime-mode:disabled"> 关闭输入法

8. 永远都会带着框架
<script language="JavaScript"><!--
if (window == top)top.location.href = "frames.htm"; //frames.htm为框架网页
// --></script>

9. 防止被人frame
<SCRIPT LANGUAGE=JAVASCRIPT><!--
if (top.location != self.location)top.location=self.location;
// --></SCRIPT>

10. 网页将不能被另存为
<noscript><iframe src="/blog/*.html>";</iframe></noscript>

11. <input type=button value=查看网页源代码
onclick="window.location = "view-source:"+ "http://www.williamlong.info"">

12.删除时确认
<a href="javascript:if(confirm("确实要删除吗?"))location="boos.asp?&areyou=删除&page=1"">删除</a>

13. 取得控件的绝对位置
//Javascript
<script language="Javascript">
function getIE(e){
var t=e.offsetTop;
var l=e.offsetLeft;
while(e=e.offsetParent)
alert("top="+t+"/nleft="+l);
}
</script>

//VBScript
<script language="VBScript"><!--
function getIE()
dim t,l,a,b
set a=document.all.img1
t=document.all.img1.offsetTop
l=document.all.img1.offsetLeft
while a.tagName<>"BODY"
set a = a.offsetParent
t=t+a.offsetTop
l=l+a.offsetLeft
wend
msgbox "top="&t&chr(13)&"left="&l,64,"得到控件的位置"
end function
--></script>

14. 光标是停在文本框文字的最后
<script language="javascript">
function cc()
{
var e = event.srcElement;
var r =e.createTextRange();
r.moveStart("character",e.value.length);
r.collapse(true);
r.select();
}
</script>
<input type=text name=text1 value="123" onfocus="cc()">

15. 判断上一页的来源
javascript:
document.referrer
       
 
 
?

16. 最小化、最大化、关闭窗口
<object id=hh1 classid="clsid:ADB880A6-D8FF-11CF-9377-00AA003B7A11">
<param name="Command" value="Minimize"></object>
<object id=hh2 classid="clsid:ADB880A6-D8FF-11CF-9377-00AA003B7A11">
<param name="Command" value="Maximize"></object>
<OBJECT id=hh3 classid="clsid:adb880a6-d8ff-11cf-9377-00aa003b7a11">
<PARAM NAME="Command" VALUE="Close"></OBJECT>
<input type=button value=最小化 onclick=hh1.Click()>
<input type=button value=最大化 onclick=hh2.Click()>
<input type=button value=关闭 onclick=hh3.Click()>
本例适用于IE

17.屏蔽功能键Shift,Alt,Ctrl
<script>
function look(){
if(event.shiftKey)
alert("禁止按Shift键!"); //可以换成ALT　CTRL
}
document.onkeydown=look;
</script>

18. 网页不会被缓存
<META HTTP-EQUIV="pragma" CONTENT="no-cache">
<META HTTP-EQUIV="Cache-Control" CONTENT="no-cache, must-revalidate">
<META HTTP-EQUIV="expires" CONTENT="Wed, 26 Feb 1997 08:21:57 GMT">
或者<META HTTP-EQUIV="expires" CONTENT="0">

19.怎样让表单没有凹凸感？
<input type=text style="border:1 solid #000000">
或
<input type=text style="border-left:none; border-right:none; border-top:none; border-bottom:

1 solid #000000"></textarea>

20.<div><span>&<layer>的区别？
<div>(division)用来定义大段的页面元素，会产生转行
<span>用来定义同一行内的元素，跟<div>的唯一区别是不产生转行
<layer>是ns的标记，ie不支持，相当于<div>

21.让弹出窗口总是在最上面:
<body onblur="this.focus();">

22.不要滚动条?
让竖条没有:
<body style="overflow:scroll;overflow-y:hidden">
</body>
让横条没有:
<body style="overflow:scroll;overflow-x:hidden">
</body>
两个都去掉？更简单了
<body scroll="no">
</body>

23.怎样去掉图片链接点击后，图片周围的虚线？
<a href="#" onFocus="this.blur()"><img src="/blog/logo.jpg" border=0></a>

24.电子邮件处理提交表单
<form name="form1" method="post" action="mailto:****@***.com" enctype="text/plain">
<input type=submit>
</form>

25.在打开的子窗口刷新父窗口的代码里如何写？
window.opener.location.reload()

26.如何设定打开页面的大小
<body onload="top.resizeTo(300,200);">
打开页面的位置<body onload="top.moveBy(300,200);">

27.在页面中如何加入不是满铺的背景图片,拉动页面时背景图不动
<STYLE>
body
{background-image:url(/blog/logo.gif); background-repeat:no-repeat;
background-position:center;background-attachment: fixed}
</STYLE>

28. 检查一段字符串是否全由数字组成
<script language="Javascript"><!--
function checkNum(str){return str.match(//D/)==null}
alert(checkNum("1232142141"))
alert(checkNum("123214214a1"))
// --></script>

29. 获得一个窗口的大小
document.body.clientWidth; document.body.clientHeight

30. 怎么判断是否是字符
if (/[^/x00-/xff]/g.test(s)) alert("含有汉字");
else alert("全是字符");

31.TEXTAREA自适应文字行数的多少
<textarea rows=1 name=s1 cols=27 onpropertychange="this.style.posHeight=this.scrollHeight">
</textarea>

32. 日期减去天数等于第二个日期
<script language=Javascript>
function cc(dd,dadd)
{
//可以加上错误处理
var a = new Date(dd)
a = a.valueOf()
a = a - dadd * 24 * 60 * 60 * 1000
a = new Date(a)
alert(a.getFullYear() + "年" + (a.getMonth() + 1) + "月" + a.getDate() + "日")
}
cc("12/23/2002",2)
</script>

33. 选择了哪一个Radio
<HTML><script language="vbscript">
function checkme()
for each ob in radio1
if ob.checked then window.alert ob.value
next
end function
</script><BODY>
<INPUT name="radio1" type="radio" value="style" checked>Style
<INPUT name="radio1" type="radio" value="barcode">Barcode
<INPUT type="button" value="check" onclick="checkme()">
</BODY></HTML>

34.脚本永不出错
<SCRIPT LANGUAGE="JavaScript">
<!-- Hide
function killErrors() {
return true;
}
window.onerror = killErrors;
// -->
</SCRIPT>

35.ENTER键可以让光标移到下一个输入框
<input onkeydown="if(event.keyCode==13)event.keyCode=9">
Top
 
       
 
 
?

36. 检测某个网站的链接速度：
把如下代码加入<body>区域中:
<script language=Javascript>
tim=1
setInterval("tim++",100)
b=1
var autourl=new Array()
autourl[1]="www.njcatv.net"
autourl[2]="javacool.3322.net"
autourl[3]="www.sina.com.cn"
autourl[4]="www.nuaa.edu.cn"
autourl[5]="www.cctv.com"
function butt(){
document.write("<form name=autof>")
for(var i=1;i<autourl.length;i++)
document.write("<input type=text name=txt"+i+" size=10 value="/blog/测试中......>" =》<input type=text
name=url"+i+" size=40> =》<input type=button value=GO

onclick=window.open(this.form.url"+i+".value)><br/>")
document.write("<input type=submit value=刷新></form>")
}
butt()
function auto(url)
else

b++
}
function run(){for(var i=1;i<autourl.length;i++)document.write("<img src=http://"+autourl+"/"+Math.random()+" width=1 height=1

onerror=auto("http://"+autourl+"")>")}
run()</script>

37. 各种样式的光标
auto ：标准光标
default ：标准箭头
hand ：手形光标
wait ：等待光标
text ：I形光标
vertical-text ：水平I形光标
no-drop ：不可拖动光标
not-allowed ：无效光标
help ：?帮助光标
all-scroll ：三角方向标
move ：移动标
crosshair ：十字标
e-resize
n-resize
nw-resize
w-resize
s-resize
se-resize
sw-resize

38.页面进入和退出的特效
进入页面<meta http-equiv="Page-Enter" content="revealTrans(duration=x, transition=y)">
推出页面<meta http-equiv="Page-Exit" content="revealTrans(duration=x, transition=y)">
这个是页面被载入和调出时的一些特效。duration表示特效的持续时间，以秒为单位。transition表示使用哪种特效，取值为1-23:
　　0 矩形缩小
　　1 矩形扩大
　　2 圆形缩小
　　3 圆形扩大
　　4 下到上刷新
　　5 上到下刷新
　　6 左到右刷新
　　7 右到左刷新
　　8 竖百叶窗
　　9 横百叶窗
　　10 错位横百叶窗
　　11 错位竖百叶窗
　　12 点扩散
　　13 左右到中间刷新
　　14 中间到左右刷新
　　15 中间到上下
　　16 上下到中间
　　17 右下到左上
　　18 右上到左下
　　19 左上到右下
　　20 左下到右上
　　21 横条
　　22 竖条
　　23 以上22种随机选择一种

39.在规定时间内跳转
<META http-equiv=V="REFRESH" content="5;URL=http://www.williamlong.info">

40.网页是否被检索
<meta name="ROBOTS" content="属性值">
　　其中属性值有以下一些:
　　属性值为"all": 文件将被检索，且页上链接可被查询；
　　属性值为"none": 文件不被检索，而且不查询页上的链接；
　　属性值为"index": 文件将被检索；
　　属性值为"follow": 查询页上的链接；
　　属性值为"noindex": 文件不检索，但可被查询链接；
　　属性值为"nofollow": 文件不被检索，但可查询页上的链接。

最大化窗口？
<script language="JavaScript">
<!--
self.moveTo(0,0)
self.resizeTo(screen.availWidth,screen.availHeight)
//-->
</script>




解 决问题：由于层与下拉框之间的优先级是：下拉框 > 层，因此在显示的时候，会因为优先级的次序而会出现如上问题。（如果几个元素都是层的话，我们可以通过层的 z-index 属性来设置）解决办法就是：给层中放一个优先级比下拉框更高的元素（iframe），从而解决此问题！具体解决代码如下：

<div id="menu" style="position:absolute; visibility:hidden; top:20px; left:20px; width:100px; height:200px; background-color:#6699cc;">
<table>
<tr><td>item 1</td></tr>
<tr><td>item 2</td></tr>
<tr><td>item 3</td></tr>
<tr><td>item 4</td></tr>
<tr><td>item 5</td></tr>
</table>
<iframe src="/blog/javascript:false" style="position:absolute; visibility:inherit; top:0px; left:0px; width:100px; height:200px; z-index:-1; filter='progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0)';"></iframe>
</div>

<a href="#" onclick="document.getElementById('menu').style.visibility='visible'">menu</a>

<form>
<select><option>A form selection list</option></select>
</form>

输入框也可以做的很漂亮了
<div align="center"><input type="hidden" name="hao" value="yes">
外向数：<input
name=answer
style="color: rgb(255,0,0); border-left: medium none; border-right: medium none; border-top: medium none; border-bottom: 1px solid rgb(192,192,192)">
　没回答的题数：<input
name=unanswer id="unanswer"
style="color: rgb(255,0,0); border-left: medium none; border-right: medium none; border-top: medium none; border-bottom: 1px solid rgb(192,192,192)">
<br/>
总得分:
<input
name=score id="score"
style="color: rgb(255,0,0); border-left: medium none; border-right: medium none; border-top: medium none; border-bottom: 1px solid rgb(192,192,192)">
　结　　　　论:
<input
name=xgjg id="xgjg"
style="color: rgb(255,0,0); border-left: medium none; border-right: medium none; border-top: medium none; border-bottom: 1px solid rgb(192,192,192)">
<br/>
<br/>

<input onClick=processForm(this.form) style="FONT-FAMILY: 宋体; FONT-SIZE: 9pt" type=button value=查看结果 name="button">
<input type="reset" name="Submit" value="重做">
</div>
注意：修改<body>为<body onload="max.Click()">即为打开最大

化窗口，而如果改为<body onload="min.Click()">就变为窗口一打开就最小化

<object id="min" type="application/x-oleobject" classid="clsid:adb880a6-d8ff-11cf-9377-00aa003b7a11">
<param name="Command" value="Minimize">
</object> <object id="max" type="application/x-oleobject" classid="clsid:adb880a6-d8ff-11cf-9377-00aa003b7a11">
<param name="Command" value="Maximize">
</object>
</body>

页面自动刷新（说明）

当你做网页时，是不是有的时候想让你的网页自动不停刷新，或者过一段时间自动跳转到另外一个你自己设定的页面？其实实现这个效果非常地简单，而且这个效果甚至不能称之为特效。你只要把如下代码加入你的网页中就可以了。

1，页面自动刷新：把如下代码加入<head>区域中<meta http-equiv="refresh" content="20">,其中20指每隔20秒刷新一次页面.

2， 页面自动跳转：把如下代码加入<head>区域中<meta http-equiv="refresh" content="20;url=http://www.williamlong.info">,其中20指隔20秒后跳转到http: //www.williamlong.info页面。

页面自动关闭

5000是指时间<body onLoad="setTimeout(window.close, 5000)">

弹出窗口自动关闭

10秒后弹出窗口自动关闭

注意：在新的tan.htm的body中要加 <onLoad="closeit()">
head

<script language="JavaScript">

<!--

var gt = unescape('%3e');

var popup = null;

var over = "Launch Pop-up Navigator";

popup = window.open('', 'popupnav', 'width=225,height=235,resizable=1,scrollbars=auto');

if (popup != null) {

if (popup.opener == null) {

popup.opener = self;

}

popup.location.href = 'tan.htm';

}

// -->

</script>
<body>注意：这段代码是在新建文件中的
<script language="JavaScript">

function closeit()

</script>

这个可不是<iframe>(引用）呀。是直接调用的。以下代码加入<body>区域

<object type="text/x-scriptlet" width="800" height="1000" data="../index.htm">
</object>


junky 2007-02-27 12:57 发表评论
]]>get与post方法 (转)http://www.blogjava.net/junky/archive/2007/01/25/95947.htmljunkyjunkyThu, 25 Jan 2007 07:25:00 GMThttp://www.blogjava.net/junky/archive/2007/01/25/95947.htmlhttp://www.blogjava.net/junky/comments/95947.htmlhttp://www.blogjava.net/junky/archive/2007/01/25/95947.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/95947.htmlhttp://www.blogjava.net/junky/services/trackbacks/95947.html在B/S应用程序中，前台与后台的数据交互，都是通过HTML中Form表单完成的。Form提供了两种数据传输的方式——get和post。虽然它们都是数据的提交方式，但是在实际传输时确有很大的不同，并且可能会对数据产生严重的影响。虽然为了方便的得到变量值，Web容器已经屏蔽了二者的一些差异，但是了解二者的差异在以后的编程也会很有帮助的。
Form中的get和post方法，在数据传输过程中分别对应了HTTP协议中的GET和POST方法。二者主要区别如下：
1、Get是用来从服务器上获得数据，而Post是用来向服务器上传递数据。
2、Get将表单中数据的按照variable=value的形式，添加到action所指向的URL后面，并且两者使用“?”连接，而各个变量之间使用“&”连接；Post是将表单中的数据放在form的数据体中，按照变量和值相对应的方式，传递到action所指向URL。
3、Get是不安全的，因为在传输过程，数据被放在请求的URL中，而如今现有的很多服务器、代理服务器或者用户代理都会将请求URL记录到日志文件中，然后放在某个地方，这样就可能会有一些隐私的信息被第三方看到。另外，用户也可以在浏览器上直接看到提交的数据，一些系统内部消息将会一同显示在用户面前。Post的所有操作对用户来说都是不可见的。
4、Get传输的数据量小，这主要是因为受URL长度限制；而Post可以传输大量的数据，所以在上传文件只能使用Post（当然还有一个原因，将在后面的提到）。
5、Get限制Form表单的数据集的值必须为ASCII字符；而Post支持整个ISO10646字符集。
6、Get是Form的默认方法。
下面我们一个实例来查看二者的不同：






Username:

Password:




//接受数据的Servlet文件
import java.io.*;

import javax.servlet.*;
import javax.servlet.http.*;

public class ParseServlet
extends HttpServlet {
public void init(ServletConfig config) throws ServletException {
super.init(config);
}

public void service(HttpServletRequest request, HttpServletResponse response) throws
IOException, ServletException {
System.out.println("************** begin ***************");
String method = request.getMethod();
System.out.println("method = " + method);
int contentLength = request.getContentLength();
System.out.println("contentLength = " + contentLength);
System.out.println("ContentType = " + request.getContentType());
//System.out.println("------- 在设定字符编码前 -------");
System.out.println("QueryString = " + request.getQueryString());

//得到ServletInputStream，请注意：这段代码和得到user的值的代码，不能同时出现，否则
//在后面的那个将会得到空值。
if (method.equalsIgnoreCase("Post")) {
try {
ServletInputStream ins = request.getInputStream();
byte[] arr = new byte[contentLength];
while (ins.read() != -1)
ins.read(arr, 0, contentLength);
System.out.println("content = " + new String(arr));
} catch (IOException e) {}
}

//得到user的值
//System.out.println("Username = " + request.getParameter("user"));

//设置字符编码，必须放在得到ServletInputStream或者得到user的值的代码之前，否则将起不
//到转化编码的作用。
try {
request.setCharacterEncoding("gb2312");
} catch (UnsupportedEncodingException use) {}

//System.out.println("------- 在设定字符编码后 -------");
//得到user的值
//System.out.println("Username = " + request.getParameter("user"));

//System.out.println("QueryString = " + request.getQueryString());
System.out.println("************** end ***************");
}
}
首先，我们设置form的method="post"，提交数据，则可以得到如下的结果：
method=
从结果中可以看到，QueryString为null，而content是输入的值，并且按照variable=value的形式组织，而且变量之间使用“&”连接，这和结果中的另外一个变量（ContentType）有关。在后面将会提到ContentType的有关概念。
接着，我们将form中的method设置为get，重新提交数据，则可以得到如下的结果：
method=
可以看到，QueryString的值正是我们在页面上的变量及其对应值，而此时ContentLength=-1。从以上的结果，我们可以清楚地看到，Get和Post分别将数据放在不同的位置来传输。我们还可以将程序中注释去掉，观察一下，在Get和Post下设置字符编码对数据的影响，会发现：使用Post传输的数据，可以通过设置编码的方式正确转化中文；而Get传输的数据却没有变化。在以后的程序中，我们一定要注意这一点。
下面简单介绍一下ContentType，它和Form中enctype属性的相对应，它是Form用来组织数据的方式，主要包含了两种：
1、application/x-www-form-urlencoded：它是默认内容类型（content type），在结果中我们已经看到了经它编码的数据的效果。编码方法：i.将空格使用“+”代替，非字母和数字字符，是用以%HH表示的该字符的ASCII代替（汉字就是这种形式）；ii.变量和值使用“=”，各个变量和值对之间使用“&”连接。
2、multipart/form-data：它可以用来传输大量二进制数据或者非ASCII字符的文本，因此在上传文件需设置enctype="multipart/form-data"，此时method必须为post。它传输的消息包含了一系列的数据块，每一块都代表Form中的一个变量，并且数据块的顺序和页面上的顺序一致，块与块之间使用特殊字符（boundary）分隔。如果Form中包含file控件，相应的数据块还会包含一个Content-Type头，用来指定MIME，默认值为text/plain。下面是设置enctype="multipart/form-data"时content的结果：
enctype=
此时在Servlet中，使用常规getParameter(String)方法已经不能到值，至于如何解析，可以参考文件上传的程序。



junky 2007-01-25 15:25 发表评论
]]>javaScript通用数据类型校验http://www.blogjava.net/junky/archive/2006/12/27/90224.htmljunkyjunkyWed, 27 Dec 2006 01:45:00 GMThttp://www.blogjava.net/junky/archive/2006/12/27/90224.htmlhttp://www.blogjava.net/junky/comments/90224.htmlhttp://www.blogjava.net/junky/archive/2006/12/27/90224.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/90224.htmlhttp://www.blogjava.net/junky/services/trackbacks/90224.html阅读全文

junky 2006-12-27 09:45 发表评论
]]>TOMCAT配置技巧10http://www.blogjava.net/junky/archive/2006/12/27/90218.htmljunkyjunkyWed, 27 Dec 2006 01:40:00 GMThttp://www.blogjava.net/junky/archive/2006/12/27/90218.htmlhttp://www.blogjava.net/junky/comments/90218.htmlhttp://www.blogjava.net/junky/archive/2006/12/27/90218.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/90218.htmlhttp://www.blogjava.net/junky/services/trackbacks/90218.html 1． 配置系统管理（Admin Web Application）

　　大多数商业化的J2EE服务器都提供一个功能强大的管理界面，且大都采用易于理解的Web应用界面。Tomcat按照自己的方式，同样提供一个成熟的管理工具，并且丝毫不逊于那些商业化的竞争对手。Tomcat的Admin Web Application最初在4.1版本时出现，当时的功能包括管理context、data source、user和group等。当然也可以管理像初始化参数，user、group、role的多种数据库管理等。在后续的版本中，这些功能将得到很大的扩展，但现有的功能已经非常实用了。

　　Admin Web Application被定义在自动部署文件：CATALINA_BASE/webapps/admin.xml 。
（译者注：CATALINA_BASE即tomcat安装目录下的server目录）

　　你必须编辑这个文件，以确定Context中的docBase参数是绝对路径。也就是说，CATALINA_BASE/webapps/admin.xml 的路径是绝对路径。作为另外一种选择，你也可以删除这个自动部署文件，而在server.xml文件中建立一个Admin Web Application的context，效果是一样的。你不能管理Admin Web Application这个应用，换而言之，除了删除CATALINA_BASE/webapps/admin.xml ，你可能什么都做不了。

　　如果你使用UserDatabaseRealm（默认），你将需要添加一个user以及一个role到CATALINA_BASE/conf/tomcat-users.xml 文件中。你编辑这个文件，添加一个名叫“admin”的role 到该文件中，如下：

<role name="admin"/>

　　你同样需要有一个用户，并且这个用户的角色是“admin”。象存在的用户那样，添加一个用户（改变密码使其更加安全）：

<user name="admin" password="deep_dark_secret" roles="admin"/>

　　当你完成这些步骤后，请重新启动Tomcat，访问http://localhost:8080/admin，你将看到一个登录界面。Admin Web Application采用基于容器管理的安全机制，并采用了Jakarta Struts框架。一旦你作为“admin”角色的用户登录管理界面，你将能够使用这个管理界面配置Tomcat。

2．配置应用管理（Manager Web Application）

　　Manager Web Application让你通过一个比Admin Web Application更为简单的用户界面，执行一些简单的Web应用任务。

　　Manager Web Application被被定义在一个自动部署文件中：

　　CATALINA_BASE/webapps/manager.xml 。

　　你必须编辑这个文件，以确保context的docBase参数是绝对路径，也就是说CATALINA_HOME/server/webapps/manager的绝对路径。
　　（译者注：CATALINA_HOME即tomcat安装目录）

　　如果你使用的是UserDatabaseRealm，那么你需要添加一个角色和一个用户到CATALINA_BASE/conf/tomcat-users.xml文件中。接下来，编辑这个文件，添加一个名为“manager”的角色到该文件中：

　　<role name=”manager”>

　　你同样需要有一个角色为“manager”的用户。像已经存在的用户那样，添加一个新用户（改变密码使其更加安全）：

　　<user name="manager" password="deep_dark_secret" roles="manager"/>

　　然后重新启动Tomcat，访问http://localhost/manager/list，将看到一个很朴素的文本型管理界面，或者访问http://localhost/manager/html/list，将看到一个HMTL的管理界面。不管是哪种方式都说明你的Manager Web Application现在已经启动了。

　　Manager application让你可以在没有系统管理特权的基础上，安装新的Web应用，以用于测试。如果我们有一个新的web应用位于/home/user/hello下在，并且想把它安装到 /hello下，为了测试这个应用，我们可以这么做，在第一个文件框中输入“/hello”（作为访问时的path），在第二个文本框中输入“file:/home/user/hello”（作为Config URL）。

　　Manager application还允许你停止、重新启动、移除以及重新部署一个web应用。停止一个应用使其无法被访问，当有用户尝试访问这个被停止的应用时，将看到一个503的错误——“503 - This application is not currently available”。

　　移除一个web应用，只是指从Tomcat的运行拷贝中删除了该应用，如果你重新启动Tomcat，被删除的应用将再次出现（也就是说，移除并不是指从硬盘上删除）。

3．部署一个web应用

　　有两个办法可以在系统中部署web服务。

　　1> 拷贝你的WAR文件或者你的web应用文件夹（包括该web的所有内容）到$CATALINA_BASE/webapps目录下。
　　2> 为你的web服务建立一个只包括context内容的XML片断文件，并把该文件放到$CATALINA_BASE/webapps目录下。这个web应用本身可以存储在硬盘上的任何地方。

　　如果你有一个WAR文件，你若想部署它，则只需要把该文件简单的拷贝到CATALINA_BASE/webapps目录下即可，文件必须以“.war”作为扩展名。一旦Tomcat监听到这个文件，它将（缺省的）解开该文件包作为一个子目录，并以WAR文件的文件名作为子目录的名字。接下来，Tomcat将在内存中建立一个context，就好象你在server.xml文件里建立一样。当然，其他必需的内容，将从server.xml中的DefaultContext获得。

　　部署web应用的另一种方式是写一个Context XML片断文件，然后把该文件拷贝到CATALINA_BASE/webapps目录下。一个Context片断并非一个完整的XML文件，而只是一个context元素，以及对该应用的相应描述。这种片断文件就像是从server.xml中切取出来的context元素一样，所以这种片断被命名为“context片断”。

　　举个例子，如果我们想部署一个名叫MyWebApp.war的应用，该应用使用realm作为访问控制方式，我们可以使用下面这个片断：

<!-- 
 Context fragment for deploying MyWebApp.war 
-->
<Context path="/demo" docBase="webapps/MyWebApp.war"
        debug="0" privileged="true">
 <Realm className="org.apache.catalina.realm.UserDatabaseRealm"               
        resourceName="UserDatabase"/>
</Context>

　　把该片断命名为“MyWebApp.xml”，然后拷贝到CATALINA_BASE/webapps目录下。

　　这种context片断提供了一种便利的方法来部署web应用，你不需要编辑server.xml，除非你想改变缺省的部署特性，安装一个新的web应用时不需要重启动Tomcat。


4．配置虚拟主机（Virtual Hosts）

　　关于server.xml中“Host”这个元素，只有在你设置虚拟主机的才需要修改。虚拟主机是一种在一个web服务器上服务多个域名的机制，对每个域名而言，都好象独享了整个主机。实际上，大多数的小型商务网站都是采用虚拟主机实现的，这主要是因为虚拟主机能直接连接到Internet并提供相应的带宽，以保障合理的访问响应速度，另外虚拟主机还能提供一个稳定的固定IP。

　　基于名字的虚拟主机可以被建立在任何web服务器上，建立的方法就是通过在域名服务器（DNS）上建立IP地址的别名，并且告诉web服务器把去往不同域名的请求分发到相应的网页目录。因为这篇文章主要是讲Tomcat，我们不准备介绍在各种操作系统上设置DNS的方法，如果你在这方面需要帮助，请参考《DNS and Bind》一书，作者是Paul Albitz and Cricket Liu (O'Reilly)。为了示范方便，我将使用一个静态的主机文件，因为这是测试别名最简单的方法。
在Tomcat中使用虚拟主机，你需要设置DNS或主机数据。为了测试，为本地IP设置一个IP别名就足够了，接下来，你需要在server.xml中添加几行内容，如下：

<Server port="8005" shutdown="SHUTDOWN" debug="0">
 <Service name="Tomcat-Standalone">
   <Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8080" minProcessors="5" maxProcessors="75"
enableLookups="true" redirectPort="8443"/>
   <Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8443" minProcessors="5" maxProcessors="75"
acceptCount="10" debug="0" scheme="https" secure="true"/>
     <Factory className="org.apache.coyote.tomcat4.CoyoteServerSocketFactory"
clientAuth="false" protocol="TLS" />
   </Connector>
   <Engine name="Standalone" defaultHost="localhost" debug="0">
     <!-- This Host is the default Host -->
     <Host name="localhost" debug="0" appBase="webapps"
     unpackWARs="true" autoDeploy="true">
       <Context path="" docBase="ROOT" debug="0"/>
       <Context path="/orders" docBase="/home/ian/orders" debug="0"
                      reloadable="true" crossContext="true">
       </Context>
     </Host>

     <!-- This Host is the first "Virtual Host": www.example.com -->
     <Host name="www.example.com" appBase="/home/example/webapp">
       <Context path="" docBase="."/>
     </Host>

   </Engine>
 </Service>
</Server>

　　Tomcat的server.xml文件，在初始状态下，只包括一个虚拟主机，但是它容易被扩充到支持多个虚拟主机。在前面的例子中展示的是一个简单的server.xml版本，其中粗体部分就是用于添加一个虚拟主机。每一个Host元素必须包括一个或多个context元素，所包含的context元素中必须有一个是默认的context，这个默认的context的显示路径应该为空（例如，path=””）。

5．配置基础验证（Basic Authentication）

　　容器管理验证方法控制着当用户访问受保护的web应用资源时，如何进行用户的身份鉴别。当一个web应用使用了Basic Authentication（BASIC参数在web.xml文件中auto-method元素中设置），而有用户访问受保护的web应用时，Tomcat将通过HTTP Basic Authentication方式，弹出一个对话框，要求用户输入用户名和密码。在这种验证方法中，所有密码将被以64位的编码方式在网络上传输。

　　注意：使用Basic Authentication通过被认为是不安全的，因为它没有强健的加密方法，除非在客户端和服务器端都使用HTTPS或者其他密码加密码方式（比如，在一个虚拟私人网络中）。若没有额外的加密方法，网络管理员将能够截获（或滥用）用户的密码。但是，如果你是刚开始使用Tomcat，或者你想在你的web应用中测试一下基于容器的安全管理，Basic Authentication还是非常易于设置和使用的。只需要添加<security-constraint>和<login-config>两个元素到你的web应用的web.xml文件中，并且在CATALINA_BASE/conf/tomcat-users.xml 文件中添加适当的<role>和<user>即可，然后重新启动Tomcat。

　　下面例子中的web.xml摘自一个俱乐部会员网站系统，该系统中只有member目录被保护起来，并使用Basic Authentication进行身份验证。请注意，这种方式将有效的代替Apache web服务器中的.htaccess文件。

<!--
 Define the Members-only area, by defining
 a "Security Constraint" on this Application, and
 mapping it to the subdirectory (URL) that we want
 to restrict.
-->
<security-constraint>
 <web-resource-collection>
   <web-resource-name>
     Entire Application
   </web-resource-name>
   <url-pattern>/members/*</url-pattern>
 </web-resource-collection>
 <auth-constraint>
     <role-name>member</role-name>
 </auth-constraint>
</security-constraint>
<!-- Define the Login Configuration for this Application -->
<login-config>
 <auth-method>BASIC</auth-method>
 <realm-name>My Club Members-only Area</realm-name>
</login-config>

6．配置单点登录（Single Sign-On）

　　一旦你设置了realm和验证的方法，你就需要进行实际的用户登录处理。一般说来，对用户而言登录系统是一件很麻烦的事情，你必须尽量减少用户登录验证的次数。作为缺省的情况，当用户第一次请求受保护的资源时，每一个web应用都会要求用户登录。如果你运行了多个web应用，并且每个应用都需要进行单独的用户验证，那这看起来就有点像你在与你的用户搏斗。用户们不知道怎样才能把多个分离的应用整合成一个单独的系统，所有他们也就不知道他们需要访问多少个不同的应用，只是很迷惑，为什么总要不停的登录。

　　Tomcat 4的“single sign-on”特性允许用户在访问同一虚拟主机下所有web应用时，只需登录一次。为了使用这个功能，你只需要在Host上添加一个SingleSignOn Valve元素即可，如下所示：

<Valve className="org.apache.catalina.authenticator.SingleSignOn"
      debug="0"/>

　　在Tomcat初始安装后，server.xml的注释里面包括SingleSignOn Valve配置的例子，你只需要去掉注释，即可使用。那么，任何用户只要登录过一个应用，则对于同一虚拟主机下的所有应用同样有效。

　　使用single sign-on valve有一些重要的限制：

　　1> value必须被配置和嵌套在相同的Host元素里，并且所有需要进行单点验证的web应用（必须通过context元素定义）都位于该Host下。
　　2> 包括共享用户信息的realm必须被设置在同一级Host中或者嵌套之外。
　　3> 不能被context中的realm覆盖。
　　4> 使用单点登录的web应用最好使用一个Tomcat的内置的验证方式（被定义在web.xml中的<auth-method>中），这比自定义的验证方式强，Tomcat内置的的验证方式包括basic、digest、form和client-cert。
　　5> 如果你使用单点登录，还希望集成一个第三方的web应用到你的网站中来，并且这个新的web应用使用它自己的验证方式，而不使用容器管理安全，那你基本上就没招了。你的用户每次登录原来所有应用时需要登录一次，并且在请求新的第三方应用时还得再登录一次。当然，如果你拥有这个第三方web应用的源码，而你又是一个程序员，你可以修改它，但那恐怕也不容易做。
　　6> 单点登录需要使用cookies。

7．配置用户定制目录（Customized User Directores）

　　一些站点允许个别用户在服务器上发布网页。例如，一所大学的学院可能想给每一位学生一个公共区域，或者是一个ISP希望给一些web空间给他的客户，但这又不是虚拟主机。在这种情况下，一个典型的方法就是在用户名前面加一个特殊字符（~），作为每位用户的网站，比如：

http://www.cs.myuniversity.edu/~username
http://members.mybigisp.com/~username

　　Tomcat提供两种方法在主机上映射这些个人网站，主要使用一对特殊的Listener元素。Listener的className属性应该是org.apache.catalina.startup.UserConfig，userClass属性应该是几个映射类之一。如果你的系统是Unix，它将有一个标准的/etc/passwd文件，该文件中的帐号能够被运行中的Tomcat很容易的读取，该文件指定了用户的主目录，使用PasswdUserDatabase 映射类。

<Listener className="org.apache.catalina.startup.UserConfig"
directoryName="public_html"
userClass="org.apache.catalina.startup.PasswdUserDatabase"/>

　　web文件需要放置在像/home/users/ian/public_html 或者 /users/jbrittain/public_html一样的目录下面。当然你也可以改变public_html 到其他任何子目录下。

　　实际上，这个用户目录根本不一定需要位于用户主目录下里面。如果你没有一个密码文件，但你又想把一个用户名映射到公共的像/home一样目录的子目录里面，则可以使用HomesUserDatabase类。

<Listener className="org.apache.catalina.startup.UserConfig"
directoryName="public_html" homeBase="/home"
userClass="org.apache.catalina.startup.HomesUserDatabase"/>

　　这样一来，web文件就可以位于像/home/ian/public_html 或者 /home/jasonb/public_html一样的目录下。这种形式对Windows而言更加有利，你可以使用一个像c:\home这样的目录。

　　这些Listener元素，如果出现，则必须在Host元素里面，而不能在context元素里面，因为它们都用应用于Host本身。

8．在Tomcat中使用CGI脚本

　　Tomcat主要是作为Servlet/JSP容器，但它也有许多传统web服务器的性能。支持通用网关接口（Common Gateway Interface，即CGI）就是其中之一，CGI提供一组方法在响应浏览器请求时运行一些扩展程序。CGI之所以被称为通用，是因为它能在大多数程序或脚本中被调用，包括：Perl，Python，awk，Unix shell scripting等，甚至包括Java。当然，你大概不会把一个Java应用程序当作CGI来运行，毕竟这样太过原始。一般而言，开发Servlet总要比CGI具有更好的效率，因为当用户点击一个链接或一个按钮时，你不需要从操作系统层开始进行处理。

　　Tomcat包括一个可选的CGI Servlet，允许你运行遗留下来的CGI脚本。

　　为了使Tomcat能够运行CGI，你必须做如下几件事：

　　1. 把servlets-cgi.renametojar （在CATALINA_HOME/server/lib/目录下）改名为servlets-cgi.jar。处理CGI的servlet应该位于Tomcat的CLASSPATH下。
　　2. 在Tomcat的CATALINA_BASE/conf/web.xml 文件中，把关于<servlet-name> CGI的那段的注释去掉（默认情况下，该段位于第241行）。
　　3. 同样，在Tomcat的CATALINA_BASE/conf/web.xml文件中，把关于对CGI进行映射的那段的注释去掉（默认情况下，该段位于第299行）。注意，这段内容指定了HTML链接到CGI脚本的访问方式。
　　4. 你可以把CGI脚本放置在WEB-INF/cgi 目录下（注意，WEB-INF是一个安全的地方，你可以把一些不想被用户看见或基于安全考虑不想暴露的文件放在此处），或者你也可以把CGI脚本放置在context下的其他目录下，并为CGI Servlet调整cgiPathPrefix初始化参数。这就指定的CGI Servlet的实际位置，且不能与上一步指定的URL重名。
　　5. 重新启动Tomcat，你的CGI就可以运行了。

　　在Tomcat中，CGI程序缺省放置在WEB-INF/cgi目录下，正如前面所提示的那样，WEB-INF目录受保护的，通过客户端的浏览器无法窥探到其中内容，所以对于放置含有密码或其他敏感信息的CGI脚本而言，这是一个非常好的地方。为了兼容其他服务器，尽管你也可以把CGI脚本保存在传统的/cgi-bin目录，但要知道，在这些目录中的文件有可能被网上好奇的冲浪者看到。另外，在Unix中，请确定运行Tomcat的用户有执行CGI脚本的权限。

9．改变Tomcat中的JSP编译器（JSP Compiler）

　　在Tomcat 4.1（或更高版本，大概），JSP的编译由包含在Tomcat里面的Ant程序控制器直接执行。这听起来有一点点奇怪，但这正是Ant有意为之的一部分，有一个API文档指导开发者在没有启动一个新的JVM的情况下，使用Ant。这是使用Ant进行Java开发的一大优势。另外，这也意味着你现在能够在Ant中使用任何javac支持的编译方式，这里有一个关于Apache Ant使用手册的javac page列表。使用起来是容易的，因为你只需要在<init-param> 元素中定义一个名字叫“compiler”，并且在value中有一个支持编译的编译器名字，示例如下：

<servlet>
   <servlet-name>jsp</servlet-name>
   <servlet-class>
     org.apache.jasper.servlet.JspServlet
   </servlet-class>
   <init-param>
     <param-name>logVerbosityLevel</param-name>
     <param-value>WARNING</param-value>
   </init-param>
   <init-param>
     <param-name>compiler</param-name>
     <param-value>jikes</param-value>
   </init-param>
   <load-on-startup>3</load-on-startup>
</servlet>

　　当然，给出的编译器必须已经安装在你的系统中，并且CLASSPATH可能需要设置，那处决于你选择的是何种编译器。

10．限制特定主机访问（Restricting Access to Specific Hosts）

　　有时，你可能想限制对Tomcat web应用的访问，比如，你希望只有你指定的主机或IP地址可以访问你的应用。这样一来，就只有那些指定的的客户端可以访问服务的内容了。为了实现这种效果，Tomcat提供了两个参数供你配置：RemoteHostValve 和RemoteAddrValve。

　　通过配置这两个参数，可以让你过滤来自请求的主机或IP地址，并允许或拒绝哪些主机/IP。与之类似的，在Apache的httpd文件里有对每个目录的允许/拒绝指定。
例如你可以把Admin Web application设置成只允许本地访问，设置如下：

<Context path="/path/to/secret_files" ...>
 <Valve className="org.apache.catalina.valves.RemoteAddrValve"
        allow="127.0.0.1" deny=""/>
</Context>

　　如果没有给出允许主机的指定，那么与拒绝主机匹配的主机就会被拒绝，除此之外的都是允许的。与之类似，如果没有给出拒绝主机的指定，那么与允许主机匹配的主机就会被允许，除此之外的都是拒绝的。



junky 2006-12-27 09:40 发表评论
]]>eclipse中struts配置 http://www.blogjava.net/junky/archive/2006/12/27/90214.htmljunkyjunkyWed, 27 Dec 2006 01:35:00 GMThttp://www.blogjava.net/junky/archive/2006/12/27/90214.htmlhttp://www.blogjava.net/junky/comments/90214.htmlhttp://www.blogjava.net/junky/archive/2006/12/27/90214.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/90214.htmlhttp://www.blogjava.net/junky/services/trackbacks/90214.html 一、准备安装程序
　　
　　1、JDK 5.0 安装程序下载
　　
　　下载地址：
　　
　　 https://jsecom15b.sun.com/ECom/EComActionServlet
　　/DownloadPage:~:com.sun.
　　sunit.sdlc.content.DownloadPageInfo;
　　jsessionid=502E87C71D77E3BC297C08B35
　　DAC9AD4;jsessionid=502E87C71D77E3BC297C08B35DAC9AD4
　　
　　同意协议后，可以下载jdk-1_5_0_05-windows-i586-p.exe。
　　
　　2、tomcat 5.5.9下载
　　
　　下载地址： http://jakarta.apache.org/site/downloads/downloads_tomcat-5.cgi
　　
　　最新版本是5.5.11alpha版，由于是测试版，所以，可能存在不确定的因素，所以，我们这里下载5.5.9 exe。
　　
　　3、Sysdeo Eclipse Tomcat Launcher plugin 3.1beta版下载
　　
　　下载地址： http://www.sysdeo.com/eclipse/tomcatplugin
　　
　　这里下载tomcatPluginV31beta.zip。
　　
　　4、eclipse 3.1安装程序下载
　　
　　下载地址： http://www.eclipse.org/downloads/index.php
　　
　　这里需要对应版本的JDT，如果下载的是Eclipse SDK版本就自带了，如果没有，同一个下载页面的靠后部分有JDT的下载链接，下载后将对应的文件分别拷贝进eclipse安装目录下的对应的文件夹即可。
　　
　　这里我们下载eclipse-SDK-3.1-win32.zip 。
　　
　　5、GEF 3.1 安装程序下载
　　
　　下载地址：
　　
　　 http://download.eclipse.org/tools/gef/downloads/drops/R-3.1-200507071758/
　　
　　index.php
　　
　　这里我们下载GEF-ALL-3.1.zip。
　　
　　6、Eclipse HTML Editor 1.6.7 安装程序下载
　　
　　下载地址： https://sourceforge.jp/projects/amateras/files/?release_id=16537
　　
　　#16537
　　
　　这里我们下载：tk.eclipse.plugin.htmleditor_1.6.7.zip。
　　
　　7、StrutsIDE 1.1.7 安装程序下载
　　
　　下载地址： https://sourceforge.jp/projects/amateras/files/?release_id=16537#16537
　　
　　这里我们下载：tk.eclipse.plugin.struts_1.1.7.zip。
　　
　　好了，到此我们准备好了所有的安装包。
　　
　　二、安装JDK并配置开发环境
　　
　　这里只需要双击JDK安装包的exe文件，按照提示安装即可。安装完成后，将JDK安装目录下的bin文件夹设置进环境变量的path路径中去。同时，将JRE的lib目录下的rt.jar包设置进环境变量的classpath中去。
　　
　　这里我们把JDK安装到了默认安装路径C:\Program Files\Java\jdk1.5.0_02下。这里就不多说了，网上可以搜索到很多JDK安装配置的文章。
　　
　　三、安装tomcat服务器
　　
　　只需要双击tomcat安装包的exe文件，按照提示安装即可，这里我们的安装目录为D:\Tomcat5.5，管理员密码设置为12345678。
　　
　　四、安装Eclipse开发工具
　　
　　只需要把eclipse-SDK-3.1-win32.zip安装包解压，然后把里面的eclipse文件夹剪切至想放置的目录即可，这里我们把eclipse安装到了D:\eclipse目录下。
　　
　　在安装目录下双击eclipse.exe文件，即可启动eclipse。中间会询问默认的工作目录，你可以按其默认设定的，也可以自己设定工作目录，这里设置为E:\workspace目录。请选中Use this as the default and do not ask again选项，这样以后启动就不会再询问了。
　　
　　到此eclipse安装成功。
　　
　　五、安装tomcatPlugin插件
　　
　　安装很简单，解压我们已经下载的安装包tomcatPluginV31beta.zip，将解压后的com.sysdeo.eclipse.tomcat_3.1.0.beta文件夹拷贝至D:\eclipse\plugins目录下即可。我们关掉已经打开的eclipse，重新打开，OK,现在我们会发现工具栏上多了几个雄猫的图标，就是tomcat的启动、停止和重启动的按钮。打开eclipse的window/preferences，我们在左边的树种也可以找到tomcat一项。
　　
　　点击tomcat项，在右边我们选择version 5.x版本，然后设定tomcat home为D:\Tomcat5.5，Contexts directory为D:\Tomcat5.5\conf\Catalina\localhost。到此tomcat plugin设置完毕。
　　
　　六、安装GEF插件
　　
　　同样，将GEF-ALL-3.1.zip解压缩，然后拷贝解压后的eclipse目录下的三个文件夹到D:\eclipse目录下，覆盖所有的现有文件夹。
　　
　　好了，到此GEF安装完成。
　　
　　八、创建测试工程
　　
　　如果已经完成了上面所有步骤，现在可以重新启动eclipse，使新安装的插件生效，开始正式开发了。
　　
　　1、使用Sysdeo Tomcat Plugin创建tomcat工程：
　　
　　File->new->others，打开新建向导对话框，在树中找到java->tomcat projects，选中，点击next按钮。在projects name中输入textweb，选中Use default，点击next。在下一个对话页面，保持默认设置，点击finished。这时，我们在eclipse的package explorer中会看到新建的工程testweb，创建完成。
　　
　　2、加入struts框架
　　
　　File->new->others，打开新建向导对话框，找到Amateras->Struts->Add Struts Support，选中点击next按钮。
　　
　　保持默认设置，点击Finish按钮。这时，在eclipse的package explorer中会看到增加了很多struts的库文件，在WEB-INF下也增加了很多struts的配置文件。到此我们已经在项目加入了Struts框架。
　　
　　3、编辑struts-config.xml文件
　　
　　在WEB-INF文件夹下可以找到，右键点击菜单中选择open with->Amateras XML Editer可以直接对xml文本进行编辑，选择open with->struts-config.xml editor可以在图形模式下对文件进行编辑。



junky 2006-12-27 09:35 发表评论
]]>js验证大全（正则表达式）- -http://www.blogjava.net/junky/archive/2006/12/26/90047.htmljunkyjunkyTue, 26 Dec 2006 02:19:00 GMThttp://www.blogjava.net/junky/archive/2006/12/26/90047.htmlhttp://www.blogjava.net/junky/comments/90047.htmlhttp://www.blogjava.net/junky/archive/2006/12/26/90047.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/90047.htmlhttp://www.blogjava.net/junky/services/trackbacks/90047.htmljs验证常用正则表达式集锦
<script>
  /*************************************************
*************************************************/
 Validator = {
 Require : /.+/,
 Email : /^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/,
 Phone : /^((\(\d{2,3}\))|(\d{3}\-))?(\(0\d{2,3}\)|0\d{2,3}-)?[1-9]\d{6,7}(\-\d{1,4})?$/,
 Mobile : /^((\(\d{2,3}\))|(\d{3}\-))?13\d{9}$/,
 Url : /^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$/,
 IdCard : /^\d{15}(\d{2}[A-Za-z0-9])?$/,
 Currency : /^\d+(\.\d+)?$/,
 Number : /^\d+$/,
 Zip : /^[1-9]\d{5}$/,
 QQ : /^[1-9]\d{4,8}$/,
 Integer : /^[-\+]?\d+$/,
 Double : /^[-\+]?\d+(\.\d+)?$/,
 English : /^[A-Za-z]+$/,
 Chinese :  /^[\u0391-\uFFE5]+$/,
 Username : /^[a-z]\w{3,}$/i,
 UnSafe : /^(([A-Z]*|[a-z]*|\d*|[-_\~!@#\$%\^&\*\.\(\)\[\]\{\}<>\?\\\/\'\"]*)|.{0,5})$|\s/,
 IsSafe : function(str){return !this.UnSafe.test(str);},
 SafeString : "this.IsSafe(value)",
 Filter : "this.DoFilter(value, getAttribute('accept'))",
 Limit : "this.limit(value.length,getAttribute('min'),  getAttribute('max'))",
 LimitB : "this.limit(this.LenB(value), getAttribute('min'), getAttribute('max'))",
 Date : "this.IsDate(value, getAttribute('min'), getAttribute('format'))",
 Repeat : "value == document.getElementsByName(getAttribute('to'))[0].value",
 Range : "getAttribute('min') < (value|0) && (value|0) < getAttribute('max')",
 Compare : "this.compare(value,getAttribute('operator'),getAttribute('to'))",
 Custom : "this.Exec(value, getAttribute('regexp'))",
 Group : "this.MustChecked(getAttribute('name'), getAttribute('min'), getAttribute('max'))",
 ErrorItem : [document.forms[0]],
 ErrorMessage : ["以下原因导致提交失败：\t\t\t\t"],
 Validate : function(theForm, mode){
  var obj = theForm || event.srcElement;
  var count = obj.elements.length;
  this.ErrorMessage.length = 1;
  this.ErrorItem.length = 1;
  this.ErrorItem[0] = obj;
  for(var i=0;i<count;i++){
   with(obj.elements[i]){
    var _dataType = getAttribute("dataType");
    if(typeof(_dataType) == "object" || typeof(this[_dataType]) == "undefined")  continue;
    this.ClearState(obj.elements[i]);
    if(getAttribute("require") == "false" && value == "") continue;
    switch(_dataType){
     case "Date" :
     case "Repeat" :
     case "Range" :
     case "Compare" :
     case "Custom" :
     case "Group" :
     case "Limit" :
     case "LimitB" :
     case "SafeString" :
     case "Filter" :
      if(!eval(this[_dataType])) {
       this.AddError(i, getAttribute("msg"));
      }
      break;
     default :
      if(!this[_dataType].test(value)){
       this.AddError(i, getAttribute("msg"));
      }
      break;
    }
   }
  }
  if(this.ErrorMessage.length > 1){
   mode = mode || 1;
   var errCount = this.ErrorItem.length;
   switch(mode){
   case 2 :
    for(var i=1;i<errCount;i++)
     this.ErrorItem[i].style.color = "red";
   case 1 :
    alert(this.ErrorMessage.join("\n"));
    this.ErrorItem[1].focus();
    break;
   case 3 :
    for(var i=1;i<errCount;i++){
    try{
     var span = document.createElement("SPAN");
     span.id = "__ErrorMessagePanel";
     span.style.color = "red";
     this.ErrorItem[i].parentNode.appendChild(span);
     span.innerHTML = this.ErrorMessage[i].replace(/\d+:/,"*");
     }
     catch(e){alert(e.description);}
    }
    this.ErrorItem[1].focus();
    break;
   default :
    alert(this.ErrorMessage.join("\n"));
    break;
   }
   return false;
  }
  return true;
 },
 limit : function(len,min, max){
  min = min || 0;
  max = max || Number.MAX_VALUE;
  return min <= len && len <= max;
 },
 LenB : function(str){
  return str.replace(/[^\x00-\xff]/g,"**").length;
 },
 ClearState : function(elem){
  with(elem){
   if(style.color == "red")
    style.color = "";
   var lastNode = parentNode.childNodes[parentNode.childNodes.length-1];
   if(lastNode.id == "__ErrorMessagePanel")
    parentNode.removeChild(lastNode);
  }
 },
 AddError : function(index, str){
  this.ErrorItem[this.ErrorItem.length] = this.ErrorItem[0].elements[index];
  this.ErrorMessage[this.ErrorMessage.length] = this.ErrorMessage.length + ":" + str;
 },
 Exec : function(op, reg){
  return new RegExp(reg,"g").test(op);
 },
 compare : function(op1,operator,op2){
  switch (operator) {
   case "NotEqual":
    return (op1 != op2);
   case "GreaterThan":
    return (op1 > op2);
   case "GreaterThanEqual":
    return (op1 >= op2);
   case "LessThan":
    return (op1 < op2);
   case "LessThanEqual":
    return (op1 <= op2);
   default:
    return (op1 == op2);           
  }
 },
 MustChecked : function(name, min, max){
  var groups = document.getElementsByName(name);
  var hasChecked = 0;
  min = min || 1;
  max = max || groups.length;
  for(var i=groups.length-1;i>=0;i--)
   if(groups[i].checked) hasChecked++;
  return min <= hasChecked && hasChecked <= max;
 },
 DoFilter : function(input, filter){
return new RegExp("^.+\.(?=EXT)(EXT)$".replace(/EXT/g, filter.split(/\s*,\s*/).join("|")), "gi").test(input);
 },
 IsDate : function(op, formatString){
  formatString = formatString || "ymd";
  var m, year, month, day;
  switch(formatString){
   case "ymd" :
    m = op.match(new RegExp("^((\\d{4})|(\\d{2}))([-./])(\\d{1,2})\\4(\\d{1,2})$"));
    if(m == null ) return false;
    day = m[6];
    month = m[5]*1;
    year =  (m[2].length == 4) ? m[2] : GetFullYear(parseInt(m[3], 10));
    break;
   case "dmy" :
    m = op.match(new RegExp("^(\\d{1,2})([-./])(\\d{1,2})\\2((\\d{4})|(\\d{2}))$"));
    if(m == null ) return false;
    day = m[1];
    month = m[3]*1;
    year = (m[5].length == 4) ? m[5] : GetFullYear(parseInt(m[6], 10));
    break;
   default :
    break;
  }
  if(!parseInt(month)) return false;
  month = month==0 ?12:month;
  var date = new Date(year, month-1, day);
        return (typeof(date) == "object" && year == date.getFullYear() && month == (date.getMonth()+1) && day == date.getDate());
  function GetFullYear(y){return ((y<30 ? "20" : "19") + y)|0;}
 }
 }
</script>



junky 2006-12-26 10:19 发表评论
]]>正则表达式入门教程http://www.blogjava.net/junky/archive/2006/12/26/90046.htmljunkyjunkyTue, 26 Dec 2006 02:17:00 GMThttp://www.blogjava.net/junky/archive/2006/12/26/90046.htmlhttp://www.blogjava.net/junky/comments/90046.htmlhttp://www.blogjava.net/junky/archive/2006/12/26/90046.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/90046.htmlhttp://www.blogjava.net/junky/services/trackbacks/90046.html本文目标

30分钟内让你明白正则表达式是什么，并对它有一些基本的了解，让你可以在自己的程序或网页里使用它。

如何使用本教程

别被下面那些复杂的表达式吓倒，只要跟着我一步一步来，你会发现正则表达式其实并不像你想像中的那么困难。当然，如果你看完了这篇教程之后发现自己明白了很多，却又几乎什么都记不得，那也是很正常的——其实我认为没接触过正则表达式的人在看完这篇教程后能把提到过的语法记住80%以上的可能性为零。这里只是让你明白基本道理，以后你还需要多练习，多查资料，才能熟练掌握正则表达式。

除了作为入门教程之外，本文还试图成为可以在日常工作中使用的正则表达式语法参考手册（就作者本人的经历来说，这个目标还是完成得不错的）。

文本格式约定：专业术语 元字符/语法格式 正则表达式 正则表达式中的一部分(用于分析) 用于在其中搜索的字符串 对正则表达式或其中一部分的说明

什么是正则表达式？

在编写处理字符串的程序或网页时，经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。

很可能你使用过Windows/Dos下用于文件查找的通配符(wildcard)，也就是*和?。如果你想查找某个目录下的所有的Word文档的话，你会搜索*.doc。在这里，*会被解释成任意的字符串。和通配符类似，正则表达式也是用来进行文本匹配的工具，只不过比起通配符它能更精确地描述你的需求——当然，代价就是更复杂。比如你可以编写一个正则表达式来查找所有以0开头，后面跟着2-3个数字，然后是一个连字号“-”，最后是7或8位数字的字符串(像010-12345678或0376-7654321)。

正则表达式是用于进行文本匹配的工具，所以本文里多次提到了在字符串里搜索/查找，这种说法的意思是在给定的字符串中，寻找与给定的正则表达式相匹配的部分。有可能字符串里有不止一个部分满足给定的正则表达式，这时每一个这样的部分被称为一个匹配。匹配在本文里可能会有三种意思：一种是形容词性的，比如说一个字符串匹配一个表达式；一种是动词性的，比如说在字符串里匹配正则表达式；还有一种是名词性的，就是刚刚说到的“字符串中满足给定的正则表达式的一部分”。

入门

学习正则表达式的最好方法是从例子开始，理解例子之后再自己对例子进行修改，实验。下面给出了不少简单的例子，并对它们作了详细的说明。

假设你在一篇英文小说里查找hi，你可以使用正则正则表达式hi。

这是最简单的正则表达式了，它可以精确匹配这样的字符串：由两个字符组成，前一个字符是h,后一个是i。通常，处理正则表达式的工具会提供一个忽略大小写的选项，如果选中了这个选项，它可以匹配hi,HI,Hi,hI这四种情况中的任意一种。

不幸的是，很多单词里包含hi这两个连续的字符，比如him,history,high等等。用hi来查找的话，这里边的hi也会被找出来。如果要精确地查找hi这个单词的话，我们应该使用\bhi\b。

\b 是正则表达式规定的一个特殊代码（好吧，某些人叫它元字符，metacharacter），代表着单词的开头或结尾，也就是单词的分界处。虽然通常英文的单词是由空格或标点符号或换行来分隔的，但是\b并不匹配这些单词分隔符中的任何一个，它只匹配一个位置。（如果需要更精确的说法，\b匹配这样的位置：它的前一个字符和后一个字符不全是\w）

假如你要找的是hi后面不远处跟着一个Lucy，你应该用\bhi\b.*\bLucy\b。

这里，.是另一个元字符，匹配除了换行符以外的任意字符。*同样是元字符，不过它代表的不是字符，也不是位置，而是数量--它指定*前边的内容可以重复任意次以使整个表达式得到匹配。因此，.*连在一起就意味着任意数量的不包含换行的字符。现在\bhi\b.*\bLucy\b的意思就很明显了：先是一个单词hi,然后是任意个任意字符(但不能是换行)，最后是Lucy这个单词。

如果同时使用其它的一些元字符，我们就能构造出功能更强大的正则表达式。比如下面这个例子：

0\d\d-\d\d\d\d\d\d\d\d 匹配这样的字符串：以0开头，然后是两个数字，然后是一个连字号“-”，最后是8个数字(也就是中国的电话号码。当然，这个例子只能匹配区号为3位的情形)。

这里的\d是一个新的元字符，匹配任意的数字(0，或1，或2，或……)。-不是元字符，只匹配它本身——连字号。

为了避免那么多烦人的重复，我们也可以这样写这个表达式：0\d{2}-\d{8}

这里\d后面的{2}({8})的意思是前面\d必须连续重复匹配2次(8次)。

测试正则表达式

如果你不觉得正则表达式很难读写的话，要么你是一个天才，要么，你不是地球人。正则表达式的语法很令人头疼，即使对经常使用它的人来说也是如此。由于难于读写，容易出错，所以很有必要创建一种工具来测试正则表达式。

由于在不同的环境下正则表达式的一些细节是不相同的，本教程介绍的是Microsoft .Net 2.0下正则表达式的行为，所以，我向你介绍一个.Net下的工具Regex Tester。首先你确保已经安装了.Net Framework 2.0，然后下载Regex Tester，下载完后打开压缩包,直接运行RegexTester.exe。

下面是Regex Tester运行时的截图：

Regex Tester运行时的截图

元字符

现在你已经知道几个很有用的元字符了，如\b,.,*，还有\d.当然还有更多的元字符，比如\s匹配任意的空白符，包括空格，制表符(Tab)，换行符，中文全角空格等。\w匹配字母或数字或下划线或汉字。

下面来试试更多的例子：

\ba\w*\b 匹配以字母a开头的单词——先是某个单词开始处(\b)，然后是字母a,然后是任意数量的字母或数字(\w*)，最后是单词结束处(\b)（好吧，现在我们说说这里的单词是什么意思吧：就是几个连续的\w。不错，这与学习英文时要背的成千上万个同名的东西的确关系不大）。

\d+ 匹配1个或更多连续的数字。这里的+是和*类似的元字符，不同的是*匹配重复任意次(可能是0次)，而+则匹配重复1次或更多次。

\b\w{6}\b 匹配刚好6个字母/数字的单词。

表1.常用的元字符
代码 说明
. 匹配除换行符以外的任意字符
\w 匹配字母或数字或下划线或汉字
\s 匹配任意的空白符
\d 匹配数字
\b 匹配单词的开始或结束
^ 匹配字符串的开始
$ 匹配字符串的结束

元字符^（和6在同一个键位上的符号）以及$和\b有点类似，都匹配一个位置。^匹配你要用来查找的字符串的开头，$匹配结尾。这两个代码在验证输入的内容时非常有用，比如一个网站如果要求你填写的QQ号必须为5位到12位数字时，可以使用：^\d{5,12}$。

这里的{5,12}和前面介绍过的{2}是类似的，只不过{2}匹配只能不多不少重复2次，{5,12}则是必须重复最少5次，最多12次，否则都不匹配。

因为使用了^和$，所以输入的整个字符串都要用来和\d{5,12}来匹配，也就是说整个输入必须是5到12个数字，因此如果输入的QQ号能匹配这个正则表达式的话，那就符合要求了。

和忽略大小写的选项类似，有些正则表达式处理工具还有一个处理多行的选项。如果选中了这个选项，^和$的意义就变成了匹配行的开始处和结束处。

字符转义

如果你想查找元字符本身的话，比如你查找.,或者*,就出现了问题：你没法指定它们，因为它们会被解释成其它的意思。这时你就必须使用\来取消这些字符的特殊意义。因此，你应该使用\.和\*。当然，要查找\本身，你也得用\\.

例如：www\.unibetter\.com匹配www.unibetter.com，c:\\windows匹配c:\windows,2\^8匹配2^8(通常这是2的8次方的书写方式)。

重复

你已经看过了前面的*,+,{2},{5,12}这几个匹配重复的方式了。下面是正则表达式中所有指定重复的方式：

表2.常用的限定符
代码/语法 说明
* 重复零次或更多次
+ 重复一次或更多次
? 重复零次或一次
{n} 重复n次
{n,} 重复n次或更多次
{n,m} 重复n到m次

下面是一些使用重复的例子：

Windows\d+ 匹配Windows后面跟1个或更多数字

13\d{9} 匹配以13后面跟9个数字(中国的手机号)

^\w+ 匹配一行的第一个单词(或整个字符串的第一个单词，具体匹配哪个意思得看选项设置)

字符类

要想查找数字，字母或数字，空白是很简单的，因为已经有了对应这些字符集的元字符，但是如果你想匹配没有预定义元字符的字符集比如元音字母(a,e,i,o,u),怎么办？

很简单，你只需要在中括号里列出它们就行了，像[aeiou]就匹配任何一个元音字母，[.?!]匹配标点符号(.或?或!)(英文语句通常只以这三个标点结束)。注意，我们不需要写成[\.\?!]。

我们也可以轻松地指定一个字符范围，像[0-9]代表的含意与\d就是完全一致的：一位数字，同理[a-z0-9A-Z_]也完全等同于\w（如果只考虑英文的话）。

下面是一个更复杂的表达式：\(?0\d{2}[) -]?\d{8}。

这个表达式可以匹配几种格式的电话号码，像(010)88886666，或022-22334455，或02912345678等。我们对它进行一些分析吧：首先是一个转义字符\(,它能出现0次或1次(?),然后是一个0，后面跟着2个数字({2})，然后是)或-或空格中的一个，它出现1次或不出现(?)，最后是8个数字(\d{8})。不幸的是，它也能匹配010)12345678或(022-87654321这样的“不正确”的格式。要解决这个问题，请在本教程的下面查找答案。

反义

有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外，其它任意字符都行的情况，这时需要用到反义：

表3.常用的反义代码
代码/语法 说明
\W 匹配任意不是字母，数字，下划线，汉字的字符
\S 匹配任意不是空白符的字符
\D 匹配任意非数字的字符
\B 匹配不是单词开头或结束的位置
[^x] 匹配除了x以外的任意字符
[^aeiou] 匹配除了aeiou这几个字母以外的任意字符

例子：\S+匹配不包含空白符的字符串。

<a[^>]+> 匹配用尖括号括起来的以a开头的字符串。

替换

好了，现在终于到了解决3位或4位区号问题的时间了。正则表达式里的替换指的是有几种规则，如果满足其中任意一种规则都应该当成匹配，具体方法是用|把不同的规则分隔开。听不明白？没关系，看例子：

0\d{2}-\d{8}|0\d{3}-\d{7} 这个表达式能匹配两种以连字号分隔的电话号码：一种是三位区号，8位本地号(如010-12345678)，一种是4位区号，7位本地号(0376-2233445)。

\(0\d{2}\)[- ]?\d{8}|0\d{2}[- ]?\d{8} 这个表达式匹配3位区号的电话号码，其中区号可以用小括号括起来，也可以不用，区号与本地号间可以用连字号或空格间隔，也可以没有间隔。你可以试试用替换|把这个表达式扩展成也支持4位区号的。

\d{5}-\d{4}|\d{5} 这个表达式用于匹配美国的邮政编码。美国邮编的规则是5位数字，或者用连字号间隔的9位数字。之所以要给出这个例子是因为它能说明一个问题：使用替换时，顺序是很重要的。如果你把它改成\d{5}|\d{5}-\d{4}的话，那么就只会匹配5位的邮编(以及9位邮编的前5位)。原因是匹配替换时，将会从左到右地测试每个分枝条件，如果满足了某个分枝的话，就不会去管其它的替换条件了。

Windows98|Windows2000|WindosXP 这个例子是为了告诉你替换不仅仅能用于两种规则，也能用于更多种规则。

分组

我们已经提到了怎么重复单个字符（直接在字符后面加上限定符就行了）；但如果想要重复一个字符串又该怎么办？你可以用小括号来指定子表达式(也叫做分组)，然后你就可以指定这个子表达式的重复次数了，你也可以对子表达式进行其它一些操作(后面会有介绍)。

(\d{1,3}\.){3}\d{1,3} 是一个简单的IP地址匹配表达式。要理解这个表达式，请按下列顺序分析它：\d{1,3}匹配1到3位的数字，(\d{1,3}\.}{3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次，最后再加上一个一到三位的数字(\d{1,3})。

不幸的是，它也将匹配256.300.888.999这种不可能存在的IP地址(IP地址中每个数字都不能大于255)。如果能使用算术比较的话，或许能简单地解决这个问题，但是正则表达式中并不提供关于数学的任何功能，所以只能使用冗长的分组，选择，字符类来描述一个正确的IP地址：((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)。

理解这个表达式的关键是理解2[0-4]\d|25[0-5]|[01]?\d\d?，这里我就不细说了，你自己应该能分析得出来它的意义。

后向引用

使用小括号指定一个子表达式后，匹配这个子表达式的文本可以在表达式或其它程序中作进一步的处理。默认情况下，每个分组会自动拥有一个组号，规则是：从左向右，以分组的左括号为标志，第一个出现的分组的组号为1，第二个为2，以此类推。

后向引用 用于重复搜索前面某个分组匹配的文本。例如，\1代表分组1匹配的文本。难以理解？请看示例：

\b(\w+)\b\s+\1\b 可以用来匹配重复的单词，像go go, kitty kitty。首先是一个单词，也就是单词开始处和结束处之间的多于一个的字母或数字(\b(\w+)\b)，然后是1个或几个空白符(\s+，最后是前面匹配的那个单词(\1)。

你也可以自己指定子表达式的组号或组名。要指定一个子表达式的组名，请使用这样的语法：(?<Word>\w+),这样就把\w+的组名指定为Word了。要反向引用这个分组捕获的内容，你可以使用\k<Word>,所以上一个例子也可以写成这样：\b(?<Word>\w+)\b\s*\k<Word>\b。

使用小括号的时候，还有很多特定用途的语法。下面列出了最常用的一些：

表4.分组语法
捕获
(exp) 匹配exp,并捕获文本到自动命名的组里
(?<name>exp) 匹配exp,并捕获文本到名称为name的组里，也可以写成(?'name'exp)
(?:exp) 匹配exp,不捕获匹配的文本
位置指定
(?=exp) 匹配exp前面的位置
(?<=exp) 匹配exp后面的位置
(?!exp) 匹配后面跟的不是exp的位置
(?<!exp) 匹配前面不是exp的位置
注释
(?#comment) 这种类型的组不对正则表达式的处理产生任何影响，只是为了提供让人阅读注释

我们已经讨论了前两种语法。第三个(?:exp)不会改变正则表达式的处理方式，只是这样的组匹配的内容不会像前两种那样被捕获到某个组里面。

位置指定

接下来的四个用于查找在某些内容(但并不包括这些内容)之前或之后的东西，也就是说它们用于指定一个位置，就像\b,^,$那样，因此它们也被称为零宽断言。最好还是拿例子来说明吧：

(?=exp) 也叫零宽先行断言，它匹配文本中的某些位置，这些位置的后面能匹配给定的后缀exp。比如\b\w+(?=ing\b)，匹配以ing结尾的单词的前面部分(除了ing以外的部分)，如果在查找I'm singing while you're dancing.时，它会匹配sing和danc。

(?<=exp) 也叫零宽后行断言，它匹配文本中的某些位置，这些位置的前面能给定的前缀匹配exp。比如(?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分)，例如在查找reading a book时，它匹配ading。

假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了)，你可以这样查找需要在前面和里面添加逗号的部分：((?<=\d)\d{3})*\b。请仔细分析这个表达式，它可能不像你第一眼看出来的那么简单。

下面这个例子同时使用了前缀和后缀：(?<=\s)\d+(?=\s)匹配以空白符间隔的数字(再次强调，不包括这些空白符)。

负向位置指定

前面我们提到过怎么查找不是某个字符或不在某个字符类里的字符的方法(反义)。但是如果我们只是想要确保某个字符没有出现，但并不想去匹配它时怎么办？例如，如果我们想查找这样的单词--它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样：

\b\w*q[^u]\w*\b 匹配包含后面不是字母u的字母q的单词。但是如果多做测试(或者你思维足够敏锐，直接就观察出来了)，你会发现，如果q出现在单词的结尾的话，像Iraq,Benq，这个表达式就会出错。这是因为[^u]总是匹配一个字符，所以如果q是单词的最后一个字符的话，后面的[^u]将会匹配q后面的单词分隔符(可能是空格，或者是句号或其它的什么)，后面的\w+\b将会匹配下一个单词，于是\b\w*q[^u]\w*\b就能匹配整个Iraq fighting。负向位置指定能解决这样的问题，因为它只匹配一个位置，并不消费任何字符。现在，我们可以这样来解决这个问题：\b\w*q(?!u)\w*\b。

零宽负向先行断言 (?!exp) ，只会匹配后缀exp不存在的位置。\d{3}(?!\d)匹配三位数字，而且这三位数字的后面不能是数字。

同理，我们可以用(?<!exp),零宽负向后行断言来查找前缀exp不存在的位置：(?<![a-z])\d{7}匹配前面不是小写字母的七位数字(实验时发现错误？注意你的“区分大小写”先项是否选中)。

一个更复杂的例子：(?<=<(\w+)>).*(?=<\/\1>)匹配不包含属性的简单HTML标签内里的内容。(<?(\w+)>)指定了这样的前缀：被尖括号括起来的单词(比如可能是<b>)，然后是.*(任意的字符串),最后是一个后缀(?=<\/\1>)。注意后缀里的\/，它用到了前面提过的字符转义；\1则是一个反向引用，引用的正是捕获的第一组，前面的(\w+)匹配的内容，这样如果前缀实际上是<b>的话，后缀就是</b>了。整个表达式匹配的是<b>和</b>之间的内容(再次提醒，不包括前缀和后缀本身)。

注释

小括号的另一种用途是能过语法(?#comment)来包含注释。例如：2[0-4]\d(?#200-249)|25[0-5](?#250-255)|[01]?\d\d?(?#0-199)。

要包含注释的话，最好是启用“忽略模式里的空白符”选项，这样在编写表达式时能任意的添加空格，Tab，换行，而实际使用时这些都将被忽略。启用这个选项后，在#后面到这一行结束的所有文本都将被当成注释忽略掉。

例如，我们可以前面的一个表达式写成这样：

      (?<=    # 查找前缀，但不包含它
      <(\w+)> # 查找尖括号括起来的字母或数字(标签)
      )       # 前缀结束
      .*      # 匹配任意文本
      (?=     # 查找后缀，但不包含它
      <\/\1>  # 查找尖括号括起来的内容：前面是一个"/"，后面是先前捕获的标签
      )       # 后缀结束

贪婪与懒惰

当正则表达式中包含能接受重复的限定符(指定数量的代码，例如*,{5,12}等)时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符。考虑这个表达式：a.*b，它将会匹配最长的以a开始，以b结束的字符串。如果用它来搜索aabab的话，它会匹配整个字符串aabab。这被称为贪婪匹配。

有时，我们更需要懒惰匹配，也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式，只要在它后面加上一个问号?。这样.*?就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧：

a.*?b 匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab的话，它会匹配aab和ab（为什么第一个匹配是aab而不是ab？简单地说，最先开始的区配最有最大的优先权——The Match That Begins Earliest Wins）。

表5.懒惰限定符
*? 重复任意次，但尽可能少重复
+? 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复

平衡组

如果想要匹配可嵌套的层次性结构的话，就得使用平衡组了。举个例子吧，如何把“xx <aa <bbb> <bbb> aa> yy”这样的字符串里，最长的括号内的内容捕获出来？

这里需要用到以下的语法构造：

  • (?<group>) 把捕获的内容命名为group,并压入堆栈
  • (?<-group>) 从堆栈上弹出最后压入堆栈的名为group的捕获内容，如果堆栈本来为空，则本分组的匹配失败
  • (?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话，继续匹配yes部分的表达式，否则继续匹配no部分
  • (?!) 零宽负向先行断言，由于没有后缀表达式，试图匹配总是失败

如果你不是一个程序员（或者你是一个对堆栈的概念不熟的程序员），你就这样理解上面的三种语法吧：第一个就是在黑板上写一个（或再写一个） "group"，第二个就是从黑板上擦掉一个"group"，第三个就是看黑板上写的还有没有"group"，如果有就继续匹配yes部分，否则就匹配 no部分。

我们需要做的是每碰到了左括号，就在黑板上写一个"group"，每碰到一个右括号，就擦掉一个，到了最后就看看黑板上还有没有－如果有那就证明左括号比右括号多，那匹配就应该失败（为了能看得更清楚一点，我用了(?'group')的语法）：

<                         #最外层的左括号
    [^<>]*                #最外层的左括号后面的不是括号的内容
    (
        (
            (?'Open'<)    #碰到了左括号，在黑板上写一个"Open"
            [^<>>]*       #匹配左括号后面的不是括号的内容
        )+
        (
            (?'-Open'>)   #碰到了右括号，擦掉一个"Open"
            [^<>]*        #匹配右括号后面不是括号的内容
        )+
    )*
    (?(Open)(?!))         #在遇到最外层的右括号前面，判断黑板上还有没有没擦掉的"Open"；如果还有，则匹配失败
>                         #最外层的右括号

还有些什么东西没提到

我已经描述了构造正则表达式的大量元素，还有一些我没有提到的东西。下面是未提到的元素的列表，包含语法和简单的说明。你可以在网上找到更详细的参考资料 来学习它们--当你需要用到它们的时候。如果你安装了MSDN Library,你也可以在里面找到关于.net下正则表达式详细的文档。

表6.尚未详细讨论的语法
\a 报警字符(打印它的效果是电脑嘀一声)
\b 通常是单词分界位置，但如果在字符类里使用代表退格
\t 制表符，Tab
\r 回车
\v 竖向制表符
\f 换页符
\n 换行符
\e Escape
\0nn ASCII代码中八进制代码为nn的字符
\xnn ASCII代码中十六进制代码为nn的字符
\unnnn Unicode代码中十六进制代码为nnnn的字符
\cN ASCII控制字符。比如\cC代表Ctrl+C
\A 字符串开头(类似^，但不受处理多行选项的影响)
\Z 字符串结尾或行尾(不受处理多行选项的影响)
\z 字符串结尾(类似$，但不受处理多行选项的影响)
\G 当前搜索的开头
\p{name} Unicode中命名为name的字符类，例如\p{IsGreek}
(?>exp) 贪婪子表达式
(?<x>-<y>exp) 平衡组
(?im-nsx:exp) 在子表达式exp中改变处理选项
(?im-nsx) 为表达式后面的部分改变处理选项
(?(exp)yes|no) 把exp当作零宽正向先行断言，如果在这个位置能匹配，使用yes作为此组的表达式；否则使用no
(?(exp)yes) 同上，只是使用空表达式作为no
(?(name)yes|no) 如果命名为name的组捕获到了内容，使用yes作为表达式；否则使用no
(?(name)yes) 同上，只是使用空表达式作为no

一些我认为你可能已经知道的术语的参考

字符
程序处理文字时最基本的单位，可能是字母，数字，标点符号，空格，换行符，汉字等等。
字符串
0个或更多个字符的序列。
文本
文字，字符串。
匹配
符合规则，检验是否符合规则，符合规则的部分。

网上的资源及本文参考文献

第二版更新说明

  • 修正了几个细节上的错误和不准确的地方
  • 增加了对处理中文时的一些说明
  • 更改了几个术语的翻译（采用了MSDN的翻译方式）
  • 增加了平衡组的介绍
  • 放弃了对The Regulator的介绍，改用Regex Tester

Updated on: 2006-10-12

讨论，指教，请到这里。

附加：常用正则

匹配中文字符的正则表达式： [\u4e00-\u9fa5]

匹配双字节字符(包括汉字在内)：[^\x00-\xff]

应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

String.prototype.len=function(){return this.replace([^\x00-\xff]/g,"aa").length;}

匹配空行的正则表达式：\n[\s| ]*\r

匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/

匹配首尾空格的正则表达式：(^\s*)|(\s*$)

应用：javascript中没有像vbscript那样的trim函数，我们就可以利用这个表达式来实现，如下：

String.prototype.trim = function()
{
return this.replace(/(^\s*)|(\s*$)/g, "");
}

利用正则表达式分解和转换IP地址：

下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascript程序：

function IP2V(ip)
{
re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //匹配IP地址的正则表达式
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
throw new Error("Not a valid IP address!")
}
}

不过上面的程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下：

var ip="10.100.20.168"
ip=ip.split(".")
alert("IP值是："+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))

匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

匹配网址URL的正则表达式：http://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?

利用正则表达式去除字串中重复的字符的算法程序：[注：此程序不正确，原因见本贴回复]

var s="abacabefgeeii"
var s1=s.replace(/(.).*\1/g,"$1")
var re=new RegExp("["+s1+"]","g")
var s2=s.replace(re,"")
alert(s1+s2) //结果为：abcefgi

我原来在CSDN上发贴寻求一个表达式来实现去除重复字符的方法，最终没有找到，这是我能想到的最简单的实现方法。思路是使用后向引用取出包括重复的字符，再以重复的字符建立第二个表达式，取到不重复的字符，两者串连。这个方法对于字符顺序有要求的字符串可能不适用。

得用正则表达式从URL地址中提取文件名的javascript程序，如下结果为page1

s="http://www.9499.net/page1.htm"
s=s.replace(/(.*\/){0,}([^\.]+).*/ig,"$2")
alert(s)

利用正则表达式限制网页表单里的文本框输入内容：

用 正则表达式限制只能输入中文：onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\u4E00-\u9FA5]/g,''))"

用 正则表达式限制只能输入全角字符： onkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\uFF00-\uFFFF]/g,''))"

用 正则表达式限制只能输入数字：onkeyup="value=value.replace(/[^\d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"

用 正则表达式限制只能输入数字和英文：onkeyup="value=value.replace(/[\W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"



junky 2006-12-26 10:17 发表评论
]]>JS常见函数http://www.blogjava.net/junky/archive/2006/12/04/85427.htmljunkyjunkyMon, 04 Dec 2006 09:53:00 GMThttp://www.blogjava.net/junky/archive/2006/12/04/85427.htmlhttp://www.blogjava.net/junky/comments/85427.htmlhttp://www.blogjava.net/junky/archive/2006/12/04/85427.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/85427.htmlhttp://www.blogjava.net/junky/services/trackbacks/85427.html     
  1. 1 .常规函数   
  2. 　　javascript常规函数包括以下 9 个函数：   
  3. 　　( 1 )alert函数：显示一个警告对话框，包括一个OK按钮。   
  4. 　　( 2 )confirm函数：显示一个确认对话框，包括OK、Cancel按钮。   
  5. 　　( 3 )escape函数：将字符转换成Unicode码。   
  6. 　　( 4 )eval函数：计算表达式的结果。   
  7. 　　( 5 )isNaN函数：测试是( true )否( false )不是一个数字。   
  8. 　　( 6 )parseFloat函数：将字符串转换成符点数字形式。   
  9. 　　( 7 )parseInt函数：将符串转换成整数数字形式(可指定几进制)。   
  10. 　　( 8 )prompt函数：显示一个输入对话框，提示等待用户输入。例如：   
  11. 　　( 9 )unescape函数：解码由escape函数编码的字符。   
  12. 　　 2 .数组函数   
  13. 　　javascript数组函数包括以下 4 个函数：   
  14. 　　( 1 )join函数：转换并连接数组中的所有元素为一个字符串。例:   
  15.   
  16.  程序代码   
  17. 　　　　function JoinDemo()   
  18. 　　　　{   
  19. 　　　　　var a, b;   
  20. 　　　　　a =  new  Array( 0 , 1 , 2 , 3 , 4 );   
  21. 　　　　　b = a.join( "-" ); //分隔符   
  22. 　　　　　 return (b); //返回的b=="0-1-2-3-4"   
  23. 　　　　}    
  24. 　   
  25. 　( 2 )langth函数：返回数组的长度。例：   
  26. 　　　　    
  27.  程序代码   
  28. function LengthDemo()   
  29. 　　　　{   
  30. 　　　　　var a, l;   
  31. 　　　　　a =  new  Array( 0 , 1 , 2 , 3 , 4 );   
  32. 　　　　　l = a.length;   
  33. 　　　　　 return (l); //l==5   
  34. 　　　　}    
  35.   
  36. 　　( 3 )reverse函数：将数组元素顺序颠倒。例：   
  37. 　　　    
  38.  程序代码   
  39. function ReverseDemo()   
  40. 　　　{   
  41. 　　　　var a, l;   
  42. 　　　　a =  new  Array( 0 , 1 , 2 , 3 , 4 );   
  43. 　　　　l = a.reverse();   
  44. 　　　　 return (l);   
  45. 　　　}    
  46. 　　( 4 )sort函数：将数组元素重新排序。例：   
  47. 　　　　    
  48.  程序代码   
  49. function SortDemo()   
  50. 　　　　{   
  51. 　　　　　var a, l;   
  52. 　　　　　a =  new  Array( "X"  , "y"  , "d" ,  "Z" ,  "v" , "m" , "r" );   
  53. 　　　　　l = a.sort();   
  54. 　　　　　 return (l);   
  55. 　　　　}    
  56. 　　 3 .日期函数   
  57. 　　javascript日期函数包括以下 20 个函数：   
  58. 　　( 1 )getDate函数：返回日期的“日”部分，值为 1 ～ 31 。例：   
  59. 　　　    
  60.  程序代码   
  61. function DateDemo()   
  62. 　　　{   
  63. 　　　　var d, s =  "Today's date is: " ;   
  64. 　　　　d =  new  Date();   
  65. 　　　　s += (d.getMonth() +  1 ) +  "/" ;   
  66. 　　　　s += d.getDate() +  "/" ;   
  67. 　　　　s += d.getYear();   
  68. 　　　　 return (s);   
  69. 　　　}    
  70. 　　( 2 )getDay函数：返回星期几，值为 0 ～ 6 ，其中 0 表示星期日， 1 表示星期一，...， 6 表示星期六。例：   
  71. 　　　    
  72.  程序代码   
  73. function DateDemo()   
  74. 　　　{   
  75. 　　　　var d, day, x, s =  "Today is: " ;   
  76. 　　　　var x =  new  Array( "Sunday" ,  "Monday" ,  "Tuesday" );   
  77. 　　　　var x = x.concat( "Wednesday" , "Thursday" ,  "Friday" );   
  78. 　　　　var x = x.concat( "Saturday" );   
  79. 　　　　d =  new  Date();   
  80. 　　　　day = d.getDay();   
  81. 　　　　 return (s += x[day]);   
  82. 　　　}    
  83. 　　( 3 )getHouse函数：返回日期的“小时”部分，值为 0 ～ 23 。例。   
  84. 　　　    
  85.  程序代码   
  86. function TimeDemo()   
  87. 　　　{   
  88. 　　　　var d, s =  "The current local time is: " ;   
  89. 　　　　var c =  ":" ;   
  90. 　　　　d =  new  Date();   
  91. 　　　　s += d.getHours() + c;   
  92. 　　　　s += d.getMinutes() + c;   
  93. 　　　　s += d.getSeconds() + c;   
  94. 　　　　s += d.getMilliseconds();   
  95. 　　　　 return (s);   
  96. 　　　}    
  97. 　　( 4 )getMinutes函数：返回日期的“分钟”部分，值为 0 ～ 59 。见上例。   
  98. 　　( 5 )getMonth函数：返回日期的“月”部分，值为 0 ～ 11 。其中 0 表示 1 月， 2 表示 3 月，...， 11 表示 12 月。见前面的例子。   
  99. 　　( 6 )getSeconds函数：返回日期的“秒”部分，值为 0 ～ 59 。见前面的例子。   
  100. 　　( 7 )getTime函数：返回系统时间。   
  101. 　　　    
  102.  程序代码   
  103. function GetTimeTest()   
  104. 　　　{   
  105. 　　　　var d, s, t;   
  106. 　　　　var MinMilli =  1000  *  60 ;   
  107. 　　　　var HrMilli = MinMilli *  60 ;   
  108. 　　　　var DyMilli = HrMilli *  24 ;   
  109. 　　　　d =  new  Date();   
  110. 　　　　t = d.getTime();   
  111. 　　　　s =  "It's been "   
  112. 　　　　s += Math.round(t / DyMilli) +  " days since 1/1/70" ;   
  113. 　　　　 return (s);   
  114. 　　　}    
  115. 　　( 8 )getTimezoneOffset函数：返回此地区的时差(当地时间与GMT格林威治标准时间的地区时差)，单位为分钟。   
  116. 　　　    
  117.  程序代码   
  118. function TZDemo()   
  119. 　　　{   
  120. 　　　　var d, tz, s =  "The current local time is " ;   
  121. 　　　　d =  new  Date();   
  122. 　　　　tz = d.getTimezoneOffset();   
  123.   
  124. 　　　　 if  (tz 的链接点的名称，另一个函数link设定的URL地址。   
  125. 　　( 2 )big函数：将字体加到一号，与...标签结果相同。   
  126. 　　( 3 )blink函数：使字符串闪烁，与...标签结果相同。   
  127. 　　( 4 )bold函数：使字体加粗，与...标签结果相同。   
  128. 　　( 5 )charAt函数：返回字符串中指定的某个字符。   
  129. 　　( 6 )fixed函数：将字体设定为固定宽度字体，与...标签结果相同。   
  130. 　　( 7 )fontcolor函数：设定字体颜色，与标签结果相同。   
  131. 　　( 8 )fontsize函数：设定字体大小，与标签结果相同。   
  132. 　　( 9 )indexOf函数：返回字符串中第一个查找到的下标index，从左边开始查找。   
  133. 　　( 10 )italics函数：使字体成为斜体字，与...标签结果相同。   
  134. 　　( 11 )lastIndexOf函数：返回字符串中第一个查找到的下标index，从右边开始查找。   
  135. 　　( 12 )length函数：返回字符串的长度。(不用带括号)   
  136. 　　( 13 )link函数：产生一个超级链接，相当于设定的URL地址。   
  137. 　　( 14 )small函数：将字体减小一号，与...标签结果相同。   
  138. 　　( 15 )strike函数：在文本的中间加一条横线，与...标签结果相同。   
  139. 　　( 16 )sub函数：显示字符串为下标字(subscript)。   
  140. 　　( 17 )substring函数：返回字符串中指定的几个字符。   
  141. 　　( 18 )sup函数：显示字符串为上标字(superscript)。   
  142. 　　( 19 )toLowerCase函数：将字符串转换为小写。   
  143. 　　( 20 )toUpperCase函数：将字符串转换为大写。   
  144.   
  145. //校验是否全由数字组成   
  146.   
  147.  程序代码   
  148. function isDigit(s)   
  149. {   
  150. var patrn=/^[ 0 - 9 ]{ 1 , 20 }$/;   
  151. if  (!patrn.exec(s))  return   false   
  152. return   true   
  153. }   
  154.   
  155. //校验登录名：只能输入5-20个以字母开头、可带数字、“_”、“.”的字串   
  156.   
  157.  程序代码   
  158. function isRegisterUserName(s)   
  159. {   
  160. var patrn=/^[a-zA-Z]{ 1 }([a-zA-Z0- 9 ]|[._]){ 4 , 19 }$/;   
  161. if  (!patrn.exec(s))  return   false   
  162. return   true   
  163. }   
  164.   
  165. //校验用户姓名：只能输入1-30个以字母开头的字串   
  166.   
  167.  程序代码   
  168. function isTrueName(s)   
  169. {   
  170. var patrn=/^[a-zA-Z]{ 1 , 30 }$/;   
  171. if  (!patrn.exec(s))  return   false   
  172. return   true   
  173. }   
  174.   
  175. //校验密码：只能输入6-20个字母、数字、下划线   
  176.   
  177.  程序代码   
  178. function isPasswd(s)   
  179. {   
  180. var patrn=/^(\w){ 6 , 20 }$/;   
  181. if  (!patrn.exec(s))  return   false   
  182. return   true   
  183. }   
  184.   
  185. //校验普通电话、传真号码：可以“+”开头，除数字外，可含有“-”   
  186.   
  187.  程序代码   
  188. function isTel(s)   
  189. {   
  190. //var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?(\d){1,12})+$/;   
  191. var patrn=/^[+]{ 0 , 1 }(\d){ 1 , 3 }[ ]?([-]?((\d)|[ ]){ 1 , 12 })+$/;   
  192. if  (!patrn.exec(s))  return   false   
  193. return   true   
  194. }   
  195.   
  196. //校验手机号码：必须以数字开头，除数字外，可含有“-”   
  197.   
  198.  程序代码   
  199. function isMobil(s)   
  200. {   
  201. var patrn=/^[+]{ 0 , 1 }(\d){ 1 , 3 }[ ]?([-]?((\d)|[ ]){ 1 , 12 })+$/;   
  202. if  (!patrn.exec(s))  return   false   
  203. return   true   
  204. }   
  205.   
  206. //校验邮政编码   
  207.   
  208.  程序代码   
  209. function isPostalCode(s)   
  210. {   
  211. //var patrn=/^[a-zA-Z0-9]{3,12}$/;   
  212. var patrn=/^[a-zA-Z0- 9  ]{ 3 , 12 }$/;   
  213. if  (!patrn.exec(s))  return   false   
  214. return   true   
  215. }   
  216.   
  217. //校验搜索关键字   
  218.   
  219.  程序代码   
  220. function isSearch(s)   
  221. {   
  222. var patrn=/^[^`~!@#$%^&*()+=|\\\][\]\{\}:;\'\,.<>/?]{ 1 }[^`~!@$%^&()+=|\\\][\]\{\}:;\'\,.<>?]{ 0 , 19 }$/;   
  223. if  (!patrn.exec(s))  return   false   
  224. return   true   
  225. }   
  226.   
  227.  程序代码   
  228. function isIP(s)  //by zergling   
  229. {   
  230. var patrn=/^[ 0 - 9 .]{ 1 , 20 }$/;   
  231. if  (!patrn.exec(s))  return   false   
  232. return   true   
  233. }   
  234.     


junky 2006-12-04 17:53 发表评论
]]>iframe高度自动调整http://www.blogjava.net/junky/archive/2006/10/27/77591.htmljunkyjunkyFri, 27 Oct 2006 04:03:00 GMThttp://www.blogjava.net/junky/archive/2006/10/27/77591.htmlhttp://www.blogjava.net/junky/comments/77591.htmlhttp://www.blogjava.net/junky/archive/2006/10/27/77591.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/77591.htmlhttp://www.blogjava.net/junky/services/trackbacks/77591.html<script>
var lastHeight;
function init() {
    autojudge();
    lastHeight= right.document.body.scrollHeight;
    setInterval(function(){
        if(right.document.body.scrollHeight!=lastHeight) {
            autojudge();
            lastHeight= right.document.body.scrollHeight;
            }
        },1);
}
function autojudge(){
    document.all('right').height=right.document.body.scrollHeight + 20;
    }
</script>



junky 2006-10-27 12:03 发表评论
]]>JavaScript方法和技巧大全http://www.blogjava.net/junky/archive/2006/10/25/77238.htmljunkyjunkyWed, 25 Oct 2006 09:18:00 GMThttp://www.blogjava.net/junky/archive/2006/10/25/77238.htmlhttp://www.blogjava.net/junky/comments/77238.htmlhttp://www.blogjava.net/junky/archive/2006/10/25/77238.html#Feedback1http://www.blogjava.net/junky/comments/commentRss/77238.htmlhttp://www.blogjava.net/junky/services/trackbacks/77238.html这篇介绍javascript方面的日志，我在是Clang上看到的。作者介绍挺全面的，所以转载过来让感兴趣的朋友看一下。呵呵～～～

有些时候你精通一门语言，但是会发现你其实整天在和其它语言打交道，也许你以为这些微不足道，不至于影响你的开发进度，但恰恰是这些你不重视的东西会浪费你很多时间，我一直以为我早在几年前就已经精通JavaScript了，直到目前，我才越来越觉得JavaScript远比我想象的复杂和强大，我开始崇拜它，就像崇拜所有OOP语言一样～
趁着节日的空隙，把有关JavaScript的方法和技巧整理下，让每个在为JavaScript而烦恼的人明白，JavaScript就这么回事！并希望JavaScript还可以成为你的朋友，让你豁然开朗，在项目中更好的应用～

适合阅读范围：对JavaScript一无所知～离精通只差一步之遥的人
基础知识：HTML


JavaScript就这么回事1：基础知识

1 创建脚本块

1: <script language=”JavaScript”>
2: JavaScript code goes here
3: </script>

 

2 隐藏脚本代码

1: <script language=”JavaScript”>
2: <!--
3: document.write(“Hello”);
4: // -->
5: </script>


在不支持JavaScript的浏览器中将不执行相关代码

3 浏览器不支持的时候显示

1: <noscript>
2: Hello to the non-JavaScript browser.
3: </noscript>

 

4 链接外部脚本文件

1: <script language=”JavaScript” src="/”filename.js"”></script>


5 注释脚本

1: // This is a comment
2: document.write(“Hello”); // This is a comment
3: /*
4: All of this
5: is a comment
6: */

 

6 输出到浏览器

1: document.write(“<strong>Hello</strong>”);

 

7 定义变量

1: var myVariable = “some value”;

 

8 字符串相加

1: var myString = “String1” + “String2”;

 

9 字符串搜索

1: <script language=”JavaScript”>
2: <!--
3: var myVariable = “Hello there”;
4: var therePlace = myVariable.search(“there”);
5: document.write(therePlace);
6: // -->
7: </script>

 

10 字符串替换

1: thisVar.replace(“Monday”,”Friday”);


11 格式化字串

1: <script language=”JavaScript”>
2: <!--
3: var myVariable = “Hello there”;
4: document.write(myVariable.big() + “<br>”);
5: document.write(myVariable.blink() + “<br>”);
6: document.write(myVariable.bold() + “<br>”);
7: document.write(myVariable.fixed() + “<br>”);
8: document.write(myVariable.fontcolor(“red”) + “<br>”);
9: document.write(myVariable.fontsize(“18pt”) + “<br>”);
10: document.write(myVariable.italics() + “<br>”);
11: document.write(myVariable.small() + “<br>”);
12: document.write(myVariable.strike() + “<br>”);
13: document.write(myVariable.sub() + “<br>”);
14: document.write(myVariable.sup() + “<br>”);
15: document.write(myVariable.toLowerCase() + “<br>”);
16: document.write(myVariable.toUpperCase() + “<br>”);
17:
18: var firstString = “My String”;
19: var finalString = firstString.bold().toLowerCase().fontcolor(“red”);
20: // -->
21: </script>

 

12 创建数组

1: <script language=”JavaScript”>
2: <!--
3: var myArray = new Array(5);
4: myArray[0] = “First Entry”;
5: myArray[1] = “Second Entry”;
6: myArray[2] = “Third Entry”;
7: myArray[3] = “Fourth Entry”;
8: myArray[4] = “Fifth Entry”;
9: var anotherArray = new Array(“First Entry”,”Second Entry”,”Third Entry”,”Fourth Entry”,”Fifth Entry”);
10: // -->
11: </script>

 

13 数组排序

1: <script language=”JavaScript”>
2: <!--
3: var myArray = new Array(5);
4: myArray[0] = “z”;
5: myArray[1] = “c”;
6: myArray[2] = “d”;
7: myArray[3] = “a”;
8: myArray[4] = “q”;
9: document.write(myArray.sort());
10: // -->
11: </script>

 

14 分割字符串

1: <script language=”JavaScript”>
2: <!--
3: var myVariable = “a,b,c,d”;
4: var stringArray = myVariable.split(“,”);
5: document.write(stringArray[0]);
6: document.write(stringArray[1]);
7: document.write(stringArray[2]);
8: document.write(stringArray[3]);
9: // -->
10: </script>

 

15 弹出警告信息

1: <script language=”JavaScript”>
2: <!--
3: window.alert(“Hello”);
4: // -->
5: </script>

 

16 弹出确认框

1: <script language=”JavaScript”>
2: <!--
3: var result = window.confirm(“Click OK to continue”);
4: // -->
5: </script>

 

17 定义函数

1: <script language=”JavaScript”>
2: <!--
3: function multiple(number1,number2) {
4: var result = number1 * number2;
5: return result;
6: }
7: // -->
8: </script>

 

18 调用JS函数

1: <a href=”#” onClick=”functionName()”>Link text</a>
2: <a href="/”javascript:functionName"()”>Link text</a>

 

19 在页面加载完成后执行函数

1: <body onLoad=”functionName();”>
2: Body of the page
3: </body>


20 条件判断

1: <script>
2: <!--
3: var userChoice = window.confirm(“Choose OK or Cancel”);
4: var result = (userChoice == true) ? “OK” : “Cancel”;
5: document.write(result);
6: // -->
7: </script>

 

21 指定次数循环

1: <script>
2: <!--
3: var myArray = new Array(3);
4: myArray[0] = “Item 0”;
5: myArray[1] = “Item 1”;
6: myArray[2] = “Item 2”;
7: for (i = 0; i < myArray.length; i++) {
8: document.write(myArray[i] + “<br>”);
9: }
10: // -->
11: </script>

 

22 设定将来执行

1: <script>
2: <!--
3: function hello() {
4: window.alert(“Hello”);
5: }
6: window.setTimeout(“hello()”,5000);
7: // -->
8: </script>

 

23 定时执行函数

1: <script>
2: <!--
3: function hello() {
4: window.alert(“Hello”);
5: window.setTimeout(“hello()”,5000);
6: }
7: window.setTimeout(“hello()”,5000);
8: // -->
9: </script>

 

24 取消定时执行

1: <script>
2: <!--
3: function hello() {
4: window.alert(“Hello”);
5: }
6: var myTimeout = window.setTimeout(“hello()”,5000);
7: window.clearTimeout(myTimeout);
8: // -->
9: </script>

 

25 在页面卸载时候执行函数

1: <body onUnload=”functionName();”>
2: Body of the page
3: </body>

JavaScript就这么回事2：浏览器输出


26 访问document对象

1: <script language=”JavaScript”>
2: var myURL = document.URL;
3: window.alert(myURL);
4: </script>

 

27 动态输出HTML

1: <script language=”JavaScript”>
2: document.write(“<p>Here’s some information about this document:</p>”);
3: document.write(“<ul>”);
4: document.write(“<li>Referring Document: “ + document.referrer + “</li>”);
5: document.write(“<li>Domain: “ + document.domain + “</li>”);
6: document.write(“<li>URL: “ + document.URL + “</li>”);
7: document.write(“</ul>”);
8: </script>


28 输出换行

1: document.writeln(“<strong>a</strong>”);
2: document.writeln(“b”);

 

29 输出日期

1: <script language=”JavaScript”>
2: var thisDate = new Date();
3: document.write(thisDate.toString());
4: </script>

 

30 指定日期的时区

1: <script language=”JavaScript”>
2: var myOffset = -2;
3: var currentDate = new Date();
4: var userOffset = currentDate.getTimezoneOffset()/60;
5: var timeZoneDifference = userOffset - myOffset;
6: currentDate.setHours(currentDate.getHours() + timeZoneDifference);
7: document.write(“The time and date in Central Europe is: “ + currentDate.toLocaleString());
8: </script>


31 设置日期输出格式

1: <script language=”JavaScript”>
2: var thisDate = new Date();
3: var thisTimeString = thisDate.getHours() + “:” + thisDate.getMinutes();
4: var thisDateString = thisDate.getFullYear() + “/” + thisDate.getMonth() + “/” + thisDate.getDate();
5: document.write(thisTimeString + “ on “ + thisDateString);
6: </script>


32 读取URL参数

1: <script language=”JavaScript”>
2: var urlParts = document.URL.split(“?”);
3: var parameterParts = urlParts[1].split(“&”);
4: for (i = 0; i < parameterParts.length; i++) {
5: var pairParts = parameterParts[i].split(“=”);
6: var pairName = pairParts[0];
7: var pairValue = pairParts[1];
8: document.write(pairName + “ ：“ +pairValue );
9: }
10: </script>

你还以为HTML是无状态的么？

33 打开一个新的document对象

1: <script language=”JavaScript”>
2: function newDocument() {
3: document.open();
4: document.write(“<p>This is a New Document.</p>”);
5: document.close();
6: }
7: </script>

 

34 页面跳转

1: <script language=”JavaScript”>
2: window.location = “http://www.liu21st.com/”;
3: </script>

 

35 添加网页加载进度窗口

1: <html>
2: <head>
3: <script language='javaScript'>
4: var placeHolder = window.open('holder.html','placeholder','width=200,height=200');
5: </script>
6: <title>The Main Page</title>
7: </head>
8: <body onLoad='placeHolder.close()'>
9: <p>This is the main page</p>
10: </body>
11: </html>

 

JavaScript就这么回事3：图像

 

36 读取图像属性

1: <img src="/”image1.jpg"” name=”myImage”>
2: <a href=”# ” onClick=”window.alert(document.myImage.width)”>Width</a>
3:


37 动态加载图像

1: <script language=”JavaScript”>
2: myImage = new Image;
3: myImage.src = “Tellers1.jpg”;
4: </script>


38 简单的图像替换

1: <script language=”JavaScript”>
2: rollImage = new Image;
3: rollImage.src = “rollImage1.jpg”;
4: defaultImage = new Image;
5: defaultImage.src = “image1.jpg”;
6: </script>
7: <a href="/”myUrl"” onMouseOver=”document.myImage.src = rollImage.src;”
8: onMouseOut=”document.myImage.src = defaultImage.src;”>
9: <img src="/”image1.jpg"” name=”myImage” width=100 height=100 border=0>


39 随机显示图像

1: <script language=”JavaScript”>
2: var imageList = new Array;
3: imageList[0] = “image1.jpg”;
4: imageList[1] = “image2.jpg”;
5: imageList[2] = “image3.jpg”;
6: imageList[3] = “image4.jpg”;
7: var imageChoice = Math.floor(Math.random() * imageList.length);
8: document.write(‘<img src=”’ + imageList[imageChoice] + ‘“>’);
9: </script>


40 函数实现的图像替换

1: <script language=”JavaScript”>
2: var source = 0;
3: var replacement = 1;
4: function createRollOver(originalImage,replacementImage) {
5: var imageArray = new Array;
6: imageArray[source] = new Image;
7: imageArray[source].src = originalImage;
8: imageArray[replacement] = new Image;
9: imageArray[replacement].src = replacementImage;
10: return imageArray;
11: }
12: var rollImage1 = createRollOver(“image1.jpg”,”rollImage1.jpg”);
13: </script>
14: <a href=”#” onMouseOver=”document.myImage1.src = rollImage1[replacement].src;”
15: onMouseOut=”document.myImage1.src = rollImage1[source].src;”>
16: <img src="/”image1.jpg"” width=100 name=”myImage1” border=0>
17: </a>


41 创建幻灯片

1: <script language=”JavaScript”>
2: var imageList = new Array;
3: imageList[0] = new Image;
4: imageList[0].src = “image1.jpg”;
5: imageList[1] = new Image;
6: imageList[1].src = “image2.jpg”;
7: imageList[2] = new Image;
8: imageList[2].src = “image3.jpg”;
9: imageList[3] = new Image;
10: imageList[3].src = “image4.jpg”;
11: function slideShow(imageNumber) {
12: document.slideShow.src = imageList[imageNumber].src;
13: imageNumber += 1;
14: if (imageNumber < imageList.length) {
15: window.setTimeout(“slideShow(“ + imageNumber + “)”,3000);
16: }
17: }
18: </script>
19: </head>
20: <body onLoad=”slideShow(0)”>
21: <img src="/”image1.jpg"” width=100 name=”slideShow”>


42 随机广告图片

1: <script language=”JavaScript”>
2: var imageList = new Array;
3: imageList[0] = “image1.jpg”;
4: imageList[1] = “image2.jpg”;
5: imageList[2] = “image3.jpg”;
6: imageList[3] = “image4.jpg”;
7: var urlList = new Array;
8: urlList[0] = “http://some.host/”;
9: urlList[1] = “http://another.host/”;
10: urlList[2] = “http://somewhere.else/”;
11: urlList[3] = “http://right.here/”;
12: var imageChoice = Math.floor(Math.random() * imageList.length);
13: document.write(‘<a href=”’ + urlList[imageChoice] + ‘“><img src=”’ + imageList[imageChoice] + ‘“></a>’);
14: </script>

JavaScript就这么回事4：表单


还是先继续写完JS就这么回事系列吧～
43 表单构成

1: <form method=”post” action=”target.html” name=”thisForm”>
2: <input type=”text” name=”myText”>
3: <select name=”mySelect”>
4: <option value=”1”>First Choice</option>
5: <option value=”2”>Second Choice</option>
6: </select>
7: <br>
8: <input type=”submit” value=”Submit Me”>
9: </form>


44 访问表单中的文本框内容

1: <form name=”myForm”>
2: <input type=”text” name=”myText”>
3: </form>
4: <a href='#' onClick='window.alert(document.myForm.myText.value);'>Check Text Field</a>


45 动态复制文本框内容

1: <form name=”myForm”>
2: Enter some Text: <input type=”text” name=”myText”><br>
3: Copy Text: <input type=”text” name=”copyText”>
4: </form>
5: <a href=”#” onClick=”document.myForm.copyText.value =
6: document.myForm.myText.value;”>Copy Text Field</a>


46 侦测文本框的变化

1: <form name=”myForm”>
2: Enter some Text: <input type=”text” name=”myText” onChange=”alert(this.value);”>
3: </form>


47 访问选中的Select

1: <form name=”myForm”>
2: <select name=”mySelect”>
3: <option value=”First Choice”>1</option>
4: <option value=”Second Choice”>2</option>
5: <option value=”Third Choice”>3</option>
6: </select>
7: </form>
8: <a href='#' onClick='alert(document.myForm.mySelect.value);'>Check Selection List</a>


48 动态增加Select项

1: <form name=”myForm”>
2: <select name=”mySelect”>
3: <option value=”First Choice”>1</option>
4: <option value=”Second Choice”>2</option>
5: </select>
6: </form>
7: <script language=”JavaScript”>
8: document.myForm.mySelect.length++;
9: document.myForm.mySelect.options[document.myForm.mySelect.length - 1].text = “3”;
10: document.myForm.mySelect.options[document.myForm.mySelect.length - 1].value = “Third Choice”;
11: </script>


49 验证表单字段

1: <script language=”JavaScript”>
2: function checkField(field) {
3: if (field.value == “”) {
4: window.alert(“You must enter a value in the field”);
5: field.focus();
6: }
7: }
8: </script>
9: <form name=”myForm” action=”target.html”>
10: Text Field: <input type=”text” name=”myField”onBlur=”checkField(this)”>
11: <br><input type=”submit”>
12: </form>


50 验证Select项

1: function checkList(selection) {
2: if (selection.length == 0) {
3: window.alert(“You must make a selection from the list.”);
4: return false;
5: }
6: return true;
7: }


51 动态改变表单的action

1: <form name=”myForm” action=”login.html”>
2: Username: <input type=”text” name=”username”><br>
3: Password: <input type=”password” name=”password”><br>
4: <input type=”button” value=”Login” onClick=”this.form.submit();”>
5: <input type=”button” value=”Register” onClick=”this.form.action = ‘register.html’; this.form.submit();”>
6: <input type=”button” value=”Retrieve Password” onClick=”this.form.action = ‘password.html’; this.form.submit();”>
7: </form>


52 使用图像按钮

1: <form name=”myForm” action=”login.html”>
2: Username: <input type=”text” name=”username”><br>
3: Password: <input type=”password”name=”password”><br>
4: <input type=”image” src="/”login.gif"” value=”Login”>
5: </form>
6:


53 表单数据的加密

1: <SCRIPT LANGUAGE='JavaScript'>
2: <!--
3: function encrypt(item) {
4: var newItem = '';
5: for (i=0; i < item.length; i++) {
6: newItem += item.charCodeAt(i) + '.';
7: }
8: return newItem;
9: }
10: function encryptForm(myForm) {
11: for (i=0; i < myForm.elements.length; i++) {
12: myForm.elements[i].value = encrypt(myForm.elements[i].value);
13: }
14: }
15:
16: //-->
17: </SCRIPT>
18: <form name='myForm' onSubmit='encryptForm(this); window.alert(this.myField.value);'>
19: Enter Some Text: <input type=text name=myField><input type=submit>
20: </form>

 


JavaScript就这么回事5：窗口和框架


54 改变浏览器状态栏文字提示

1: <script language=”JavaScript”>
2: window.status = “A new status message”;
3: </script>


55 弹出确认提示框

1: <script language=”JavaScript”>
2: var userChoice = window.confirm(“Click OK or Cancel”);
3: if (userChoice) {
4: document.write(“You chose OK”);
5: } else {
6: document.write(“You chose Cancel”);
7: }
8: </script>


56 提示输入

1: <script language=”JavaScript”>
2: var userName = window.prompt(“Please Enter Your Name”,”Enter Your Name Here”);
3: document.write(“Your Name is “ + userName);
4: </script>


57 打开一个新窗口

1: //打开一个名称为myNewWindow的浏览器新窗口
2: <script language=”JavaScript”>
3: window.open(“http://www.liu21st.com/”,”myNewWindow”);
4: </script>


58 设置新窗口的大小

1: <script language=”JavaScript”>
2: window.open(“http://www.liu21st.com/”,”myNewWindow”,'height=300,width=300');
3: </script>


59 设置新窗口的位置

1: <script language=”JavaScript”>
2: window.open(“http://www.liu21st.com/”,”myNewWindow”,'height=300,width=300,left=200,screenX=200,top=100,screenY=100');
3: </script>


60 是否显示工具栏和滚动栏

1: <script language=”JavaScript”>
2: window.open(“http:


61 是否可以缩放新窗口的大小

1: <script language=”JavaScript”>
2: window.open('http://www.liu21st.com/' , 'myNewWindow', 'resizable=yes' );</script>


62 加载一个新的文档到当前窗口

1: <a href='#' onClick='document.location = '125a.html';' >Open New Document</a>


63 设置页面的滚动位置

1: <script language=”JavaScript”>
2: if (document.all) { //如果是IE浏览器则使用scrollTop属性
3: document.body.scrollTop = 200;
4: } else { //如果是NetScape浏览器则使用pageYOffset属性
5: window.pageYOffset = 200;
6: }</script>


64 在IE中打开全屏窗口

1: <a href='#' onClick=”window.open('http://www.juxta.com/','newWindow','fullScreen=yes');”>Open a full-screen window</a>


65 新窗口和父窗口的操作

1: <script language=”JavaScript”>
2: //定义新窗口
3: var newWindow = window.open(“128a.html”,”newWindow”);
4: newWindow.close(); //在父窗口中关闭打开的新窗口
5: </script>
6: 在新窗口中关闭父窗口
7: window.opener.close()


66 往新窗口中写内容

1: <script language=”JavaScript”>
2: var newWindow = window.open(“”,”newWindow”);
3: newWindow.document.open();
4: newWindow.document.write(“This is a new window”);
5: newWIndow.document.close();
6: </script>


67 加载页面到框架页面

1: <frameset cols=”50%,*”>
2: <frame name=”frame1” src="/”135a.html"”>
3: <frame name=”frame2” src="/”about:blank"”>
4: </frameset>
5: 在frame1中加载frame2中的页面
6: parent.frame2.document.location = “135b.html”;


68 在框架页面之间共享脚本
如果在frame1中html文件中有个脚本

1: function doAlert() {
2: window.alert(“Frame 1 is loaded”);
3: }

那么在frame2中可以如此调用该方法

1: <body onLoad=”parent.frame1.doAlert();”>
2: This is frame 2.
3: </body>
69 数据公用
可以在框架页面定义数据项，使得该数据可以被多个框架中的页面公用

1: <script language=”JavaScript”>
2: var persistentVariable = “This is a persistent value”;
3: </script>
4: <frameset cols=”50%,*”>
5: <frame name=”frame1” src="/”138a.html"”>
6: <frame name=”frame2” src="/”138b.html"”>
7: </frameset>
这样在frame1和frame2中都可以使用变量persistentVariable
70 框架代码库
根据以上的一些思路，我们可以使用一个隐藏的框架页面来作为整个框架集的代码库1: <frameset cols=”0,50%,*”>
2: <frame name=”codeFrame” src="/”140code.html"”>
3: <frame name=”frame1” src="/”140a.html"”>
4: <frame name=”frame2” src="/”140b.html"”>
5: </frameset>



junky 2006-10-25 17:18 发表评论
]]>prototype.js开发笔记http://www.blogjava.net/junky/archive/2006/10/23/76811.htmljunkyjunkyMon, 23 Oct 2006 10:36:00 GMThttp://www.blogjava.net/junky/archive/2006/10/23/76811.htmlhttp://www.blogjava.net/junky/comments/76811.htmlhttp://www.blogjava.net/junky/archive/2006/10/23/76811.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/76811.htmlhttp://www.blogjava.net/junky/services/trackbacks/76811.html阅读全文

junky 2006-10-23 18:36 发表评论
]]>CSS属性列表http://www.blogjava.net/junky/archive/2006/09/15/69824.htmljunkyjunkyFri, 15 Sep 2006 02:38:00 GMThttp://www.blogjava.net/junky/archive/2006/09/15/69824.htmlhttp://www.blogjava.net/junky/comments/69824.htmlhttp://www.blogjava.net/junky/archive/2006/09/15/69824.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/69824.htmlhttp://www.blogjava.net/junky/services/trackbacks/69824.html 属性名称

字体属性（Font）
font-family
font-style
font-variant
font-weight
font-size


颜色和背景属性
Color
Background-color
Background-image
Background-repeat
Background-attachment
Background-position


文本属性
Word-spacing
Letter-spacing
Text-decoration

Vertical-align

Text-transform

Text-align
Text-indent
Line-height


边距属性
Margin-top
Margin-right
Margin-bottom
Margin-left

填充距属性
Padding-top
Padding-right
Padding-bottom
Padding-left

边框属性
Border-top-width
Border-right-width
Border-bottom-width
Border-left-width
Border-width
Border-color
Border-style
Border-top
Border-right
Border-bottom
Border-left
Width
Height
Float
Clear

分级属性
Display
White-space
List-style-type
List-style-image
List-style-position
List-style

鼠标（Cursor）属性 属性含义


使用什么字体
字体是否斜体
是否用小体大写
字体的粗细
字体的大小



定义前景色
定义背景色
定义背景图案
重复方式
设置滚动
初始位置



单词之间的间距
字母之间的间距
文字的装饰样式

垂直方向的位置

文本转换

对齐方式
首行的缩进方式
文本的行高



顶端边距
右侧边距
底端边距
左侧边距


顶端填充距
右侧填充距
底端填充距
左侧填充距


顶端边框宽度
右侧边框宽度
底端边框宽度
左侧边框宽度
一次定义宽度
设置边框颜色
设置边框样式
一次定义顶端
一次定义右侧
一次定义底端
一次定义左侧
定义宽度属性
定义高度属性
文字环绕
哪一边环绕


定义是否显示
怎样处理空白
加项目编号
加图案
第二行起始位置
一次定义列表


自动
定位“十”字
默认指针
手形
移动
箭头朝右方
箭头朝右上方
箭头朝左上方
箭头朝上方
箭头朝右下方
箭头朝左下方
箭头朝下方
箭头朝左方
文本“I”形
等待
帮助
属性值


所有的字体
Normal、italic、oblique
Normal、small-caps
Normal、bold、bolder、lithter等
Absolute-size、relative-size、length、percentage等


颜色
颜色
路径
Repeat-x、repeat-y、no-repeat
Scroll、Fixed
Percentage、length、top、left、
right、bottom等


Normal <length>
同上
None|underline|overline|line-
through|blink
Baseline|sub|super|top|text-top|middle|bottom|text-bottom|
Capitalize|uppercase|
lowercase|none
Left|right|center|justify
<length>|<percentage>
Normal|<number>|<length>|
<percentage>


Length|percentage|auto
同上
同上
同上


Length|percentage
同上
同上
同上


Thin|medium|thick|length
同上
同上
同上
同上
Color
None|dotted|dash|solid等
Border-top-width|color等
同上
同上
同上
Length|percentage|auto
Length|auto
Left|right|none
Left|right|none|both


Block、inline、list-item、none
Normal、pre、nowrap
Disc、circle、square等
<url>|none
Inside、outside
<keyword>|<position>|<url>


Auto
Crosshair
Default
Hand
Move
e-resize
Ne-resize
Nw-resize
n-resize
Se-resize
Sw-resize
s-resize
w-resize
Text
Wait
Help

junky 2006-09-15 10:38 发表评论
]]>利用Lucene搜索Java源代码http://www.blogjava.net/junky/archive/2006/08/30/66747.htmljunkyjunkyWed, 30 Aug 2006 15:50:00 GMThttp://www.blogjava.net/junky/archive/2006/08/30/66747.htmlhttp://www.blogjava.net/junky/comments/66747.htmlhttp://www.blogjava.net/junky/archive/2006/08/30/66747.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/66747.htmlhttp://www.blogjava.net/junky/services/trackbacks/66747.html
在这篇文章中，我推荐使用Lucene，它是基于Java的开源搜索引擎，通过提取和索引相关的源码元素来搜索源代码。这里，我仅限定搜索Java源代码。然而，Lucene同样可以做到对其他编程语言的源代码的搜索。

文章给出了在Lucene环境下搜索引擎重点方面的简短概述。要了解更多细节信息，参考Resources部分。

版权声明：任何获得Matrix授权的网站，转载时请务必保留以下作者信息和链接
作者:Renuka;Knightchen(作者的blog:http://blog.matrix.org.cn/page/Knightchen)
原文:http://www.matrix.org.cn/resource/article/44/44362_Lucene+Java.html
关键字:Lucene;Java

概述
Lucene是最流行的开源搜索引擎库之一。它由能文本索引和搜索的核心API组成。Lucene能够对给出一组文本文件创建索引并且允许你用复杂的查询来搜索这些索引，例如：+title:Lucene -content:Search、search AND Lucene、+search +code。在进入搜索细节之前，先让我来介绍一下Lucene的一些功能。

在Lucene中索引文本

搜索引擎对所有需要被搜索的数据进行扫描并将其存储到能有效获取的一个结构里。这个最有名的结构被称为倒排索引。例如，现在考虑对一组会议记录进行索引。首先，每个会议记录的文件被分为几个独立的部分或者域：如标题、作者、email、摘要和内容。其次，每一域的内容被标记化并且提取出关键字或者术语。这样就可以建立如下表所示会议记录的倒排索引。
image
        ....                 

对于域中的每一术语而言，上图存储了两方面的内容：该术语在文件中出现的数量（即频率【DF】）以及包含该术语的每一文件的ID。对于每个术语保存的其它细节：例如术语在每个文件中出现的次数以及出现的位置也被保存起来。无论如何，对于我们非常重要的一点是要知道：利用Lucene检索文件意味着将其保存为一种特定格式，该格式允许高效率查询及获取。

分析被索引的文本

Lucene使用分析器来处理被索引的文本。在将其存入索引之前，分析器用于将文本标记化、摘录有关的单词、丢弃共有的单词、处理派生词（把派生词还原到词根形式，意思是把bowling、bowler和bowls还原为bowl）和完成其它要做的处理。Lucene提供的通用分析器是：
&#61548;        SimpleAnalyzer：用字符串标记一组单词并且转化为小写字母。
&#61548;        StandardAnalyzer：用字符串标记一组单词，可识别缩写词、email地址、主机名称等等。并丢弃基于英语的stop words (a, an, the, to)等、处理派生词。

检索（搜索索引）
索引结构建立后，可以通过指定被搜索的字段和术语构造复杂的查询来对索引进行检索。例如，用户查询abstract：system AND email:abc@mit.edu得到的结果是所有在摘要中包含system、在email地址中有abc@mit.edu的文件。也就是说，如果在前面倒排索引表的基础上搜索就返回Doc15。与查询匹配的文件是按照术语在文件中出现的次数以及包含该术语的文档的数量进行排列的。Lucene执行一种顺序排列机制并且提供了给我们更改它的弹性。

源代码搜索引擎

现在我们知道了关于搜索引擎的基本要点，下面让我们看一看用于搜索源代码的搜索引擎应如何实现。下文中展示在搜索Java示例代码时，开发者主要关注以下Java类：
继承一个具体类或实现一个接口。
调用特定的方法。
使用特定的Java类。

综合使用上述部分的组合可以满足开发者获取他们正在寻找相关代码的需要。因此搜索引擎应该允许开发者对这些方面进行单个或组合查询。IDEs【集成开发环境】有另一个局限性：大部分可使用的工具仅仅基于上述标准之一来支持搜索源代码。在搜索中，缺乏组合这些标准进行查询的灵活性。

现在我们开始建立一个支持这些要求的源代码搜索引擎。

编写源代码分析器
第一步先写一个分析器，用来提取或去除源代码元素，确保建立最佳的索引并且仅包含相关方面的代码。在Java语言中的关键字--public,null,for,if等等，在每个.java文件中它们都出现了，这些关键字类似于英语中的普通单词（the,a,an,of）。因而，分析器必须把这些关键字从索引中去掉。

我们通过继承Lucene的抽象类Analyzer来建立一个Java源代码分析器。下面列出了JavaSourceCodeAnalyzer类的源代码，它实现了tokenStream（String，Reader）方法。这个类定义了一组【stop words】，它们能够在索引过程中，使用Lucene提供的StopFilter类来被去除。tokenStream方法用于检查被索引的字段。如果该字段是“comment”，首先要利用LowerCaseTokenizer类将输入项标记化并转换成小写字母，然后利用StopFilter类除去英语中的【stop words】（有限的一组英语【stop words】），再利用PorterStemFilter移除通用的语形学以及词尾后缀。如果被索引的内容不是“comment”，那么分析器就利用LowerCaseTokenizer类将输入项标记化并转换成小写字母，并且利用StopFilter类除去Java关键字。

package com.infosys.lucene.code JavaSourceCodeAnalyzer.;

import java.io.Reader;
import java.util.Set;
import org.apache.lucene.analysis.*;

public class JavaSourceCodeAnalyzer extends Analyzer {
      private Set javaStopSet;
      private Set englishStopSet;
      private static final String[] JAVA_STOP_WORDS = {
         "public","private","protected","interface",
            "abstract","implements","extends","null""new",
           "switch","case", "default" ,"synchronized" ,
            "do", "if", "else", "break","continue","this",
           "assert" ,"for","instanceof", "transient",
            "final", "static" ,"void","catch","try",
            "throws","throw","class", "finally","return",
            "const" , "native", "super","while", "import",
            "package" ,"true", "false" };
     private static final String[] ENGLISH_STOP_WORDS ={
            "a", "an", "and", "are","as","at","be" "but",
            "by", "for", "if", "in", "into", "is", "it",
            "no", "not", "of", "on", "or", "s", "such",
            "that", "the", "their", "then", "there","these",
            "they", "this", "to", "was", "will", "with" };
     public SourceCodeAnalyzer(){
            super();
            javaStopSet = StopFilter.makeStopSet(JAVA_STOP_WORDS);
            englishStopSet = StopFilter.makeStopSet(ENGLISH_STOP_WORDS);
     }
     public TokenStream tokenStream(String fieldName, Reader reader) {
            if (fieldName.equals("comment"))
                     return   new PorterStemFilter(new StopFilter(
                        new LowerCaseTokenizer(reader),englishStopSet));
            else
                     return   new StopFilter(
                   new LowerCaseTokenizer(reader),javaStopSet);
     }
}


编写类JavaSourceCodeIndexer
第二步生成索引。用来建立索引的非常重要的类有IndexWriter、Analyzer、Document和Field。对每一个源代码文件建立Lucene的一个Document实例。解析源代码文件并且摘录出与代码相关的语法元素，主要包括：导入声明、类名称、所继承的类、实现的接口、实现的方法、方法使用的参数和每个方法的代码等。然后把这些句法元素添加到Document实例中每个独立的Field实例中。然后使用存储索引的IndexWriter实例将Document实例添加到索引中。

下面列出了JavaSourceCodeIndexer类的源代码。该类使用了JavaParser类解析Java文件和摘录语法元素，也可以使用Eclipse3.0 ASTParser。这里就不探究JavaParser类的细节了，因为其它解析器也可以用于提取相关源码元素。在源代码文件提取元素的过程中，创建Filed实例并添加到Document实例中。
import org.apache.lucene.document.*;
import org.apache.lucene.index.*;
import com.infosys.lucene.code.JavaParser.*;

public class JavaSourceCodeIndexer {
    private static JavaParser parser = new JavaParser();
        private static final String IMPLEMENTS = "implements";
        private static final String IMPORT = "import";
        ...
        public static void main(String[] args) {
                File indexDir = new File("C:\\Lucene\\Java");
                File dataDir = new File("C:\\JavaSourceCode ");
                IndexWriter writer = new IndexWriter(indexDir,
                    new JavaSourceCodeAnalyzer(), true);
                indexDirectory(writer, dataDir);
                writer.close();
        }
        public static void indexDirectory(IndexWriter writer, File dir){
            File[] files = dir.listFiles();
            for (int i = 0; i < files.length; i++) {
                    File f = files[i];
                // Create a Lucene Document
                Document doc = new Document();
                //  Use JavaParser to parse file
                parser.setSource(f);
                addImportDeclarations(doc, parser);
                        addComments(doc, parser);
                 // Extract Class elements Using Parser
                JClass cls = parser.getDeclaredClass();
                addClass(doc, cls);
                 // Add field to the Lucene Document
                       doc.add(Field.UnIndexed(FILENAME, f.getName()));
                writer.addDocument(doc);
                    }
        }
        private static void addClass(Document doc, JClass cls) {
                   //For each class add Class Name field
            doc.add(Field.Text(CLASS, cls.className));
            String superCls = cls.superClass;
            if (superCls != null)
                   //Add the class it extends as extends field
        doc.add(Field.Text(EXTENDS, superCls));
            // Add interfaces it implements
            ArrayList interfaces = cls.interfaces;
            for (int i = 0; i < interfaces.size(); i++)
                doc.add(Field.Text(IMPLEMENTS, (String) interfaces.get(i)));
                    //Add details  on methods declared
            addMethods(cls, doc);
            ArrayList innerCls = cls.innerClasses;
                   for (int i = 0; i < innerCls.size(); i++)
                addClass(doc, (JClass) innerCls.get(i));
         }
        private static void addMethods(JClass cls, Document doc) {
            ArrayList methods = cls.methodDeclarations;
            for (int i = 0; i < methods.size(); i++) {
                       JMethod method = (JMethod) methods.get(i);
                // Add method name field
                doc.add(Field.Text(METHOD, method.methodName));
                // Add return type field
                doc.add(Field.Text(RETURN, method.returnType));
                ArrayList params = method.parameters;
                for (int k = 0; k < params.size(); k++)
                // For each method add parameter types
                    doc.add(Field.Text(PARAMETER, (String)params.get(k)));
                String code = method.codeBlock;
                if (code != null)
                //add the method code block
                    doc.add(Field.UnStored(CODE, code));
            }
        }
        private static void addImportDeclarations(Document doc, JavaParser parser) {
                   ArrayList imports = parser.getImportDeclarations();
            if (imports == null)     return;
            for (int i = 0; i < imports.size(); i++)
                    //add import declarations as keyword
                doc.add(Field.Keyword(IMPORT, (String) imports.get(i)));
        }
}


Lucene有四种不同的字段类型：Keyword，UnIndexed，UnStored和Text，用于指定建立最佳索引。
&#61548;        Keyword字段是指不需要分析器解析但需要被编入索引并保存到索引中的部分。JavaSourceCodeIndexer类使用该字段来保存导入类的声明。
&#61548;        UnIndexed字段是既不被分析也不被索引，但是要被逐字逐句的将其值保存到索引中。由于我们一般要存储文件的位置但又很少用文件名作为关键字来搜索，所以用该字段来索引Java文件名。
&#61548;        UnStored字段和UnIndexed字段相反。该类型的Field要被分析并编入索引，但其值不会被保存到索引中。由于存储方法的全部源代码需要大量的空间。所以用UnStored字段来存储被索引的方法源代码。可以直接从Java源文件中取出方法的源代码，这样作可以控制我们的索引的大小。
&#61548;        Text字段在索引过程中是要被分析、索引并保存的。类名是作为Text字段来保存。下表展示了JavaSourceCodeIndexer类使用Field字段的一般情况。

image

1.
   用Lucene建立的索引可以用Luke预览和修改，Luke是用于理解索引很有用的一个开源工具。图1中是Luke工具的一张截图，它显示了JavaSourceCodeIndexer类建立的索引。

image
图1：在Luke中索引截图

如图所见，导入类的声明没有标记化或分析就被保存了。类名和方法名被转换为小写字母后，才保存的。

查询Java源代码
建立多字段索引后，可以使用Lucene来查询这些索引。它提供了这两个重要类分别是IndexSearcher和QueryParser，用于搜索文件。QueryParser类则用于解析由用户输入的查询表达式，同时IndexSearcher类在文件中搜索满足查询条件的结果。下列表格显示了一些可能发生的查询及它的含义：
image

用户通过索引不同的语法元素组成有效的查询条件并搜索代码。下面列出了用于搜索的示例代码。
public class JavaCodeSearch {
public static void main(String[] args) throws Exception{
    File indexDir = new File(args[0]);
    String q =  args[1]; //parameter:JGraph code:insert
    Directory fsDir = FSDirectory.getDirectory(indexDir,false);
    IndexSearcher is = new IndexSearcher(fsDir);

    PerFieldAnalyzerWrapper analyzer = new
        PerFieldAnalyzerWrapper( new
                JavaSourceCodeAnalyzer());

    analyzer.addAnalyzer("import", new KeywordAnalyzer());
    Query query = QueryParser.parse(q, "code", analyzer);
    long start = System.currentTimeMillis();
    Hits hits = is.search(query);
    long end = System.currentTimeMillis();
    System.err.println("Found " + hits.length() +
                " docs in " + (end-start) + " millisec");
    for(int i = 0; i < hits.length(); i++){
    Document doc = hits.doc(i);
        System.out.println(doc.get("filename")
                + " with a score of " + hits.score(i));
    }
    is.close();
}
}


IndexSearcher实例用FSDirectory来打开包含索引的目录。然后使用Analyzer实例分析搜索用的查询字符串，以确保它与索引（还原词根，转换小写字母，过滤掉，等等）具有同样的形式。为了避免在查询时将Field作为一个关键字索引，Lucene做了一些限制。Lucene用Analyzer分析在QueryParser实例里传给它的所有字段。为了解决这个问题，可以用Lucene提供的PerFieldAnalyzerWrapper类为查询中的每个字段指定必要的分析。因此，查询字符串import：org.w3c.* AND code:Document将用KeywordAnalyzer来解析字符串org.w3c.*并且用JavaSourceCodeAnalyzer来解析Document。QueryParser实例如果查询没有与之相符的字段，就使用默认的字段：code，使用PerFieldAnalyzerWrapper来分析查询字符串，并返回分析后的Query实例。IndexSearcher实例使用Query实例并返回一个Hits实例，它包含了满足查询条件的文件。

结束语

这篇文章介绍了Lucene——文本搜索引擎，其可以通过加载分析器及多字段索引来实现源代码搜索。文章只介绍了代码搜索引擎的基本功能，同时在源码检索中使用愈加完善的分析器可以提高检索性能并获得更好的查询结果。这种搜索引擎可以允许用户在软件开发社区搜索和共享源代码。

资源
这篇文章的示例Sample code
Matrix:http://www.matrix.org.cn
Onjava:http://www.onjava.com/
Lucene home page
"Introduction to Text Indexing with Apache Jakarta Lucene:" 这是篇简要介绍使用Lucene的文章。
Lucene in Action: 在使用Lucene方面进行了深入地讲解。


junky 2006-08-30 23:50 发表评论
]]>值得收藏的javascript精华代码http://www.blogjava.net/junky/archive/2006/05/30/49135.htmljunkyjunkyTue, 30 May 2006 15:35:00 GMThttp://www.blogjava.net/junky/archive/2006/05/30/49135.htmlhttp://www.blogjava.net/junky/comments/49135.htmlhttp://www.blogjava.net/junky/archive/2006/05/30/49135.html#Feedback0http://www.blogjava.net/junky/comments/commentRss/49135.htmlhttp://www.blogjava.net/junky/services/trackbacks/49135.html 1.oncontextmenu="window.event.returnvalue=false"将彻底屏蔽鼠标右键
<tableborderoncontextmenu=return(false)><td>no</table>可用于table
2.<bodyonselectstart="returnfalse">取消选取、防止复制

3.onpaste="returnfalse"不准粘贴

4.oncopy="returnfalse;"oncut="returnfalse;"防止复制

5.<linkrel="shortcuticon"href="favicon.ico">ie地址栏前换成自己的图标

6.<linkrel="bookmark"href="favicon.ico">可以在收藏夹中显示出你的图标

7.<inputstyle="ime-mode:disabled">关闭输入法

8.永远都会带着框架
<scriptlanguage="javascript"><!--
if(window==top)top.location.href="frames.htm";//frames.htm为框架网页
//--></script>

9.防止被人frame
<scriptlanguage=javascript><!--
if(top.location!=self.location)top.location=self.location;
//--></script>

10.<noscript><iframesrc=*.html></iframe></noscript>网页将不能被另存为

11.<inputtype=buttonvalue=查看网页源代码
onclick="window.location=view-source:+<img src="pic/url.gif"
align=absmiddle border=0>http://www.csdn.net/";;>

12.怎样通过asp的手段来检查来访者是否用了代理
<%ifrequest.servervariables("http_x_forwarded_for")<>""then
response.write"<fontcolor=#ff0000>您通过了代理服务器，"&_
"真实的ip为"&request.servervariables("http_x_forwarded_for")
endif
%>

13.取得控件的绝对位置

//javascript
<scriptlanguage="javascript">
functiongetie(e){
vart=e.offsettop;
varl=e.offsetleft;
while(e=e.offsetparent){
t+=e.offsettop;
l+=e.offsetleft;
}
alert("top="+t+"\nleft="+l);
}
</script>

//vbscript
<scriptlanguage="vbscript"><!--
functiongetie()
dimt,l,a,b
seta=document.all.img1
t=document.all.img1.offsettop
l=document.all.img1.offsetleft
whilea.tagname<>"body"
seta=a.offsetparent
t=t+a.offsettop
l=l+a.offsetleft
wend
msgbox"top="&t&chr(13)&"left="&l,64,"得到控件的位置"
endfunction
--></script>

14.光标是停在文本框文字的最后
<scriptlanguage="javascript">
functioncc()
{
vare=event.srcelement;
varr=e.createtextrange();
r.movestart(character,e.value.length);
r.collapse(true);
r.select();
}
</script>
<inputtype=textname=text1value="123"onfocus="cc()">

15.判断上一页的来源
asp:
request.servervariables("http_referer")

javascript:
document.referrer

16.最小化、最大化、关闭窗口
<objectid=hh1classid="clsid:adb880a6-d8ff-11cf-9377-00aa003b7a11">
<paramname="command"value="minimize"></object>
<objectid=hh2classid="clsid:adb880a6-d8ff-11cf-9377-00aa003b7a11">
<paramname="command"value="maximize"></object>
<objectid=hh3classid="clsid:adb880a6-d8ff-11cf-9377-00aa003b7a11">
<paramname="command"value="close"></object>

<inputtype=buttonvalue=最小化onclick=hh1.click()>
<inputtype=buttonvalue=最大化onclick=hh2.click()>
<inputtype=buttonvalue=关闭onclick=hh3.click()>
本例适用于ie

17.
<%
定义数据库连接的一些常量
constadopenforwardonly=0游标只向前浏览记录，不支持分页、recordset、bookmark
constadopenkeyset=1键集游标，其他用户对记录说做的修改将反映到记录集中，但其他
用户增加或删除记录不会反映到记录集中。支持分页、recordset、bookmark
constadopendynamic=2动态游标功能最强，但耗资源也最多。用户对记录说做的修改，
增加或删除记录都将反映到记录集中。支持全功能浏览(access不支持)。
constadopenstatic=3静态游标，只是数据的一个快照，用户对记录说做的修改，增加
或删除记录都不会反映到记录集中。支持向前或向后移动

constadlockreadonly=1锁定类型，默认的，只读，不能作任何修改
constadlockpessimistic=2当编辑时立即锁定记录，最安全的方式
constadlockoptimistic=3只有在调用update方法时才锁定记录集，而在此前的其他
操作仍可对当前记录进行更改、插入和删除等
constadlockbatchoptimistic=4当编辑时记录不会被锁定，而更改、插入和删除是
在批处理方式下完成的

constadcmdtext=&h0001
constadcmdtable=&h0002
%>

18.网页不会被缓存
htm网页
<metahttp-equiv="pragma"content="no-cache">
<metahttp-equiv="cache-control"content="no-cache,must-revalidate">
<metahttp-equiv="expires"content="wed,26feb199708:21:57gmt">
或者<metahttp-equiv="expires"content="0">
asp网页
response.expires=-1
response.expiresabsolute=now()-1
response.cachecontrol="no-cache"
php网页
header("expires:mon,26jul199705:00:00gmt");
header("cache-control:no-cache,must-revalidate");
header("pragma:no-cache");


19.检查一段字符串是否全由数字组成
<scriptlanguage="javascript"><!--
functionchecknum(str){returnstr.match(/\d/)==null}
alert(checknum("1232142141"))
alert(checknum("123214214a1"))
//--></script>

20.获得一个窗口的大小
document.body.clientwidth,document.body.clientheight

21.怎么判断是否是字符
if(/[^\x00-\xff]/g.test(s))alert("含有汉字");
elsealert("全是字符");

22.textarea自适应文字行数的多少
<textarearows=1 name=s1 cols=27 onpropertychange="this.style.posheight=
this.scrollheight">
</textarea>

23.日期减去天数等于第二个日期
<scriptlanguage=javascript>
functioncc(dd,dadd)
{
//可以加上错误处理
vara=newdate(dd)
a=a.valueof()
a=a-dadd*24*60*60*1000
a=newdate(a)
alert(a.getfullyear()+"年"+(a.getmonth()+1)+"月"+a.getdate()+"日")
}
cc("12/23/2002",2)
</script>

24.选择了哪一个radio
<html><scriptlanguage="vbscript">
functioncheckme()
foreachobinradio1
ifob.checkedthenwindow.alertob.value
next
endfunction
</script><body>
<input name="radio1" type="radio" value="style" checked>style
<input name="radio1" type="radio" value="barcode">barcode
<input type="button" value="check"onclick="checkme()">
</body></html>

25.获得本页url的request.servervariables("")集合
response.write"<tableborder=1><!--tableheader--><tr><td><b>variables
</b></td><td><b>value</b></td></tr>"
foreachobinrequest.servervariables
response.write"<tr><td>"&ob&"</td><td>"&request.servervariables(ob)&"
</td></tr>"
next
response.write"</table>"

26.
本机ip<%=request.servervariables("remote_addr")%>
服务器名<%=request.servervariables("server_name")%>
服务器ip<%=request.servervariables("local_addr")%>
服务器端口<%=request.servervariables("server_port")%>
服务器时间<%=now%>
iis版本<%=request.servervariables"server_software")%>
脚本超时时间<%=server.scripttimeout%>
本文件路径<%=server.mappath(request.servervariables("script_name"))%>
服务器cpu数量<%=request.servervariables("number_of_processors")%>
服务器解译引擎<%=scriptengine&"/" & scriptenginemajorversion &"." &
scriptengineminorversion & "." & scriptenginebuildversion%>
服务器操作系统<%=request.servervariables("os")%>

27.enter键可以让光标移到下一个输入框
<input onkeydown="if(event.keycode==13)event.keycode=9">

28.检测某个网站的链接速度：
把如下代码加入<body>区域中:
<scriptlanguage=javascript>
tim=1
setinterval("tim++",100)
b=1

varautourl=newarray()
autourl[1]="< src="pic/url.gif" align=absmiddle border=0>www.njcatv.net"
autourl[2]="javacool.3322.net"
autourl[3]="< src="pic/url.gif" align=absmiddle border=0>www.sina.com.cn"
autourl[4]="www.nuaa.edu.cn"
autourl[5]="< src="pic/url.gif" align=absmiddle border=0>www.cctv.com"

functionbutt(){
document.write("<formname=autof>")
for(vari=1;i<autourl.length;i++)
document.write("<inputtype=textname=txt"+i+"size=10value=测试中……>=》
<inputtype=textname=url"+i+"size=40>=》
<inputtype=buttonvalue=goonclick=window.open(this.form.url"+i+".value)><br/>")
document.write("<inputtype=submitvalue=刷新></form>")
}
butt()
functionauto(url){
document.forms[0]["url"+b].value=url
if(tim>200)
{document.forms[0]["txt"+b].value="链接超时"}
else
{document.forms[0]["txt"+b].value="时间"+tim/10+"秒"}
b++
}
functionrun(){for(vari=1;i<autourl.length;i++)document.write
("<imgsrc=http://"+autourl+"/"+math.random()+"width=1height=
1onerror=auto(< src="pic/url.gif" align=absmiddle border=0>
http://";;;+autourl+")>")}
run()</script>


29.各种样式的光标
auto：标准光标
default：标准箭头
hand：手形光标
wait：等待光标
text：i形光标
vertical-text：水平i形光标
no-drop：不可拖动光标
not-allowed：无效光标
help：?帮助光标
all-scroll：三角方向标
move：移动标
crosshair：十字标
e-resize
n-resize
nw-resize
w-resize
s-resize
se-resize
sw-resize

1.本地无缓存，每次自动刷新
response.expires=0
response.addheader"pragma","no-cache"
response.addheader"cache-control","private"

2.修改contenttype并下载gif等格式
<%
functiondl(f,n)
onerrorresumenext

sets=createobject("adodb.stream")
s.mode=3
s.type=1
s.open
s.loadfromfile(server.mappath(f))
iferr.number>0then
response.writeerr.number&":"&err.description
else
response.contenttype="application/x-gzip"
response.addheader"content-disposition:","attachment;filename="&n
response.binarywrite(s.read(s.size))
endif
endfunction

calldl("012922501.gif","t1.gif")
%>


19.检查一段字符串是否全由数字组成
<scriptlanguage="javascript"><!--
functionchecknum(str){return!/\d/.test(str)}
alert(checknum("1232142141"))
alert(checknum("123214214a1"))
//--></script>

20.获得一个窗口的大小
document.body.clientwidth,document.body.clientheight
document.body.offsetwidth,document.body.offsetheight
有时还需要知道window.screentop,window.screenleft

21.怎么判断是否含有汉字
if(escape(str).indexof("%u")!=-1)alert("含有汉字");
elsealert("全是字符");

22.textarea自适应文字行数的多少
ie5.5+可以用overflow-y:visible
<textarearows=1name=s1cols=27style="overflow-y:visible">
</textarea>

23.日期减去天数等于第二个日期
<scriptlanguage=javascript>
functioncc(dd,dadd)
{
//可以加上错误处理
vard=newdate(dd.replace("-","/"))
d.setdate(d.getdate()+dadd)
alert(d.getfullyear()+"年"+(d.getmonth()+1)+"月"+d.getdate()+"日")
}
cc("2002-2-28",2)
</script>



junky 2006-05-30 23:35 发表评论
]]>