BlogJava-xiekai-blog-随笔分类-JAVA相关技术

利用MAP进行排序

小言身寸 — Thu, 29 Nov 2007 07:40:00 GMT

假设List myList 中存放了n个数据对象，每个数据对象包含m个属性。现在要将这n个数据对象按照某一个或几个属性值重新排序，得到排序后的List。为此，可以利用java中的TreeMap来方便地实现。
再具体一些，假设这n个数据对象类型为MyEntity, 其中有A, B, C, D, E五个属性，现要依次按照A, E, B的升序来排序。

//排序
Map map = sortMyEntity(myList);
//得到排序后的List
myList = convertMapToList(map);

/**
*sortMyEntity方法的实现
*/
public Map sortMyEntity(List myList) {
    Map sortMap = new TreeMap();
    for (int i = 0; i < myList.size(); i++) {
        MyEntity entity = (MyEntity)myList.get(i);
        String key = entity.getA().toString() + ":" + entity.getE().toString() + ":" + entity.getB().toString();
        sortMap.put(key, entity);
    }
    return sortMap;
}

/**
*将排序后的Map转换回List
*/
public List convertMapToList(Map sortMap) {
    List resultList = new ArrayList();
    Iterator itKey = sortMap.keySet().iterator();
    while (itKey.hasNext()) {
        String key = (String)itKey.next();
        MyEntity entity = (MyEntity)sortMap.get(key);
        resultList.add(entity);
    }
    return resultList;
}

小言身寸 2007-11-29 15:40 发表评论

Weblogic远程重启动命令

小言身寸 — Mon, 02 Jul 2007 08:42:00 GMT

Deploy的时候，有时需要重启weblogic，方法如下：

1）通过Tera Term Pro这样的工具，连接服务器。端口23。
※也可以直接用cmd命令行窗口，输入telnet IP 。例如：telnet 11.111.11.11
2）按照提示，输入用户名和口令
3）登陆成功后，就可以输入停止、启动weblogic的命令了，如下：
     stop:
     sudo /etc/init.d/weblogic stop

     start:
     sudo /etc/init.d/weblogic start

4）有时，stop之后，进程还没有结束，还在停止中状态，这时需要等待。可通过下面的命令查看进程是否停止了：
     ps ax|grep
    例如： ps ax|grep "mfserver\|myserver"

小言身寸 2007-07-02 16:42 发表评论

取得最小开始日期，JAVA中Set和Iterator的使用一例

小言身寸 — Wed, 23 May 2007 05:34:00 GMT

     //画面表示する開始日を判断する為のSET
     Set strYmdSet = new HashSet();

     strYmdSet.add(strYmd1().toString());
     strYmdSet.add(strYmd2().toString());
     。。。
     strYmdSet.add(strYmdn().toString());

    /**
     * セットから最小の開始日を取得します。
     *
     * @param strYmdSet 開始日のセット
     * @return 最小の開始日
     */
    private String getMinStrYtiYmd(Set strYmdSet) {
        String minStrYmd = "99999999";

        Iterator itr = strYmdSet.iterator();
        while (itr.hasNext()) {
            String strYmd = (String) itr.next();
            if (strYmd == null) {
                strYmd = "";
            }
            if (minStrYmd.compareTo(strYmd) > 0) {
                minStrYmd = strYmd;
            }
        }
        return minStrYmd;
    }

小言身寸 2007-05-23 13:34 发表评论

WebLogic 如何设置session超时时间

小言身寸 — Tue, 13 Feb 2007 07:17:00 GMT

1 web.xml

设置WEB应用程序描述符web.xml里的元素。这个值以分钟为
单位，并覆盖weblogic.xml中的TimeoutSecs属性

54

此例表示Session将在54分钟后过期
当设置为－2，表示将使用在weblogic.xml中设置的
TimeoutSecs这个属性值。
当设置为－1，表示Session将永不过期，而忽略在
weblogic.xml中设置的TimeoutSecs属性值。
该属性值可以通过console控制台来设置

2 weblogic.xml

设置WebLogic特有部署描述符weblogic.xml的元素的
TimeoutSecs属性。这个值以秒为单位


      TimeoutSecs
      3600


默认值是3600

小言身寸 2007-02-13 15:17 发表评论

RiA：Rich Internet Application（C/B/S架构）

小言身寸 — Fri, 15 Sep 2006 09:46:00 GMT

RiA：Rich Internet Application（C/B/S架构）

Coofucoo http://blog.csdn.net/coofucoo/archive/2006/03/17/626909.aspx

RiA就是Rich Internet Application的缩写。
“Rich”代表功能强大，高交互性，高用户体验。
“Internet”代表方便。应用程序部署方便，用户使用方便。跨系统，跨语言。

其实RiA实际上一种基于Web的C/S架构（我称之为C/B/S）。由于有一个客户端，所以RiA应用可以提供强大的功能，让用户体验到高交互性，高用户体验。同时，RiA又是基于Internet浏览器的应用，所以，用户使用RiA非常方便。理想来说，用户使用RiA应当像现在使用普通网页一样方便。用户不需要安装任何的客户端软件，只要拥有浏览器。当用户通过浏览器发出指令，希望运行某种RiA应用程序时，一切都会飞快的建立在客户端机器上，就像你在Web上点击一个页面一样。

目前，典型的RiA的代表有如下几种技术：
MS ClickOnce
Sun Java Web Start
Adobe Flash
Ajax

RiA实际上代表的是一种回归。

最开始流行的C/S结构，因为功能强大，而且范围有限，不需要害怕部署问题。之后随着用户的增加，部署问题越来越大，导致B/S模式的产生。
B/S模式虽然功能有限，但是却使用非常方便。从长期来看，方便的作用还是非常巨大的。功能可以不断增强，但是如果不方便，将吓走所有的客户。实际上观察一下Web的发展，就会发现，如今百花齐放的Web开发技术，其目的都是为了提高B/S架构的交互性，让他更能适应需要而已。
不过，随着目前越来越多的应用需要一直到Web上，人们终于发现B/S模式的缺点。各种技术上的硬性问题均限制着B/S模式的发展。从最基本的请求/相应模型，HTTP协议，到所有负载均运行在服务器上的事实，让我们迫切需要一种方式来提高Web的交互能力，但同时又不能丧失它的使用方便性。
于是，RiA诞生了。RiA就是基于浏览器的C/S结构。它将部分的服务器负载转移到客户端，同时又不会丧失使用和部署上的方便性。
所以说，RiA就是一次回归，只不过这次回归我们没有原地不动，相反，我们找到了最佳结合点，也就是C/S和B/S的交集。

小言身寸 2006-09-15 17:46 发表评论

用Ant构建Java项目（续）

小言身寸 — Thu, 31 Aug 2006 03:42:00 GMT

这一篇讲述如何自动运行JUnit测试进行自动化测试。我们将JUnit测试放在test目录。
第一步：编译测试
首先，在build.xml文件里定义一个单独的构建目标，以便编译测试源文件。





compile-tests目标用任务在test.dir目录编译测试源文件，并将结果类文件放入build.test.dir目录，用project.classpath路径作为测试代码的类路径。
第二步：运行测试
在build.xml文件里定义构建目标，使所有的JUnit测试自动运行。





                  includes="**/*Test.class" />





test目标的depends属性生成与刚定义的compile-tests目标的依存关系。
如果构建成功，意味着所有的东西不仅都编译过，还都通过了测试。
将haltonfailure属性设为true会使构建随着任何测试失败而失败。
这里我们再次用project.classpath定义了运行JUnit测试的类路径。
下面定义了一个输出格式化器，在元素中，使用brief类型来输出每个运行的测试用例的名称及其统计信息，仅当测试失败时才有更详细的信息（plain类型默认比brief类型输出信息多一些；xml类型将测试结果以XML格式输出）。将usefile属性值设为false会将测试结果送往控制台，而不是写入文件。
任务收集从封闭元素中返回的所有测试，并自动创建包含了所有测试的测试suite。我们将对所有的测试类用*Test.java命名约定取名，这些文件将编译成*Test.class文件，放在的build.test.dir性质指向的目录中。
最后，元素定义系统性质为一个键值对，这些性质可以在测试代码中访问。这里，测试需要知道从哪里找到文档，以及向哪里放入文档的索引结果，在运行测试时我们将传递这些结果，例如，测试在运行时查看送入的doc.dir系统性质来定位项目目录结构中doc目录的绝对路径。
要运行测试，请执行test目标：
$ ant test
最后，打扫战场
我们可以定义一个删除所有构建输出的Ant目标。



clean目标使用任务来删除build.dir所指的目录。要删除目录，请运行clean目标：
$ ant clean
冲掉这些构建输出有积极的作用：从头开始生成构建，可以发现可能被累积构建掩盖的错误。

完整的build.xml：

xml version="1.0"?>

<project name="dms" default="compile" basedir=".">

  <property name="build.dir"      location="build"/>
  <property name="build.prod.dir" location="${build.dir}/prod"/>
  <property name="build.test.dir" location="${build.dir}/test"/>
  <property name="doc.dir"        location="doc"/>
  <property name="index.dir"      location="index"/>
  <property name="src.dir"        location="src"/>
  <property name="test.dir"       location="test"/>
  <property name="vendor.lib.dir" location="vendor/lib"/>

  <path id="project.classpath">
    <pathelement location="${build.prod.dir}" />
    <pathelement location="${build.test.dir}" />
    <fileset dir="${vendor.lib.dir}">
      <include name="*.jar"/>
    fileset>
  path>

  <target name="prepare">
    <mkdir dir="${build.prod.dir}"/>
    <mkdir dir="${build.test.dir}"/>
  target>

  <target name="compile" depends="prepare">
    <javac srcdir="${src.dir}" destdir="${build.prod.dir}">
      <classpath refid="project.classpath" />
    javac>
  target>

  <target name="compile-tests" depends="compile">
    <javac srcdir="${test.dir}" destdir="${build.test.dir}">
      <classpath refid="project.classpath" />
    javac>
  target>

  <target name="test" depends="compile-tests">
    <junit haltonfailure="true">
      <classpath refid="project.classpath" />
      <formatter type="brief" usefile="false" />
      <batchtest>
        <fileset dir="${build.test.dir}"
          includes="**/*Test.class" />
      batchtest>
      <sysproperty key="doc.dir"   value="${doc.dir}" />
      <sysproperty key="index.dir" value="${index.dir}" />
    junit>
  target>

  <target name="clean">
    <delete dir="${build.dir}" />
  target>

project>

下面再举一个实际项目中用到的构建文件的例子：

xml version="1.0" ?>

<project name="JSBook" default="compile" basedir=".">

  <property environment="env" />
  <property name="src" value="WEB-INF/src" />
  <property name="classes" value="WEB-INF/classes" />
  <property name="lib" value="WEB-INF/lib" />
  <property name="dist" value="dist" />

  <path id="task.classpath">
    <pathelement location="${classes}" />
    <pathelement location="${lib}" />

    <pathelement location="${lib}/servlet-api.jar" />

    <pathelement location="${lib}/jsp-api.jar" />
  path>

  <target name="init" >
    <echo>Init Complete !echo>
    <echo>ant home = ${ant.home} echo>
    <echo>java home = ${java.home} echo>
    <echo>user home = ${user.home} echo>
  target>

  <target name="compile" depends="init" >
    <javac classpathref="task.classpath" srcdir="${src}" destdir="${classes}" />
    <echo level="verbose">Seen with -verboseecho>
    <echo level="debug">Seen with -debugecho>
    <echo>Compilation Complete !echo>
  target>

  <target name="war" >
    <jar jarfile="${dist}/JSPBook.war" basedir="."/>
  target>

project>

也许你已经看出来了，这就是〈〈jsp2.0技术手册〉〉里面的build.xml文件啦！

小言身寸 2006-08-31 11:42 发表评论

用Ant构建Java项目

小言身寸 — Wed, 30 Aug 2006 09:36:00 GMT

Ant是一个开放源代码的构建工具，专门用于构建Java项目。
Ant入门的最容易的方法就是编写一个构建文件------build.xml。当Ant运行时，会在当前目录下寻找名为build.xml的文件。

编写Ant构建文件：
第一步：定义项目(project)
在项目根目录下创建build.xml文件。第一行指明其为XML格式，然后在第二行定义项目。

一个Ant构建文件定义一个项目，使用元素的name属性命名项目，将default属性设为compile，告诉Ant当你在命令行键入ant而无其他参数时，将执行构建过程的compile步骤。我们稍候将定义此步骤；将basedir属性设为"."，告诉Ant，该构建文件内的全部其他路径都是相对于build.xml文件所在路径而言的。
第二步：定义性质(property)
下一步，为项目的每一个目录定义性质，以便让Ant了解项目的目录结构。

location属性所指的目录相对于元素定义的basedir属性值（基目录）。
使用Ant性质命名相对目录有两个优点。首先，当Ant运行构建文件时，会定位build.xml文件所在目录的全部相对目录。第二个好处是，性质可以使构建文件易于维护。例如用build.dir性质指代build目录，当以后决定更改build目录为classes时，只要修改build.dir性质的location属性值即可。在构建文件中所有引用build.dir性质的地方，都将会自动指向新的classes目录。
第三步：定义路径(path)
下面定义表示项目Java类路径的路径。







元素创建路径project.classpath。我们将在构建过程的编译步骤用到此路径。
首先，用元素向路径加入两个构建目录，以便Java编译器可以找到所有的类文件，然后使用元素，加入所有厂家.jar文件至此路径，使Java编译器可以找到我们用到的厂家类。
第四步：定义目标(target)
接着我们定义首个构建步骤------称为“目标”。该目标创建编译步骤将要存放Java类文件的目录。




目标只是定义了一系列任务按照指定的顺序执行的有名字的构建步骤。prepare目标使用任务创建构建输出目录，这与在命令行上执行mkdir是等效的。但前者可以工作于任何操作系统下，不会因为目录已经存在而失败，而且必要时会创建父目录。
第五步：定义编译步骤
终于我们可以定义编译步骤了。他将编译所有的产品源文件，将结果类文件放到prepare目标所生成的目录下。





通过目标的depends属性，可以生成目标间的依存关系，从而指定目标顺序。该属性值是一个目标名间用逗号隔开的清单。
例如，compile目标使用depends属性来声明与prepare目标的依存关系，这意味着要运行compile目标必须首先运行prepare目标，以在编译源文件前生成要求的目录。与shell脚本或批处理文件总是顺序执行命令相比，这是一个很大的优点。
prepare目标运行后，compile目标运行任务，从而调用Java编译器。编译器处理src.dir性质所指目录下的全部Java源文件，在build.prod.dir性质所指目录下生成对应的类文件。
元素告诉编译器使用project.classpath代表的值作为类路径。

下面是完整的构建文件：

运行构建：
在命令行环境中，切换至build.xml所在的目录，运行Ant：
D:\MyProject> ant
运行Ant前，请确认ANT_HOME环境变量指向你的Ant安装目录，且PATH环境变量中加入了%ANT_HOME%\bin。
Ant读取build.xml，以预先定义的顺序执行构建步骤（目标）。

小言身寸 2006-08-30 17:36 发表评论

TOMCAT创建和发布WEB应用(TOMCAT与Java Web开发技术详解第二章阅读笔记)

小言身寸 — Tue, 22 Aug 2006 03:00:00 GMT

本来准备自己整理的，结果发现网上有现成的，爽，省了好多功夫，稍作修改，如下：

TOMCAT 的目录结构

目录	描述
/bin	存放 windows 或 Linux 平台上启动和关闭 Tomcat 的脚本文件
/conf	存放 Tomcat 服务器的各种配置文件，其中最重要的是 server.xml
/server	包含三个子目录： classes 、 lib 和 webapps
/server/lib	存放 Tomcat 服务器所需的各种 jar 文件（只能被Tomcat服务器访问）
/server/webapps	存放 Tomcat 自带的两个 WEB 应用： admin 应用和 manager 应用
/common/lib	存放 Tomcat 服务器以及所有 web 应用都可以访问的 jar 文件
/shared/lib	存放所有 web 应用都可以访问的 jar 文件（但是不能被 Tomcat 服务器访问）
/logs	存放 Tomcat 的日志文件
/webapps	当发布 Web 应用时，默认情况下把 Web 应用文件放于此目录
/work	Tomcat 把由 JSP 生成的 Servlet 放于此目录下
WEB应用的目录结构假设在 /webapps 下有 helloapp 的 web 应用，如下：
/helloapp	Web 应用的根目录，所有的 jsp 文件和 html 文件都在此目录下
/helloapp/WEB_INF	存放 web 发布时的描述文件 web.xml
/helloapp/WEB_INF/class	存放各种 class 文件， Servlet 文件也存放于此目录下。
/helloapp/WEB_INF/lib	存放各钟 Web 应用所需要的 jar 文件。比如可以存放 JDBC 驱动程序的 JAR 文件
配置虚拟主机 ------Host 元素的属性
name	指定虚拟主机名字
debug	指定日志级别
appBase	指定虚拟主机目录，可以是绝对目录，也可以指定相对于的相对目录。如果此项没有设定则默认的是 /webapps 。
unpackWARs	如果此项设置为 true ，表示将把 Web 应用的 WAR 文件先展开为开放目录结构后再运行。如果为 false , 则直接运行 WAR 文件
autoDeploy	如果此项设置为 true ，表示当 Tomcat 服务器处于运行状态时，能够监测appBase下的文件，如有新的 Web 加入进来，则会自动发布这个 Web 应用。
alias	指定虚拟主机的别名，可以指定多个别名。
deployOnStarup	如果此项设为 true，则表示 Tomcat 服务器启动时会自动发布 appBase 目录下的所有 Web 应用。如果 Web 应用在 server.xml 中没有相应的元素 , 则将采用默认的 Context 配置。 deployOnStarup 的默认设置是 true
在server.xml中加入元素 ------Context 元素属性
path	指定 Web 应用的 URL 入口
docBase	指定 Web 应用的文件路径，可以给定绝对路径，也可以是相对于 Host 的 appBase 属性的相对路径（参见上面 Host 的 appBase 属性）。如果 Web 应用采用开放目录结构，则指定 Web 应用的根目录；如果 Web 应用是个 WAR 文件，则指定 WAR 文件的路径。
reloadable	如果为 true ,Tomcat 服务器在运行状态下会监视在 WEB-INF/class 和 WEB-INF/lib 下 class 文件的改动。如果检测到有 class 文件更新，服务器会自动载入 Web 应用。
在web.xml中加入和元素 ------ 元素的属性
	定义 Servlet 的名字。
	指定实现这个 Servlet 的类。
	定义 Servlet 的初始化参数（包括参数名和参数值），一个元素中可以有多个元素。
	指定当 Web 应用启动时，装载 Servlet 的次序。当这个值为正数或零， Servlet 容器先加载数值小的 Servlet ，再依次加载其他数值大的 Servlet 。如果这个值为负数或没有设定， Servlet 将在 Web 客户首次访问这个 Servlet 时加载它。

小言身寸 2006-08-22 11:00 发表评论

java中连接Oracle数据源

小言身寸 — Tue, 08 Aug 2006 02:49:00 GMT

本地不安装Oracle，用JAVA实现连接Oracle数据源：

数据库服务器：lips-db 端口：1521 数据库名：JAVATECH
连接用户名：ebt 连接密码：ebt06

import java.sql.*;
/**
*

Title:

*
*

Description:

*
*

Company:

*
* @author not attributable
* @version 1.0
*/
public class Welcome {

    public static Connection getConnect() throws SQLException
    {
        DriverManager.registerDriver(new oracle.jdbc.OracleDriver());
        Connection conn = DriverManager.getConnection(
            "jdbc:oracle:thin:@lips-db:1521:javatech", "ebt", "ebt06");
        return conn;
    }

    public static void main(String[] args) {
        try {
            Connection conn = Welcome.getConnect();
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery("select * from tbm_student");

            ResultSetMetaData rsmd = rs.getMetaData();
            for (int i = 1, n = rsmd.getColumnCount(); i <= n; i++)
            {
                System.out.print(rsmd.getColumnName(i));
                System.out.print(",");
                System.out.print(rsmd.getColumnClassName(i));
                System.out.print(",");
                System.out.print(rsmd.getColumnTypeName(i));
                System.out.println("");
            }
        }
        catch (SQLException se) {
            //
        }
        catch (Exception ex) {
            //
        }
    }
}

要成功运行，还需要引入classesxx.jar或者classesxx.zip：

xml version="1.0" encoding="UTF-8"?>
<classpath>
    <classpathentry kind="src" path=""/>
    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
    <classpathentry kind="lib" path="C:/oracle/ora92/jdbc/lib/classes12.jar"/>
    <classpathentry kind="output" path=""/>
classpath>

小言身寸 2006-08-08 10:49 发表评论

J2EE中的EJB和EJB Container

小言身寸 — Fri, 04 Aug 2006 03:41:00 GMT

J2EE中两种主要容器(Container)
1 Servlet/JSP Container
2 EJB Container

EJB究竟是什么？说一个不很恰当的比喻，EJB就像你,一个公司做软件开发工作的员工。你是EJB，公司就是EJBContainer. 公司(Container) 负责与外界打交道，比如销售商，客户，工商，税务，银行等等。你(EJB)就可以专心做软件开发。公司(Container)还负责员工(EJB)之间的协调。当然了公司和员工是双向选择的。EJB和Container也是这样。所以J2EE&Container&EJB不是突发奇想,也不是天外来客，就是我们..............

下面是网上copy的一些名词定义，比较晦涩，希望大家踊跃给出更形象生动而又不失准确的定义。

EJB
　　Enterprise JavaBeans，Java中用于开发企业级应用的技术标准，他定义了一个用于开发和发布可重用的服务器端组件的模型，包括Session beans，Entity beans以及Message-driven beans三种。

Container 容器
　　一个为组件提供生命周期管理，安全，配置，和运行时服务的实体。每一个类型的容器（EJB, Web, JSP, servlet, applet, 和application client）也会提供各自组件相关的服务

servlet container
　　一个提供网络服务的容器，通过它，请求和应答被传送，请求被解码，应答被格式化。所有的servlet container必须支持HTTP协议的请求和应答，也可以支持其它的请求应答型协议比如HTTPS。

JSP container
　　一个提供和servlet容器同样服务的容器和一个把JSP页面转换成servlet的引擎。

EJB container EJB容器
　　一个实现了J2EE体系结构中EJB组件规范的容器。这个规范指定了一个Enterprise bean的运行时环境，包括安全，一致性，生命周期，事务，配置，和其他的服务。一个EJB容器可以由EJB或者J2EE服务器提供。

Web container
　　实现J2EE体系结构中Web组件协议的容器。这个协议规定了一个Web组件运行时的环境，包括安全，一致性，生命周期管理，事务，配置和其它的服务。一个提供和JSP和J2EE平台APIs界面相同服务的容器。一个Web container 由Web服务器或者J2EE服务器提供。

小言身寸 2006-08-04 11:41 发表评论

TOMCAT简介(TOMCAT与Java Web开发技术详解第一章阅读笔记)

小言身寸 — Wed, 12 Jul 2006 05:18:00 GMT

Tomcat 服务器是一个 Servlet/Jsp 容器 . 不但支持运行 Servlet 和 Jsp , 还具备作为商业 Java Web 应用容器的特性 , 如 Tomcat 管理和控制平台 , 安全域管理 , Tomcat 阀等 .

Tomcat 作为 Servlet 容器 , 负责把客户请求传送给 Servlet 并把响应结果返回给客户 . 当客户请求某个 Servlet 时 , Servlet 容器将首先创建一个 ServletRequest 对象和 ServletResponse 对象 ( 在 ServletRequest 对象中封装了客户请求信息 ), 然后 Servlet 容器把 ServletRequest 对象和 ServletResponse 对象传给客户所请求的 Servlet , Servlet 把响应结果写到 ServletResponse 中 , 最后由 Servlet 容器把响应结果传给客户 .

Tomcat 的结构 : Tomcat 服务器由一系列可配置的组件构成 . 这些组件在 / conf/server.xml 文件中进行配置 , 每个 Tomcat 组件在 server.xml 文件中对应一种配置元素 .
server.xml 的结构如下 :

<Server>
  <Service>
    <Connector/>
    <Engine>
      <Host>
        <Context>
        Context>
      Host>
    Engine>
  Service>
Server>

所有配置元素分为 4 类 :

1. 顶层类元素 : < Server> 元素和元素 .

2. 连接器类元素 : , 客户与服务器之间的通信接口 .

3. 容器类元素 : , 用于处理客户请求 .

4. 嵌套类元素 : 如 < Logger> , 代表可以加入到容器中的组件 .

元素:
代表整个Catalina Servlet容器 , 元素可以包含一个或多个元素.
元素:
  包含一个元素 , 以及一个或多个元素 , 这些元素共享一个元素.
元素:
  代表和客户实际交互的组件 , 负责接收客户请求 , 以及向客户返回响应结果.
元素:
  每个元素只能包含一个元素. 元素处理在同一个元素中所有元素接收到的客户请求.
元素:
  一个元素可以包含多个元素 , 每个元素定义了一个虚拟主机 , 它可以包含一个或多个web应用.
元素:
  每个元素代表了运行在虚拟主机上的单个web应用.一个元素可以包含多个元素.

Tomcat 各个组件间的嵌套关系如下图所示 :

Tomcat各个组件间响应客户请求的过程如下图所示:

Tomcat 的工作模式 .

1. 独立的 Servlet 容器 .( Tomcat 的默认工作模式 )

2. 进程内的 Servlet 容器 .( 与其它 Web 服务器集成 )

3. 进程外的 Servlet 容器 .( 与其它 Web 服务器集成 )

Servlet容器响应Web客户请求流程的URL时序图，如下：

小言身寸 2006-07-12 13:18 发表评论

JSP与Servlet(1) - 第一个servlet

小言身寸 — Mon, 03 Jul 2006 05:40:00 GMT

摘要: 什么是servlet ? 一个 servlet 就是 Java 编程语言中的一个类 , ... 阅读全文

小言身寸 2006-07-03 13:40 发表评论

MyEclipse + Tomcat + Eclipse 开发struts应用

小言身寸 — Fri, 30 Jun 2006 06:34:00 GMT

在MyEclipse环境下开发struts,网上已经有很多很详细的叙述,今天弄了一个上午,终于成功地将一个登录认证程序实现了.感觉还是比较简单的,但还是遇到了一些问题,花费了不少时间,小结一下:

1.要注意struts1.1和struts1.2这两个不同的版本.因为是开源的,版本变动有时候会很大,如果对其不了解,很容易在开发中遇到各种奇怪的问题.常见的是使用标签引起的错误.
如果是struts1.2,在Action或者Form的validate中可以这样写:
ActionErrors errors = new ActionErrors();
if(......){
errors.add("name", new ActionMessage("error"));
}
如果是struts1.1,则必须将ActionMessage改为ActionError.

2.在MyEclipse配置项中有一项叫作Validation,默认设置如下图所示:

因此在我写好JSP,编译后,发现代码行的左边有好几个红叉叉,可是代码又能正常运行,如下图:

不知道这个Validation有什么作用,到底做的是怎样的代码检查我也不清楚,如有知道的,还望不吝赐教.

小言身寸 2006-06-30 14:34 发表评论

关注 struts, jsf, 甚至ajax

小言身寸 — Wed, 28 Jun 2006 10:59:00 GMT

MVC结构到今天，已经到了顶峰。

在2000年初诞生的Struts以及其他类似的 MVC(Model View Controler)框架主要都是以操作为中心，且都是无状态的开发模型，而现在，基于组件(component-based)和事件驱动(event- driven)的开发模型逐渐流行起来，在很多时候都成了Struts的有利竞争者，这其中来自jcp的JavaServer Faces(JSF)以及来自apache的Tapestry是其中的佼佼者。

struts也好类似的webwork也好，尽管其有一定的优势，但不可避免的要衰亡，但谁来代替它们？
jsf？tapestry？甚至ajax？

现在很难说。
jsf在各大家的支持下，正在茁壮成长，tapestry还没有看到成为主流的迹象，ajax虽然热火，但还不是非常成熟。

就目前趋势看,感觉jsf将会成为主流。

Ajax基础教程

   ajax入门推荐书籍.书中讲解了ajax出现得背景 , 相关得技术.最有价值得是书中   第5章  构建完备的Ajax开发工具箱  第6章  使用JsUnit测试JavaScript代码  第7章  分析JavaScript调试工具和技术这三章花25块钱也值了.
   该书定位很准 , 对高级知识没有讲解 , 只为入门.

   推荐指数:  4星.
   推荐理由: 绝对最好的入门书籍 , 尤其是把最先进的ajax开发方式介绍给大家.

小言身寸 2006-06-28 18:59 发表评论

使用 JSF 架构进行设计(转载)

小言身寸 — Wed, 28 Jun 2006 10:21:00 GMT

Anand Prakash Joshi , 软件工程师, IBM

2006 年 1 月 04 日

本文中，作者 Anand Joshi 使用 JSF 框架中的设计模式阐释了 JavaServer™ Faces (JSF) 体系结构。他讨论了 JSF 体系结构中使用的 GoF 设计模式，以及这些模式在 JSF 框架中的作用。任何对设计模式和 JSF 体系结构有一定了解的人都能从 Anand 详细的介绍中有所收获。*读者应该对 GoF 设计模式和 JSF 技术有很好的了解。

设计模式可以帮助用户在更高层次上抽象细节，更好地理解体系结构。如果比较熟悉 GoF 设计模式和 JavaServer Faces (JSF) 框架，本文可以帮助您洞察 JSF 框架中使用的设计模式，深入理解其工作原理。

本文探讨了 JSF 框架中使用的设计模式。详细讨论的设计模式包括 Singleton、Model-View-Controller、Factory Method、State、Composite、Decorator、Strategy 、Template Method 和 Observer 模式。

设计模式和 JavaServer Faces (JSF) 技术

首先简要地介绍一下模式和 JSF 框架。

模式。设计模式是对问题和解决方案进行抽象的普遍适用的方法。因为模式是所有开发人员和架构师公认的，所以模式可以节约时间和资源。用外行话来说，模式就是关于某个人所共知的问题的经过验证的解决方案。模式可以重用，重用使得解决方案更健壮。
Java Server Faces。 JSF 体系结构是一种 Web 应用程序框架。它是 Java Community Process (JCP) 推动的，有望成为 Web 应用程序开发的标准框架。目前用于开发 Web 应用程序的框架有 50 多个，这说明迫切需要实现框架的标准化，这正是 JSF 框架的目标！

深入剖析 JSF 模式

现在我们来讨论 JSF 体系结构中的各种设计模式。本文将详细讨论 Singleton、Model-View-Controller、 Factory Method、State、Composite、Decorator、Strategy、Template Method 和 Observer 设计模式。我将分析每种模式的用途及其在 JSF 框架中的作用。

Singleton 模式

Singleton 模式的目的是保证类只有一个实例被加载，该实例提供一个全局访问点。当启动具有 JSF 支持的 Web 应用程序时，Web 容器初始化一个 FacesServlet 实例。在这个阶段，FacesServlet 对每个 Web 应用程序实例化 Application 和 LifeCycle 实例一次。这些实例就采用众所周知的 Singleton 模式，通常只需要该类型的一个实例。

使用 JSF 的 Web 应用程序只需要 Application 和 LifeCycle 类的一个实例。LifeCycle 管理多个 JSF 请求的整个生命期。因为其状态和行为在所有请求之间共享，这些对象采用 Singleton 模式合情合理。LifeCycle 维护的 PhaseListeners 也是 Singleton 模式的。 PhaseListeners 由所有 JSF 请求共享。在 JSF 框架中可以广泛使用 Singleton 模式，以减少内存占用和提供对象的全局访问。 NavigationHandler（用于确定请求的逻辑结果）和 ViewHandler（用于创建视图）也是使用 Singleton 模式的例子。

Model-View-Controller (MVC)

MVC 模式的目的是从数据表示（View）中将数据（即 Model）分离出来。如果应用程序有多种表示，可以仅替换视图层而重用控制器和模型代码。类似的，如果需要改变模型，可以在很大程度上不改变视图层。控制器处理用户动作，用户动作可能造成模型改变和视图更新。当用户请求一个 JSF 页面时，请求发送到 FacesServlet。 FacesServlet 是 JSF 使用的前端控制器 servlet。和其他很多 Web 应用程序框架一样，JSF 使用 MVS 模式消除视图和模型之间的耦合。为了集中处理用户请求，控制器 servlet 改变模型并将用户导航到视图。

FacesServlet 是 JSF 框架中所有用户请求都要经过的控制器元素。FacesServlet 分析用户请求，使用托管 bean 对模型调用各种动作。后台（backing）或托管（managed）bean 就是该模型的例子。JSF 用户界面（UI）组件是视图层的例子。MVC 模式把任务分解给具有不同技能的开发人员，使这些任务能够同时进行，这样 GUI 设计人员就可以使用丰富的 UI 组件创建 JSF 页面，同时后端开发人员可以创建托管 bean 来编写专门的业务逻辑代码。

Factory Method 模式

Factory Method 模式的目的是定义一个用于创建对象的接口，但是把对象实例化推迟到子类中。在 JSF 体系结构中，Factory Method 模式被用于创建对象。LifeCycleFactory 是一个创建和返回 LifeCycle 实例的工厂对象。LifeCycleFactory 的 getLifeCycle (String LifeCycleId) 方法采用 Factory Method 模式，根据 LifeCycleId 创建（如果需要）并返回 LifeCycle 实例。自定义的 JSF 实现可以重新定义 getLifeCycle 抽象方法来创建自定义的 LifeCycle 实例。默认的 JSF 实现提供默认的 LifeCycle 实例。此外，对于每个 JSF 请求，FacesServlet 都从 FacesContextFactory 得到 FacesContext。FacesContextFactory 是一个抽象类，公开了 getFacesContext API，JSF 实现提供了 FacesContextFactory 和 getFacesContext API 的具体实现。这是另外一个使用 Factory Method 模式的例子，具体的 FacesContextFactory 实现创建 FacesContext 对象。

State 模式

State 模式的目的是在表示状态的不同类之间分配与状态有关的逻辑。FacesServlet 对 LifCycle 实例调用 execute 和 render 方法。LifeCycle 协调不同的 Phrase 以便执行 JSF 请求。在这里 JSF 实现就遵循了 State 模式。如果没有使用这种模式， LifeCycle 实现就会被大量的条件（即 “if” 语句）搅得一塌糊涂。JSF 实现为每个状态（或阶段）创建单独的类并调用 step。phase 是一个抽象类，定了每个 step 的公共接口。在 JSF 框架中定义了六个 phrase（即 step）：RestoreViewPhase、ApplyRequestValues、 ProcessValidationsPhase、UpdateModelValuesPhase、InvokeApplicationPhase 和 RenderResponsePhase。

在 State 模式中， LifeCycle 把 FacesContext 对象传递给 phase。每个阶段或状态改变传递给它的上下文信息，然后设置 FacesContext 本身中的标志表明下一个可能的步骤。JSF 实现在每个步骤中改变其行为。每个阶段都可以作为下一个阶段的起因。FacesContext 有两种标志 renderResponse 和 responseComplete 可以改变执行的顺序。每个步骤执行完成后，LifeCycle 检查上一阶段是否设置了这些标志。如果设置了 responseComplete，LifeCycle 则完全放弃请求的执行。如果经过某个阶段后设置了 renderResponse 标志，JSF 就会跳过剩下的阶段而直接进入 Render Response 阶段。如果这两个标志都没有设置，LifeCycle 就会按顺序继续执行下一步。

Composite 模式

Composite 模式让客户代码能够统一处理复合对象和基本对象。复合对象是基本对象的容器。在第一阶段（Restore View 阶段）和最后一个阶段（Render Response 阶段），使用 JSF UI 组件构造 UI View。UIComponentBase 就是 Composite 模式中 Component 抽象类的一个例子。UIViewRoot 是 Composite 类，而 UIOutput（比方说）就是叶子（或者基本类）。UIComponentBase 类定义了叶子和复合对象的公共方法，如编码/解码值和子节点管理函数。子节点管理函数，如 getChildren，对于叶子节点返回空列表，对于复合节点则返回其子节点。

Decorator 模式

Decorator 模式的目的是不通过子类化动态扩展对象的行为。JSF 框架有很多扩展点（即可插入机制）。JSF 实现可使用 Decorator 模式替换默认的 PropertyResolver、VariableResolver、ActionListener 、NavigationHandler、ViewHandler 或 StateManager。通常自定义实现接受通过构造函数传递给它的默认实现的引用。自定义实现仅仅改写功能的一个子集，而将其他功能委托给默认实现。如果希望实现自定义的 ViewHandler，改写默认 ViewHandler 实现的 calculateLocale 方法，可以像清单 1 那样编写 CustomViewHandler 类：
清单 1. CustomViewHandler 片段


public class CustomViewHandler extends ViewHandler {
 public CustomViewHandler(ViewHandler handler) {
		 super();
		 oldViewHandler = handler;
 }
private ViewHandler oldViewHandler  = null;
public void renderView (facesContext context, UIViewRoot view) {
            //delegate method to oldViewHandler
		 oldViewHandler.renderView(context, view);
}
//custom implementation of calculateLocale
public Locale calculateLocale(FacesContext context) {
}
}

Strategy 模式

Strategy 模式的目的是封装不同的概念。JSF 框架采用 Strategy 模式使用委托实现模型呈现 UI 组件。JSF 技术支持两种呈现模型。在直接实现模型中，UI 组件对收到的请求中的数据进行解码，然后编码这些数据进行显示。在委托实现模型中，解码和编码操作委托给和组建关联的专门呈现器。后一种模型利用了 Strategy 设计模式，比直接实现更灵活。在 Strategy 模式中，将不同的算法封装在单独的对象中，从而可以动态地改变算法。JSF 实现可以用已有的 renderkit 实例注册另外的呈现器，当应用程序启动的时候，JSF 实现读取配置文件将这些呈现器和 UI 组件联系在一起。

Template Method 模式

Template Method 模式的目的是将变化的步骤推迟到子类中，而在父类中定义那些固定的算法步骤。JSF 框架通过 PhraseListeners 展现了 Template Method 模式提供的功能。采用 Template Method（或者 “hook”）使得 Web 作者可以为不同阶段之间的可选步骤提供实现，而主要阶段仍然和 JSF 框架的定义一致。JSF 框架提供了 PhaseListeners，概念上类似于 Template Method 模式中的可变步骤。JSF 框架有六个预定义的阶段，在每个阶段之间，Web 作者可以实现 PhaseListeners 来提供类似于 Template Method hook 的 hook。事实上，这种结构比 Template Method 模式更具有扩展性。可以通过注册 PhraseId 为 ANY_PHRASE 的 PhaseListener 在每个阶段后提供 hook。如果 PhaseId 是 ANY_PHASE，JSF 实现就会在每个阶段之前和之后调用该 PhaseListener。JSF 框架中的实现略有不同，因为可以根本没有 PhaseListener，但是在 Template Method 模式中，子类通常重新定义父类中抽象的可变步骤。

Observer 模式

Observer 模式的目的是当目标对象的状态改变时自动通知所有依赖的对象（即观察器）。JSF 在 UI 组件中实现了 Observer 模式。JSF 有两类内建事件：ActionEvent 和 ValueChangedEvent。ActionEvent 用于确定用户界面组件（如按钮）的激活。当用户单击按钮时，JSF 实现通知添加到该按钮上的一个或多个动作监听程序。于是该按钮被激活，或者说按钮（主体）的状态改变了。添加到按钮上的所有监听程序（即观察器）都收到通知该主体状态已经改变。类似的，当输入 UI 组件中的值改变时，JSF 实现通知 ValueChangeListener。

结束语

JSF 框架利用了 Singleton、Model-View-Controller、Factory Method、State、Composite、Decorator、Strategy、 Template Method 和 Observer 设计模式。因为它的体系结构建立在已经验证的设计模式的基础上，这是一个健壮的框架，模式在 JSF 框架中得到了很好的利用。

参考资料

学习

您可以参阅本文在 developerWorks 全球站点上的英文原文。
请访问 Gang of Four Design Patterns 进一步了解这些设计模式。
请阅读 “怀疑论者的 JSF: JSF 应用程序的生命周期” 进一步了解 JavaServer Faces 框架（developerWorks，2005 年 3 月）。
请访问 developerWorks Java 技术专区。这里专门发表各种基于 Web 和 Java 的解决方案的文章和教程。

获得产品和技术

从 Sun Developer Network 免费下载 JSF。
下载 IBM Rational Software Architect 的免费试用版。

讨论

参与 developerWorks blogs 并加入 developerWorks 社区。
参与 Sun Developer Network 上的 Java 论坛 —— JavaServer Faces Technology。

关于作者


	Anand 是一位 Sun 认证的企业架构师，几年来一直研究 Web 技术。他对 WebSphere 管理控制台应用程序的设计和开发做了多方面的贡献。Anand 曾经在 IBM 美国工作过几年，目前在 IBM 印度工作。

小言身寸 2006-06-28 18:21 发表评论

BlogJava-xiekai-blog-随笔分类-JAVA相关技术

利用MAP进行排序

Weblogic远程重启动命令

取得最小开始日期，JAVA中Set和Iterator的使用一例

WebLogic 如何设置session超时时间

RiA：Rich Internet Application（C/B/S架构）

RiA：Rich Internet Application（C/B/S架构）

用Ant构建Java项目（续）

用Ant构建Java项目

TOMCAT创建和发布WEB应用(TOMCAT与Java Web开发技术详解 第二章 阅读笔记)

本来准备自己整理的，结果发现网上有现成的，爽，省了好多功夫，稍作修改，如下：

TOMCAT 的目录结构

java中连接Oracle数据源

J2EE中的EJB和EJB Container

TOMCAT简介(TOMCAT与Java Web开发技术详解 第一章 阅读笔记)

JSP与Servlet(1) - 第一个servlet

MyEclipse + Tomcat + Eclipse 开发struts应用

关注 struts, jsf, 甚至ajax

使用 JSF 架构进行设计(转载)

TOMCAT创建和发布WEB应用(TOMCAT与Java Web开发技术详解第二章阅读笔记)

TOMCAT简介(TOMCAT与Java Web开发技术详解第一章阅读笔记)