BlogJava-xyz's blog-文章分类-网络文摘

轻松实现Apache,Tomcat集群和负载均衡

xyz — Tue, 13 May 2008 11:29:00 GMT

来源：http://hi.baidu.com/luodaijun/blog/item/5bbe4cfb5ffef864034f56a1.html

作者:罗代均 ldj_work#126.com,转载请保持完整性

0，环境说明

Apache :apache_2.0.55 1 个

Tomcat: apache-tomcat-5.5.17 (zip版) 2个

mod_jk:: mod_jk-apache-2.0.55.so 1个

第一部分：负载均衡

负载均衡，就是apache将客户请求均衡的分给tomcat1,tomcat2....去处理

1.安装apche,tomcat

http://httpd.apache.org/ 下载Apache 2.0.55

http://tomcat.apache.org/download-55.cgi 下载tomcat5.5 zip版本（解压即可，绿色版）

http://apache.justdn.org/tomcat/tomcat-connectors/jk/binaries/win32/jk-1.2.15/ 下载mod_jk,注意和 apache版本匹配

按照jdk,我的路径为:E:\ide\apache\Apache2

解压两份Tomcat, 路径分别为 E:\ide\tomcat1,E:\ide\tomcat2

下载mod_jk

2.修改Apache配置文件http.conf

在apache安装目录下conf目录中找到http.conf

在文件最后加上下面一句话就可以了

include "E:\ide\apache\Apache2\conf\mod_jk.conf"

2. http.conf 同目录下新建mod_jk.conf文件，内容如下

#加载mod_jk Module
LoadModule jk_module modules/mod_jk-apache-2.0.55.so

#指定 workers.properties文件路径
JkWorkersFile conf/workers.properties

#指定那些请求交给tomcat处理,"controller"为在workers.propertise里指定的负载分配控制器

JkMount /*.jsp controller

3.在http.conf同目录下新建 workers.properties文件，内容如下

worker.list = controller,tomcat1,tomcat2 #server 列表

#========tomcat1========

worker.tomcat1.port=8009 #ajp13 端口号，在tomcat下server.xml配置,默认8009
worker.tomcat1.host=localhost #tomcat的主机地址，如不为本机，请填写ip地址
worker.tomcat1.type=ajp13
worker.tomcat1.lbfactor = 1 #server的加权比重，值越高，分得的请求越多

#========tomcat2========

worker.tomcat2.port=9009 #ajp13 端口号，在tomcat下server.xml配置,默认8009
worker.tomcat2.host=localhost #tomcat的主机地址，如不为本机，请填写ip地址
worker.tomcat2.type=ajp13
worker.tomcat2.lbfactor = 1 #server的加权比重，值越高，分得的请求越多

#========controller,负载均衡控制器========
worker.controller.type=lb
worker.controller.balanced_workers=tomcat1,tomcat2 #指定分担请求的tomcat
worker.controller.sticky_session=1

4.修改tomcat配置文件server.xml

如果你在不同电脑上安装tomcat,tomcat的安装数量为一个，可以不必修改tomcat配置文件

我这里是在同一台电脑上安装两个tomcat，所以需要更改其中一个的设置

打开tomcat2/conf/server.xml文件

5.编写一个测试jsp

建立一个目录test.里面新建一个test.jsp,内容为

<%
System.out.println("===========================");
%>

把test放到tomcat1,tomcat2的webapps下

6.启动apache,tomcat1,tomcat2,进行测试

通过 http://localhost/test/test.jsp 访问，查看tomcat1的窗口，可以看到打印了一行"=========="

再刷新一次，tomcat2也打印了一条，再刷新，可以看到请求会被tomcat1,tomcat2轮流处理,实现了负载均衡

第二部分，配置集群

只配置负载均衡还不行，还要session复制，也就是说其中任何一个tomcat的添加的session，是要同步复制到其它tomcat，集群内的tomcat都有相同的session

1. 修改tomcat1, tomcat2的server.xml,将集群部分配置的在注释符删掉,并将tomcat2的4001端口改为4002，以避免与tomcat冲突，当然，如果是两台电脑，是不用改端口的，去掉注释符即可

2，修改测试项目test

修改test.jsp,内容如下

<%@ page contentType="text/html; charset=GBK" %>
<%@ page import="java.util.*" %>
Cluster App Test

Server Info:
<%
out.println(request.getLocalAddr() + " : " + request.getLocalPort()+"
");%>
<%
out.println("
ID " + session.getId()+"
");

// 如果有新的 Session 属性设置
String dataName = request.getParameter("dataName");
if (dataName != null && dataName.length() > 0) {
String dataValue = request.getParameter("dataValue");
session.setAttribute(dataName, dataValue);
}

out.print("Session 列表");

Enumeration e = session.getAttributeNames();
while (e.hasMoreElements()) {
     String name = (String)e.nextElement();
     String value = session.getAttribute(name).toString();
     out.println( name + " = " + value+"
");
         System.out.println( name + " = " + value);
   }
%>

然后在test 新建WEB-INF目录，WEB-INF下新建web.xml,内容如下

http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">

TomcatDemo

注意：在你的应用的web.xml加入即可

ok,讲test复制到tomcat1,tomcat2的webapps下，重启apache,tomcat1,tomcat2,

输入网址 http://localhost/test/test.jsp

新建一个名称为 xiaoluo ,值为 cdut 的session,提交查询，新开一个ie窗口，再提交查询，如图，可以看到，两个tomcat 是负载均衡，并且session同步的

xyz 2008-05-13 19:29 发表评论

实践中整理出tomcat集群和负载均衡

xyz — Tue, 13 May 2008 11:25:00 GMT

来源：http://macrochen.blogdriver.com/macrochen/1207263.html

(一)环境说明
(1)服务器有4台，一台安装apache,三台安装tomcat
(2)apache2.0.55、tomcat5.5.15、jk2.0.4、jdk1.5.6或jdk1.4.2
(3)ip配置,一台安装apache的ip为192.168.0.88,三台安装tomcat的服务器ip分别为192.168.0.1/2/4
(二)安装过程
(1)在三台要安装tomcat的服务器上先安装jdk
(2)配置jdk的安装路径,在环境变量path中加入jdk的bin路径,新建环境变量JAVA_HOME指向jdk的安装路径
(3)在三台要安装tomcat的服务器上分别安装tomcat,调试三个tomcat到能够正常启动
(4)tomcat的默认WEB服务端口是8080,默认的模式是单独服务,我的三个tomcat的WEB服务端口修改为7080/8888/9999
修改位置为tomcat的安装目录下的conf/server.xml
修改前的配置为
                    maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" redirectPort="8443" acceptCount="100"
               connectionTimeout="20000" disableUploadTimeout="true" />
修改后的配置为
                    maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" redirectPort="8443" acceptCount="100"
               connectionTimeout="20000" disableUploadTimeout="true" />
依次修改每个tomcat的监听端口(7080/8888/9999)

(5)分别测试每个tomcat的启动是否正常
http://192.168.0.1:7080
http://192.168.0.2:8888
http://192.168.0.4:9999
(三)负载均衡配置过程
(1)在那台要安装apache的服务器上安装apache2.0.55,我的安装路径为默认C:\Program Files\Apache Group\Apache2
(2)安装后测试apache能否正常启动，调试到能够正常启动http://192.168.0.88
(3)下载jk2.0.4后解压缩文件
(4)将解压缩后的目录中的modules目录中的mod_jk2.so文件复制到apache的安装目录下的modules目录中,我的为C:\Program Files\Apache Group\Apache2\modules
(5)修改apache的安装目录中的conf目录的配置文件httpd.conf，在文件中加LoadModule模块配置信息的最后加上一句LoadModule jk2_module modules/mod_jk2.so
(6)分别修改三个tomcat的配置文件conf/server.xml，修改内容如下
修改前






修改后







将其中的jvmRoute="jvm1"分别修改为jvmRoute="tomcat1"和jvmRoute="tomcat2"和jvmRoute="tomcat3"

(7)然后重启三个tomcat，调试能够正常启动。
(8)在apache的安装目录中的conf目录下创建文件workers2.propertie，写入文件内容如下

# fine the communication channel
[channel.socket:192.168.0.1:8009]
info=Ajp13 forwarding over socket
#配置第一个服务器
tomcatId=tomcat1 #要和tomcat的配置文件server.xml中的jvmRoute="tomcat1"名称一致
debug=0
lb_factor=1 #负载平衡因子，数字越大请求被分配的几率越高

# Define the communication channel
[channel.socket:192.168.0.2:8009]
info=Ajp13 forwarding over socket
tomcatId=tomcat2
debug=0
lb_factor=1

# Define the communication channel
[channel.socket:192.168.0.4:8009]
info=Ajp13 forwarding over socket
tomcatId=tomcat3
debug=0
lb_factor=1

[status:]
info=Status worker, displays runtime information.

[uri:/jkstatus.jsp]
info=Display status information and checks the config file for changes.
group=status:

[uri:/*]
info=Map the whole webapp
debug=0
(9)在三个tomcat的安装目录中的webapps建立相同的应用,我和应用目录名为TomcatDemo,在三个应用目录中建立相同 WEB-INF目录和页面index.jsp,index.jsp的页面内容如下
<%@ page contentType="text/html; charset=GBK" %>
<%@ page import="java.util.*" %>
Cluster App Test

Server Info:
<%
out.println(request.getLocalAddr() + " : " + request.getLocalPort()+"
");%>
<%
  out.println("
ID " + session.getId()+"
");

  // 如果有新的 Session 属性设置
  String dataName = request.getParameter("dataName");
  if (dataName != null && dataName.length() > 0) {
     String dataValue = request.getParameter("dataValue");
     session.setAttribute(dataName, dataValue);
  }

  out.print("Session 列表");

  Enumeration e = session.getAttributeNames();
  while (e.hasMoreElements()) {
     String name = (String)e.nextElement();
     String value = session.getAttribute(name).toString();
     out.println( name + " = " + value+"
");
         System.out.println( name + " = " + value);
   }
%>

(10)重启apache服务器和三个tomcat服务器,到此负载均衡已配置完成。测试负载均衡先测试apache,访问http://192.168.0.88/jkstatus.jsp
能否正常访问，并查询其中的内容，有三个tomcat的相关配置信息和负载说明,访问http://192.168.0.88/TomcatDemo/index.jsp看能够运行,
能运行，则已建立负载均衡。
(四)tomcat集群配置
(1)负载均衡配置的条件下配置tomcat集群
(2)分别修改三个tomcat的配置文件conf/server.xml,修改内容如下
修改前

修改后

                          managerClassName="org.apache.catalina.cluster.session.DeltaManager"
                 expireSessionsOnShutdown="false"
                 useDirtyFlag="true"
                 notifyListenersOnReplication="true">

                             className="org.apache.catalina.cluster.mcast.McastService"
                mcastAddr="228.0.0.4"
                mcastPort="45564"
                mcastFrequency="500"
                mcastDropTime="3000"/>

                             className="org.apache.catalina.cluster.tcp.ReplicationListener"
                tcpListenAddress="auto"
                tcpListenPort="4001"
                tcpSelectorTimeout="100"
                tcpThreadCount="6"/>

                             className="org.apache.catalina.cluster.tcp.ReplicationTransmitter"
                replicationMode="pooled"
                ackTimeout="5000"/>

                                filter=".*\.gif;.*\.js;.*\.jpg;.*\.png;.*\.htm;.*\.html;.*\.css;.*\.txt;"/>

                                   tempDir="/tmp/war-temp/"
                      deployDir="/tmp/war-deploy/"
                      watchDir="/tmp/war-listen/"
                      watchEnabled="false"/>




将集群配置选项的注释放开即可，如上。
(3)重启三个tomcat。到此tomcat的集群已配置完成。

(五)应用配置
对于要进行负载和集群的的tomcat目录下的webapps中的应用中的WEB-INF中的web.xml文件要添加如下一句配置

配置前

  TomcatDemo

配置后

  TomcatDemo

xyz 2008-05-13 19:25 发表评论

Tomcat集群与负载均衡

xyz — Tue, 13 May 2008 11:23:00 GMT

来源:http://blog.csdn.net/ladofwind/archive/2006/08/29/1138484.aspx

在单一的服务器上执行WEB应用程序有一些重大的问题，当网站成功建成并开始接受大量请求时，单一服务器终究无法满足需要处理的负荷量，所以就有点显得有点力不从心了。另外一个常见的问题是会产生单点故障，如果该服务器坏掉，那么网站就立刻无法运作了。不论是因为要有较佳的扩充性还是容错能力，我们都会想在一台以上的服务器计算机上执行WEB应用程序。所以，这时候我们就需要用到集群这一门技术了。

在进入集群系统架构探讨之前，先定义一些专门术语：
1. 集群(Cluster)：是一组独立的计算机系统构成一个松耦合的多处理器系统，它们之间通过网络实现进程间的通信。应用程序可以通过网络共享内存进行消息传送，实现分布式计算机。
2. 负载均衡(Load Balance)：先得从集群讲起，集群就是一组连在一起的计算机，从外部看它是一个系统，各节点可以是不同的操作系统或不同硬件构成的计算机。如一个提供Web服务的集群，对外界来看是一个大Web服务器。不过集群的节点也可以单独提供服务。
3. 特点：在现有网络结构之上，负载均衡提供了一种廉价有效的方法扩展服务器带宽和增加吞吐量，加强网络数据处理能力，提高网络的灵活性和可用性。集群系统(Cluster)主要解决下面几个问题：
高可靠性（HA）：利用集群管理软件，当主服务器故障时，备份服务器能够自动接管主服务器的工作，并及时切换过去，以实现对用户的不间断服务。
高性能计算（HP）：即充分利用集群中的每一台计算机的资源，实现复杂运算的并行处理，通常用于科学计算领域，比如基因分析，化学分析等。
负载平衡：即把负载压力根据某种算法合理分配到集群中的每一台计算机上，以减轻主服务器的压力，降低对主服务器的硬件和软件要求。

目前比较常用的负载均衡技术主要有：
　　1. 基于DNS的负载均衡
　　通过DNS服务中的随机名字解析来实现负载均衡，在DNS服务器中，可以为多个不同的地址配置同一个名字，而最终查询这个名字的客户机将在解析这个名字时得到其中一个地址。因此，对于同一个名字，不同的客户机会得到不同的地址，他们也就访问不同地址上的Web服务器，从而达到负载均衡的目的。

　　2. 反向代理负载均衡（如Apache+JK2+Tomcat这种组合）
　　使用代理服务器可以将请求转发给内部的Web服务器，让代理服务器将请求均匀地转发给多台内部Web服务器之一上，从而达到负载均衡的目的。这种代理方式与普通的代理方式有所不同，标准代理方式是客户使用代理访问多个外部Web服务器，而这种代理方式是多个客户使用它访问内部Web服务器，因此也被称为反向代理模式。

　　3. 基于NAT（Network Address Translation）的负载均衡技术（如Linux Virtual Server，简称LVS）
　　网络地址转换为在内部地址和外部地址之间进行转换，以便具备内部地址的计算机能访问外部网络，而当外部网络中的计算机访问地址转换网关拥有的某一外部地址时，地址转换网关能将其转发到一个映射的内部地址上。因此如果地址转换网关能将每个连接均匀转换为不同的内部服务器地址，此后外部网络中的计算机就各自与自己转换得到的地址上服务器进行通信，从而达到负载分担的目的。

介绍完上面的集群技术之后，下面就基于Tomcat的集群架构方案进行说明：

上面是采用了Apache httpd作为web服务器的，即作为Tomcat的前端处理器，根据具体情况而定，有些情况下是不需要Apache httpd作为 web 服务器的，如系统展现没有静态页面那就不需要Apache httpd，那时可以直接使用Tomcat作为web 服务器来使用。使用Apache httpd主要是它在处理静态页面方面的能力比Tomcat强多了。
1、用户的网页浏览器做完本地 DNS和企业授权的DNS之的请求/响应后，这时候企业授权的DNS（即21cn BOSS DNS）会给用户本地的DNS服务器提供一个NAT请求分配器（即网关）IP。

2、 NAT分配器，它会根据特定的分配算法，来决定要将连接交给哪一台内部 Apache httpd来处理请求。大多数的NAT请求分配器提供了容错能力：根据侦测各种WEB服务器的失效状况，停止将请求分配给已经宕掉的服务器。并且有些分配器还可以监测到WEB服务器机器的负载情况，并将请求分配给负载最轻的服务器等等。Linux Virtual Server是一个基于Linux操作系统上执行的VS-NAT开源软件套件，而且它有丰富的功能和良好的说明文件。商业硬件解决方案 Foundry Networks的ServerIron是目前业界公认最佳的请求分配器之一。

3、 Apache httpd + Mod_JK2在这里是作为负载均衡器，那为什么要做集群呢？如果集群系统要具备容错能力，以便在任何单一的硬件或软件组件失效时还能100%可用，那么集群系统必须没有单点故障之忧。所以，不能只架设一台有mod_jk2的Apache httpd，因为如果 httpd或mod_jk2失效了，将不会再有请求被会送交到任何一个Tomcat 实例。这种情况下，Apache httpd就是瓶劲，特别在访问量大的网站。

4、 Mod_JK2负载均衡与故障复原，决定把Apache httpd当成web服务器，而且使用mod_jk2将请求传送给Tomcat，则可以使用mod_jk2的负载均衡与容错功能。在集群系统中，带有mod_jk2的Apache httpd可以做的事情包括：
A、将请求分配至一或多个Tomcat实例上
你可以在mod_jk2的workers.properties文件中，设定许多Tomcat实例，并赋于每个实例一个lb_factor值，以作为请求分配的加权因子。

B、侦测Tomcat实例是否失败
当Tomcat实例的连接器服务不再响应时，mod_jk2会及时侦测到，并停止将请求送给它。其他的Tomcat实例则会接受失效实例的负载。

C、侦测Tomcat实例在失效后的何时恢复
因连接器服务失效，而停止将请求分配给Tomcat实例之后，mod_jk2会周期性地检查是否已恢复使用性，并自动将其加入现行的Tomcat实例池中。

5、 Tomcat中的集群原理是通过组播的方式进行节点的查找并使用TCP连接进行会话的复制。这里提示一下就是，对每个请求的处理，Tomcat都会进行会话复制，复制后的会话将会慢慢变得庞大。

6、 Mod_jk2同时支持会话亲和和会话复制。在tomcat 5中如何实现会话亲和和会话复制？把server.xml中的标签去掉就实现会话亲和，把标签加上就实现会话复制。

7、会话亲和：就是表示来自同会话的所有请求都由相同的Tomcat 实例来处理，这种情况下，如果Tomcat实例或所执行的服务器机器失效，也会丧失Servlet的会话数据。即使在集群系统中执行更多的Tomcat实例，也永远不会复制会话数据。这样是提高集群性能的一种方案，但不具备有容错能力了。

8、使用会话复制，则当一个Tomcat实例宕掉时，由于至少还有另一个Tomcat实例保有一份会话状态数据，因而数据不会丧失。但性能会有所降低。

xyz 2008-05-13 19:23 发表评论

freemarker 点滴

xyz — Tue, 13 May 2008 10:40:00 GMT

FreeMarker概述

FreeMarker是一个模板引擎，一个基于模板生成文本输出的通用工具，使用纯Java编写
Template + data model = output
Hello world
FreeMarkerTest.java

 

import java.io.StringWriter;import java.util.HashMap;import java.util.Locale;

 

import freemarker.template.Configuration;import freemarker.template.Template;

 

publicclass FreeMarkerTest {

 

publicstaticvoid main(String[] args){

FreeMarkerTest test = new FreeMarkerTest();

test.sayHello("Hermit");

}

 

publicvoid sayHello(String name){

Configuration freemarkerCfg = new Configuration();

freemarkerCfg.setClassForTemplateLoading(this.getClass(), "/");

 

freemarkerCfg.setEncoding(Locale.getDefault(), "UTF-8");

Template template;

Locale.setDefault(Locale.ENGLISH);

try{

template = freemarkerCfg.getTemplate("Hello.ftl");

template.setEncoding("UTF-8");

HashMap root = newHashMap();

root.put("user", name);

 

StringWriter writer = newStringWriter();

template.process(root, writer);

System.out.println(writer.toString());

}catch(Exception e){

e.printStackTrace();

}}

 

 

 

}

Hello.ftl

 

 

Hello ${user}!

输出

Hello Hermit!

空值的处理

在我们的程序中难免会碰到值为空的时候，如果用一个空值直接去替换模板中的标记，freemarker会毫不犹豫的抛出异常，并把错误信息直接写到输出结果里。为了对付这种情况我们有两种写法

模板

 

Hello ${user!}!

Hello ${user?if_exists}

Hello ${user!'your name'}!

Hello ${user?default('your name')}

程序

 

test.sayHello(null);

输出

 

Hello !

Hello your name!

Hello 

Hello your name

freemarker国际化模板

freemarker支持多语言国际化，只要把模板名称按照java资源文件的写法就可以了,也就是name_语言_国家地区.ftl 如果找不到对应的语言，就会用默认语言的模板。

程序

 

import java.io.StringWriter;import java.util.HashMap;import java.util.Locale;

 

import freemarker.template.Configuration;import freemarker.template.Template;

 

publicclass FreeMarkerTest {

 

publicstaticvoid main(String[] args){

FreeMarkerTest test = new FreeMarkerTest();

test.sayHello("hermit",Locale.CHINA);

test.sayHello("hermit",Locale.ENGLISH);

}

 

publicvoid sayHello(String name,Locale locale){

Configuration freemarkerCfg = new Configuration();

freemarkerCfg.setClassForTemplateLoading(this.getClass(), "/");

 

freemarkerCfg.setEncoding(Locale.getDefault(), "UTF-8");

Template template;

Locale.setDefault(Locale.ENGLISH);

try{

template = freemarkerCfg.getTemplate("Hello.ftl",locale);

template.setEncoding("UTF-8");

HashMap root = newHashMap();

root.put("user", name);

 

StringWriter writer = newStringWriter();

template.process(root, writer);

System.out.println(writer.toString());

}catch(Exception e){

e.printStackTrace();

}

}

  

}

默认语言模版:Hello.ftl

Hello ${user!}! 

中文模版:Hello_zh_CN.ftl 

你好 ${user!}!



输出

你好 hermit!

Hello hermit!

在struts项目中使用freemarker

1、引入freemarker.jar

2、web.xml加入

	

>>freemarker>>

freemarker.ext.servlet.FreemarkerServlet

>

 



>

>TemplatePath>

>/>

>

>

>NoCache>

>true>

>

>

>ContentType>

>text/html>

>

 

>>template_update_delay>>0>



>>>default_encoding>

>utf-8>>

>>locale>>en_US>>

>>number_format>>0.##########>>

 

>1>>

 

>>freemarker>>*.ftl>>

3、一个示例页面

 

</span></span>Say Hello<span style="color: rgb(0,153,0)"><span style="font-weight: bold; color: rgb(0,0,0)">HTTP-EQUIV="Content-Type"CONTENT="text/html; charset=utf-8">Hello ${user}!

我们完全可以用freemarker的模板取代JSP页面。用freemarker的模板看起更简洁，可读性更强。比如现在struts2的UI标签就是用freemarker做的。

freemarker用struts标签做国际化

示例模板

<#assign  html =JspTaglibs["/WEB-INF/struts-html.tld"]><#assign  bean =JspTaglibs["/WEB-INF/struts-bean.tld"]><#assign  logic =JspTaglibs["/WEB-INF/struts-logic.tld"]></span></span> FreeMarker Struts Example <span style="color: rgb(0,153,0)"><span style="font-weight: bold; color: rgb(0,0,0)">http-equiv ="Content-type"content ="text/html; charset=utf-8"></ head ><@bean.message key ="hello"  arg0 ="hermit"/>

主要是引入标签的时候要这样写：

<#assign  html =JspTaglibs["/WEB-INF/struts-html.tld"]>

freemarker直接使用资源文件进行多语言国际化

程序

import java.io.StringWriter;import java.util.HashMap;import java.util.Locale;import java.util.ResourceBundle;

 

import freemarker.ext.beans.BeansWrapper;import freemarker.ext.beans.ResourceBundleModel;import freemarker.template.Configuration;import freemarker.template.Template;

 

publicclass FreeMarkerTest {

 

publicstaticvoid main(String[] args){

FreeMarkerTest test = new FreeMarkerTest();

test.sayHello("hermit",Locale.CHINA);

test.sayHello("hermit",Locale.ENGLISH);

}

 

publicvoid sayHello(String name,Locale locale){

Configuration freemarkerCfg = new Configuration();

freemarkerCfg.setClassForTemplateLoading(this.getClass(), "/");

 

freemarkerCfg.setEncoding(Locale.getDefault(), "UTF-8");

Template template;

Locale.setDefault(Locale.ENGLISH);

try{

template = freemarkerCfg.getTemplate("Hello.ftl");

template.setEncoding("UTF-8");

HashMap root = newHashMap();

root.put("user", name);

ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle("ApplicationResources",locale);

ResourceBundleModel rsbm = new ResourceBundleModel(RESOURCE_BUNDLE,new BeansWrapper());

root.put("bundle", rsbm);

StringWriter writer = newStringWriter();

template.process(root, writer);

System.out.println(writer.toString());

}catch(Exception e){

e.printStackTrace();

}}

 

 

 

} 



模板

${bundle("hello","hermit")} 



默认语言资源文件

hello=Hello {0}\! 



中文资源文件 



hello=你好 {0}\!

输出

你好 hermit!

Hello hermit!

关键的地方就是用ResourceBundleModel把ResourceBundle转换一下。

常用的2种加载模板的方式

普通java类根据当前class上下文环境加载模板

cfg.setClassForTemplateLoading(this.getClass(), "/");

在web项目中根据servlet上下文环境加载模板

cfg.setServletContextForTemplateLoading(this.getServlet().getServletContext(), "/");

xyz 2008-05-13 18:40 发表评论

freemarker 基本指令

xyz — Tue, 13 May 2008 10:22:00 GMT

一：if指令：
<#if condition>...
<#elseif condition2>...
<#elseif condition3>...
...<#else>...

二：switch
<#switch value>
<#case refValue1>...<#break>
<#case refValue2>...<#break>...
<#case refValueN>...<#break>
<#default>...

三：list，break
<#list sequence as item>
...

两个特殊的循环变量：
item_index: 当前变量的索引值。
item_has_next: 是否存在下一个对象。

可以用<#break/>指令离开loop循环。

四：include指令
<#include filename>或者
<#include filenameoptions>
filename: 表达式转换为字符串
options: encoding=encoding, parse=parse encoding: 表达式转换为字符串
parse: 表达式转换为逻辑值，是否作为ftl文件解析。
<#include "/common/navbar.html" parse=false encoding="Shift_JIS">

<#include "*/footer.ftl">表示当前目录下以及所有父目录下的文件。如果当前模版在/foo/bar/template.ftl ，那么查找footer.ftl的顺序为：/foo/bar/footer.ftl
/foo/footer.ftl/footer.ftl这种方式讲允许设计者将通用的模版放在父文件夹里面。
也可以只指定部分路径：<#include "*/commons/footer.ftl">

五：import指令<#import path as hash>
六：noparse
<#noparse>
...

七：compress
<#compress>
...

八：escape，noescape
<#escape identifier as expression>
...
<#noescape>...
...

escape指令body区的ftl的interpolations都会被自动加上escape表达式。但是不会影响字符串内的interpolations。而且也只会影响到body内出现的interpolations，比如不会影响到include的ftl的interpolations。
<#escape x as x?html>
First name: ${firstName}
Last name: ${lastName}
Maiden name: ${maidenName}
等同于：

First name: ${firstName?html}
Last name: ${lastName?html}
Maiden name: ${maidenName?html}

escape指令在解析模版时起作用，而不是运行时起作用。

escape指令还能嵌套使用，子继承父的escape规则。

<#escape x as x?html>
Customer Name: ${customerName}
Items to ship:
<#escape x as itemCodeToNameMap[x]>
${itemCode1}
${itemCode2}
${itemCode3}
${itemCode4}

等同于：Customer Name: ${customerName?html}
Items to ship:
${itemCodeToNameMap[itemCode1]?html}
${itemCodeToNameMap[itemCode2]?html}
${itemCodeToNameMap[itemCode3]?html}
${itemCodeToNameMap[itemCode4]?html}

九：assign指令
<#assign name=value>or<#assign name1=value1name2=value2... nameN=valueN>or<#assign same as above... in namespacehash>or<#assign name> capture thisor<#assign name in namespacehash> capture this创建或者替换一个已经存在的变量，只能作用于顶层变量。不好的做法：<#assign x>Hello ${user}!更改为：<#assign x="Hello ${user}!">
十：global指令
<#global name=value>
or
<#global name1=value1name2=value2... nameN=valueN>or<#global name>
capture this

十一：local指令
<#local name=value>
or
<#local name1=value1name2=value2... nameN=valueN>or<#local name>
capture this
只能用于macro的定义body中。

十二：setting指令：

<#setting name=value>
name的取值范围：
local：number_format：
boolean_format:缺省值为"true,false"
date_format, time_format, datetime_format
time_zone：url_escaping_charset
classic_compatible

十三：用户自定义指令
<@macro_or_transfparam1=val1param2=val2...paramN=valN/><@macro_or_transfparam1=val1param2=val2...paramN=valN ; lv1, lv2, ..., lvN/><@macro_or_transf...> ...</@macro_or_transf><@macro_or_transf...> ...</@><@macro_or_transfval1, val2, ..., valN/>
十四：macro,nested,return
<#macro nameparam1param2... paramN>
...
<#nested loopvar1, loopvar2, ..., loopvarN>
...
<#return>
...

十五：function, return
<#function nameparam1param2... paramN>
... <#return returnValue>
...

<#function avg x y>
<#return (x + y) / 2>

${avg(10, 20)}

十六：flush
<#flush>

十七：stop
<#stop>
or
<#stop reason>取消处理模版。

十八：ftl指令
<#ftl param1=value1param2=value2...paramN=valueN>
ftl指令必须放在ftl文件的最上面。

参数范围：
encoding：
strip_whitespace
strip_text
strict_syntax

十九：t, lt, rt
二十：attempt, recover
<#attempt>
attempt block<#recover>
recover block

<#attempt>
Optional content: ${thisMayFails}
<#recover>
Ops! The optional content is not available.

xyz 2008-05-13 18:22 发表评论

学习FreeMarker（一）

xyz — Mon, 12 May 2008 15:51:00 GMT

来源：http://www.blogjava.net/pepsixp/archive/2005/03/11/1685.html
FreeMarker是一个用Java编写的模板引擎，主要用来生成HTML Web页面，特别是基于MVC模式的应用程序。虽然FreeMarker具有一些编程的能力，但不像PHP，通常由Java程序准备要显示的数据，由FreeMarker模板生成页面。 FreeMarker可以作为Web应用框架一个组件，但它与容器无关，在非Web应用程序环境也能工作的很好。 FreeMarker适合作为MVC的视图组件，还能在模板中使用JSP标记库。

<html>
<head>
  <title>Welcome!title>
head>
<body>
  <h1>Welcome ${user}!h1>
  <p>Our latest product:
  <a href="${latestProduct.url}">${latestProduct.name}a>!
body>
html>

上面的例子中，在简单的HTML中加入了一些由${…}包围的特定FreeMarker的指令，这个文件就称为模板了。而user、latestProduct.url和latestProduct.name来自于数据模型，由Java程序提供，模板设计者就不用关心数据从哪来的。

FreeMarker模板中可以包括下面四种特定部分：
一.) 文本：直接输出
二.) FTL标记(FreeMarker模板语言标记)：类似于HTML标记，名字前加#(有些以@开始，用户自定义标记)予以区分，不会输出。
字符串－使用单引号或双引号限定；如果包含特殊字符需要转义符：${"It's \"quoted\" andthis is a backslash: \\"}
有一类特殊的字符串:${r"C:\foo\bar"}，输出结构为：C:\foo\bar，在引号前面加r被认为是纯文本。
数字－直接输入，不需要引号。${08}, ${+8}, ${8.00} and ${8} 都是相同的
布尔值－true和false，不使用引号
Sequences(序列)－由逗号分隔的变量列表，由方括号限定，类似java中的一维数组：

<#list ["winter", "spring", "summer", "autumn"] as x>
${x}
#list>

输出结果：
winter
spring
summer
autumn

例二：[2 + 2, [1, 2, 3, 4], "whatnot"]
例三：2..5，等同于[2, 3, 4, 5]；5..2，等同于[5,4,3,2]。注意方括号是不需要的。

Hashes(散列)－由逗号分隔的键-值列表，由大括号限定，键和值之间用冒号分隔：{"name":"green mouse", "price":150}，键和值都是表达式，但是键必须是字符串。

获取变量－${variable}，变量名只能是字母、数字、下划线、$、@和#的组合，且不能以数字开头。下列表达式是等价的：
book.author.name
book["author"].name
book.author.["name"]
book["author"]["name"]

获取Sequence(序列)片断－使用[startindex..endindex]，例如：seq中存储了"a", "b", "c", "d","e"，那么seq[1..2]包含了b和c两个值。

可以使用.variablename语法访问FreeMarker内置变量。

字符串操作
{"Hello ${user}!"} <==> ${"Hello " + user + "!"}
${"${user}${user}${user}${user}"} <==> ${user + user + user + user}

${…}只能在文本中使用，下面是错误的代码：
<#if ${isBig}>Wow!
<#if "${isBig}">Wow! //此处的代码也是错误的，因为if指令需要的是boolean，实际的却是个字符串

子字符串的操作，假设user的值为"Big Joe"：
${user[0]}${user[4]} <==> BJ
${user[1..4]} <==> ig J

Sequences(序列)操作

<#list ["Joe", "Fred"] + ["Julia", "Kate"] as user>
- ${user}
#list>

结果：
- Joe
- Fred
- Julia
- Kate

Hashes(散列)操作

<#assign ages = {"Joe":23, "Fred":25} + {"Joe":30, "Julia":18}>
- Joe is ${ages.Joe}
- Fred is ${ages.Fred}
- Julia is ${ages.Julia}

结果：
- Joe is 30
- Fred is 25
- Julia is 18

算术运算

<#-- x的值设定为5 -->
${x * x - 100}
${x / 2}
${12 % 10}

结果：
-75
2.5
2

注意：操作符两边必须是数字；使用"+"时，如果一边是数字，一边是字符串，就会自动将数字转换为字符串。

使用内建的指令int获得整数部分：

${(x/2)?int}
${1.1?int}
${1.999?int}
${-1.1?int}
${-1.999?int}

结果：
2
1
1
-1
-1

比较操作符－<#if expression>...
1.)使用=（或==，完全相等）测试两个值是否相等，使用!= 测试两个值是否不相等
2.)=和!=两边必须是相同类型的值，否则会产生错误，例如<#if 1 = "1">会引起错误
3.)Freemarker是精确比较，所以"x"、"x "和"X"是不相等的
4.)对数字和日期可以使用<、<=、>和>=，但不能用于字符串
5.)由于Freemarker会将>解释成FTL标记的结束字符，所以对于>和>=可以使用括号来避免这种情况，例如<#if (x > y)>，另一种替代的方法是，使用lt、lte、gt和gte来替代<、<=、>和>=

逻辑操作符－&&(and)、||(or)、!(not)，只能用于布尔值，否则会产生错误
<#if x < 12 && color = "green">
We have less than 12 things, and they are green.

<#if !hot> <#-- here hot must be a boolean -->
It's not hot.

内置函数－用法类似访问hash(散列)的子变量，只是使用"?"替代"."，例如：user?upper_case
下面列出常用的一些函数：
对于字符串
html－对字符串进行HTML编码
cap_first－使字符串第一个字母大写
lower_case－将字符串转换成小写
trim－去掉字符串前后的空白字符
对于Sequences(序列)
size－获得序列中元素的数目
对于数字
int－取得数字的整数部分（如-1.9?int的结果是-1）

例一：

<#-- test的值为Tom & Jerry -->
${test?html}
${test?upper_case?html}

结果：
Tom & Jerry
TOM & JERRY

例二：

<#-- seasons的值为"winter", "spring", "summer", "autumn" -->
${seasons?size}
${seasons[1]?cap_first} <#-- left side can by any expression -->
${"horse"?cap_first}

结果：
4
Spring
Horse

方法的调用
${repeat("What", 3)}
${repeat(repeat("x", 2), 3) + repeat("What", 4)?upper_case}
结果：
WhatWhatWhat
xxxxxxWHATWHATWHATWHAT

操作符优先顺序
后缀            [subvarName] [subStringRange] . (methodParams)
一元            +expr、-expr、!
内建           ?
乘法          *、 / 、%
加法          +、-
关系         <、>、<=、>=（lt、lte、gt、gte）
相等            =、!=
逻辑            &&
逻辑          ||
数字范围      ..

三.) Interpolation：由${...}或#{...}两种类型，输出计算值，可以定义输出的格式
例一：

<#setting number_format="currency"/>
<#assign answer=42/>
${answer}
${answer?string} <#-- the same as ${answer} -->
${answer?string.number}
${answer?string.currency}
${answer?string.percent}

结果：
$42.00
$42.00
42
$42.00
4,200%

例二：

${lastUpdated?string("yyyy-MM-dd HH:mm:ss zzzz")}
${lastUpdated?string("EEE, MMM d, ''yy")}
${lastUpdated?string("EEEE, MMMM dd, yyyy, hh:mm:ss a '('zzz')'")}

结果：
2003-04-08 21:24:44 Pacific Daylight Time
Tue, Apr 8, '03
Tuesday, April 08, 2003, 09:24:44 PM (PDT)

例三：

<#assign foo=true/>
${foo?string("yes", "no")}

结果：
yes

例四：

<#-- x is 2.582 and y is 4 -->
#{x; M2}   <#-- 2.58 -->
#{y; M2}   <#-- 4    -->
#{x; m1}   <#-- 2.6 -->
#{y; m1}   <#-- 4.0 -->
#{x; m1M2} <#-- 2.58 -->
#{y; m1M2} <#-- 4.0  -->

说明：mX－小数部分最小X位；MX－小数部分最大X位。

四.) 注释：<#--和-->

下面是一个常用的模板例子：

<p>We have these animals:
<table border=1>
  ><th>Name<th>Price
  <#list animals as being>
  <tr>
    <td>
      <#if being.size = "large"><b>#if>
      ${being.name}
      <#if being.size="large">b>#if>
    <td>${being.price} Euros
  #list>
table>
<#include "/copyright_footer.html">

注意点：
1.) FreeMarker是区分大小写的；
2.) FTL标记不能位于另一个FTL标记内部，例如：<#if <#include 'foo'>='bar'>...；
3.) ${…}只能在文本中使用；
4.) 多余的空白字符会在模板输出时去除；
5.) 如果使用的指令不存在，会产生一个错误消息。

xyz 2008-05-12 23:51 发表评论

acegi初体验

xyz — Mon, 21 Apr 2008 09:57:00 GMT

来源：http://www.blogjava.net/baputista
还以我传统的例子为例:
毕业设计选题系统,三种角色:教师,学生,管理员,我想让他们的登陆都在一个界面下自动识别,而无需进行身份选择,登陆后,他们将分别到各自的admin.jsp,stu.jsp,teacher.jsp
在数据库中的表结构如下(很多属性略):
id--- user---password--type---about

type是用来存储用户的类别,分别有a,t,s分别对应三种角色
about对应的是acegi里所需要的enable,用户是否可用

在model里,我们采用了继承关系:

父类user:
package subject.model;

public abstract class User extends BaseObject
{
private Integer id;
private String user;
private String password;
private String name;
private String telphone;

//set and get method

public abstract String getType(); //这个是用来反映用户角色的关键函数,在子类实现,从而实现多态
}

子类的实现:
======================
package subject.model;

import subject.Constants;

public class Teacher extends User
{
private String level; //教师的职称

//set and get method

public String getType()
{
return Constants.TEACHER;
}
}
================
package subject.model;

import subject.Constants;

public class Student extends User
{
private static final long serialVersionUID = 1L;

private SchoolClass schoolClass; //学生的班级
private String sn; //学生的学号

//set and get method

public String getType()
{
return Constants.STUDENT;
}
}
=================
package subject.model;

import subject.Constants;

public class Admin extends User
{
private String grade; //管理员的级别
//set and get method

public String getType()
{
return Constants.ADMIN;
}
}

对于三者所共有的属性在数据库里,都存在一个字段,而依据不同的角色拥有不同的含义,学生的班级则存放在了about里,只要学生有班级,他就able,否则就enable了!而管理员和教师则默认为1!

这种是属于一个继承树存放在一个表的情况,Hibernate的配置如下:

        column="about" update="false" insert="false" />

=============================================
上面的这些都是模型的基础,下面再讲怎么样配合Spring和Acegi实现系统的安全与登陆
在Spring中Hibernate的配置只介绍不说明:

    subject/model/User.hbm.xml




    org.hibernate.dialect.MySQLInnoDBDialect

    PROPAGATION_REQUIRED
    PROPAGATION_REQUIRED
    PROPAGATION_REQUIRED,readOnly













==================
上面具体的不用了解,无非就是调用和数据库的操作,
下面就要对Acegi进行声明了:
我不用Ctrl+c和Ctrl+V的方式对Acegi进行介绍,没有意义,随便google就一大堆
我们想主要在这样的系统中需要的安全策略都有哪些?
1.用户的登陆
2.防止多个用户登陆一个帐号
3.用户的注销
4.防止非法用户的访问

我这个程序所涉及到的只有这些,下面就进行说明:

在web.xml的声明:


        securityFilter
        org.acegisecurity.util.FilterToBeanProxy

            targetClass
            org.acegisecurity.util.FilterChainProxy




        securityFilter
        /*


Acegi通过实现了Filter接口的FilterToBeanProxy提供一种特殊的使用Servlet Filter的方式，它委托Spring中的Bean -- FilterChainProxy来完成过滤功能，这样就简化了web.xml的配置，并且利用Spring IOC的优势。FilterChainProxy包含了处理认证过程的filter列表，每个filter都有各自的功能。



    CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
    PATTERN_TYPE_APACHE_ANT

    /**=httpSessionContextIntegrationFilter,logoutFilter,authenticationProcessingFilter,
         securityContextHolderAwareRequestFilter,exceptionTranslationFilter,filterInvocationInterceptor



大体上先介绍一下:
httpSessionContextIntegrationFilter:每次request前 HttpSessionContextIntegrationFilter从Session中获取Authentication对象，在request完后, 又把Authentication对象保存到Session中供下次request使用,此filter必须其他Acegi filter前使用，使之能跨越多个请求。
logoutFilter:用户的注销
authenticationProcessingFilter:处理登陆请求
exceptionTranslationFilter:异常转换过滤器
filterInvocationInterceptor:在访问前进行权限检查

这些就犹如在web.xml声明一系列的过滤器,不过当把他们都声明在spring中就可以享受Spring给我们带来的方便了。

下面就是对这些过滤器的具体声明：
只对有用的地方进行声明，别的地方几乎都是默许的

  class="org.acegisecurity.context.HttpSessionContextIntegrationFilter" />

               离开后所转向的位置





          定义用户注销的地址，

下面的这个过滤器，我们根据自己的需求有了自己的实现：

    下面会介绍的用来起到认证管理的作用
    登陆失败的地址
         登陆成功的地址
        登陆请求的地址
          自己添加的属性，这样就可以访问到我们的业务逻辑
     出现异常所对应的地址

                org.acegisecurity.AuthenticationException=/login.htm?error=fail     登陆失败                org.acegisecurity.concurrent.ConcurrentLoginException=/login.htm?error=too        已登陆了

    //如果用户没登陆就想访问，先到这里登陆吧




         认证服务






                             //这里定义数据库中存放的角色和我们在这里声明的角色间是否需要加个前缀？我没加







                PATTERN_TYPE_APACHE_ANT

                /admin.htm*=a         这里就是数据库中对应的tyep a
                /student*=s           由于没有前缀和数据库里一样
                /teacher*=t



          class="org.acegisecurity.event.authentication.LoggerListener"/>       记录事件

下面就要说明我们的认证服务了，其起到的关键作用就是用来保证用户登陆身份的验证：

它将验证的功能委托给多个Provider，并通过遍历Providers, 以保证获取不同来源的身份认证，若某个Provider能成功确认当前用户的身份，authenticate()方法会返回一个完整的包含用户授权信息的Authentication对象，否则会抛出一个AuthenticationException。

先声明一个管理器吧，在上面的过滤器中都已经用到过了



       我仅仅用到从数据库中读取用户信息验证身份



        class="org.acegisecurity.concurrent.ConcurrentSessionControllerImpl">

     1每个用户同时登陆一位








来实现唯一的一个Provider，从数据库验证身份


                class="org.acegisecurity.userdetails.jdbc.JdbcDaoImpl">



                  select user,password,about from user where user = ?        查找用户的查询语句，只需要把你数据库中的用户和密码以及enable相对应上就行




                  select user,type from user where user = ?           这里就是把用户和权限对应上，在appfuse中用的两个表，我都放一个表里了，所以就用这一个就行问题的关键是要让它能找到两个字段，构成一个对象




   缓存都这么写：












==============
对于上面登陆请求的处理器我借鉴了springSide，实现的方法如下：
package subject.web.filter;

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

import org.acegisecurity.Authentication;
import org.acegisecurity.context.SecurityContext;
import org.acegisecurity.context.SecurityContextHolder;
import org.acegisecurity.ui.webapp.AuthenticationProcessingFilter;
import org.acegisecurity.userdetails.UserDetails;

import subject.Constants;
import subject.model.User;
import subject.service.UserManager;

public class UserAuthenticationProcessingFilter extends
AuthenticationProcessingFilter
{
private UserManager userManager;

public void setUserManager( UserManager userManager )
{
this.userManager = userManager;
}

protected boolean requiresAuthentication( HttpServletRequest request ,
   HttpServletResponse response )
{
  boolean requiresAuth = super.requiresAuthentication( request, response );
  HttpSession httpSession = null;
  try
  {
   httpSession = request.getSession( false );
  }
  catch ( IllegalStateException ignored )
  {
  }
  if ( httpSession != null )
  {
   if ( httpSession.getAttribute( Constants.USER ) == null )
   {
    if ( !requiresAuth )
    {
     SecurityContext sc = SecurityContextHolder.getContext();
     Authentication auth = sc.getAuthentication();
     if ( auth != null
       && auth.getPrincipal() instanceof UserDetails )
     {
      UserDetails ud = (UserDetails) auth.getPrincipal();//上面声明的sql无非就是要包装成这个对象
      User user = userManager.getUser( ud.getUsername() );从业务逻辑里找到用户，放到session里
      httpSession.setAttribute( Constants.USER, user );
     }
    }
   }
  }
  return requiresAuth;
}
}

在看看我的login.htm在登陆成功时是怎么工作的吧？
public class UserAction extends BaseAction
{
private UserManager mgr;

public void setUserManager( UserManager mgr )
{
this.mgr = mgr;
}

public ActionForward login( ActionMapping mapping , ActionForm form ,
   HttpServletRequest request , HttpServletResponse response )
   throws Exception
{
  User user = (User) getSessionObject( request, Constants.USER );
  ActionMessages msg = new ActionMessages();
  if ( user != null )
  {
   return new ActionForward( user.getType() + ".htm", true );成功就去type.htm
  }
  else
  {
   String error = getParameter( request, Constants.ERROR );
   if ( error != null )对于不同的错误，都加以提示
   {
    if ( error.equalsIgnoreCase( "wrong" ) )
     msg.add( "msg", new ActionMessage( "fail.login.wrong" ) );
    else if ( error.equalsIgnoreCase( "too" ) )
     msg.add( "msg", new ActionMessage( "fail.login.too" ) );
    else if ( error.equalsIgnoreCase( "fail" ) )
     msg.add( "msg", new ActionMessage( "fail.login.fail" ) );
    else
     msg.add( "msg", new ActionMessage( "fail.login.please" ) );
   }
   else
    msg.add( "msg", new ActionMessage( "fail.login.please" ) );
  }
  saveErrors( request, msg );
  return mapping.findForward( "fail" );
}

}

当然，Acegi需要介绍的东西太多了，我只把我这次认为有必要解释的东西写在了上面让大家来参考，作为能google到的东西，比如对于认证的方式还有很多，我就没有详细的介绍，在学习Acegi过程中，把它自带的例子弄清楚很关键，希望大家一起学习一起共勉！

xyz 2008-04-21 17:57 发表评论

JSTL详解--EL表达式

xyz — Mon, 14 Apr 2008 16:15:00 GMT

    在 JSP 页面中，使用标签库代替传统的 Java 片段语言来实现页面的显示逻辑已经不是新技术了，然而，由自定义标签很容易造成重复定义和非标准的实现。鉴于此，出现了 JSTL （ JSP Standard Tag Library ）。大多数 JSP 页面逻辑提供了实现的 JSTL 技术，该技术本身就是一个标签库。
Sun 公司 Java 规范标准的 JSTL 由 apache jakarta 组织负责维护。作为开源的标准技术，它一直在不断地完善。 JSTL 的发布包有两个版本： Standard-1.0 Taglib 、 Standard-1.1 Taglib ，它们在使用时是不同的。
q         Standard-1.0 Taglib （ JSTL1.0 ）支持 Servlet2.3 和 JSP1.2 规范， Web 应用服务器 Tomcat4 支持这些规范，而它的发布也在 Tomcat 4.1.24 测试通过了。
q         Standard-1.1 Taglib （ JSTL1.1 ）支持 Servlet2.4 和 JSP2.0 规范， Web 应用服务器 Tomcat5 支持这些规范，它的发布在 Tomcat 5.0.3 测试通过了。
在本章的介绍中，将以由 Sun 发布的 Standard-1.1 Taglib 标签库为主，而 apache jakarta 组织发布的开源标签库，可以从 http://jakarta.apache.org/taglibs/ 找到所需要的帮助。 Sun 发布的标准 JSTL1.1 标签库有以下几个标签：
q         核心标签库：包含 Web 应用的常见工作，比如：循环、表达式赋值、基本输入输出等。
q         国际化标签库：用来格式化显示数据的工作，比如：对不同区域的日期格式化等。
q         数据库标签库：可以做访问数据库的工作。
q         XML 标签库：用来访问 XML 文件的工作，这是 JSTL 标签库的一个特点。
q         函数标签库：用来读取已经定义的某个函数。
此外， JSTL 还提供了 EL 表达式语言（ Expression Language ）来进行辅助的工作。

JSTL 标签库由标签库和 EL 表达式语言两个部分组成。 EL 在 JSTL 1.0 规范中被引入，当时用来作为 Java 表达式来工作，而该表达式必须配合 JSTL 的标签库才能得到需要的结果。
说明：在 JSTL 1.1 规范中， JSP2.0 容器已经能够独立的理解任何 EL 表达式。 EL 可以独立出现在 JSP 页面的任何角落。本文随后的内容将以 JSTL 1.1 规范作为介绍的重点。
一 JSTL EL表达式语言简介
EL 是从 JavaScript 脚本语言得到启发的一种表达式语言，它借鉴了 JavaScript 多类型转换无关性的特点。在使用 EL 从 scope 中得到参数时可以自动转换类型，因此对于类型的限制更加宽松。 Web 服务器对于 request 请求参数通常会以 String 类型来发送，在得到时使用的 Java 语言脚本就应该是 request.getParameter(“XXX”) ，这样的话，对于实际应用还必须进行强制类型转换。而 EL 就将用户从这种类型转换的繁琐工作脱离出来，允许用户直接使用 EL 表达式取得的值，而不用关心它是什么类型。
下面的示例就是一个 EL 表达式，见例 1 。
例 1 ：简单 EL 表达式
<%@ page contentType="text/html; charset=UTF-8"%>

    ${sampleValue + 1}

这个示例将在 JSP 页面显示为“ 1 ”， EL 表达式必须以“ ${XXX} ”来表示，其中“ XXX ”部分就是具体表达式内容，“ ${} ”将这个表达式内容包含在其中作为 EL 表达式的定义。本示例可以在满足 JSP2.0 规范的任何 Web 应用服务器中使用。
二 EL表达式的默认变量
一个 EL 表达式包含变量和操作符两个内容。任何存在于 JSP 作用范围的 JavaBean 都可以被转化成 EL 表达式来使用，它所包含的默认变量如下：
1 ．默认变量 pageScope 、 requestScope 、 sessionScope 、 applicationScope
这 4 个默认变量包含 Scope 作用范围的参数集合，相当于被保存在 java.util.Map 中的某个参数。下面看简单的示例 2 ：
例 2 ：使用 sessionScope 变量的 EL 表达式
<%request.getSession().setAttribute("sampleValue", new Integer(10));%>
${sessionScope.sampleValue}
取得保存在 Session 中参数的 sessionScope 变量的 EL 表达式，“ . ”是 property 访问操作符，在这里表示从 Session 中取得“键”为“ sampleValue ”的参数，并显示出来。显示结果为“ 10 ”。
2 ．默认变量 param 、 paramValues
这两个默认变量包含请求参数的集合， param 表明请求包含的参数为单一控件， paramValues 表明请求包含的参数为控件数组。下面看一个简单示例 3 ：
例 3 ：提交请求的页面和接受的页面
<%@ page contentType="text/html; charset=UTF-8"%>



在这个页面中定义了两组控件，控件名为“ sampleValue ”的是一套控件数组，控件名为“ sampleSingleValue ”的是单一控件，通过递交将请求参数传送到 SampleJsp.jsp 。
<%@ page contentType="text/html; charset=UTF-8"%>

    ${paramValues.sampleValue[2]}

    ${param.sampleSingleValue}

这是请求转发到的页面，通过 EL 表达式的 paramValues 变量得到控件数组中最后一个控件的递交参数，通过 EL 表达式的 param 变量得到单一控件的递交参数。控件数组参数的 EL 表达式使用“ [] ”来指定数组下标。本示例将显示控件数组中最后一个控件的值“ 12 ”和单一控件的值“ SingleValue ”。
3 ．默认变量 header 、 headerValues
这两个默认变量包含请求参数头部信息的集合， header 变量表示单一头部信息， headerValues 则表示数组型的头部信息。
4 ．默认变量 cookie
包含所有请求的 cookie 集合，集合中的每个对象对应 javax.servlet.http.Cookie 。
5 ．默认变量 initParam
包含所有应用程序初始化参数的集合。
6 ．默认变量 pageContext
等价于 page 环境类 javax.servlet.jsp.PageContext 的实例，用来提供访问不同的请求参数。
11 个默认变量几乎包含了 Web 应用的所有基本操作，若一个表达式不使用这些变量而直接使用参数名，那么就采用就近原则。该表达式将使用最近取得的参数值。
三.EL表达式的操作符
EL 表达式中还有许多操作符可以帮助完成各种所需的操作，之前的示例中“ . ”、“ [] ”就是其中的两个，下面将用表 9.1 来展示所有操作符及它们各自的功能。
表 9.1 EL 表达式的操作符

操作符

功能和作用
.

访问一个 bean 属性或者 Map entry
[]

访问一个数组或者链表元素
()

对子表达式分组，用来改变赋值顺序
? :

条件语句，比如：条件 ?ifTrue:ifFalse
如果条件为真，表达式值为前者，反之为后者
+

数学运算符，加操作
-

数学运算符，减操作或者对一个值取反
*

数学运算符，乘操作
/ 或 div

数学运算符，除操作
% 或 mod

数学运算符，模操作 ( 取余 )
== 或 eq

逻辑运算符，判断符号左右两端是否相等，如果相等返回 true ，否则返回 false
!= 或 ne

逻辑运算符，判断符号左右两端是否不相等，如果不相等返回 true ，否则返回 false
< 或 lt

逻辑运算符，判断符号左边是否小于右边，如果小于返回 true ，否则返回 false
> 或 gt

逻辑运算符，判断符号左边是否大于右边，如果大于返回 true ，否则返回 false
<= 或 le

逻辑运算符，判断符号左边是否小于或者等于右边，如果小于或者等于返回 true ，否则返回 false
>= 或 ge

逻辑运算符，判断符号左边是否大于或者等于右边，如果大于或者等于返回 true ，否则返回 false
&& 或 and

逻辑运算符，与操作赋。如果左右两边同为 true 返回 true ，否则返回 false
|| 或 or

逻辑运算符，或操作赋。如果左右两边有任何一边为 true 返回 true ，否则返回 false
! 或 not

逻辑运算符，非操作赋。如果对 true 取运算返回 false ，否则返回 true
empty

用来对一个空变量值进行判断 : null 、一个空 String 、空数组、空 Map 、没有条目的 Collection 集合
func(args)

调用方法 , func 是方法名， args 是参数，可以没有，或者有一个、多个参数 . 参数间用逗号隔开
这些操作符都是极其有用的，下面通过几个示例来演示它们的使用方法：
例 4 ：几组操作符的示例
${pageScope.sampleValue + 12}
           // 显示 12
${(pageScope.sampleValue + 12)/3}
     // 显示 4.0
${(pageScope.sampleValue + 12) /3==4}
         // 显示 true
${(pageScope.sampleValue + 12) /3>=5}
         // 显示 false
// 显示值为 10 的 Text 控件
可以看到，对于这些示例，程序设计者完全无需管理它们的类型转换，在表达式内部都已经处理了。有了 EL 表达式，在 JSP 页面的编程变得更灵活，也更容易。

xyz 2008-04-15 00:15 发表评论

jstl之foreach循环

xyz — Sat, 29 Mar 2008 13:18:00 GMT

<%@ page contentType="text/html; charset=GBK" %>
<%@ page import="java.util.*" %>

<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %>
<html>
  <head>
    <title>JSTL测试1--c:forEach循环title>
  head>

  <body>
一、整数
    <c:forEach var="i" begin="1" end="10" step="1">
      <c:out value="" />,
    c:forEach><p>

二、计算x的平方
   <table>
   <tr><th>Valueth>
    <th>Squareth>tr>
    <c:forEach var="x" begin="0" end="10" step="2">
    <tr><td><c:out value=""/>td>
        <td><c:out value="0"/>td>tr>
   c:forEach>
  table> <p>
三、字符串"47,52,53,55,46,22,16,2" 分隔.
   <table border="1">
   <c:forTokens items="47,52,53,55,46,22,16,2" delims="," var="dailyPrice">
    <tr><td><c:out value=""/>td>tr>
   c:forTokens>
   table><p>
四、使用步长
   <table>
    <tr><th>secondth>
    <th>secondth>tr>
    <c:forEach var="seconds" begin="0" end="1800" step="60">
    <tr><td><c:out value=""/>td>
        <td><c:out value=""/>td>tr>
   c:forEach>
  table> <p>
五、对数组进行循环<p>
  <% int ai[] = {10, 20, 30, 40, 50};
  pageContext.setAttribute("ary", ai);
  %>
  <c:forEach var="i" items="">
    <c:out value=""/>*
  c:forEach><p>

<%
   Cookie c=new Cookie("cookie1","one");
   response.addCookie(c);
%>

<%
  Cookie cookies[]=request.getCookies();
  Cookie sCookie=null;
  String sname=null;
  String name=null;
  if(cookies==null) // 如果没有任何cookie
    out.print("none any cookie");
  else
  {
    //out.print(cookies.length + "
");
    for(int i=0;i<cookies.length; i++) // 循环列出所有可用的Cookie
    {
     sCookie=cookies[i];
      sname=sCookie.getName();
      name = sCookie.getValue();
      out.println(sname + "->" + name + "
");
    }
  }
%>

<table border="1" align="center">
   <tr><th>Cookie Nameth>
    <th>Cookie Valueth>tr>
    <c:forEach var="cook" items="">
    <tr><td><c:out value=""/>td>
        <td><c:out value=""/>td>tr>
   c:forEach>
  table> <p>

六、字符串数组循环
<% String as[] = {
            "A first string", "La deuxieme string", "Ella troisiemo stringo"
        };
        request.setAttribute("stringArray", as);
%><p>
<c:forEach var="string" items="">
  <c:out value=""/><br>
c:forEach>
七、枚举
<%
Hashtable hashtable1 = new Hashtable();
           pageContext.setAttribute("numberMap", hashtable1);

        hashtable1.put(new Integer(1), "uno");
        hashtable1.put(new Integer(2), "dos");
        hashtable1.put(new Integer(3), "tres");
        hashtable1.put(new Integer(4), "cuatro");
        hashtable1.put(new Integer(5), "cinco");
        hashtable1.put(new Integer(6), "seis");
        hashtable1.put(new Integer(7), "siete");
        hashtable1.put(new Integer(8), "ocho");
        hashtable1.put(new Integer(9), "nueve");
        hashtable1.put(new Integer(10), "diez");

        java.util.Enumeration enumeration = hashtable1.keys();
        pageContext.setAttribute("enumeration", enumeration);
%>

   <c:forEach var="item" items="" begin="2" end="10" step="2">
     <c:out value=""/><br>
   c:forEach><p>
八、map<p>
   <c:forEach var="prop" items="" begin="1" end="5">
     <c:out value=""/> = <c:out value=""/><br>
   c:forEach>



body>
html>

xyz 2008-03-29 21:18 发表评论

JSP页面EL表达式无效的问题

xyz — Mon, 17 Mar 2008 09:14:00 GMT

来源：http://gimgen1026.javaeye.com/category/

关键字: el, web.xml

以前用WSAD wizard做的，都可以在JSP页面中解析到EL表达式，当然前提是JSP2.0的情况下。
今天遇到了一个莫名其妙的问题。刚下载Eclipse3.3+MyEclipse6.0体验的过程中，遇上了解析不到EL表达式的问题。经过好几个小时的琢磨终于发现了，给大家share一下：
问题就出在建Web Project的时候web.xml声明上。
web.xml声明部分一般分为如下版本的xsd,
web-app_2_2.xsd
web-app_2_3.xsd
web-app_2_4.xsd
web-app_2_5.xsd

更详细的列出各版本web.xml声明部分吧，如下：
web-app_2_2.xsd

web-app_2_3.xsd

web-app_2_4.xsd

web-app_2_5.xsd

确定web.xml里的xsd版本之后一定要在JSP的声明(<%@page %>)部分加一行，如下：
<%@ page isELIgnored="false" %>
这样设为false才能解析EL表达式。
经过各版本的test之后....
注意!! 其中servlets 2.4(我没记错的话JSP 2.0出来之后的第一个版本)，这个版本的isELIgnored默认设置为false。所以使用web.xml里用web-app_2_4.xsd声明的时候在JSP页面不用特意声明。

下面是官方Documention中isELIgnored Attribute的详解：
The isELIgnored Attribute
• Format
– <%@ page isELIgnored="false" %>
– <%@ page isELIgnored="true" %>
Purpose
– To control whether the JSP 2.0 Expression Language
(EL) is ignored (true) or evaluated normally (false).
• Notes
– If your web.xml specifies servlets 2.3 (corresponding to
JSP 1.2) or earlier, the default is true
• But it is still legal to change the default—you are permitted
to use this attribute in a JSP-2.0-compliant server
regardless of the web.xml version.
– If your web.xml specifies servlets 2.4 (corresponding to
JSP 2.0) or earlier, the default is false

xyz 2008-03-17 17:14 发表评论

Hibernate级联保存和更新

xyz — Sat, 15 Mar 2008 15:56:00 GMT

来源：http://www.tianxiaboke.com/u/lyeerwy

级联保存和更新
当Hibernate持久化一个临时对象时，在默认情下，他不会自动持久化所关联的其他临时对象，如果希望当持久化对象时把他所关联的所有临时对象进行持久化的话：可以把的cascade属性设置为"save-update" ,cascade的默认属性值为none。
cascade:设置操作对象时的级联操作，即层级之间的连锁操作
值 save-update ：表示当保存和更新当前对象(即insert和update语句时)，会级联保存和更新与他关联的对象
值 all ：表示任何情况下都会进行级联操作，即对一个对象进行操作，也会对和他关联的其他对象进行同样的操作
值 delete ：表示在执行delete时，进行级联操作，删除和他关联的对象
值 none ：表示任何情况下，都不会进行级联操作
元素的inverse属性

在运行上面的程序时，如果hibernate的"show-sql"设置为true时，就会看到Hibernate会生成很多sql语句，其实很多sql语句都是重复的
eg：
insert into  test.order(o_name,c_id)values(?,?)
insert into  test.order(o_name,c_id)values(?,?)
insert into  test order   set c_id=? where id=?
insert into  test order   set c_id=? where id=?

为了解决这个问题，我们可以利用在标签中加上inverse属性。术语：inverse是指反转的意思，在Hibernate中，表示关联关系中的方向关联关系中，inverse="false"的主控方，由主动方负责维护对象关系我们在customer对象的对象配置文件中加上

声明在Customer和Order的双向关联关系中，Customer端的关联只是Order端关联的镜象（即Order端是主空端，负责维护Customer和order对象之间的关联关系），当hibernate探测到持久化对象Customer或Order的状态发生变化时(主要是关联关系的改变),仅按照Order对象的状态的变化来同步更新数据库。
按次配置，如果在程序中，我们仅仅使用Customer.getOrder().add(order)（涉及了和Order的关联关系的改变），是不能让数据库跟对象的变化来进行数据库同步更新的，只有利用Order对象的方法改变的Order对象状态(eg：order.setCustomer(customer)----涉及到了和Customer的关联关系的改变)时，数据库才会根据变化来同步更新数据库，即只有主控方的状态（涉及到了和另一方面的关联关系的改变）发生了变化后，才会触发对象和数据库的同步更新。

映射一对多双向关联关系
当类与类之间建立了关联，就可以方便的从一个对象导航到另一个对象或一组与他关联的对象当中，根据上面的程序，对于一个给定的Order对象，如果想获取与他关联的Customer对象，我们只需要调用入下方法：
Customer c=order.geCustomer(); 那么当我们得到一个Customer对象后，想查出和这个Customer对象关联的所有Order对象时，应该怎么办呢？由于在Customer中没有建立对Order对象的关联，所以，不能通过加载Customer对象来自动加载和他关联的所有Order对象，唯一的方法只能通过JDBC或SQL语言人工写出代码来查询数据库Order表来返回所需要的信息
上面的问题虽然解决，但不能算是最好，因为这样性能会有所下降，对象位于内存中，在内存中从一个对象导航到另一个对象显然比到数据库中查询数据要快得多

具体实现

1：由于Customer和Order是一对多，即一个Customer要对应多个Order，所以在Customer中应该建立一个Set对象，用于存放和本Customer对象关联的所有Order对象。
2：在customer.hbm.xml通过建立对Order表的关联关系
注意：应该放置在标签中
我们先来看看Customer类的设计和customer.hbm.xml文件的内容

------------------------------------------------------
Customer Order 双向一对多
1：Customer类中建立一个容器对象，包含关联的所有Order对象
2：Order类中建立一个Customer对象，关联Customer
inverse="true"表示将维护关联的权利交给引起Hibernate语句的生成

customer.getOrders().add(order);
customer.setName("dddddd");

inverse="true"（设置此属性的一方----是被控方）
当主控方修改对象之间的关联关系时，让Hibernate生成sql语句

xyz 2008-03-15 23:56 发表评论

优化程序之前，可用Jamon来监测你的Spring应用

xyz — Fri, 14 Mar 2008 06:40:00 GMT

**
*作者：张荣华(ahuaxuan)
*2007-8-15
*转载请注明出处及作者
*/

前两天在看Spring内置的拦截器的时候，发现了一个之前没有注意的类：org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor，好奇心促使我上网查了一下这个jamon。大概看了一下之后发现这个玩意还真挺好用的而且挺重要的，而且现在国内对它的介绍也很少，所以写了一篇文章和大家分享。

一，Jamon简介：
Jamon的全名是：Java Application Monitor。它是一个小巧的，免费的，高性能的，线程安全的性能监测工具。它可以用来测定系统的性能瓶颈，也可以用来监视用户和应用程序之间的交互情况。 Jamon主要是用来检测jee的应用程序。它最新的版本是2.1，可以用在1.4以上的jdk上。

二，将jamon导入到你的应用程序中去
首先下载jamon的开发包，见我的附件，同时你也可以去Sourceforge上自己下载。Sourceforge的下载地址为http://jamonapi.sourceforge.net。解压之后可以得到一个jar包和一个war包。jar包是自己会用到的，而war包是一个例子（不要小看这个例子，待会也要把它导入到项目中）。把war包之间丢到服务器上，访问：localhost:8080/jamon就可以看到这个例子了，这个例子是一个简单的性能监控系统。

接着把例子中的所有的包都导入到项目中，并把war包中的jsp和images还有css都考到项目中，比如新建一个目录叫monitor（它和WEB-INF是同级目录）。

三，正确配置自己的应用
我们在性能监测的时候最监测的就是页面的访问率和类中方法的访问率。所以在这一部分主要讲解一下如何监测自己的页面和类中方法的访问。

1，检测自己的页面访问率
首先我们需要在web.xml中添加一个filter，这个filter就是用来判断哪些页面需要被监视的，如下所示：

Java代码

JAMonFilter
class>com.easywebwork.filter.EasyPageMonFilterclass>
JAMonFilter
/*


JAMonFilter
com.easywebwork.filter.EasyPageMonFilter


JAMonFilter
/*

接下来我们看看这个filter的写法：

Java代码

/**
* @author 张荣华（ahuaxuan）
*
* @since 2007-8-13
*/
public class PageMonFilter extends JAMonFilter{
private static final long serialVersionUID = 5746197114960908454L;
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
Monitor allPages = MonitorFactory.start(new MonKeyImp("org.easywebwork.allPages",getURI(request),"ms."));
//这里就是我们要监视的所有的页面的配置
Monitor monitor = MonitorFactory.start(getURI(request));
//这里就是我们要监视的某个页面的配置
try {
filterChain.doFilter(request, response);
} finally {
monitor.stop();
allPages.stop();
}
}
protected String getURI(ServletRequest request) {
if (request instanceof HttpServletRequest) {
return ((HttpServletRequest) request).getRequestURI();
} else {
return "Not an HttpServletRequest";
}
}
private FilterConfig filterConfig = null;
}}

/**
* @author 张荣华（ahuaxuan）
*
* @since 2007-8-13
*/
public class PageMonFilter extends JAMonFilter{
private static final long serialVersionUID = 5746197114960908454L;
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
Monitor allPages = MonitorFactory.start(new MonKeyImp("org.easywebwork.allPages",getURI(request),"ms."));
//这里就是我们要监视的所有的页面的配置
Monitor monitor = MonitorFactory.start(getURI(request));
//这里就是我们要监视的某个页面的配置
try {
filterChain.doFilter(request, response);
} finally {
monitor.stop();
allPages.stop();
}
}
protected String getURI(ServletRequest request) {
if (request instanceof HttpServletRequest) {
return ((HttpServletRequest) request).getRequestURI();
} 	else {
return "Not an HttpServletRequest";
}
}
private FilterConfig filterConfig = null;
}}

这个类看上去很简单，其实也挺简单的，就是得到uri，然后把它注册到MonitorFactory类中。这样只要我们去访问刚才创建的monitor目录下的jsp就可以看到性能监测页面了。

2，，接下来我们看看在使用spring的情况下如何监测一个bean的方法调用。Spring也提供了对Jamon的支持(spring支持的东西还真多啊)，也就是文章开头提出的那个拦截器，为了给我们的bean加上拦截器，我们在spring的applicationcontext配置文件中加入如下语句：

Java代码

class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
"beanNames">
userService
"interceptorNames">
jamonInterceptor
"jamonInterceptor" class="org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor">




userService




jamonInterceptor



jamonInterceptor" class="org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor">

上面这个是典型的spring的aop的配置，如果对spring的aop配置不了解的可以去看一下spring中文文档，当然如果不想了解的话即使直接把这段配置拷到自己的项目中也是可以直接使用的。

还有一个步骤就是在你的log4j.properties中加入这句代码：

Java代码

log4j.logger.org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor = TRACE

log4j.logger.org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor = TRACE

如果没有这一行，那么这个拦截器是不会把方法调用的信息向MonitorFactory注册的。

只需要这些步骤，userservice中的方法在调用的时候就可以被拦截，然后将其注册到MonitorFactory中去了。

所有的配置完成之后我们来看一下效果吧:
http://www.javaeye.com/topics/download/b2bac96e-6c18-4340-b7e0-f84c7bb6adca从这个图上我们可以看到，所有页面被访问的次数，UserService中的getAllUsers被调用的次数，最右边的是访问时间。这只是整个图的一部分，当然这个页面中也包括每一个页面被访问的次数和第一次访问的时间等等。下载附件运行，就可以看到所有的页面了。

三，总结
根据以上的步骤，我们就可以监测我们的程序了，应用程序中哪些页面被访问的多，哪些页面被访问的少，哪些方法被访问的多，哪些方法被访问的少，以及访问高峰期集中在什么时间等等，有了这些参数，我们更可以有针对性的对应用程序进行优化了，比如说某个页面访问比较频繁，我就可以用ehcache或oscache给这个页面做一个缓存。如果某个方法的访问比较频繁那就看看这个方法能否进一步优化，是需要异步，还是需要缓存，还是需要其他等等，总之有了jamon可以给我们带来更多的便捷，既可以让我们知道我们的客户的行为，也可以让我们知道我们开发的程序的“能力”。

其实本文提供的只是对页面和方法调用的监控，但是jamon可以提供更多功能，比如说sql语句的监控等等，这就需要我们共同去发掘了。

附件中包括了一个easywebwork的例子，我把jamon导入到这个例子工程中去，大家可以直接下载运行观看效果。Easywebwork是一个旨在减少webwork2.2.x系列的xml配置文件的项目，
如果对这个主题感兴趣请到
http://www.javaeye.com/topic/91614
http://www.javaeye.com/topic/93814
参加讨论。

xyz 2008-03-14 14:40 发表评论

由DWR1.0到DWR2.0常出现的问题

xyz — Tue, 04 Mar 2008 16:22:00 GMT

在1.0的时候是好使的换成2.0的时候就出现 Missing method or missing parameter converters 这个错误了

2007-11-29 17:44:14 org.directwebremoting.util.CommonsLoggingOutput warn
警告: Marshalling exception: Missing method or missing parameter converters:

主要原因就是DWR2中更新了的内容，原文如下：

The callback-as-first-parameter system has been deprecated since version 0.9 in favor of the callback-as-last-parameter system. In version 2.0 we removed support for the first-parameter option because it caused some hard to detect bugs with null parameters. From version 2.0 the callback must be the last parameter, and can not be the first parameter.

就是说以前版本callback参数是放在参数列表第一个参数，而在0.9版本中callback参数改为参数列表最后一个参数。到2.0版本取消了对callback参数前置的支持。

xyz 2008-03-05 00:22 发表评论

DWR总结

xyz — Tue, 04 Mar 2008 14:29:00 GMT

这两天学了下DWR，现在总结一下。
DWR是方便使用AJAX连接JS和JAVA的的一个框架,把服务器端 Java 对象的方法公开给 JavaScript 代码。
如果是用dwr2.0的jar包，还需要同时导入log4j.jar和commons-loggin.jar,勿忘!!
web.xml和dwr.xml放在WEB-INF下!
-----------------------------
配置web.xml:WEB工程启动的时候会在这个里面找到具体所用到的类的路径，由此进行加载

dwr-invoke

uk.ltd.getahead.dwr.DWRServlet

//这个是调试用，如果正式发布请该为false，不过听说2.0就默认为true了

debug

true

//这个是DWR2.0必须的,不然会报java.lang.IllegalArgumentException

classes

java.lang.Object

dwr-invoke

/dwr/*

-----------------------------
配置dwr.xml: dwr.xml的作用是让你告诉DWR哪些class中的哪些方法你需要暴露给前台使用，当DWR启动时候根据dwr.xml这个文件把java类中的方法转成js中可用的类中方法，使前台可以使用。

注:以下是不全按dwr2.0写的，如果用的是DWR2.0，那java里暴露类(蓝字显示)不能写在属性里，应删除后写在前，。


       class="***java里暴露的class,必须写完整路径***">




-----------------------------
在html或js页面中加入
//切记不能 //Dwr的脚本驱动Js,以上两个必写
   //这是个工具包，可以不调用

其实我们调用AAA.bbb([参数],callBack);就是做了以下这一步：
(下面红字是包装好的，不在前台，所以即使你没有创建html或者jsp来调用，也可以通过localhost:8080/工程名/dwr 来看到你暴露的java类进行测试)
    function AAA() { };
    AAA.bbb = function([参数], callback)
    {
        DWREngine._execute('/dwr/dwr', 'AAA', 'bbb', [参数], callback);
    }

通过在dwr.xml暴露的方法得到js里的方法，当我们调用AAA.bbb时候再通过/dwr/dwr转到DWRServlet中去用JAVA里的AAA.bbb方法，然后返回值到callback中(中间经过dwr.xml的convert)

----------------------------
上面对dwr的工作大致分析了下，现在对于参数类型的不同，对dwr.xml也要进行修正。

DWR自动地在Java和JavaScript表示之间调整简单数据类型,这些类型包括Java原生类型和它们各自的封装类表示，还有String、Date、数组和集合类型。但如果参数类型非简单数据类型，则要通过转换。

调用返回JavaBean的java方法

在dwr.xml的标签中加入

//int,String,list等不需要显式的转换就可以被js拿到
//这句可以不写

标签负责公开用于Web远程的类和类的方法，标签则负责这些方法的参数和返回类型。convert元素的作用是告诉DWR在服务器端Java 对象表示和序列化的JavaScript之间如何转换数据类型。

这样在js端回调函数直接拿到的data就是一个javabean,可以直接通过data.xxx拿到bean的属性xxx。

调用有JavaBean参数的java方法

dwr.xml配置同上。

在JS端，把要传入的参数写成javabean方式，例：要传入一个名为student的javabean,参数有name,password,则
var stu = {name:"zhangsan",password:"zspassword"}; //这是json的表示方法
AAA.bbb(stu,callBack);

调用返回List、Set或者Map的java方法

dwr.xml配置同上。如果Collection里的数据是简单数据类型，则可不需要写

在JS端，以List，里面数据是bean为例，data是一个List型，只要用for循环就可以依次拿到数据。
遍历方法1:
for(var i=0;i     /*对于java方法的返回值为List(Set)的情况，DWR将其转                                 化为Object数组，传递个javascript*/
{
    alert(data[i].name+":"+data[i].password);
}

遍历方法2:
for(var property in data) //property为序号,从0开始
{
var bean = data[property];
alert(bean.name+":"+bean.password);
}

相比返回为javabean多了一个遍历而已。

如果java方法的返回值为Map,则如下

for(var property in data) //property为key值
    /*对于 java方法的返回值为Map的情况，DWR将其转化为一个Object，
     其中Object的属性为原Map的key值，属性值为原Map相应的 value值*/
{
var bean = data[property];
alert(bean.username);
alert(bean.password);
}

如果知道key值，则可直接用:data.key拿到value

调用有List、Set或者Map参数的java方法

在dwr.xml的标签内加入:标签。

标签是用来声明java方法中List、Set或者Map参数所包含的确切类，以便java代码作出判断，是js-->java的。

例参数是javabean的List,则只要在参数为javabean的例子里构造时候加上[]即可，如下：

var stu = [{name:"zhangsan",password:"zspassword"},{name:"lisi",password:"lspassword"}];
//把List当作数组来处理
AAA.bbb(stu,callBack);

并且在dwr.xml中增加如下的配置段(刚才试验了下，不加也可以)

import java.util.List;
import com.dwr.AAA; //AAA的包路径要写完整
import com.dwr.TestBean; //javabean
AAA.bbb(List);
]]>

例参数是javabean的Map,key是String,value是javabean,如下:
var stu =

{
"key1":{name:"zhangsan",password:"zspassword"},
"key2":{name:"lisi",password:"lspassword"}
};

AAA.bbb(stu,callBack);

并且在dwr.xml中增加如下的配置段(刚才试验了下，不加也可以)

import java.util.List;
import com.dwr.AAA; //AAA的包路径要写完整
import com.dwr.TestBean; //javabean
AAA.bbb(Map);
]]>

xyz 2008-03-04 22:29 发表评论

struts+spring+hibernate+DWR

xyz — Tue, 04 Mar 2008 14:13:00 GMT

做了一个DWR的验证和eXtremeTable的应用的例子

前期的系统创建、struts、hibernate、spring的集成工作就不用说了，一路下来…………

主要看DWR的应用，它用于表单验证：

1、先看它的配置：

（1）在web.xml里加上：

xml 代码

<servlet>
<servlet-name>dwr-invokerservlet-name>
<servlet-class>uk.ltd.getahead.dwr.DWRServletservlet-class>
<init-param>
<param-name>debugparam-name>
<param-value>trueparam-value>
init-param>
<load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
<servlet-name>dwr-invokerservlet-name>
<url-pattern>/dwr/*url-pattern>
servlet-mapping>

（2）再建一个类，用于获取验证输出信息的属性文件，这个文件是参考了良葛格的DWR 入門與應用（一）

里的Book代码

java 代码

package test.common;
import java.util.ResourceBundle;
public class GetProperties{
private ResourceBundle resource;
public GetProperties()
{
resource = ResourceBundle.getBundle("dwrPro");
}
public String getDescription(String key)
{
return resource.getString(key);
}
}

（3）编写属性文件dwrPro_zh_CN.propertie（中文）和dwr_en.properties（英文）

java 代码

username_hasUsed = 用户名已用，请选择别的用户名
username_canUse = 恭喜！用户名可以使用
username_hasUsed =username has used!
username_canUse = username can use!

（4）配置dwr.xml，里面用了spring的bean 和java类

xml 代码

<dwr>
<allow>
<create creator="spring" javascript="userManager">
<param name="beanName" value="userManager"/>
<include method="findUserIsExist"/>
create>
<create creator="new" javascript="User" scope="application">
<param name="class" value="test.common.GetProperties"/>
create>
allow>
dwr>

spring beanName 的value =“userManager”从applicationContext.xml里取得

xml 代码

<bean id="userManagerTarget" class="test.spring.serviceImpl.UserServiceImpl">
<property name="userDao">
<ref bean="userDao"/>
property>
bean>
<bean id="userManager" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>test.spring.service.IUserServicevalue>
property>
<property name="interceptorNames">
<list>
<idref bean="transactionInterceptor"/>
<idref bean="userManagerTarget"/>
list>
property>
bean>

这里应该大家都懂，就不罗嗦了

（5）配好了这些，就可以在页面里用了

java 代码

"-//W3C//DTD HTML 4.01 Transitional//EN">
interface/userManager.js'>
interface/GetProperties.js'>
}
"0">
Login:
"text" name="user.name" id="username" onblur="checkName()"/>"check_username">
Password:
"password" name="user.password" id="username" onblur="checkpassword()"/>"check_password">
"2" align="center">

这里当填了Login框，当光标从输入框移开时就实行了

js 代码

function checkName()
{
var username = document.userForm.username.value;
userManager.findUserIsExist(username,callback);
}

userManager.findUserIsExist(username,callback)时关键，这里就用了

读取dwr.xml的userManager，然后读取applicationContext.xml里userManager bean ，进而实行findUserIsExist方法。

xyz 2008-03-04 22:13 发表评论

代码重构

xyz — Wed, 27 Feb 2008 08:32:00 GMT

摘要: 来源：http://www.blogjava.net/martinx 今天无意中在springframework中见到这个函数 this.getHibernateTemplate().findByExampl(Object obj) 以前没注意到，看了一下源码，原来就是Criteria中的Example. 以前代码如下 package martin.xpost... 阅读全文

xyz 2008-02-27 16:32 发表评论

Hibernate+Spring 对DAO的处理实列!

xyz — Wed, 27 Feb 2008 07:44:00 GMT

摘要: 引用"Spring"手册上的话说: Hibernate+Spring显然是天生的结合. 下面是我用spring处理的一个HibernateDAO实例,可以看到,代码量大大减少了. java代码: ... 阅读全文

xyz 2008-02-27 15:44 发表评论

如何使用Log4j？

xyz — Sat, 02 Feb 2008 01:36:00 GMT

来源:java涂鸦

1、 Log4j是什么？
Log4j可以帮助调试（有时候debug是发挥不了作用的）和分析，要下载和了解更详细的内容，还是访问其官方网站吧： http://jakarta.apache.org/log4j 。

2、Log4j的概念
   Log4j中有三个主要的组件，它们分别是 Logger、Appender和Layout，Log4j 允许开发人员定义多个Logger，每个Logger拥有自己的名字，Logger之间通过名字来表明隶属关系。有一个Logger称为Root，它永远存在，且不能通过名字检索或引用，可以通过Logger.getRootLogger()方法获得，其它Logger通过 Logger.getLogger(String name)方法。
   Appender则是用来指明将所有的log信息存放到什么地方，Log4j中支持多种appender，如 console、files、GUI components、NT Event Loggers等，一个Logger可以拥有多个Appender，也就是你既可以将Log信息输出到屏幕，同时存储到一个文件中。
   Layout的作用是控制Log信息的输出方式，也就是格式化输出的信息。
   Log4j中将要输出的Log信息定义了5种级别，依次为DEBUG、INFO、WARN、ERROR和FATAL，当输出时，只有级别高过配置中规定的级别的信息才能真正的输出，这样就很方便的来配置不同情况下要输出的内容，而不需要更改代码，这点实在是方便啊。

3、Log4j的配置文件
虽然可以不用配置文件，而在程序中实现配置，但这种方法在如今的系统开发中显然是不可取的，能采用配置文件的地方一定一定要用配置文件。Log4j支持两种格式的配置文件：XML格式和Java的property格式，本人更喜欢后者，首先看一个简单的例子吧，如下：

log4j.rootLogger=debug, stdout, R
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=example.log
log4j.appender.R.MaxFileSize= 100KB

# Keep one backup file
log4j.appender.R.MaxBackupIndex=1

log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

首先，是设置root，格式为 log4j.rootLogger=[level],appenderName, ...，其中level就是设置需要输出信息的级别，后面是appender的输出的目的地，appenderName就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。配置日志信息输出目的地Appender，其语法为
log4j.appender.appenderName = fully.qualified.name.of.appender.class
log4j.appender.appenderName.option1 = value1
...
log4j.appender.appenderName.option = valueN
Log4j提供的appender有以下几种：
org.apache.log4j.ConsoleAppender（控制台）
org.apache.log4j.FileAppender（文件）
org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生新文件）
org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
配置日志信息的格式（布局），其语法为：
log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
log4j.appender.appenderName.layout.option1 = value1
....
log4j.appender.appenderName.layout.option = valueN
Log4j提供的layout有以下几种：
org.apache.log4j.HTMLLayout（以HTML表格形式布局），
org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，打印参数如下： %m 输出代码中指定的消息

　　 %p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
　　%r 输出自应用启动到输出该log信息耗费的毫秒数
　　%c 输出所属的类目，通常就是所在类的全名
　　%t 输出产生该日志事件的线程名
　　%n 输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“\n”
　　%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似： 2002年10月18日 22：10：28，921
　　%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)

4、Log4j在程序中的使用
要在自己的程序中使用Log4j，首先需要将commons-logging.jar和logging-log4j-1.2.9.jar导入到构建路径中。然后再将log4j.properties放到src根目录下。这样就可以在程序中使用log4j了。在类中使用log4j，首先声明一个静态变量 Logger logger=Logger.getLog("classname")；现在就可以使用了，用法如下：logger.debug("debug message")或者logger.info("info message")，看下面一个小例子：

import com.foo.Bar;
import org.apache.log4j.Logger;
  import org.apache.log4j.PropertyConfigurator;
  public class MyApp {
static Logger logger = Logger.getLogger(MyApp.class.getName());
   public static void main(String[] args) {
    // BasicConfigurator replaced with PropertyConfigurator.
     PropertyConfigurator.configure(args[0]);
      logger.info("Entering application.");
      Bar bar = new Bar();
      bar.doIt();
      logger.info("Exiting application.");
    }
  }

xyz 2008-02-02 09:36 发表评论

史上最简单的struts+spring+hibernate配置实例[修订版]

xyz — Sun, 27 Jan 2008 06:13:00 GMT

摘要: 作者:NetFetch http://www.ad0.cn/netfetch 本文不关心必须的JAR包，这个东东在网上能够找到很多，本文只关心如何配置，才能够让STRUTS SPRING HIBERNATE和MYSQL相关连。开发环境：wsad5.1 Spring-Version: 1.1.4 Struts Framework 1.1 Hiberna... 阅读全文

xyz 2008-01-27 14:13 发表评论

在myeclipse下整合spring和hibernate（转载）

xyz — Fri, 25 Jan 2008 01:37:00 GMT

摘要: 来源:互联网整合hibernate和spring这样的文章已经很多了,下面我们来看看如何利用myeclipse的功能为整合提速咯 1.首先,创建工程,可以直接选创建J2EE web工程 (这....就不用贴图了吧) 2.导入spring, 选择myeclipse的add spring capabilities,注意把copy .....打勾(注,如果... 阅读全文

xyz 2008-01-25 09:37 发表评论

使用 Spring 更好地处理 Struts 动作三种整合 Struts 应用程序与 Spring 的方式

xyz — Wed, 23 Jan 2008 05:53:00 GMT

来源:http://www.blogjava.net/shmily432685

整合 Struts 和 spring in action

与 Struts 相似，Spring 可以作为一个 MVC 实现。这两种框架都具有自己的优点和缺点，尽管大部分人同意 Struts 在 MVC 方面仍然是最好的。很多开发团队已经学会在时间紧迫的时候利用 Struts 作为构造高品质软件的基础。Struts 具有如此大的推动力，以至于开发团队宁愿整合 spring in action 框架的特性，而不愿意转换成 spring in action MVC。没必要进行转换对您来说是一个好消息。Spring 架构允许您将 Struts 作为 Web 框架连接到基于 spring in action 的业务和持久层。最后的结果就是现在一切条件都具备了。

在接下来的小窍门中，您将会了解到三种将 Struts MVC 整合到 spring in action 框架的方法。我将揭示每种方法的缺陷并且对比它们的优点。一旦您了解到所有三种方法的作用，我将会向您展示一个令人兴奋的应用程序，这个程序使用的是这三种方法中我最喜欢的一种。

三个小窍门

接下来的每种整合技术（或者窍门）都有自己的优点和特点。我偏爱其中的一种，但是我知道这三种都能够加深您对 Struts 和 spring in action 的理解。在处理各种不同情况的时候，这将给您提供一个广阔的选择范围。方法如下：

使用 spring in action 的 ActionSupport 类整合 Structs
使用 spring in action 的 DelegatingRequestProcessor 覆盖 Struts 的 RequestProcessor
将 Struts Action 管理委托给 spring in action 框架

装载应用程序环境

无论您使用哪种技术，都需要使用 spring in action 的 ContextLoaderPlugin 为 Struts 的 ActionServlet 装载 spring in action 应用程序环境。就像添加任何其他插件一样，简单地向您的 struts-config.xml 文件添加该插件，如下所示：



            
            "org.springframework.web.struts.ContextLoaderPlugIn">

            
            "contextConfigLocation" value="/WEB-INF/beans.xml"/>

前面已经提到过，在下载部分，您能够找到这三个完全可使用的例子的完整源代码。每个例子都为一个书籍搜索应用程序提供一种不同的 Struts 和 spring in action 的整合方法。您可以在这里看到例子的要点，但是您也可以下载应用程序以查看所有的细节。

窍门 1. 使用 spring in action 的 ActionSupport

手动创建一个 spring in action 环境是一种整合 Struts 和 spring in action 的最直观的方式。为了使它变得更简单，Spring 提供了一些帮助。为了方便地获得 spring in action 环境，org.springframework.web.struts.ActionSupport 类提供了一个 getWebApplicationContext() 方法。您所做的只是从 spring in action 的 ActionSupport 而不是 Struts Action 类扩展您的动作，如清单 1 所示：

清单 1. 使用 ActionSupport 整合 Struts



            package ca.nexcel.books.actions;

            

            import java.io.IOException;

            

            import javax.servlet.ServletException;

            import javax.servlet.http.HttpServletRequest;

            import javax.servlet.http.HttpServletResponse;

            

            import org.apache.struts.action.ActionError;

            import org.apache.struts.action.ActionErrors;

            import org.apache.struts.action.ActionForm;

            import org.apache.struts.action.ActionForward;

            import org.apache.struts.action.ActionMapping;

            import org.apache.struts.action.DynaActionForm;

            import org.springframework.context.ApplicationContext;

            import org.springframework.web.struts.ActionSupport;

            

            import ca.nexcel.books.beans.Book;

            import ca.nexcel.books.business.BookService;

            

            public class SearchSubmit extends ActionSupport {   |(1)

            

            

            public ActionForward execute(

            ActionMapping mapping,

            ActionForm form,

            HttpServletRequest request,

            HttpServletResponse response)

            throws IOException, ServletException {

            

            DynaActionForm searchForm = (DynaActionForm) form;

            String isbn = (String) searchForm.get("isbn");

            

            //the old fashion way

            //BookService bookService = new BookServiceImpl();

            

            ApplicationContext ctx = 

            getWebApplicationContext();    |(2)

            BookService bookService = 

            (BookService) ctx.getBean("bookService");   |(3)

            

            Book book = bookService.read(isbn.trim());

            

            if (null == book) {

            ActionErrors errors = new ActionErrors();

            errors.add(ActionErrors.GLOBAL_ERROR,new ActionError

            ("message.notfound"));

            saveErrors(request, errors);

            return mapping.findForward("failure") ;

            }

            

            request.setAttribute("book", book);

            return mapping.findForward("success");

            }

            }

让我们快速思考一下这里到底发生了什么。在 (1) 处，我通过从 spring in action 的 ActionSupport 类而不是 Struts 的 Action 类进行扩展，创建了一个新的 Action。在 (2) 处，我使用 getWebApplicationContext() 方法获得一个 ApplicationContext。为了获得业务服务，我使用在 (2) 处获得的环境在 (3) 处查找一个 spring in action bean。

这种技术很简单并且易于理解。不幸的是，它将 Struts 动作与 spring in action 框架耦合在一起。如果您想替换掉 spring in action，那么您必须重写代码。并且，由于 Struts 动作不在 spring in action 的控制之下，所以它不能获得 spring in action AOP 的优势。当使用多重独立的 spring in action 环境时，这种技术可能有用，但是在大多数情况下，这种方法不如另外两种方法合适。

窍门 2. 覆盖 RequestProcessor

将 spring in action 从 Struts 动作中分离是一个更巧妙的设计选择。分离的一种方法是使用 org.springframework.web.struts.DelegatingRequestProcessor 类来覆盖 Struts 的 RequestProcessor 处理程序，如清单 2 所示：

清单 2. 通过 spring in action 的 DelegatingRequestProcessor 进行整合



            

            

            
            "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"

            "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">

            

            

            

            
            type="org.apache.struts.validator.DynaValidatorForm">

            

            

            

            

            

            

            

            

            

            

            

            

            

            

            
            type="ca.nexcel.books.actions.SearchSubmit"

            input="/searchEntry.do"

            validate="true"

            name="searchForm">

            

            

              

            

            

            

            

            

             |(1)

            

            

            
            value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/>

我利用了标记来用 DelegatingRequestProcessor 覆盖默认的 Struts RequestProcessor。下一步是在我的 spring in action 配置文件中注册该动作，如清单 3 所示：

清单 3. 在 spring in action 配置文件中注册一个动作



            

            
            "http://www.springframework.org/dtd/spring-beans.dtd">

            

            

            

            

            
            class="ca.nexcel.books.actions.SearchSubmit"> |(1)

注意：在 (1) 处，我使用名称属性注册了一个 bean，以匹配 struts-config 动作映射名称。SearchSubmit 动作揭示了一个 JavaBean 属性，允许 spring in action 在运行时填充属性，如清单 4 所示：

清单 4. 具有 JavaBean 属性的 Struts 动作



            package ca.nexcel.books.actions;

            

            import java.io.IOException;

            

            import javax.servlet.ServletException;

            import javax.servlet.http.HttpServletRequest;

            import javax.servlet.http.HttpServletResponse;

            

            import org.apache.struts.action.Action;

            import org.apache.struts.action.ActionError;

            import org.apache.struts.action.ActionErrors;

            import org.apache.struts.action.ActionForm;

            import org.apache.struts.action.ActionForward;

            import org.apache.struts.action.ActionMapping;

            import org.apache.struts.action.DynaActionForm;

            

            import ca.nexcel.books.beans.Book;

            import ca.nexcel.books.business.BookService;

            

            public class SearchSubmit extends Action {

            

            private BookService bookService;

            public BookService getBookService() {

            return bookService;

            }

            

            public void setBookService(BookService bookService) { | (1)

            this.bookService = bookService; 

            } 

            

            public ActionForward execute(

            ActionMapping mapping,

            ActionForm form,

            HttpServletRequest request,

            HttpServletResponse response)

            throws IOException, ServletException {

            

            DynaActionForm searchForm = (DynaActionForm) form;

            String isbn = (String) searchForm.get("isbn");

            

            Book book = getBookService().read(isbn.trim());  |(2)

            

            if (null == book) {

            ActionErrors errors = new ActionErrors();

            errors.add(ActionErrors.GLOBAL_ERROR,new ActionError("message.notfound"));

            saveErrors(request, errors);

            return mapping.findForward("failure") ;

            }

            

            request.setAttribute("book", book);

            return mapping.findForward("success");

            }

            

            }

在清单 4 中，您可以了解到如何创建 Struts 动作。在 (1) 处，我创建了一个 JavaBean 属性。DelegatingRequestProcessor自动地配置这种属性。这种设计使 Struts 动作并不知道它正被 spring in action 管理，并且使您能够利用 Sping 的动作管理框架的所有优点。由于您的 Struts 动作注意不到 spring in action 的存在，所以您不需要重写您的 Struts 代码就可以使用其他控制反转容器来替换掉 spring in action。

DelegatingRequestProcessor 方法的确比第一种方法好，但是仍然存在一些问题。如果您使用一个不同的 RequestProcessor，则需要手动整合 spring in action 的 DelegatingRequestProcessor。添加的代码会造成维护的麻烦并且将来会降低您的应用程序的灵活性。此外，还有过一些使用一系列命令来代替 Struts RequestProcessor 的传闻。这种改变将会对这种解决方法的使用寿命造成负面的影响。

窍门 3. 将动作管理委托给 spring in action

一个更好的解决方法是将 Strut 动作管理委托给 spring in action。您可以通过在 struts-config 动作映射中注册一个代理来实现。代理负责在 spring in action 环境中查找 Struts 动作。由于动作在 spring in action 的控制之下，所以它可以填充动作的 JavaBean 属性，并为应用诸如 spring in action 的 AOP 拦截器之类的特性带来了可能。

清单 5 中的 Action 类与清单 4 中的相同。但是 struts-config 有一些不同：

清单 5. spring in action 整合的委托方法



            

            

            
            "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"

            "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">

            

            

            

            
            type="org.apache.struts.validator.DynaValidatorForm">

            

            

            

            

            

            

            

            

            

            

            

            

            

            

            
            type="org.springframework.web.struts.DelegatingActionProxy" |(1)

            input="/searchEntry.do"

            validate="true"

            name="searchForm">

            

            

              

            

            

            

            

            

            

            

            
            property="pathnames" 

            value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/>

            

            

            

            
            className="org.springframework.web.struts.ContextLoaderPlugIn">

清单 5 是一个典型的 struts-config.xml 文件，只有一个小小的差别。它注册 spring in action 代理类的名称，而不是声明动作的类名，如（1）处所示。DelegatingActionProxy 类使用动作映射名称查找 spring in action 环境中的动作。这就是我们使用 ContextLoaderPlugIn 声明的环境。

将一个 Struts 动作注册为一个 spring in action bean 是非常直观的，如清单 6 所示。我利用动作映射使用标记的名称属性（在这个例子中是 "/searchSubmit"）简单地创建了一个 bean。这个动作的 JavaBean 属性像任何 spring in action bean 一样被填充：

清单 6. 在 spring in action 环境中注册一个 Struts 动作



            

            
            "http://www.springframework.org/dtd/spring-beans.dtd">

            

            

            

            

            
            class="ca.nexcel.books.actions.SearchSubmit">

动作委托的优点

动作委托解决方法是这三种方法中最好的。Struts 动作不了解 spring in action，不对代码作任何改变就可用于非 spring in action 应用程序中。RequestProcessor 的改变不会影响它，并且它可以利用 spring in action AOP 特性的优点。

动作委托的优点不止如此。一旦让 spring in action 控制您的 Struts 动作，您就可以使用 spring in action 给动作补充更强的活力。例如，没有 spring in action 的话，所有的 Struts 动作都必须是线程安全的。如果您设置标记的 singleton 属性为“false”，那么不管用何种方法，您的应用程序都将在每一个请求上有一个新生成的动作对象。您可能不需要这种特性，但是把它放在您的工具箱中也很好。您也可以利用 spring in action 的生命周期方法。例如，当实例化 Struts 动作时，标记的 init-method 属性被用于运行一个方法。类似地，在从容器中删除 bean 之前，destroy-method 属性执行一个方法。这些方法是管理昂贵对象的好办法，它们以一种与 Servlet 生命周期相同的方式进行管理。

拦截 Struts

前面提到过，通过将 Struts 动作委托给 spring in action 框架而整合 Struts 和 spring in action 的一个主要的优点是：您可以将 spring in action 的 AOP 拦截器应用于您的 Struts 动作。通过将 spring in action 拦截器应用于 Struts 动作，您可以用最小的代价处理横切关注点。

虽然 spring in action 提供很多内置拦截器，但是我将向您展示如何创建自己的拦截器并把它应用于一个 Struts 动作。为了使用拦截器，您需要做三件事：

创建拦截器。
注册拦截器。
声明在何处拦截代码。

这看起来非常简单的几句话却非常强大。例如，在清单 7 中，我为 Struts 动作创建了一个日志记录拦截器。这个拦截器在每个方法调用之前打印一句话：

清单 7. 一个简单的日志记录拦截器



            package ca.nexcel.books.interceptors;

            

            import org.springframework.aop.MethodBeforeAdvice;

            

            import java.lang.reflect.Method;

            

            public class LoggingInterceptor implements MethodBeforeAdvice {

            

            public void before(Method method, Object[] objects, Object o) throws Throwable {

            System.out.println("logging before!");

            }

            }

这个拦截器非常简单。before() 方法在拦截点中每个方法之前运行。在本例中，它打印出一句话，其实它可以做您想做的任何事。下一步就是在 spring in action 配置文件中注册这个拦截器，如清单 8 所示：

清单 8. 在 spring in action 配置文件中注册拦截器



            

            
            "http://www.springframework.org/dtd/spring-beans.dtd">

            

            

            

            

            
            class="ca.nexcel.books.actions.SearchSubmit">

            

            

            

            

            

             

            
            class="ca.nexcel.books.interceptors.LoggingInterceptor"/> |(1)

            

            

            
            class="org.springframework.aop.framework.autoproxy.

            BeanNameAutoProxyCreator"> |(2)

            

            /searchSubmit|(3)

            

            

            

            logger |(4)

您可能已经注意到了，清单 8 扩展了清单 6 中所示的应用程序以包含一个拦截器。具体细节如下：

在 (1) 处，我注册了这个拦截器。
在 (2) 处，我创建了一个 bean 名称自动代理，它描述如何应用拦截器。还有其他的方法定义拦截点，但是这种方法常见而简便。
在 (3) 处，我将 Struts 动作注册为将被拦截的 bean。如果您想要拦截其他的 Struts 动作，则只需要在 "beanNames" 下面创建附加的标记。
在 (4) 处，当拦截发生时，我执行了在 (1) 处创建的拦截器 bean 的名称。这里列出的所有拦截器都应用于“beanNames”。

就是这样。就像这个例子所展示的，将您的 Struts 动作置于 spring in action 框架的控制之下，为处理您的 Struts 应用程序提供了一系列全新的选择。在本例中，使用动作委托可以轻松地利用 spring in action 拦截器提高 Struts 应用程序中的日志记录能力。

结束语

在本文中，您已经学习了将 Struts 动作整合到 spring in action 框架中的三种窍门。使用 spring in action 的 ActionSupport 来整合 Struts（第一种窍门中就是这样做的）简单而快捷，但是会将 Struts 动作与 spring in action 框架耦合在一起。如果您需要将应用程序移植到一个不同的框架，则需要重写代码。第二种解决方法通过委托 RequestProcessor 巧妙地解开代码的耦合，但是它的可扩展性不强，并且当 Struts 的 RequestProcessor 变成一系列命令时，这种方法就持续不了很长时间。第三种方法是这三种方法中最好的：将 Struts 动作委托给 spring in action 框架可以使代码解耦，从而使您可以在您的 Struts 应用程序中利用 spring in action 的特性（比如日志记录拦截器）。

xyz 2008-01-23 13:53 发表评论

Myeclipse平台struts+hibernate+spring项目开发示例来来源

xyz — Wed, 23 Jan 2008 03:13:00 GMT

摘要: 来源:http://www.blogjava.net/shmily432685 开发前准备: 1、新建项目包：如下图： Dao：数据层；service：逻辑层；web：web展现层。 2、建立好三层架构，部署好包名。建立一个jsp文件，取名为：logi... 阅读全文

xyz 2008-01-23 11:13 发表评论

JAVA高级：JavaVM，反射机制与动态代理

xyz — Mon, 17 Dec 2007 08:19:00 GMT

JavaVM，反射与动态代理

Java程序的工作机制：Java对象都以单独的class文件存在，java虚拟机将其载入并执行其虚拟机指令。

Java虚拟机查找这些java对象：

java虚拟机根据class path来查找java对象，而虚拟机的class path又分为三层：

bootstrap：sun.boot.class.path

extension: java.ext.dirs

application: java.class.path

三个class path各有对应的classloader。由上而下形成父子关系

当程序中调用new指令，或者ClassLoader.load方法时。其顺序如下：

1. 首先查看application的classloader中是否已有对应的class缓存，如果有则返回，并根据class分配内存。如果没有，接下一步。

2. 首先查看extension的classloader中是否已有对应的class缓存，如果有则返回，并根据class分配内存。如果没有，接下一步。

3. 首先查看bootstrap的classloader中是否已有对应的class缓存，如果有则返回，并根据class分配内存。如果没有，接下一步。

4. 由bootstrap的classloader在其class path中试图加载该class，如果有，则将该class放入cache中，并返回。如果没有，接下一步。

5. 由extension的classloader在其class path中试图加载该class，如果有，则将该class放入cache中，并返回。如果没有，接下一步。

6. 由application的classloader在其class path中试图加载该class，如果有，则将该class放入cache中，并返回。如果没有，则抛出ClassNotFound的exception。

Java虚拟机加载这些java对象：

每个java虚拟机都在其启动时产生一个唯一的class heap，并把所有的class instance都分配在其中。其中每个类实例的信息又分两部分，fields域和methods域。每个类实例各自拥有fields，但同一个类的不同实例共享methods

反射

JVM对反射的处理

简单例子代码：

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.InvocationTargetException;

import java.io.IOException;

public class Main {

public static void main(String[] args){

TempImpl t1 = new TempImpl("temp1");

try {

Method t1Talk = t1.getClass().getMethod("Talk", new Class[0]) ;

t1Talk.invoke(t1, null);

} catch (NoSuchMethodException e) {

e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.

} catch (IllegalAccessException e) {

e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.

} catch (InvocationTargetException e) {

e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.

}

try {

System.in.read();

} catch (IOException e) {

e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.

}

}

}

复杂例子代码：

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.InvocationTargetException;

import java.io.IOException;

public class Main {

public static void main(String[] args){

TempImpl t1 = new TempImpl("temp1");

TempImpl t2 = new TempImpl("temp2");

Temp2 temp2 = new Temp2();

try {

Method t1Talk = t1.getClass().getMethod("Talk", new Class[0]) ;

Method t2Talk = t2.getClass().getMethod("Talk", new Class[0]) ;

t1Talk.invoke(t2, null);

t2Talk.invoke(t1, null);

if(t1Talk.equals(t2Talk)){

System.out.println("equals");

}

else{

System.out.println("not equals");

}

if(t1Talk==t2Talk){

System.out.println("ref equals");

}

else{

System.out.println("ref not equals");

}

t2Talk.invoke(temp2, null);

} catch (NoSuchMethodException e) {

e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.

} catch (IllegalAccessException e) {

e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.

} catch (InvocationTargetException e) {

e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.

}

try {

System.in.read();

} catch (IOException e) {

e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.

}

}

}

分析：java虚拟机把每个methods当作一个执行单元。该执行单元带有两种签名：类签名和属性签名（public，static等）。反射的第一步，验证签名的合法性。验证通过后，顺序执行该method中的指令，当需要访问类实例的fields和传入参数时，由虚拟机注入。

动态代理

Sun对动态代理的说明：

一个简单例子代码：

动态代理的内部实现——代码生成：

研究JDK源代码，发现在Proxy的sun实现中调用了sun.misc.ProxyGenerator类的generateProxyClass( proxyName, interfaces)方法，其返回值为byte[]和class文件的内存类型一致。于是做如下试验：

public class ProxyClassFile{

public static void main(String[] args){

String proxyName = "TempProxy";

TempImpl t = new TempImpl("proxy");

Class[] interfaces =t.getClass().getInterfaces();

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(

proxyName, interfaces);

File f = new File("classes/TempProxy.class");

try {

FileOutputStream fos = new FileOutputStream(f);

fos.write(proxyClassFile);

fos.flush();

fos.close();

} catch (FileNotFoundException e) {

e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.

} catch (IOException e) {

e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.

}

}

}

运行该类，到class文件夹下，利用反编译技术，发现原来其采用了代码生产技术：

public interface Temp{

public void Talk();

public void Run();

}

import java.lang.reflect.*;

public final class TempProxy extends Proxy

implements Temp{

private static Method m4;

private static Method m2;

private static Method m0;

private static Method m3;

private static Method m1;

public TempProxy(InvocationHandler invocationhandler) {

super(invocationhandler);

}

public final void Run() {

try {

h.invoke(this, m4, null);

return;

}

catch(Error _ex) { }

catch(Throwable throwable) {

throw new UndeclaredThrowableException(throwable);

}

}

public final String toString(){

try{

return (String)h.invoke(this, m2, null);

}

catch(Error _ex) { }

catch(Throwable throwable) {

throw new UndeclaredThrowableException(throwable);

}

return "";

}

public final int hashCode() {

try {

return ((Integer)h.invoke(this, m0, null)).intValue();

}

catch(Error _ex) { }

catch(Throwable throwable){

throw new UndeclaredThrowableException(throwable);

}

return 123;

}

public final void Talk(){

try{

h.invoke(this, m3, null);

return;

}

catch(Error _ex) { }

catch(Throwable throwable) {

throw new UndeclaredThrowableException(throwable);

}

}

public final boolean equals(Object obj) {

try {

return ((Boolean)h.invoke(this, m1, new Object[] {

obj

})).booleanValue();

}

catch(Error _ex) { }

catch(Throwable throwable) {

throw new UndeclaredThrowableException(throwable);

}

return false;

}

static{

try{

m4 = Class.forName("Temp").getMethod("Run", new Class[0]);

m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);

m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);

m3 = Class.forName("Temp").getMethod("Talk", new Class[0]);

m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {

Class.forName("java.lang.Object")

});

}

catch(NoSuchMethodException nosuchmethodexception) {

throw new NoSuchMethodError(nosuchmethodexception.getMessage());

}

catch(ClassNotFoundException classnotfoundexception) {

throw new NoClassDefFoundError(classnotfoundexception.getMessage());

}

}

}

xyz 2007-12-17 16:19 发表评论

【经典推荐】每个初学者都应该搞懂的问题！

xyz — Mon, 17 Dec 2007 08:13:00 GMT

对于这个系列里的问题，每个学Java的人都应该搞懂。当然，如果只是学Java玩玩就无所谓了。如果你认为自己已经超越初学者了，却不很懂这些问题，请将你自己重归初学者行列。内容均来自于CSDN的经典老贴。

问题一：我声明了什么！

String s = "Hello world!";

许多人都做过这样的事情，但是，我们到底声明了什么？回答通常是：一个String，内容是“Hello world!”。这样模糊的回答通常是概念不清的根源。如果要准确的回答，一半的人大概会回答错误。
这个语句声明的是一个指向对象的引用，名为“s”，可以指向类型为String的任何对象，目前指向"Hello world!"这个String类型的对象。这就是真正发生的事情。我们并没有声明一个String对象，我们只是声明了一个只能指向String对象的引用变量。所以，如果在刚才那句语句后面，如果再运行一句：

String string = s;

我们是声明了另外一个只能指向String对象的引用，名为string，并没有第二个对象产生，string还是指向原来那个对象，也就是，和s指向同一个对象。

问题二："=="和equals方法究竟有什么区别？

==操作符专门用来比较变量的值是否相等。比较好理解的一点是：
int a=10;
int b=10;
则a==b将是true。
但不好理解的地方是：
String a=new String("foo");
String b=new String("foo");
则a==b将返回false。

根据前一帖说过，对象变量其实是一个引用，它们的值是指向对象所在的内存地址，而不是对象本身。a和b都使用了new操作符，意味着将在内存中产生两个内容为"foo"的字符串，既然是“两个”，它们自然位于不同的内存地址。a和b的值其实是两个不同的内存地址的值，所以使用"=="操作符，结果会是 false。诚然，a和b所指的对象，它们的内容都是"foo"，应该是“相等”，但是==操作符并不涉及到对象内容的比较。
对象内容的比较，正是equals方法做的事。

看一下Object对象的equals方法是如何实现的：
boolean equals(Object o){

return this==o;

}
Object 对象默认使用了==操作符。所以如果你自创的类没有覆盖equals方法，那你的类使用equals和使用==会得到同样的结果。同样也可以看出， Object的equals方法没有达到equals方法应该达到的目标：比较两个对象内容是否相等。因为答案应该由类的创建者决定，所以Object把这个任务留给了类的创建者。

看一下一个极端的类：
Class Monster{
private String content;
...
boolean equals(Object another){ return true;}

}
我覆盖了equals方法。这个实现会导致无论Monster实例内容如何，它们之间的比较永远返回true。

所以当你是用equals方法判断对象的内容是否相等，请不要想当然。因为可能你认为相等，而这个类的作者不这样认为，而类的equals方法的实现是由他掌握的。如果你需要使用equals方法，或者使用任何基于散列码的集合（HashSet,HashMap,HashTable），请察看一下java doc以确认这个类的equals逻辑是如何实现的。

问题三：String到底变了没有？

没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。请看下列代码：

String s = "Hello";
s = s + " world!";

s 所指向的对象是否改变了呢？从本系列第一篇的结论很容易导出这个结论。我们来看看发生了什么事情。在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。
通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer 类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。
同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做：
public class Demo {
private String s;
...
public Demo {
s = "Initial Value";
}
...
}
而非
s = new String("Initial Value");
后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个 String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。
上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。
至于为什么要把String类设计成不可变类，是它的用途决定的。其实不只String，很多Java标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，即 StringBuffer。

问题四：final关键字到底修饰了什么？

final使得被修饰的变量"不变"，但是由于对象型变量的本质是“引用”，使得“不变”也有了两种含义：引用本身的不变，和引用指向的对象不变。

引用本身的不变：
final StringBuffer a=new StringBuffer("immutable");
final StringBuffer b=new StringBuffer("not immutable");
a=b;//编译期错误

引用指向的对象不变：
final StringBuffer a=new StringBuffer("immutable");
a.append(" broken!"); //编译通过

可见，final只对引用的“值”(也即它所指向的那个对象的内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。这很类似==操作符：==操作符只负责引用的“值”相等，至于这个地址所指向的对象内容是否相等，==操作符是不管的。

理解final问题有很重要的含义。许多程序漏洞都基于此----final只能保证引用永远指向固定对象，不能保证那个对象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改，一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final，意图使得它“永远不变”。其实那是徒劳的。

问题五：到底要怎么样初始化！

本问题讨论变量的初始化，所以先来看一下Java中有哪些种类的变量。
1. 类的属性，或者叫值域
2. 方法里的局部变量
3. 方法的参数

对于第一种变量，Java虚拟机会自动进行初始化。如果给出了初始值，则初始化为该初始值。如果没有给出，则把它初始化为该类型变量的默认初始值。

int类型变量默认初始值为0
float类型变量默认初始值为0.0f
double类型变量默认初始值为0.0
boolean类型变量默认初始值为false
char类型变量默认初始值为0(ASCII码)
long类型变量默认初始值为0
所有对象引用类型变量默认初始值为null，即不指向任何对象。注意数组本身也是对象，所以没有初始化的数组引用在自动初始化后其值也是null。

对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。这个问题会在以后的系列中进行详细讨论。

对于第二种变量，必须明确地进行初始化。如果再没有初始化之前就试图使用它，编译器会抗议。如果初始化的语句在try块中或if块中，也必须要让它在第一次使用前一定能够得到赋值。也就是说，把初始化语句放在只有if块的条件判断语句中编译器也会抗议，因为执行的时候可能不符合if后面的判断条件，如此一来初始化语句就不会被执行了，这就违反了局部变量使用前必须初始化的规定。但如果在else块中也有初始化语句，就可以通过编译，因为无论如何，总有至少一条初始化语句会被执行，不会发生使用前未被初始化的事情。对于try-catch也是一样，如果只有在try块里才有初始化语句，编译部通过。如果在 catch或finally里也有，则可以通过编译。总之，要保证局部变量在使用之前一定被初始化了。所以，一个好的做法是在声明他们的时候就初始化他们，如果不知道要出事化成什么值好，就用上面的默认值吧！

其实第三种变量和第二种本质上是一样的，都是方法中的局部变量。只不过作为参数，肯定是被初始化过的，传入的值就是初始值，所以不需要初始化。

问题六：instanceof是什么东东？

instanceof是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。举个例子：

String s = "I AM an Object!";
boolean isObject = s instanceof Object;

我们声明了一个String对象引用，指向一个String对象，然后用instancof来测试它所指向的对象是否是Object类的一个实例，显然，这是真的，所以返回true，也就是isObject的值为True。
instanceof有一些用处。比如我们写了一个处理账单的系统，其中有这样三个类：

public class Bill {//省略细节}
public class PhoneBill extends Bill {//省略细节}
public class GasBill extends Bill {//省略细节}

在处理程序里有一个方法，接受一个Bill类型的对象，计算金额。假设两种账单计算方法不同，而传入的Bill对象可能是两种中的任何一种，所以要用instanceof来判断：

public double calculate(Bill bill) {
if (bill instanceof PhoneBill) {
//计算电话账单
}
if (bill instanceof GasBill) {
//计算燃气账单
}
...
}
这样就可以用一个方法处理两种子类。

然而，这种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实现，这是面向对象变成应有的做法，避免回到结构化编程模式。只要提供两个名字和返回值都相同，接受参数类型不同的方法就可以了：

public double calculate(PhoneBill bill) {
//计算电话账单
}

public double calculate(GasBill bill) {
//计算燃气账单
}

所以，使用instanceof在绝大多数情况下并不是推荐的做法，应当好好利用多态。

xyz 2007-12-17 16:13 发表评论

Java 关于中文乱码问题的解决方案与经验

xyz — Mon, 17 Dec 2007 08:07:00 GMT

一、字节和unicode

Java内核是unicode的，就连class文件也是，但是很多媒体，包括文件/流的保存方式是使用字节流的。因此Java要对这些字节流经行转化。 char是unicode的，而byte是字节。Java中byte/char互转的函数在sun.io的包中间有。其中 ByteToCharConverter类是中调度，可以用来告诉你，你用的convertor。其中两个很常用的静态函数是：

public static ByteToCharConverter getDefault();

public static ByteToCharConverter getConverter(String encoding);

如果你不指定converter，则系统会自动使用当前的encoding,gb平台上用gbk,en平台上用8859_1。

byte ——〉char：

"你"的gb码是：0xc4e3 ,unicode是0x4f60

String encoding = "gb2312";

byte b[] = {(byte)''"u00c4'',(byte)''"u00e3''};

ByteToCharConverter converter = ByteToCharConverter.getConverter(encoding);

char c[] = converter.convertAll(b);

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

System.out.println(Integer.toHexString(c[i]));

}

结果是什么？0x4f60

如果encoding ="8859_1"，结果又是什么？0x00c4,0x00e3（这表明8859_1是以字节为单位的）

如果代码改为：

byte b[] = {(byte)''"u00c4'',(byte)''"u00e3''};

ByteToCharConverter converter = ByteToCharConverter. getDefault();

char c[] = converter.convertAll(b);

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

System.out.println(Integer.toHexString(c[i]));

}

结果将又是什么？

这就要根据平台的编码而定。

char ——〉byte：

String encoding = "gb2312";

char c[] = {''"u4f60''};

CharToByteConverter converter = CharToByteConverter.getConverter(encoding);

byte b[] = converter.convertAll(c);

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

System.out.println(Integer.toHexString(b[i]));

}

结果是什么？0x00c4,0x00e3

如果encoding ="8859_1"，结果又是什么？0x3f

如果代码改为

String encoding = "gb2312";

char c[] = {''"u4f60''};

CharToByteConverter converter = CharToByteConverter.getDefault();

byte b[] = converter.convertAll(c);

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

System.out.println(Integer.toHexString(b[i]));

}

结果将又是什么？还是根据平台的编码而定。

很多中文问题就是从这两个最简单的类派生出来的。而却有很多类不直接支持把encoding输入，这给我们带来诸多不便。很多程序难得用encoding了，直接用default的encoding，这就给我们移植带来了很多困难。

二、utf-8

utf-8是和unicode一一对应的，其实现很简单：

7位的unicode: 0 _ _ _ _ _ _ _

11位的unicode: 1 1 0 _ _ _ _ _ 1 0 _ _ _ _ _ _

16位的unicode: 1 1 1 0 _ _ _ _ 1 0 _ _ _ _ _ _ 1 0 _ _ _ _ _ _

21位的unicode: 1 1 1 1 0 _ _ _ 1 0 _ _ _ _ _ _ 1 0 _ _ _ _ _ _ 1 0 _ _ _ _ _ _

大多数情况是只使用到16位以下的unicode:

"你"的gb码是：0xc4e3 ,unicode是0x4f60

0xc4e3的二进制：

1100 ，0100 ，1110 ，0011

由于只有两位我们按照两位的编码来排，但是我们发现这行不通，因为第７位不是0因此，返回"?"

0x4f60的二进制：

0100 ，1111 ，0110 ，0000

我们用utf-8补齐，变成：

1110 ，0100 ，1011 ，1101 ，1010 ，0000

e4--bd-- a0

于是返回：0xe4,0xbd,0xa0。

三、string和byte[]

string其实核心是char[],然而要把byte转化成string，必须经过编码。string.length()其实就是char数组的长度，如果使用不同的编码，很可能会错分，造成散字和乱码。例如：

String encoding = “”;

byte [] b={(byte)''"u00c4'',(byte)''"u00e3''};

String str=new String(b,encoding);

如果encoding=8859_1，会有两个字，但是encoding=gb2312只有一个字这个问题在处理分页是经常发生。

四、Reader,Writer / InputStream,OutputStream

Reader和Writer核心是char，InputStream和OutputStream核心是byte。但是Reader和Writer的主要目的是要把char读/写InputStream/OutputStream。例如：

文件test.txt只有一个"你"字，0xc4,0xe3

String encoding = "gb2312";

InputStreamReader reader = new InputStreamReader(new FileInputStream(

"text.txt"), encoding);

char c[] = new char[10];

int length = reader.read(c);

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

System.out.println(c[i]);

}

结果是什么？是"你"。如果encoding ="8859_1"，结果是什么？"??"两个字符，表示不认识。反过来的例子自己做。

五、我们要对Java的编译器有所了解：

Javac ?encoding

我们常常没有用到encoding这个参数。其实encoding这个参数对于跨平台的操作是很重要的。如果没有指定encoding，则按照系统的默认encoding,gb平台上是gb2312，英文平台上是iso8859_1。Java的编译器实际上是调用 sun.tools.Javac.main的类，对文件进行编译，这个类有compile函数中间有一个encoding的变量,-encoding的参数其实直接传给encoding变量。编译器就是根据这个变量来读取Java文件的，然后把用utf-8形式编译成class文件。例子代码：

String str = "你";

FileWriter writer = new FileWriter("text.txt");

write.write(str);

writer.close();

如果用gb2312编译，你会找到e4 bd a0的字段；

如果用8859_1编译， 00c4 00e3的二进制：

0000，0000 ，1100，0100 ，0000，0000 ，1110，0011

因为每个字符都大于7位，因此用11位编码：

1100，0001，1000，0100，1100，0011，1010，0011

c1-- 84--　c3--　 a3

你会找到c1 84 c3 a3

但是我们往往忽略掉这个参数，因此这样往往会有跨平台的问题：

样例代码在中文平台上编译，生成zhclass

样例代码在英文平台上编译，输出enclass

(1) zhclass在中文平台上执行ok,但是在英文平台上不行

(2) enclass在英文平台上执行ok,但是在中文平台上不行

原因是：

(1) 在中文平台上编译后，其实str在运行态的char[]是0x4f60,　在中文平台上运行，filewriter的缺省编码是gb2312,因此 chartobyteconverter会自动用调用gb2312的converter,把str转化成byte输入到fileoutputstream 中，于是0xc4,0xe3放进了文件。但是如果是在英文平台下，chartobyteconverter的缺省值是8859_1, filewriter会自动调用8859_1去转化str,但是他无法解释，因此他会输出"?"

(2) 在英文平台上编译后，其实str在运行态的char[]是0x00c4 0x00e3, 在中文平台上运行，中文无法识别，因此会出现??；在英文平台上，0x00c4-->0xc4,0x00e3->0xe3，因此 0xc4,0xe3被放进了文件。

六、其它原因：

<%@ page contentType="text/html; charset=GBK" %>

设置浏览器的显示编码，如果response的数据是utf8编码，显示将是乱码，但是乱码和上述原因还不一样。

七、发生编码的地方：

1. 从数据库到Java程序 byte——〉char

2. 从Java程序到数据库 char——〉byte

3. 从文件到Java程序 byte——〉char

4. 从Java程序到文件 char——〉byte

5. 从Java程序到页面显示 char——〉byte

6. 从页面form提交数据到Java程序byte——〉char

7. 从流到Java程序byte——〉char

8. 从Java程序到流char——〉byte

可以使用配置过滤器的方法解决中文乱码的：

RequestFilter

net.golden.uirs.util.RequestFilter

charset

gb2312

RequestFilter

*.Jsp

public void doFilter(ServletRequest req, ServletResponse res,

FilterChain fChain) throws IOException, ServletException {

HttpServletRequest request = (HttpServletRequest) req;

HttpServletResponse response = (HttpServletResponse) res;

HttpSession session = request.getSession();

String userId = (String) session.getAttribute("userid");

req.setCharacterEncoding(this.filterConfig.getInitParameter("charset"));

// 设置字符集？

实际上是设置了byte ——〉char的encoding

try {

if (userId == null || userId.equals("")) {

if (!request.getRequestURL().toString().matches(

".*/uirs/logon/logon(Controller){0,1}""x2EJsp$")) {

session.invalidate();

response.sendRedirect(request.getContextPath() +

"/uirs/logon/logon.Jsp");

}

else {

// 看看是否具有信息上报系统的权限

if (!net.golden.uirs.util.UirsChecker.check(userId, "信息上报系统",

net.golden.uirs.util.UirsChecker.ACTION_DO)) {

if (!request.getRequestURL().toString().matches(

".*/uirs/logon/logon(Controller){0,1}""x2EJsp$")) {

response.sendRedirect(request.getContextPath() +

"/uirs/logon/logonController.Jsp");

}

catch (Exception ex) {

response.sendRedirect(request.getContextPath() +

"/uirs/logon/logon.Jsp");

}

fChain.doFilter(req, res);

}

xyz 2007-12-17 16:07 发表评论

JAVA反编译工具

xyz — Mon, 17 Dec 2007 03:11:00 GMT

JAVA反编译工具

目前，比较流行的JAVA反编译工具有近30种，其中有三款堪称精品：

一、应用广泛的JAD

在众多的JAVA反编译工具中，有几种非常著名的工具使用了相同的核心引擎——JAD，其中主要包括：Front End Plus、mDeJava、Decafe Pro、Cavaj Java Decompiler、DJ Java Decompiler、NMI’s Java Class Viewer和国产的JAVA源代码反编译专家。

JAD本身是一个命令行工具，没有图形界面，上述的这些工具大多是在JAD内核的基础之上加了一个图形界面而已。这么多种产品的共同选择，足可证明JAD在JAVA反编译领域中的尊贵地位。

笔者用来测试的JAD版本是1.5.8f，其运行界面如下图：
http://www.blogchina.com/resource/upload/pic/2006/03/17/264618335.1001.0161.jpg
JAD是使用Microsoft Visual C++开发的，运行速度非常快，可以处理很复杂的JAVA编译文件。众多的参数使JAD可以灵活应付多种加密手段，令反编译的代码更加优化和易读。由于JAD参数太多，没必要一一解释，其中有几个最常用的如下：

-d

- 用于指定输出文件的目录

-s - 输出文件扩展名(默认为: .jad)，通常都会把输出文件扩展名直接指定为.java，以方便修改的重新编译。

-8 - 将Unicode字符转换为ANSI字符串，如果输出字符串是中文的话一定要加上这个参数才能正确显示。

最常用的反编译指令如下所示：

Jad –d c:\javasource –s .java -8 javatest.class

这条指令将当前目录下的javatest.class反编译为javatest.java并保存在c:\javasource目录里，其中的提示输出为中文，而不是Unicode代码。

二、源码开放的JODE

JODE是全球最大的开源项目网站Sourceforge.net的成员，不要以为源码开放就小瞧它，在所有的JAVA反编译器中，JODE的反编译效果是最好的，尤其是对付一些常见的加密手段，例如混淆技术等，更是出类拔粹。

JODE本身也是纯JAVA开发的，最近越来越多的JAVA反编译软件也选择JODE来做它们的核心引擎，例如JCavaj Java Decompiler、BTJ (Back To Java)、jEdit's JavaInsight plugin等。

JODE是一个可运行的JAR文件，在windows环境下双击即可运行，其运行界面如下：

http://www.blogchina.com/resource/upload/pic/2006/03/17/264618335.1002.0373.jpg
需要特别说明的是，JODE不是通过常规的Open->File的方式来加载JAVA编译后的类文件（*.class）或是类包（*.jar）的，而是通过在Options菜单中的Set Classpath来实现的，单独的类文件可以将它的上一级目录作为Classpath输入，然后再选择Reload Classpath即可：
http://www.blogchina.com/resource/upload/pic/2006/03/17/264618335.1003.07741.jpg
http://www.blogchina.com/resource/u....1004.08813.jpg

新加入的类包或是类的名字会在左侧窗口出现，双击类包名可以展开目录树结构，双击需要反编译的类名则在右上角的窗口中直接显示反编译后的源代码。

三、独树一帜的DAVA

DAVA不是一个独立的JAVA反编译器，而是JAVA代码优化工具Soot的一部分。Soot和JODE一样是纯JAVA开发的，也是一个独立的JAR包，但却不能通过双击直接运行，而是象JAD一样在命令行状态运行。
http://www.blogchina.com/resource/upload/pic/2006/03/17/264618335.1005.09938.jpg
Soot对环境变量的配置要求非常严格，通常情况下要对CLASSPATH做如下设置：

Set CLASSPATH=%CLASSPATH%;c:\sootdir\sootclasses-2.1.0.jar;.;

其中的c:\sootdir\是下载的soot类包放置的路径，CLASSPATH末尾的.;代表了当前目录，如果不加上这个的话Soot经常会报一个找不到类的错误。

DAVA是作为Soot的一个参数使用的，通常的用法如下：

Java soot.Main –f dava –d c:\javasource javatest

注意最后的类名不用带.class后缀，因为它默认是处理class文件，这个操作与前述的JAD的参数效果相同。
DAVA采取了流程优化的方式进行反编译，与传统反编译思路不尽相同，但却对改变流程类的加密方法有独特的反编译效果。
上述的三种工具各有千秋，但效果都非常不错。经测试，它们基本上都可以把JDK自带的一些例程完全反编译，然后不加任何修改可再编译成功，并能正常运行！

xyz 2007-12-17 11:11 发表评论

abstract class和interface的区别

xyz — Sun, 16 Dec 2007 03:33:00 GMT

abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制，正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性，甚至可以相互替换，因此很多开发者在进行抽象类定义时对于 abstract class和interface的选择显得比较随意。其实，两者之间还是有很大的区别的，对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析，试图给开发者提供一个在二者之间进行选择的依据。

理解抽象类

abstract class和interface在Java语言中都是用来进行抽象类（本文中的抽象类并非从abstract class翻译而来，它表示的是一个抽象体，而abstract class为Java语言中用于定义抽象类的一种方法，请读者注意区分）定义的，那么什么是抽象类，使用抽象类能为我们带来什么好处呢？

在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。

在面向对象领域，抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的；同时，通过从这个抽象体派生，也可扩展此模块的行为功能。熟悉OCP的读者一定知道，为了能够实现面向对象设计的一个最核心的原则OCP(Open- Closed Principle)，抽象类是其中的关键所在。

OCP(Open-Closed Principle) 意思是,在一个系统中,对于扩展是开放的,对于修改是关闭的,一个好的系统是在不修改源代码的情况下,可以扩展你的功能..而实现开闭原则的关键就是抽象化. 在"开-闭"原则中,不允许修改的是抽象的类或者接口,允许扩展的是具体的实现类,抽象类和接口在"开-闭"原则中扮演着极其重要的角色，即要预知可能变化的需求，又预见所有可能已知的扩展，所以在这里"抽象化"是关键!!!

从语法定义层面看abstract class和interface

在语法层面，Java语言对于abstract class和interface给出了不同的定义方式，下面以定义一个名为Demo的抽象类为例来说明这种不同。

使用abstract class的方式定义Demo抽象类的方式如下：

abstract class Demo ｛
abstract void method1();
abstract void method2();
…
｝

使用interface的方式定义Demo抽象类的方式如下：

interface Demo {
void method1();
void method2();
…
}

在abstract class方式中，Demo可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface方式的实现中，Demo只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在interface中一般不定义数据成员），所有的成员方法都是abstract的。从某种意义上说，interface是一种特殊形式的abstract class。

从编程的角度来看，abstract class和interface都可以用来实现"design by contract "(DBC,契约式设计)的思想。但是在具体的使用上面还是有一些区别的。

首先，abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。也许，这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。

其次，在abstract class的定义中，我们可以赋予方法的默认行为。但是在interface的定义中，方法却不能拥有默认行为，为了绕过这个限制，必须使用委托，但是这会增加一些复杂性，有时会造成很大的麻烦。

在抽象类中不能定义默认行为还存在另一个比较严重的问题，那就是可能会造成维护上的麻烦。因为如果后来想修改类的界面（一般通过abstract class或者interface来表示）以适应新的情况（比如，添加新的方法或者给已用的方法中添加新的参数）时，就会非常的麻烦，可能要花费很多的时间（对于派生类很多的情况，尤为如此）。但是如果界面是通过abstract class来实现的，那么可能就只需要修改定义在abstract class中的默认行为就可以了。

同样，如果不能在抽象类中定义默认行为，就会导致同样的方法实现出现在该抽象类的每一个派生类中，违反了"one rule，one place"原则，造成代码重复，同样不利于以后的维护。因此，在abstract class和interface间进行选择时要非常的小心。

从设计理念层面看abstract class和interface

上面主要从语法定义和编程的角度论述了abstract class和interface的区别，这些层面的区别是比较低层次的、非本质的。本小节将从另一个层面：abstract class和interface所反映出的设计理念，来分析一下二者的区别。作者认为，从这个层面进行分析才能理解二者概念的本质所在。

前面已经提到过，abstarct class在Java语言中体现了一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is a"关系，即父类和派生类在概念本质上应该是相同的（参考文献〔3〕中有关于"is a"关系的大篇幅深入的论述，有兴趣的读者可以参考）。对于interface 来说则不然，并不要求interface的实现者和interface定义在概念本质上是一致的，仅仅是实现了interface定义的契约而已。为了使论述便于理解，下面将通过一个简单的实例进行说明。

考虑这样一个例子，假设在我们的问题领域中有一个关于Door的抽象概念，该Door具有执行两个动作open和close，此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型，定义方式分别如下所示：

使用abstract class方式定义Door：

abstract class Door {
abstract void open();
abstract void close()；
}

使用interface方式定义Door：

interface Door {
void open();
void close();
}

其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。

如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢（在本例中，主要是为了展示abstract class和interface反映在设计理念上的区别，其他方面无关的问题都做了简化或者忽略）。下面将罗列出可能的解决方案，并从设计理念层面对这些不同的方案进行分析。

解决方案一：

简单的在Door的定义中增加一个alarm方法，如下：

abstract class Door {
abstract void open();
abstract void close()；
abstract void alarm();
}

或者

interface Door {
void open();
void close();
void alarm();
}

那么具有报警功能的AlarmDoor的定义方式如下：

class AlarmDoor extends Door {
void open() { … }
void close() { … }
void alarm() { … }
}

或者

class AlarmDoor implements Door ｛
void open() { … }
void close() { … }
void alarm() { … }
｝

这种方法违反了面向对象设计中的一个核心原则ISP（Interface Segregation Priciple），在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变（比如：修改alarm方法的参数）而改变，反之依然。

解决方案二：

既然open、close和alarm属于两个不同的概念，根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有：这两个概念都使用 abstract class方式定义；两个概念都使用interface方式定义；一个概念使用abstract class方式定义，另一个概念使用interface方式定义。

显然，由于Java语言不支持多重继承，所以两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的，但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。

如果两个概念都使用interface方式来定义，那么就反映出两个问题：1、我们可能没有理解清楚问题领域，AlarmDoor在概念本质上到底是 Door还是报警器？2、如果我们对于问题领域的理解没有问题，比如：我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的，那么我们在实现时就没有能够正确的揭示我们的设计意图，因为在这两个概念的定义上（均使用interface方式定义）反映不出上述含义。

如果我们对于问题领域的理解是：AlarmDoor在概念本质上是Door，同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢？前面已经说过，abstract class在Java语言中表示一种继承关系，而继承关系在本质上是"is a"关系。所以对于Door这个概念，我们应该使用abstarct class方式来定义。另外，AlarmDoor又具有报警功能，说明它又能够完成报警概念中定义的行为，所以报警概念可以通过interface方式定义。如下所示：

abstract class Door {
abstract void open();
abstract void close()；
}
interface Alarm {
void alarm();
}
class AlarmDoor extends Door implements Alarm {
void open() { … }
void close() { … }
void alarm() { … }
}

这种实现方式基本上能够明确的反映出我们对于问题领域的理解，正确的揭示我们的设计意图。其实abstract class表示的是"is a"关系，interface表示的是"like a"（“has a”）关系，大家在选择时可以作为一个依据，当然这是建立在对问题领域的理解上的，比如：如果我们认为AlarmDoor在概念本质上是报警器，同时又具有Door的功能，那么上述的定义方式就要反过来了。

xyz 2007-12-16 11:33 发表评论

关于AutoComplete（文本框的自动填充）

xyz — Wed, 12 Dec 2007 01:32:00 GMT

1：默认情况下AutoComplete是打开的。见IE-工具-内容-自动完成选项

<form>
请双击文本框 <input type="text" name="wd"> <input type="text" name="email">
form>

2：有时候我们并不需要AutoComplete，例如需要用户自己再次输入而非自动完成。只要将所在表单元素的autocomplete属性设置为off即可。

<form>
请双击文本框 <input type="text" name="wd" autocomplete="off"> <input type="text" name="email" autocomplete="off">
form>

3：那么，如果所有表单元素都不想使用autocomplete功能呢？见下面的方法：

<form autocomplete="off">
请双击文本框 <input type="text" name="wd"> <input type="text" name="email">
form>

xyz 2007-12-12 09:32 发表评论

从javascript语言本身谈项目实战

xyz — Sun, 09 Dec 2007 07:20:00 GMT

从javascript语言本身谈项目实战

[b]从javascript语言本身谈项目实战[/b]

                     dulao5 [url=http://dulao5.blog.hexun.com/2156811_d.html][color=blue]blog原文[/color][/url]
                     TrackBack Ping URL： [url=http://dulao5.blog.hexun.com/trackback.aspx?articleid=2156811][color=#000000]
http://dulao5.blog.hexun.com/trackback.aspx?articleid=2156811[/color][/url]

   随着ajax的升温，javascript越来越得到人们的重视。重要的是，ajax在一定程度上带来了web软件架构上的变化，人们把越来越多的功能分配到客户端实现，javascript子项目规模越来越大。如何更高效的使用javascript，如何更科学的组织javascript，如何更顺利的保证项目进展？我想就我的经验谈一点浅见。

[b]一。开发人员需要认真学习javascript语言本身[/b]
   由于javascript是世界上最被误解的语言, 大部分人对javascript语法并没有全面了解过，只是凭借看起来很像c或者java的关键字按照自己的理解写javascript代码。其实 javascript是一种很独特的语言，和c++/java有非常大的区别，要想用javascript做大一些的项目，开发人员必须老老实实的学习 javascript的语法。真正掌握了语法后，我们才不会把delete看成释放内存对象，才不会为到底参数传递是值传递还是引用传递而烦恼。真正理解了javascript的基于原型的OO方式，才可能写出具有良好架构的javascript程序。
   [color=Green]《javascript权威指南》[/color]是一本最合适的书，郑重推荐。另外[url=http://www.ecma-international.org/publications/standards/Ecma-262.htm][color=Green]ECMA262[/color][/url] 文档可以作为参考。网上流行的jscript手册chm版本使用起来比较方便，不过这是微软的jscript实现，和标准的javascript略有区别，使用时应该注意上面的注脚信息。关于javascript的原型和OO,网上已经有很多文章介绍了，在此不再多说。

[b]二。良好的代码来源于良好的设计[/b]
   只有设计优良，代码才会写的漂亮。现在的javascript子项目已经不是以前web项目中的“边角料”和散兵游勇了，在较大的ajax项目内， javascript将非常复杂，ajax的异步模型也和以前顺序执行的程序设计有所区别。所以建议做javascript前首先做好设计。推荐使用用例驱动的方式，把用例分析清楚，以便全局考虑所有可能的页面交互过程，绘出页面内一些对象之间的交互图，分析一些数据对象的状态，作出精细的 javascript设计。

[b]三。使用设计模式，复用其他领域的设计经验[/b]
      如果javascript非常复杂，可以考虑使用一些模式。我想大部分做javascript的开发者都不是“javascript科班”出身吧[img]掌握了javascript的语言本质，就可以复用我们在其他领域的经验了。使用javascript框架或者ajax框架，使用单例模式做一个全局的数据缓冲池，或者使用观察者模式把界面对象和数据对象分离，使用命令模式实现用户的操作队列等等。

[b]四。调试代码的技巧[/b]
      javascript的代码不太好调试，这是由于：

[b]* 一般的开发人员对javascript语言本身不太精通[/b]。也就是上面提到的。
[b]* web项目包含较多的因素[/b]，复杂性加剧。服务端脚本、模板、html、js等很多环节都可能增加调试难度。
[b]* 浏览器存在兼容性问题[/b]。有可能在一个细节问题上IE、Mozilla、opera等浏览器都有差异。
[b]* 工具的缺乏[/b]。虽然mozilla的jsdebugger非常好用（还有bug，比如eval时调试器有些问题），但是其他浏览器环境下调试工具就不怎么样了。ms系统自带的script debug工具调试本地代码还可以，直接调试网站js代码表现欠佳。opera除了javascript控制台外我没有找到其他调试工具。

   在此我推荐几个调试技巧：

[b]1. 使用Mozilla firefox的jsdebugger插件。[/b]这个我不再多说了，最经典的js调试工具。在线调试远程站点的javascript效果非常棒。
[b]2. 把问题隔离，建立本地的html文件和js文件，使用ms script debug调试工具来调试。[/b]如果js模块比较独立，可以使用这个工具的。如果写hta的项目，这个工具当然是首选了。
[b]3. httpWatch[/b] 这是一个ie下的插件，非常好用，能够监视ie中的任何http会话，并能够看到http会话的原文。可以通过这个工具了解你的程序有没有和服务器产生会话，参数＆返回的数据到底是什么。
[b]4. 在网页内建立用于调试的textarea[/b]
   可以在网页内建立一个textarea来接受你想运行的js语句，然后加一个按钮使用js的eval函数执行你输入的代码。
   这种方式非常适合在线调试，网页出错后写代码输出页面内的对象值。建议写一些dump工具函数配合使用，效果更佳。
   我非常喜欢这种方式，可以随时使用开关打开页面内隐藏的textarea进行调试，感觉很像给一台服务器接上了终端，然后使用shell可以做任何事情函数可以在这里重新定义，可以任意操作界面中的任何元素，调用任何对象的任何函数，输出任何你需要的运行时刻值。
[b]5. 使用异常(exception)和断言(assert)[/b]
   使用try{}catch(e){}结构不光可以屏蔽出错信息，让界面更友好。我们的程序可以使用异常、抛出异常来构建一种更好的出错处理机制。
   有这样一个故事，我在使用string.localeCompare函数时随手写了这样的代码：
   var iRe = str1.localeCompare(str2);
   switch(iRe){
   0: return ....
   1: return ....
   -1:return ....
   defalut:throw "error:localeCompare return other value"
   }
   写完就忘了，没想到我的同事在linux下使用firefox时，异常被抛出了，然后我们得知：linux firefox下localeCompare返回的不只是0/1/-1,而是返回一个具体值.
   这个异常抛出有效的检测出了代码的不完美。

   firefox下的异常dump后能得到较为详细的调用栈信息，这一点非常好。IE的异常信息没有这么详细。

   异常和断言也可以结合成为一个非常有效的调试工具。
   断言(assert)是在其他语言中的一种很有效的调试工具，常常以这种形式出现：
   assert(  ) ;
   在程序处于debug状态，当条件为假时，系统中止运行并报告这个断言。由于断言是我们自己定义的，所以我们可以很容易的判断出出错的地方，进而找到bug所在。
   javascript语言没有提供宏，也没有提供assert，我们可以这样模拟
   if(_is_debug) assert = function(expression , strLable){
      if( !expression ) throw Error(strLable);
   }
   else assert = function(){};//_is_debug是一个全局变量
   这样可以实现在发生"不可能的事情"的时候，让程序在调试模式下抛出异常，在发布版本中不作理会。

   可以这样输出当前栈的调用信息,弥补刚才提到的IE中异常对象没有栈信息的缺陷:
   function callStackInfo(){
   var s="",line="";
   var cer=arguments.callee.caller;
   while(cer){
   var sf=cer.toString();
   s+=line+sf.substring(sf.indexOf('function'),sf.indexOf('{'))+"\n";
   line=".."+line;
   cer=cer.caller;
   }
   return s;
   }

   本文只就javascript在web开发，特别是在ajax方面的开发做了一些讨论，主要在于管窥如何更好的使用“纯javascript”。web开发还有很多其他方面，比如xml和Dom等实际上和javascript息息相关，但是本文没有涉及，还请见谅。欢迎各位朋友就我的讨论多提意见。

xyz 2007-12-09 15:20 发表评论

获取客户端IP地址的方法

xyz — Sun, 02 Dec 2007 09:00:00 GMT

java 代码

1private final String getClientAddress(HttpServletRequest request) {
2
3    String address = request.getHeader("X-Forwarded-For");
4
5    if (address != null && StringUtil.isIPAddress(address)) {
6
7        return address;
8
9    }
10
11    return request.getRemoteAddr();
12
13}
14

另外原因主要是Squid的使用：

参见：www.blogjava.net/Alpha/archive/2006/07/12/57764.aspx

在很多应用下都可能有需要将用户的真实IP记录下来，这时就要获得用户的真实IP地址，在JSP里，获取客户端的IP地址的方法是：request.getRemoteAddr()，这种方法在大部分情况下都是有效的。但是在通过了Apache,Squid等反向代理软件就不能获取到客户端的真实IP地址了。

这段时间在做IP统计的程序设计，由于服务器作了集群，使用了反向代理软件，将http://192.168.1.110:2046/的URL反向代理为http://www.xxx.com/的URL时，用request.getRemoteAddr()方法获取的IP地址是：127.0.0.1　或　192.168.1.110，而并不是客户端的真实ＩＰ。这是什么原因呢？

这是反向代理的原因。经过代理以后，由于在客户端和服务之间增加了中间层，因此服务器无法直接拿到客户端的IP，服务器端应用也无法直接通过转发请求的地址返回给客户端。但是在转发请求的HTTP头信息中，增加了X－FORWARDED－FOR信息。用以跟踪原有的客户端IP地址和原来客户端请求的服务器地址。当我们访问http://www.xxx.com/index.jsp/时，其实并不是我们浏览器真正访问到了服务器上的index.jsp文件，而是先由代理服务器去访问http://192.168.1.110:2046/index.jsp，代理服务器再将访问到的结果返回给我们的浏览器，因为是代理服务器去访问index.jsp的，所以index.jsp中通过request.getRemoteAddr()的方法获取的IP实际上是代理服务器的地址，并不是客户端的IP地址。

xyz 2007-12-02 17:00 发表评论

BlogJava-xyz's blog-文章分类-网络文摘

轻松实现Apache,Tomcat集群和负载均衡

实践中整理出tomcat集群和负载均衡

Tomcat集群与负载均衡

freemarker 点滴

FreeMarker概述

Hello world

空值的处理

freemarker国际化模板

在struts项目中使用freemarker

Hello ${user}!

freemarker用struts标签做国际化

freemarker直接使用资源文件进行多语言国际化

常用的2种加载模板的方式

freemarker 基本指令

学习FreeMarker（一）

acegi初体验

JSTL详解--EL表达式

jstl之foreach循环

JSP页面EL表达式无效的问题

来源：http://gimgen1026.javaeye.com/category/

Hibernate级联保存和更新

优化程序之前，可用Jamon来监测你的Spring应用

由DWR1.0到DWR2.0常出现的问题

DWR总结

struts+spring+hibernate+DWR

代码重构

Hibernate+Spring 对DAO的处理实列!

如何使用Log4j？

史上最简单的struts+spring+hibernate配置实例[修订版]

在myeclipse下整合spring和hibernate（转载）

使用 Spring 更好地处理 Struts 动作 三种整合 Struts 应用程序与 Spring 的方式

Myeclipse平台struts+hibernate+spring项目开发示例来来源

JAVA高级：JavaVM，反射机制与动态代理

【经典推荐】每个初学者都应该搞懂的问题！

Java 关于中文乱码问题的解决方案与经验

JAVA反编译工具

JAVA反编译工具

abstract class和interface的区别

关于AutoComplete（文本框的自动填充）

从javascript语言本身谈项目实战

获取客户端IP地址的方法

使用 Spring 更好地处理 Struts 动作三种整合 Struts 应用程序与 Spring 的方式