日历
| |||||||||
| 日 | 一 | 二 | 三 | 四 | 五 | 六 | |||
| 1 | 2 | 3 | 4 | 5 | 6 | ||||
| 7 | 8 | 9 | 10 | 11 | 12 | 13 | |||
| 14 | 15 | 16 | 17 | 18 | 19 | 20 | |||
| 21 | 22 | 23 | 24 | 25 | 26 | 27 | |||
| 28 | 29 | 30 | |||||||
搜索标题
最新来客
统计信息
- 访问量: 1421
- 日志数: 27
- 书签数: 3
- 建立时间: 2008-04-03
- 更新时间: 2008-08-05
RSS订阅
我的最新日志
-
SUDO
2008-8-05
-
PUTTY介绍
2008-6-02
-
About Connection Methods
2008-5-19
-
X-Win32 8
2008-5-19
-
生病常用英文
2008-5-09
-
Groovy和Grails简介
2008-5-07
摘要
Java Web应用程序框架是企业Java得以成功的重要原因之一。人们怀疑如果没有Apache Struts框架Java EE是否能够如此成功。虽然底层编程语言很重要，但通常是框架使编程语言成为引人注目的中心的。如果您经常访问讨论论坛，就会注意到Ruby语言和Ruby On Rails框架之间也是这种情况。Ruby已经出现十多年了，然而只是在Ruby On Rails框架流行之后，开发人员才开始注意到Ruby语言。
诸如Ruby、PHP和Python之类的脚本语言最近几年越来越流行，因此，需要开发一个Java脚本备选语言和类似Rails的针对Java环境的框架。Groovy就是这个脚本语言，而Grails就是这个框架。
在本文中我将讨论Groovy的Web开发功能，然后继续讨论Grails框架。我将开发一个示例Grails Web应用程序，并讨论此框架的各种特性。
Groovy是什么？
Groovy是一种语言，其语法类似于Java，但比Java更简单。它通常被视为脚本/灵活/动态的语言，但是我不喜欢这类形容词，因为我认为它们只会令人困惑。如果说Java是一位明智的中年男子，那么Groovy就是他十几岁的儿子。Groovy具有父亲的许多特点，但是更为狂野且更为有趣。他们也可以很好地合作。
Groovy的规则比Java少得多。例如，要在Java中获得标准的"Hello World"输出，您需要编写一个类、一个具有合适参数的主方法，等等。但是在Groovy中，如果不想编写所有样板代码，您可以抛开类定义和主方法，仅编写一行代码即可打印出"Hello World"。
以下是打印Hello World的文件 Hello.groovy 的内容：
println "Hello World"
Java平台仅关心使字节码得到执行。同样，此平台不强迫您使用Java语言。只要提供了字节码，工作就会进行。Groovy代码会被编译为字节码，而对于Java平台来说，字节码是从Java代码还是Groovy代码生成的并没有任何区别。
以下是一个Groovy例子，它显示了Groovy对清单、映射和范围的内置支持，并证明了Groovy的简单性及其利用Java的强大功能的能力：
// Print Date def mydate = new java.util.Date() println mydate //Iterate through a map def numbersMAP = ['1':'ONE', '2':'TWO'] for (entry in numbersMAP) { println "${entry.key} = ${entry.value}" } //Introducing the range def range = 'a'..'d' //Lists def numberlist = [1, 2, 3, 4, 5, 6, 7, 8] println numberlist; println "Maximum value: ${numberlist.max()}"请注意以上代码直接使用java.util.Date ，对收集的内置支持减少了使用清单、映射和范围所需的代码。还有许多其他有趣的Groovy特性，例如闭包和简化的XML处理。您可以在groovy.codehaus.org上找到详细清单。
现在让我们来讨论如何将Groovy用于Web开发。
使用Groovy进行Web开发
大多数Java EE教程都从一个基本servlet例子开始。对于Groovy Web开发来说，您将从groovlet（在groovy中servlet的对应概念）开始。如果您在servlet中摆脱了类和doXX() 方法声明，那么剩下的内容就与groovlet很像了。以下是一个名为 Login.groovy 的groovlet例子，您需要将它置于Web应用程序的最高级目录：
def username= request.getParameter("username") def password= request.getParameter("password") if (username == "java" && password == "developer") { response.sendRedirect("home.jsp") session = request.getSession(true); session.setAttribute("name", username) } else { println """ <h1>Login Invalid</h1> <p>Your IP has been logged > ${request.remoteHost}</p> """ paramMap = request.getParameterMap() println "<p>You Submitted:</p>" for (entry in paramMap) { println "${entry.key} = ${entry.value}<br/>" } }您可以仅创建一个简单的HTML表单，然后将此表单的行为属性发送到 action="Login.groovy"。然后将以下标签添加到web.xml：
<servlet> <servlet-name>Groovy</servlet-name> <servlet-class>groovy.servlet.GroovyServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>Groovy</servlet-name> <url-pattern>*.groovy</url-pattern> </servlet-mapping>现在只需将要求的Groovy jar 文件添加到WEB-INF/lib 目录，您的Groovy Web应用程序就准备好在任意Java EE应用服务器上运行了。
您应该已经注意到代码中没有分号，而且使用了隐式变量如request和response。其他隐式变量有context、application、session、out、sout和 html。
GSP是JSP在groovy中的对应概念。您无需使用println生成HTML；只需将Groovy代码嵌入HTML页面。本文中的例子将在提到Grails时使用GSP。
请注意，因为所有代码最终都要转换为字节码，所以groovlet和GSP能够与servlet和JSP轻松协作。因此您无需区分groovlet和GSP或者servlet和JSP。
现在让我们讨论前途无量的Grails框架。如果成功的话，Grails能够极大地改变开发Java Web应用程序的方式。Ruby on Rails对Ruby的影响，Grails也能够对Groovy实现。
Grails特性和架构
Grails试图使用Ruby On Rails的“规约编程”（coding by convention）范例来降低对配置文件和其他样板代码的需求。使用“规约编程” ，如果文件的名称本身就能说明此文件的用途，那么您就不需要在配置文件中再次声明这些内容了。此框架会查看文件名，并自己弄清文件用途。通过使用“规约编程” ，Grails还将自动生成Web应用程序中需要的许多内容。通过使用Grails，您将能够在很短的时间内、以最小的复杂性使Web应用程序就绪。请看以下例子。
Grails基于开源技术，例如Spring、Hibernate和SiteMesh。如果您已经擅长这些技术，那么这是件好事；但是如果您由于某种原因不喜欢这些技术，或者您认为不仅需要学习Grails，还需要学习其他三种框架，那么这就不是件好事了。虽然这些技术能够帮助Grails执行得更好，但是学习四种框架对于大多数人来说是一个很高的门槛。Grails文档目前主要关注它与Spring、Hibernate和其他程序的集成，然而我认为它需要采用相反的方法，将Grails推行为一个简单快速的Web应用程序开发框架。开发人员无需担心或考虑底层发生了什么。
幸运的是，一旦您开始使用Grails，您将发现Grails隐藏了这些框架的大多数底层复杂性。如果您忘掉在底层运行的是Spring、Hibernate和其他程序，那么事情就会变得简单。
- 由视图和控制器组成的Web层
- 由域类和服务组成的业务逻辑层
- 由域类和数据源组成的持久层
大多数框架都有数十种特性，其中只有很少几种得到了广泛使用。对于Grails来说，这种关键特性是指“规则编程”（coding by convention）范例和构件的自动生成。
Grails的其他特性包括对Ajax、验证、单元测试和功能测试的内置支持。它使用免费的开源Canoo WebTest项目来实现Web应用程序的功能测试。Grails还提供与Quartz Scheduler的集成。
现在是时候安装Grails框架并且编写您的第一个应用程序了。
Grails安装
安装过程非常简单。以下是Grails下载页面：http://grails.org/Download。您可以从http://dist.codehaus.org/grails/grails-bin-0.2.1.zip下载version 0.2.1。请注意Grails源代码和文档作为单独的下载提供。下载zip文件之后，只需将其内容解压缩到一个目录即可，在我的案例中此目录是 C:\groovy\grails-0.2.1\。
创建一个名为GRAILS_HOME 的新环境变量，并将其值设为 C:\groovy\grails-0.2.1\。接下来将GRAILS_HOME\bin 添加到PATH 环境变量。这样安装就完成了。通过在命令提示符界面中运行grails 命令您可以检查安装是否成功。您应该获得此命令的使用信息。
既然您有了一个运行中的Grails安装，那么您已经为创建Grails Web应用程序做好了准备。
开发Grails应用程序：应用程序结构
多年来我一直计划开发一个可以帮助我管理衣服的应用程序——这个应用程序应该能够告诉我我最喜欢的T恤衫放在哪里、是否洗过、是否熨过，等等。总有一天我会靠销售这个应用程序挣上几百万，但是现在我将把它用作Grails例子。
第一步是创建一个Grails项目目录结构。在这一步我将在C:\groovy\grailsapps 创建一个新目录，并在此级别打开一个命令提示符窗口。在此窗口中，执行命令grails create-app。要求您输入应用程序名称。输入 ClothesMgt。Grails将显示它为您创建的全部目录和文件。图1显示了最后得到的命令结构。
图1：Grails项目目录结构
此命令将创建约800 KB大小的文件和目录。这里的想法是此框架遵循已经建立的Web应用程序开发惯例，因此它创建的文件和目录在大多数Web应用程序中是有用的。虽然有些人可能不喜欢这种强制使用某种结构的想法，但是这种基于惯例的自动生成正是Grails的RAD特性的基础。
如果更仔细地看一下这些目录，您就会发现存在用于诸如控制器、视图、测试、配置文件和标签库之类东西的目录。您还会发现存在一些基本Javascrīpt和CSS文件。那么现在应用程序的基本结构已经有了。您只需做些填空，应用程序即可就绪。
请注意自动生成目录和文件的命令是可选的。您可以手动创建全部文件和目录。如果熟悉Apache Ant，那么您甚至可以打开GRAILS_HOME 目录中的\src\grails\build.xml 文件，来仔细查看每个Grails命令的用途。
数据库
在此例中我将使用一个 运行于localhost的名为Clothes_Grails的MySQL数据库。Grails内置一个HSQL数据库，这对测试简单的应用程序或仅试用Grails非常有用。如果您使用HSQL DB，那么无需执行以下几步。我将使用MySQL来证明您能够非常轻松地使用HSQL之外的数据库。
从http://www.mysql.com/products/connector/j/ 下载MySQL驱动器，并将mysql-connector-java-<version number>-stable-bin.jar 文件放置在ClothesMgt\lib 目录中。接下来您需要编辑 ClothesMgt\grails-app\conf\ApplicationDataSource.groovy文件。
现在此文件的内容应该类似以下内容：
class ApplicationDataSource { boolean pooling = true String dbCreate = "create-drop" String url = "jdbc:mysql://localhost/Clothes_Grails" String driverClassName = "com.mysql.jdbc.Driver" String username = "grails" String password = "groovy" }现在让我们看一下如何使用此数据库和对象关系映射。
域类
Grails的对象关系映射(GORM)功能在内部使用Hibernate 3，但是您无需了解或更改任何Hibernate设置。Grails具有称为“域类”的东西，这些域类的对象被映射到数据库。您可以使用关系来链接域类，它们也提供用于CRUD（创建/读取/更新/删除）操作的功能非常强大的动态方法。
在此例中，我们将创建三个域类，其名称分别是Shirt、Trouser和Cabinet。要创建域类，只需运行命令 grails create-domain-class。请记住在您的项目目录（而不是它的上级目录）内运行此命令。这是一个常见错误，虽然我已经提醒了您，您还是会犯至少一次这样的错误。
您必须提供给create-domain-class 命令的唯一输入是类的名称。运行此命令三次，将Shirt、Trouser和Cabinet作为三个域类的名称。Grails现在将在目录 grails-app/domain/中创建这些域类。它们将仅具有两个属性id 和 version。我将为这些类添加属性，以便使它们更能代表衬衫、裤子和衣橱。
清单1：Cabinet.groovy
class Cabinet { Long id Long version String name String location def relatesToMany = [ shirts : Shirt, trousers : Trouser ] Set shirts = new HashSet() Set trousers = new HashSet() String toString() { "${this.class.name} : $id" } boolean equals(other) { if(other?.is(this))return true if(!(other instanceof Cabinet)) return false if(!id || !other?.id || id!=other?.id) return false return true } int hashCode() { int hashCode = 0 hashCode = 29 * (hashCode + ( !id ? 0 : id ^ (id >>> 32)) ) } }清单2： Trouser.groovy
class Trouser { Long id Long version String name String color Cabinet cabinet def belongsTo = Cabinet String toString() { "${this.class.name} : $id" } boolean equals(other) { if(other?.is(this))return true if(!(other instanceof Trouser)) return false if(!id || !other?.id || id!=other?.id) return false return true } int hashCode() { int hashCode = 0 hashCode = 29 * (hashCode + ( !id ? 0 : id ^ (id >>> 32) ) ) } }清单3： Shirt.groovy
class Shirt { Long id Long version String name String color Cabinet cabinet def belongsTo = Cabinet String toString() { "${this.class.name} : $id" } boolean equals(other) { if(other?.is(this))return true if(!(other instanceof Shirt)) return false if(!id || !other?.id || id!=other?.id) return false return true } int hashCode() { int hashCode = 0 hashCode = 29 * (hashCode + ( !id ? 0 : id ^ (id >>> 32))) } }我添加的仅有的几行声明了字段名称和颜色，然后声明了Cabinet、Shirt和Trouser之间的关系。每个Shirt和Trouser都属于Cabinet，而Cabinet具有shirt和trouser的集合。belongsTo 属性在此案例中是可选的，因为在一对多关系中，Grails会将“一”这一方视为所有者。因此您就无需显式声明了。在这里我进行显式声明只是为了使这种关系更明显。
接下来我们将讨论Grails应用程序的控制器和视图部分。
控制器和视图
既然域类已经就绪，让我们使用generate-all命令自动生成基本CRUD Web应用程序。运行grails generate-all 命令三次，当被询问时提供域类名称。generate-all 命令的目的是生成每个域类的控制器和视图，但是由于bug-245，Grails 0.2.1不能生成控制器。您必须手动生成控制器，其方法是对每个域类使用generate-controller 命令。
现在您应该在grails-app\controllers 目录中看到三个控制器。这些控制器负责处理Web应用程序中针对特定域类的请求。因此ShirtController.groovy 将处理Web应用程序中与Shirt域类相关的CRUD请求，等等。现在控制器具有多个闭包，每个闭包映射到一个URI。闭包是Groovy语言很好的一个特性，然而要习惯它还是需要一些时间的。清单4显示了Shirtcontroller.groovy的一段摘录。
清单4：ShirtController.groovy 摘录
class ShirtController { def index = { redirect(action:list,params:params) } def list = { [ shirtList: Shirt.list( params ) ] } def show = { [ shirt : Shirt.get( params.id ) ] } def delete = { def shirt = Shirt.get( params.id ) if(shirt) { shirt.delete() flash.message = "Shirt ${params.id} deleted." redirect(action:list) } else { flash.message = "Shirt not found with id ${params.id}" redirect(action:list) } } // ... }在此例中，ShirtController 中的list闭包将处理URI是/shirt/list的请求，等等。您可在控制器中使用您习惯在Java Web应用程序中使用的东西，例如请求、会话和servletContext。
请注意：闭包也将值作为显式返回语句返回，或者作为闭包体中的最后一个语句的值返回。不要因为Grails生成的代码中没有return 而困惑。
一旦控制器完成了对请求的处理，它必须委托给合适的视图。Grails使用惯例机制实现此操作。因此ShirtController 中的list闭包将委托给视图 /grails-app/views/shirt/list.gsp 或 /grails-app/views/shirt/list.jsp。 尽管您在使用Grails，全部视图可以是JSP文件而不是GSP。我几乎没有编写任何代码，但是我已经准备好了一个Web应用程序。
让我们尝试部署和运行我们的应用程序。
在Java EE Server上部署和运行Grails
Grails具有一个内置Resin服务器，您可使用grails run-app 命令运行应用程序。此命令会将应用程序部署到Resin服务器并启动服务器。因此您现在可以在http://localhost:8080/ClothesMgt 访问此应用程序。您还可以同样轻松地将应用程序部署到任意JavaEE服务器。我尝试将它部署到Tomcat。要实现此操作，我所需要做的是运行grails war 命令，将生成的war文件复制到Tomcat中的webapps目录！
在此案例中生成的war文件的名称为 ClothesMgt.war。一旦部署到Tomcat，您就应该能够在http://localhost:8080/ClothesMgt/ 上访问它，并看到如图2所示的屏幕。
图2：Grails 应用程序
通过此应用程序，能够获得Shirt、Trouser和Cabinet的全部CRUD功能。可以显示衣橱的全部数据、向衣橱添加新衬衫和裤子、编辑它们的值和删除记录——实现这些操作都无需编写任何业务逻辑、视图或数据访问代码。仅在几分钟内您就在JavaEE服务器上部署好了一个合适的Web应用程序。很酷吧？！
让我们更进一步来定制Grails。
创建自定义控制器
我现在将把新功能和页面添加到Web应用程序，同时重用已经存在的域类。shirt/list 和 trouser/list 会分别显示衬衫和裤子的清单，现在让我们添加一个新的显示，来同时显示衬衫和裤子的清单。要创建一个新的显示，您需要一个新的控制器和视图。
使用 generate-controller 和 generate-views 命令，可以轻松实现使用域类自动生成视图和控制器。然而，在此案例中我希望创建一个与域类不直接关联的控制器。因此我将使用grails create-controller命令。当被提示输入控制器名称时，声明Display。Grails将在grails-app/controllers/ 目录创建一个名为DisplayController.groovy 的控制器，在grails-tests 目录创建一个测试套件。如清单5所示编辑控制器。
清单5：DisplayController.groovy
class DisplayController { def index = {redirect(action:list,params:params)} def list = { params['max'] = 10 return [ shirtList: Shirt.list( params ), trouserList: Trouser.list( params )] } }index 闭包将请求重定向到清单。在list 闭包中我将最大参数设为10，然后使用动态方法Shirt.list 和 Trouser.list。然后返回Groovy Map，它有两个清单——衬衫清单和裤子清单。
作为Java开发人员，当看到Shirt.list()时会自然认为是在Shirt域类中的list 方法。然而，如果打开Shirt.groovy，会发现并没有此方法。对于Java开发人员来说，不了解Groovy的特性就使用Grails不仅是令人困惑的，而且是死胡同。动态方法是Grails的特殊特性，它是构建于Groovy语言的一个非常特殊的特性元对象协议 (MOP)之上的。如此证明可以使用动态方法查询域类。因此，在控制器中，您将注意到在域类上调用的方法似乎在域类中不存在。您可以在这里阅读关于使用动态方法查询的更多信息。可以在这里找到对Grails控制器和域类中可用的动态方法的参考资料。
既然控制器能够处理请求、获取清单并转发到视图，我需要创建相应视图。
创建自定义视图
当创建控制器时，Grails还在grails-app\views 目录创建了一个新的显示目录，并将以下映射添加到web.xml 文件中。
<servlet-mapping> <servlet-name>grails</servlet-name> <url-pattern>/display/*</url-pattern> </servlet-mapping>
目前Grails有一个generate-views 命令，此命令能够生成基于域类的视图，然而没有能够自动生成视图的create-view 命令。请看图3中的例子。
图3：一个显示Trousers的默认视图
因为我希望创建一个独立于域类的视图，所以让我们手动创建视图文件。在目录grails-app\views\display\中，创建一个名为 list.gsp的文件，如清单6所示。
清单6：list.gsp
<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/> <title>Display Shirt And Trouser List</title> <link rel="stylesheet" href="${createLinkTo(dir:'css',file:'main.css')}"></link> </head> <body> <div class="nav"> <span class="menuButton"><a href="${createLinkTo(dir:'')}">Home</a></span> </div> <div class="body"> <h1>Shirt List</h1> <table> <tr> <th>Id</th><th>Cabinet</th> <th>Color</th><th>Name</th> </tr> <g:each in="${shirtList}"> <tr> <td>${it.id}</td> <td>${it.cabinet.name}</td> <td>${it.color}</td> <td>${it.name}</td> </tr> </g:each> </table> <h1>Trouser List</h1> <table> <tr> <th>Id</th> <th>Cabinet</th> <th>Color</th> <th>Name</th> </tr> <g:each in="${trouserList}"> <tr> <td>${it.id}</td> <td>${it.cabinet.name}</td> <td>${it.color}</td> <td>${it.name}</td> </tr> </g:each> </table> </div> </body> </html>与我之前使用的方式类似，您现在也可以使用run-app 命令运行应用程序，或者创建一个war文件并将其部署到Tomcat。您应该在http://localhost:8080/ClothesMgt/display/下看到新的视图，如图4所示。
图4：新创建的列出衬衫和裤子清单的视图
现在让我们快速讨论一下Grails服务。
服务
如果您想知道如何分开业务逻辑以及放置业务逻辑的位置，答案在Grails 服务中。服务以SomeNameService.groovy 格式命名，且被置于 /grails-app/services/目录。服务可利用依赖注入特性，您能够轻松地从控制器内部调用这些服务。
让我们来看一个使用服务的例子。首先，使用create-service 命令创建新服务。运行此命令并命名服务Order。Grails将创建两个文件——grails-app/services/OrderService.groovy 和 grails-tests/OrderTests.groovy。
现在编辑OrderService.groovy，如清单7所示。当引入新的orderGoods() 方法时会自动生成serviceMethod() 。
清单7：OrderService.groovy
class OrderService { boolean transactional = true def serviceMethod() { // TODO } def orderGoods() { return "Order Placed - New shirts and trousers \ will be sent shortly." } }现在编辑DisplayController，如清单8所示。引入使用OrderService的重排闭包。请注意服务将由Groovy注入。
清单8：DisplayController.groovy
class DisplayController { OrderService orderService def index = {redirect(action:list,params:params)} def list = { params['max'] = 10 return [ shirtList: Shirt.list( params ) , trouserList: Trouser.list( params )] } def reorder = { render(orderService.orderGoods()) } }现在当您访问URL http://localhost:8080/ClothesMgt/display/reorder时，重排闭包将调用 OrderService，响应会被发回到浏览器。您能够以类似方式将全部业务逻辑移入服务，然后使用Grails的注入功能非常轻松地使用它们。
动态方法和属性
正如之前提到的，域类没有能够从数据库获取数据或更新/删除现有数据的任何方法，例如find()、 findAll() 或 save() 。在控制器中您也没有编写诸如 redirect() 或 render() 之类的方法。但是域类和控制器有它们的计划目的，且允许所有要求的操作。原因是Grails中动态方法和属性的存在。动态方法被动态添加到类，就好像功能是在程序中编译的一样。
这些是可用的方法和属性，无需编写。这些动态方法涵盖了大多数Web应用程序开发中会碰到的常见情况。对于域类来说，存在诸如find()、findAll()、list()、executeQuery()、save()和 delete()之类的动态方法。控制器具有诸如session、request和response之类的动态属性，以及诸如chain()、render()和 redirect()之类的方法。要真正利用Grails的强大功能，您需要了解所有这些动态方法和属性的功能。
顺便介绍一下：自动重载和@Property
Grails的一个重要特性是能够在开发过程中进行了更改时自动重载文件。因此只需编辑和保存gsp文件，就会自动重载新文件。然而这里创建的类似OrderService 的事务服务不会被重载。您会在服务器控制台看到以下消息"[groovy] Cannot reload class [class OrderService] reloading of transactional service classes is not currently possible. Set class to non-transactional first. "。
Grails的自动重载功能会为您节省许多时间，您就无需浪费时间来重启服务器了。我碰到过一些Grails不能自动重载的案例，例如将一个jsp文件重命名到gsp。然而，Grails的这项功能有望在未来版本中得到进一步改进。
在Groovy JSR 06 的之前版本中，您必须使用@Property 来定义Groovy中的新属性。因此您会在线看到许多使用@Property的旧的Groovy例子。然而请注意，@Property已经从Groovy JSR 06中移除，在Grails 0.2和之后的版本中也不会再需要它。请参阅@Property 建议来获得更多细节。
结束语
在本文中，我介绍了Grails框架的基本特性，并使用Grails创建了一个应用程序。Groovy和Grails最大的好处是一切都运行在优秀的旧Java和Java EE上——因此您能够使用Groovy和Grails的RAD特性快速开发应用程序，然后将应用程序部署到可靠的Java EE服务器上。考虑到关于Ruby和Rails的宣传噪音，显然需要一个Java备选方案。Groovy和Grails看起来非常适合这个角色。
-
什么是JMX
2008-5-07
JMX（Java Management Extensions，即Java管理扩展）是一个为应用程序、设备、系统等植入管理功能的框架。JMX可以跨越一系列异构操作系统平台、系统体系结构和网络传输协议，灵活的开发无缝集成的系统、网络和服务管理应用。Java管理扩展JMX(Java Management Extensions)是一个为应用程序植入管理功能的框架。JMX是一套标准的代理和服务，实际上，用户可以在任何Java应用程序中使用这些代理和服务实现管理。
Java管理扩展JMX的前身是JMAPI。
Java管理扩展JMX致力于解决分布式系统管理的问题，因此，能够适合于各种不同的环境是非常重要的。为了能够利用功能强大的Java计算环境解决这一的问题，Sun公司扩充了Java基础类库，开发了专用的管理类库。
JMX是一种应用编程接口，可扩充对象和方法的集合体，可以用于跨越一系列不同的异构操作系统平台、系统体系结构和网络传输协议，灵活的开发无缝集成的系统、网络和服务管理应用它提供了用户界面指导、Java类和开发集成系统、网络及网络管理应用的规范。
管理对象是JMX应用程序的核心。JMX结构包括：支持Java的Web浏览器用户接口，管理运行模块ARM(Admin Runtime Module)和应用。这三个部件之间通过RMI（Remote Method Invocation）进行通信。这里需要说明的是，RMI是使得一个Java虚拟机（JVM）上运行的程序可以调用远程服务器上另一个JVM总的对象。
用户接口用来发布管理操作，这些操作可以间接的通过浏览器或通过单独的应用程序来激发。管理运行模块用来给应用提供实例化的管理对象。它包括Agent对象接口，通知接口和被管数据接口。应用指的是那些被管设备单元。
JMX是一个完整的网络管理应用程序开发环境，它同时提供了：厂商需要收集的完整的特性清单，可生成资源清单表格，图形化的用户接口；访问SNMP的网络API；主机间远程过程调用；数据库访问方法。
JMX这一轻型的管理基础结构，价值在于对被管理资源的服务实现了抽象，提供了低层的基本类集合，开发人员在保证大多数的公共管理类的完整性和一致性的前提下，进行扩展以满足特定网络管理应用的需要。
JMX注重于构造管理工具的软件框架，并尽量采用已成熟的技术。
JMX可以用来管理网络，设备，应用程序等资源，当前规范为1.2版。
一、Java管理扩展JMX的优点
1：可以非常容易的使应用程序具有被管理的功能
2：提供具有高度伸缩性的架构
每个JMX Agent服务可以很容易的放入到Agent中，每个JMX的实现都提供几个核心的Agent服务，你也可以自己编写服务，服务可以很容易的部署，取消部署。
3：主要提供接口，允许有不同的实现
二、Java管理扩展JMX的体系结构
JMX框架
1)设备层（Instrumentation Level）：主要定义了信息模型。在JMX中，各种管理对象以管理构件的形式存在，需要管理时，向MBean服务器进行注册。该层还定义了通知机制以及一些辅助元数据类。
2)代理层（Agent Level）：主要定义了各种服务以及通信模型。该层的核心是一个MBean服务器，所有的管理构件都需要向它注册，才能被管理。注册在MBean服务器上管理构件并不直接和远程应用程序进行通信，它们通过协议适配器和连接器进行通信。而协议适配器和连接器也以管理构件的形式向MBean服务器注册才能提供相应的服务。
3)分布服务层（Distributed Service Level）：主要定义了能对代理层进行操作的管理接口和构件，这样管理者就可以操作代理。然而，当前的JMX规范并没有给出这一层的具体规范。
4)附加管理协议API：定义的API主要用来支持当前已经存在的网络管理协议，如SNMP、TMN、CIM/WBEM等。
1．2 设备层（Instrumentation Level）
该层定义了如何实现JMX管理资源的规范。一个JMX管理资源可以是一个Java应用、一个服务或一个设备，它们可以用Java开发，或者至少能用Java进行包装，并且能被置入JMX框架中，从而成为JMX的一个管理构件(Managed Bean)，简称MBean。管理构件可以是标准的，也可以是动态的，标准的管理构件遵从JavaBeans构件的设计模式；动态的管理构件遵从特定的接口，提供了更大的灵活性。该层还定义了通知机制以及实现管理构件的辅助元数据类。
1．2．1 管理构件（MBean）
在JMX规范中，管理构件定义如下：它是一个能代表管理资源的Java对象，遵从一定的设计模式，还需实现该规范定义的特定的接口。该定义了保证了所有的管理构件以一种标准的方式来表示被管理资源。管理接口就是被管理资源暴露出的一些信息，通过对这些信息的修改就能控制被管理资源。一个管理构件的管理接口包括：
1)能被接触的属性值；
2)能够执行的操作；
3)能发出的通知事件；
4)管理构件的构建器。管理构件通过公共的方法以及遵从特定的设计模式封装了属性和操作，以便暴露给管理应用程序。例如，一个只读属性在管理构件中只有Get方法，既有Get又有Set方法表示是一个可读写的属性。
其余的JMX的构件，例如JMX代理提供的各种服务，也是作为一个管理构件注册到代理中才能提供相应的服务。
JMX对管理构件的存储位置没有任何限制，管理构件可以存储在运行JMX代理的Java虚拟机的类路径的任何位置，也可以从网络上的任何位置导入。
JMX定义了四种管理构件：标准、动态、开放和模型管理构件。每一种管理构件可以根据不同的环境需要进行制定。
1.标准管理构件
标准管理构件的设计和实现是最简单的，它们的管理接口通过方法名来描述。标准管理构件的实现依靠一组命名规则，称之为设计模式。这些命名规则定义了属性和操作。检查标准管理构件接口和应用设计模式的过程被称为内省（Introspection）[22]。JMX代理通过内省来查看每一个注册在MBean 服务器上的管理构件的方法和超类，看它是否遵从一定设计模式，决定它是否代表了一个管理构件，并辨认出它的属性和操作。
2.动态管理构件
动态管理构件提供了更大的灵活性，它可以在运行期暴露自己的管理接口。它的实现是通过实现一个特定的接口DynamicMBean（如下图）。
JMX代理通过getMBeanInfo方法来获取该动态管理构件暴露的管理接口，该方法返回的对象是MbeanInfo类的实例，包含了属性和操作的签名。由于该方法的调用是发生在动态管理构件向MBean服务器注册以后，因此管理接口是在运行期获取的。不同于标准管理构件，JMX代理不需要通过内省机制来确定动态管理构件的管理接口。由于DynamicMBean的接口是不变的，因此可以屏蔽实现细节。由于这种在运行期获取管理接口的特性，动态管理构件提供了更大的灵活性。3.开放管理构件
开放管理构件是一种专门化的动态管理构件，其中所有的与该管理构件相关的参数、返回类型和属性都围绕一组预定义的数据类型（String、Integer、Float 等）来建立，并且通过一组特定的接口来进行自我描述。JMX代理通过获得一个OpenMBeanInfo对象来获取开放管理构件的管理接口，OpenMBeanInfo是MbeanInfo的子类。
4.模型管理构件
模型管理构件也是一种专门化的动态管理构件。它是预制的、通用的和动态的 MBean 类，已经包含了所有必要缺省行为的实现，并允许在运行时添加或覆盖需要定制的那些实现。JMX规范规定该类必须实现为javax.management.modelmbean.RequiredModelMBean，管理者要做的就是实例化该类，并配置该构件的默认行为并注册到JMX代理中，即可实现对资源的管理。JMX代理通过获得一个ModelMBeanInfo对象来获取管理接口。
模型管理构件具有以下新的特点[23]：
1)持久性
定义了持久机制，可以利用Java的序列化或JDBC来存储模型MBean的状态。
2)通知和日志功能
能记录每一个发出的通知，并能自动发出属性变化通知。
3)属性值缓存
具有缓存属性值的能力。
1．2．2 通知模型
一个管理构件提供的管理接口允许代理对其管理资源进行控制和配置。然而，对管理复杂的分布式系统来说，这些接口只是提供了一部分功能。通常，管理应用程序需要对状态变化或者当特别情况发生变化时作出反映。为此，JMX定义了通知模型。通知模型仅仅涉及了在同一个JMX代理中的管理构件之间的事件传播。JMX通知模型依靠以下几个部分：
1)Notification，一个通用的事件类型，该类标识事件的类型，可以被直接使用，也可以根据传递的事件的需要而被扩展。
2)NotificationListener接口，接受通知的对象需实现此接口。
3)NotificationFilter接口，作为通知过滤器的对象需实现此接口，为通知监听者提供了一个过滤通知的过滤器。
4)NotificationBroadcaster接口，通知发送者需实现此接口，该接口允许希望得到通知的监听者注册。发送一个通用类型的通知，任何一个监听者都会得到该通知。因此，监听者需提供过滤器来选择所需要接受的通知。
任何类型的管理构件，标准的或动态的，都可以作为一个通知发送者，也可以作为一个通知监听者，或两者都是。
1．2．3 辅助元数据类
辅助元数据类用来描述管理构件。辅助元数据类不仅被用来内省标准管理构件，也被动态管理构件用来进行自我描述。这些类根据属性、操作、构建器和通告描述了管理接口。JMX代理通过这些元数据类管理所有管理构件，而不管这些管理构件的类型。部分辅助元类如下：
1)MBeanInfo--包含了属性、操作、构建器和通知的信息。
2)MBeanFeatureInfo--为下面类的超类。
3)MBeanAttributeInfo--用来描述管理构件中的属性。
4)MBeanConstructorInfo--用来描述管理构件中的构建器。
5)MBeanOperationInfo--用来描述管理构件中的操作。
6)MBeanParameterInfo--用来描述管理构件操作或构建器的参数。
7)MBeanNotificationInfo--用来描述管理构件发出的通知。
1．3 代理层
代理层是一个运行在Java虚拟机上的管理实体，它活跃在管理资源和管理者之间，用来直接管理资源，并使这些资源可以被远程的管理程序所控制。代理层由一个MBean服务器和一系列处理被管理资源的服务所组成。下图表示了代理层的组成：
1．3．1 MBean服务器
Mbean服务器为代理层的核心，设备层的所有管理构件都在其注册，管理者只用通过它才能访问管理构件。
管理构件可以通过以下三种方法实例化和注册：
1)通过另一个管理构件
2)管理代理本身
3)远程应用程序
注册一个管理构件时，必须提供一个唯一的对象名。管理应用程序用这个对象名进行标识管理构件并对其操作。这些操作包括：
1)发现管理构件的管理接口
2)读写属性值
3)执行管理构件中定义的操作
4)获得管理构件发出的通告
5)基于对象名和属性值来查询管理构件
1．3．2 协议适配器和连接器
MBean服务器依赖于协议适配器和连接器来和运行该代理的Java虚拟机之外的管理应用程序进行通信。协议适配器通过特定的协议提供了一张注册在MBean服务器的管理构件的视图。例如，一个HTML适配器可以将所有注册过的管理构件显示在Web 页面上。不同的协议，提供不同的视图。连接器还必须提供管理应用一方的接口以使代理和管理应用程序进行通信，即针对不同的协议，连接器必须提供同样的远程接口来封装通信过程。当远程应用程序使用这个接口时，就可以通过网络透明的和代理进行交互，而忽略协议本身。
适配器和连接器使MBean服务器与管理应用程序能进行通信。因此，一个代理要被管理，它必须提供至少一个协议适配器或者连接器。面临多种管理应用时，代理可以包含各种不同的协议适配器和连接器。
当前已经实现和将要实现的协议适配器和连接器包括：
1)RMI连接器
2)SNMP协议适配器
3)IIOP协议适配器
4)HTML协议适配器
5)HTTP连接器
1．3．3 代理服务
代理服务可以对注册的管理构件执行管理功能。通过引入智能管理，JMX可以帮助我们建立强有力的管理解决方案。代理服务本身也是作为管理构件而存在，也可以被MBean服务器控制。JMX规范定义了代理服务有：
1)动态类装载--通过管理小程序服务可以获得并实例化新的类，还可以使位于网络上的类库本地化。
2)监视服务--监视管理构件的属性值变化，并将这些变化通知给所有的监听者。
3)时间服务--定时发送一个消息或作为一个调度器使用。
4)关系服务--定义并维持管理构件之间的相互关系。1.动态类装载
动态类装载是通过m-let（management applet）服务来实现的，它可以从网络上的任何URL处下载并实例化管理构件，然后向MBean服务器注册。在一个M-let服务过讨校紫仁窍略匾桓鰉-let文本文件，该文件是XML格式的文件，文件的内容标识了管理构件的所有信息，比如构件名称、在MBean服务器中唯一标识该构件的对象名等。然后根据这个文件的内容，m-let服务完成剩余的任务。下图例示这一过程：
2.监视服务通过使用监视服务，管理构件的属性值就会被定期监视，从而保证始终处于一个特定的范围。当监视的属性值的变化超出了预期定义的范围，一个特定的通告就会发出。JMX规范当前规定了三种监视器：
1)计数器监视器，监视计数器类型的属性值，通常为整型，且只能按一定规律递增。
2)度量监视器，监视度量类型的属性值，通常为实数，值能增能减。
3)字符串监视器，监视字符串类型的属性值。每一个监视器都是作为一个标准管理构件存在的，需要提供服务时，可以由相应的管理构件或远程管理应用程序动态创建并配置注册使用。
下图例示了计数器监视器的使用情况：
3.时间服务时间服务可以在制定的时间和日期发出通告，也可以定期的周期性的发出通告，依赖于管理应用程序的配置。时间服务也是一个管理构件，它能帮助管理应用程序建立一个可配置的备忘录，从而实现智能管理服务。
4.关系服务
JMX规范定义了管理构件之间的关系模型。一个关系是用户定义的管理构件之间的N维联系。
关系模型定义如下一些术语：
1)角色：就是是一个关系中的一类成员身份，它含有一个角色值。
2)角色信息：描述一个关系中的一个角色。
3)关系类型：由角色信息组成，作为创建和维持关系的模板。
4)关系：管理构件之间的当前联系，且必须满足一个关系类型的要求。
5)角色值：在一个关系中当前能满足给定角色的管理构件的列表。
6)关系服务：是一个管理构件，能接触和维持所有关系类型和关系实例之间的一致性。在关系服务中，管理构件之间的关系由通过关系类型确定的关系实例来维护。仅仅只有注册到MBean服务器上并且能被对象名标识的管理构件才能成为一个关系的成员。关系服务从来就不直接操作它的成员--管理构件，为了方便查找它仅仅提供了对象名。
关系服务能锁定不合理关系类型的创建，同样，不合理的关系的创建也会被锁定。角色值的修正也要遵守一致性检查。
由于关系是定义在注册的管理构件之间的联系，所以当其中的管理构件卸载时，就会更改关系。关系服务会自动更改角色值。所有对关系实例的操作比如创建、更新、删除等都会使关系服务发出通告，通告会提供有关这次操作的信息。
JMX关系模型只能保证所有的管理构件满足它的设计角色，也就是说，不允许一个管理构件同时出现在许多关系中。
1．4 分布服务层
当前，SUN并没有给出这一层的具体规范，下面给出的只是一个简要描述。该层规定了实现JMX应用管理平台的接口。这一层定义了能对代理层进行操作的管理接口和组件。这些组件能：
1)为管理应用程序提供一个接口，以便它通过一个连接器能透明和代理层或者JMX管理资源进行交互。
2)通过各种协议的映射（如SNMP、HTML等），提供了一个JMX代理和所有可管理组件的视图。
3)分布管理信息，以便构造一个分布式系统，也就是将高层管理平台的管理信息向其下众多的JMX代理发布。
4)收集多个JMX 代理端的管理信息并根据管理终端用户的需要筛选用户感兴趣的信息并形成逻辑视图送给相应的终端用户。
5)提供了安全保证。通过管理应用层和另一管理代理和以及他的设备层的联合，就可以为我们提供一个完整的网络管理的解决方案。这个解决方案为我们带来了独一无二的一些优点：轻便、根据需要部署、动态服务、还有安全性。
1．5 附加管理协议API
该层提供了一些API来支持当前已经存在的一些管理协议。这些附加的协议API并没有定义管理应用的功能，或者管理平台的体系结构，他们仅仅定义了标准的Java API和现存的网络管理技术通信，例如SNMP。
网络管理平台和应用的开发者可以用这些API来和他们的管理环境进行交互，并将这个交互过程封装在一个JMX管理资源中。例如，通过SNMP可以对一个运行有SNMP代理的交换机进行管理，并将这些管理接口封装成为一个管理构件。在动态网络管理中，可以随时更换这些管理构件以适应需求。
这些API可以帮组开发者根据最通常的工业标准来部署他们的管理平台和应用。新的网路管理的解决方案可以和现存的基础结构合为一体，这样，现存的网络管理也能很好的利用基于Java技术的网络管理应用。
这些API目前在JCP（Java Community Process）内作为独立的JSR（Java Specification Request）开发。
他们包括：
1)SNMP Manager API
2)CIM/WBEM manager and protocol API
1．6 JMX的当前实现及应用
自从SUN发布了JMX规范，许多大公司纷纷行动起来，实现规范或者实现相应的基于JMX的网络管理系统，下面列出了当前的主要实现及应用情况：1)SUN为JMX规范了作出了相应的参考实现，并在此基础上开发了一个全新的用于网络管理的产品JDMK（Java动态管理工具集），其中定义了资源的开发过程和方法、动态JMX代理的实现、远程管理应用的实现。同时，JDMK也提供了一个完整的体系结构用来构造分布式的网络管理系统，并提供了多种协议适配器和连接器，如SNMP协议适配器、HTML协议适配器、HTTP连接器、RMI连接器。
2)IBM Tivoli实现了JMX规范的产品为TivoliJMX，它为JAVA管理应用程序和网络提供了架构、设计模式、一些API集和一些服务。
3)Adventnet开发的关于JMX的产品为AdventNet Agent Toolkit，它使得定义新的SNMP MIB、开发JMX和Java SNMP Agent的过程自动化。
4)JBoss实现的J2EE应用服务器以JMX为微内核，各个模块以管理构件的形式提供相应的服务。
5)BEA的Weblogic应用服务器也将JMX技术作为自己的管理基础。
6)金蝶的Apusic也是一个以JMX为内核开发出的J2EE应用服务器。
三、JMX的好处。可减少对JAVA应用实施管理的投资
。提供了一个可伸缩的管理框架
。集成现有的管理方案：如：WBEM，SNMP，TMN
。使用现有的标准JAVA技术
。能使用未来的一些管理概念：如Jini连接技术、通用即插即用、服务定位协议(Service Location Protocol)
。只定义了一些可以访问的接口四、JMX架构的了解
JMX应该说是关于网络应用管理的的框架，如果你开发了一个比较复杂的系统，无疑你要提供这个系统的自身管理 系统，JMX更多应用是体现在Server上，如果你要使用java开发一个自己Server或复杂的应用系统，那么推荐你基于JMX架构来开发， JBoss 3.0 weblogic等就是基于JMX开发的符合J2EE规范的服务器软件。
了解JMX可以使你深入了解J2EE服务器， 为什么我们平时说 "EJB"是个比较"Weight"的方案选择，其中一个原因是J2EE服务器软件本身 也是你的系统中一部分，它作为你系统的容器，对你的系统有至关重要的作用，如果无法直接介入 管理或“调教”它，那么无疑你的系统本身存在着隐含的危险， 现在，通过JMX，你现在可以深入到你J2EE容器内部的管理了。 (好像国内出现了第一个自己J2ee服务器，不知道那是不是基于JMX开发的?)
J2EE并不能概括所有的应用领域，比如对速度和性能要求极高的游戏或股票行情等系统就需要自己直接来开发Server， 如果是能够基于JMX开发，那么可以说就大大提高编写管理程序的效率，可以将你的模块变成JMX的MBean，可以通过Agent在程序内部或者通过 WEB管理页面对你的MBean模块进行初始化 重启 以及参数设置。
JMX的好处还有：可以方便整合连接现有的Java技术，如JNDI JDBC JTS及其它。特别是能够使用Jini的查询 发现机制以及协议，我们知道,Jini提供了一种服务的查询和发现机制，这些services都可以通过JMX 来实现管理。
现在我们开始JMX的了解：
1.到java.sun.com首页的JMX页面，下载JMX的规定说明和Samples程序。
2.按照JMX的说明进行一次Tutorial，了解如何加入 删除 配置一个MBean，Tutorial中是以SimpleMBean为例，那么我们能否建立一个自己的MBean?我们来做一个Hello 的MBean，这里有一个小关键点，你的class取名有个规则， 需要以MBean为结尾，如这里我们取名为HelloMbean:
public interface HelloMBean {// management attributes
public String getName();
public void setName(String name);// management operations
public void print();}
在这个Class里，有一个隐含attributes: name, 提供了set和get的方法，同时有一个操作方法print()：
再定义一个concrete类:
public class Hello implements HelloMBean {
private String name = "";
public String getName() {
return name;
}public void setName(String name) {
this.name = name;
}public void print() {
System.out.println("Hello, " + name + "!!" );
}
}
这样一个简单的MBean就做好了，我们可以通过admin界面加入这个Hello，再按 Tutorial启动BaseAgent，在Agent Administration中参考Simple填入：
Domain: Standard_Hello_MBeansKeys : name=Hello,number=1
Java Class: Hello
将出现Create Successful信息。进入MBean View 给Name赋值，点按Apply ，然后再按print，这是你的Hello中的方法，在控制台你会看到输出。
是不是很惊奇Hello中的 attributes 和operations能被动态的访问和控制？ 已经隐约感到JMX的架构原理了吧？
下面再深入明确一些概念：
上面HelloMBean资源是通过admin这样的HTTP WEB界面管理，这种管理资源方式是属于JMX的Distributed服务层， JMX 通过Distributed层能够部署和管理MBean资源。就象上面的例子，是通过HtmlAdaptor提供的HTTP WEB界面来方面的维护管理HelloMBean.那么我们能否在程序中自动管理和部署我的MBean？当然可以，这是通过Agent层来完成，现在我们已经有了这个层次，MBean所在的资源层，
最外面的Distributed服务层，Distributed服务层是通过Agent层来访问MBean资源的，看看下面来自Sun公司JMX规定的架构图：
从图中看出，Agent Level(Agent层)包括MBean Server和Agent Services,那么我们来做一个上面例子HelloMBean的Agent：
// CREATE the MBeanServer
//
System.out.println("\n\tCREATE the MBeanServer.");
MBeanServer server = MBeanServerFactory.createMBeanServer();// CREATE Registe HelloMBean
//
System.out.println("\n\tCREATE, REGISTER a new Hello Standard_MBean:");
HelloMBean helloMBean = new Hello();ObjectName hello_name = null;
try {
hello_name = new ObjectName("Standard_Hello_MBeans:name=Hello,number=1");
System.out.println("\tOBJECT NAME = " + hello_name);//将HelloMBean注册到MBeanServer中去
server.registerMBean(helloMBean, hello_name);
}
catch (Exception e) {
e.printStackTrace();
return;
}向MBeanServer注册后，以后JMX就知道有了这个HelloMBean资源。
管理一个agent的MBean资源或使用它提供的服务必须通过一个protocol adaptor 或者connector,adaptor 或者connector属于Distributed layer level(Distributed服务层)，我们上面例子中通过HTTP WEB界面管理HelloMBean就是浏览器通过HtmlAdaptor这个adaptor来实现的。
通过本篇文章，你应该大体了解了JMX的架构和一些原理和应用，再深入可以研究SUN的JMX Specification.
-
一本好书： 开发者突击：Java Web主流框架整合开发
2008-5-07
很少看见这么好的书了，现在很多技术书，都是东拼西凑，没有张法，这一本，我觉得真的很好，很合适才入门的朋友看。定价：￥89.80
编辑推荐每一个开发者，都是软件世界里的列兵！每一个技术，都是前进道路上的堡礁。
从零起步，循序渐进，注重实战，本书从不同角度剖析了Java Web整合开发中的：三大基础技术JSP/JavaBean/Servlet，三大核心框架Struts/Hibernate/Spring，四种辅助技术JDBC/Log4j/Sitemesh/JUnit，MTEC开发环境MySQL/Tomcat/Eclipse/CVS。
以J2EE（JSP、JavaBean、Servlet）、SSH（Struts、Spring、Hibernate）为核心技术，逐步构建十大软件架构原型，构建的每—个系统原型都可以直接作为系统开发的基础
以经典组合MTEC，即MySQL、Tomcat、Eclipse、CVS搭配经典的开发环境。MySQL是免费开源的数据库，Tomcat是免费开源的Web服务器，Eclipse是免费开源的Java集成开发工具，CVS是流行的版本控制工具，通过MTEC将这四者的优点发挥到极致。
使用流行的辅助技术，包括JDBC、Log4j、Sitemesh、JUnit。JDBC用以进行数据库操作，Log4j用以记录日志Sitemesh用以进行站点布局，JUnit用以进行单元测试。
以登录、注册、退出为基础需求构建十大软件架构原型，并在最终的原型SSH（Struts+Spring+Hibemate）和SSH2（Struts 2+Spring+Hibernate）基础上分别开发完整的办公自动化系统。 内容简介本书详细介绍了Java Web软件架构中的各种开发技术。主要内容包括：以MySQL为数据库、Tomcat为Web服务器、Eclipse为开发工具、CVS为版本控制工具的开发环境的构建过程；基于JSP、JavaBean、Servlet技术实现3种J2EE的基础架构；分3篇重点讲解Struts、Hibernate、Spring框架技术及这些技术的整合应用；基于Struts1的SSH整合架构，并开发个人通讯录和一个完整的办公自动化系统，实现的功能包括日程安排、工作日志、短消息管理、公告管理、会议管理；基于Struts2的SSH2整合架构，并在此架构基础上实现一个完整的办公自动化系统。在本书架构讲解的过程中，穿插介绍了JDBC、Log4j、Sitemesh、JUnit技术。
随书附赠光盘内容包括本书10种架构原型程序包、个人通讯录及办公自动化系统源程序。
本书内容循序渐进，通俗易懂，覆盖了Java Web开发的最流行技术，无论对于Java Web架构设计还是软件开发，本书都是精通开发Java Web应用的必备的实用手册。
本书面向读者对象：Java和J2EE软件架构师与设计师、软件开发工程师、软件开发项目及技术经理。 目录绪言
一、了解软件架构
（一）基本概念
（二）软件架构的历史
（三）软件架构的目标
二、J2EE开发模型分析
（一）一层架构模式
（二）两层架构模式Model 1
（三）三层架构模式Model 2
（四）多层架构模式
三、J2EE架构技术选择
（一）JSP页面技术
（二）JavaBean组件技术
（三）Servlet技术
（四）Struts 1.2与Struts 2.0
（五）Hibernate 3.0
（六）Spring 2.0
四、开发工具软件及版本选择
（一）JDK软件
（二）数据库软件MySQL
（三）Web服务器Tomcat
（四）集成开发工具Eclipse+MyEclipse
（五）版本控制软件CVS
五、定位开发目标
（一）demo(JSP).zip
（二）demo(JSP+JavaBean).zip
（三）demo(JSP+JavaBean+Servlet).zip
（四）demo(Struts).zip
（五）demo(Struts+Hibernate).zip
（六）demo(Spring).zip
（七）demo(Spring+Hibernate).zip
（八）demo(Struts+Spring).zip
（九）demo(Struts+Spring+Hibernate).zip
（十）demo(Struts2+Hibernate+Spring).zip
六、继续下一主题：需求设计
第1部分 起步篇
第1章 需求设计
1.1 软件需求
1.1.1 软件需求的定义
1.1.2 软件需求的层次
1.1.3 软件分析的过程
1.2 设计需求功能
1.3 设计系统界面
1.3.1 登录界面
1.3.2 登录后的欢迎界面
1.3.3 注册界面
1.4 继续下一主题：构建数据库
第2章 构建数据库
2.1 设计数据库表
2.1.1 数据库实体分析
2.1.2 设计用户表user
2.2 安装MySQL
2.2.1 安装MySQL
2.2.2 启动MySQL
2.3 创建数据库
2.3.1 MySQL客户端软件SQL-Front
2.3.2 新建数据库demo
2.3.3 新建用户表user
2.3.4 添加一条用户数据
2.4 继续下一主题：构建开发环境
第3章 构建开发环境
3.1 构建CVS服务器
3.1.1 安装CVS服务器
3.1.2 配置CVS代码资源库
3.1.3 添加CVS账户
3.2 构建客户端开发环境
3.2.1 安装JDK
3.2.2 安装Tomcat
3.2.3 安装Eclipse
3.2.4 中文化Eclipse
3.2.5 安装MyEclipse
3.3 配置Eclipse集成开发环境
3.3.1 集成配置JDK
3.3.2 集成配置Tomcat
3.3.3 连接CVS服务器
3.4 继续下一主题：开始逐步构建JSP、JavaBean、Servlet架构
第2部分 J2EE基础架构篇
第4章 开始构建项目
4.1 构建新的项目
4.1.1 在Eclipse下新建项目
4.1.2 共享项目到CVS服务器
4.1.3 从CVS服务器取得项目到本地
4.2 如何使用CVS进行协作开发
4.2.1 使本地文件与CVS资源库同步
4.2.2 将本地文件提交到资源库
4.2.3 从资源库更新文件
4.2.4 管理资源库
4.3 在Eclipse中发布项目到Tomcat并运行
4.3.1 发布项目到Tomcat
4.3.2 启动Tomcat
4.3.3 运行项目
4.4 Java Web部署描述符web.xml
4.4.1 头元素
4.4.2 文档类型申明
4.4.3 Web应用图标
4.4.4 Web应用名称
4.4.5 Web应用描述
4.4.6 分布式属性
4.4.7 上下文参数
4.4.8 过滤器定义
4.4.9 过滤器映射
4.4.10 监听器
4.4.11 Servlet定义
4.4.12 Servlet映射
4.4.13 控制会话超时
4.4.14 MIME类型映射
4.4.15 指定欢迎文件页
4.4.16 错误处理页
4.4.17 定位TLD
4.4.18 资源管理对象
4.4.19 资源工厂使用的资源
4.4.20 安全限制
4.4.21 登录验证
4.4.22 安全角色
4.4.23 Web环境参数
4.4.24 EJB申明
4.4.25 本地EJB申明
4.4.26 Servlet 2.4新增标签
4.5 继续下一主题：开发JSP架构
第5章 开发JSP框架
5.1 JSP基本语法
5.1.1 一个典型的JSP文件
5.1.2 两种注释类型
5.1.3 3个脚本元素
5.1.4 3个指令元素
5.1.5 8个动作指令
5.2 JSP内置对象
5.2.1 Request：请求对象
5.2.2 Response：响应对象
5.2.3 Session：会话对象
5.2.4 Application：应用程序对象
5.2.5 Out：输出对象
5.2.6 Cookie：客户端对象
5.2.7 Config：配置对象
5.2.8 Page：页面对象
5.2.9 PageContext：页面上下文对象
5.2.10 Exception：例外对象
5.3 JDBC核心技术
5.3.1 通过Connection对象建立数据库连接
5.3.2 通过DatabaseMetaData对象了解数据库的信息
5.3.3 使用Statement对象
5.3.4 结果集ResultSet对象
5.3.5 PreparedStatement接口
5.3.6 CallableStatement对象
5.4 从jdbc_blank配置连接MySQL并进行测试
5.4.1 添加MySQL驱动mysq1-2.0.4.jar
5.4.2 数据库参数文件inc.jsp
5.4.3 测试MySQL连接testjdbc.jsp
5.5 开发JSP显示页面和响应处理页面
5.5.1 登录页面login.jsp
5.5.2 登录验证操作login_action.jsp
5.5.3 欢迎页面welcome.jsp
5.5.4 退出操作logout.jsp
5.5.5 注册页面register.jsp
5.5.6 注册用户操作register_action.jsp
5.6 架构1：demo(JSP).zip
5.6.1 程序结构图
5.6.2 系统架构图
5.6.3 如何在该架构上开发新的功能
5.7 继续下一主题：使用JavaBean组件处理业务逻辑
第6章 开发JSP+JavaBean框架
6.1 JavaBean技术基础
6.1.1 JavaBean简介
6.1.2 一个简单的JavaBean的例子
6.1.3 JavaBean属性
6.1.4 JSP与JavaBean结合
6.1.5 JSP与JavaBean结合实例
6.2 开发数据库底层处理JavaBean—DBAccess.java
6.2.1 定义JavaBean变量
6.2.2 编写getter/setter函数
6.2.3 创建数据库连接
6.2.4 更新SQL函数
6.2.5 查询SQL函数
6.2.6 关闭数据库连接对象
6.3 开发JavaBean业务逻辑组件—UserBean.java
6.3.1 登录验证函数
6.3.2 修改login_action.jsp调用JavaBean
6.3.3 用户注册时检查用户名是否存在
6.3.4 增加一个用户
6.3.5 修改register_action.jsp调用JavaBean
6.4 架构2：demo(JSP+JavaBean).zip
6.4.1 程序结构图
6.4.2 系统架构图
6.4.3 如何在该架构上开发新的功能
6.5 继续下一主题：使用Servlet接收用户请求
第7章 开发JSP+JavaBean+Servlet框架
7.1 Servlet技术基础
7.1.1 一个简单的Servlet
7.1.2 Servlet基本概念
7.1.3 Servlet生命周期
7.1.4 Servlet的重要函数
7.2 Servlet经典实例
7.2.1 编码过滤器
7.2.2 站点计数监听器
7.3 开发Servlet接收用户请求UserServlet
7.3.1 在web.xml中添加Servlet配置
7.3.2 新建com.demo.servlet.UserServlet
7.3.3 处理登录验证Servlet
7.3.4 处理退出Servlet
7.3.5 处理注册Servlet
7.4 架构3：demo(JSP+JavaBean+Servlet).zip
7.4.1 程序结构图
7.4.2 系统架构图
7.4.3 如何在该架构上开发新的功能
7.5 继续下一主题：改建Struts架构
第3部分 Struts架构篇
第8章 构建Struts开发环境
8.1 第一种方式：使用MyEclipse添加Struts开发环境
8.2 第二种方式：手动添加Struts开发环境
8.3 配置Struts日志组件
8.3.1 添加日志组件包
8.3.2 添加日志配置文件
8.3.3 修改commons-logging.properties调用Log4j
8.3.4 Log4j配置文件log4j.properties
8.4 继续下一主题：开发Struts核心功能
第9章 开发Struts核心功能
9.1 Struts内部机制
9.1.1 MVC模式
9.1.3 Struts核心组件文件
9.1.2 Struts体系结构
9.1.4 Struts工作流程
9.2 Struts开发流程
9.2.1 Struts开发流程图
9.2.2 编写输入表单页面input.jsp
9.2.3 配置struts-config.xml
9.2.4 编写ActionForm Bean类
9.2.5 编写Action处理类
9.2.6 编写返回JSP页面
9.3 Struts配置文件详解—struts-config.xml
9.3.1 配置数据源：元素
9.3.2 配置ActionForm：元素
9.3.3 配置全局异常处理：元素
9.3.4 配置全局跳转：元素
9.3.5 配置映射关系：元素
9.3.6 配置RequestProcessor：元素
9.3.7 配置国际化资源文件：元素
9.3.8 配置Plug-in插件：元素
9.3.9 分离Struts配置文件
9.4 ActionForm Bean开发技术
9.4.1 使用默认表单ActionForm
9.4.2 使用动态表单DynaActionForm
9.4.3 使用自动校验表单DynaValidatorForm
9.5 Action组件开发技术
9.5.1 使用默认的Action
9.5.2 可直接转发的ForwardAction
9.5.3 可包含文件的IncludeAction
9.5.4 可自动分发的DispatchAction
9.5.5 可进行多个提交的LookupDispatchAction
9.5.6 可实现交换的SwitchAction
9.6 开发登录处理流程
9.6.1 添加默认首页index.do指向登录页面login.jsp
9.6.2 修改login.jsp的登录提交地址为login.do
9.6.3 配置：添加登录表单loginForm
9.6.4 配置：添加登录组件login
9.6.5 开发ActionForm Bean：创建登录表单类LoginForm.java
9.6.6 开发Action：创建登录处理类LoginAction.java
9.6.7 登录处理流程图
9.7 开发退出处理流程
9.7.1 修改welcome.jsp的退出提交地址为logout.do
9.7.2 配置：添加退出组件logout
9.7.3 开发Action：创建退出处理类LogoutAction.java
9.7.4 退出处理流程图
9.8 开发注册处理流程
9.8.1 修改login.jsp的注册链接地址为register.do
9.8.2 修改register.jsp的注册提交地址为register.do
9.8.3 配置：添加注册表单registerForm
9.8.4 配置：添加登录组件register
9.8.5 开发ActionForm Bean：创建注册表单类RegisterForm.java
9.8.6 开发Action：创建注册处理类RegisterAction.java
9.8.7 注册处理流程图
9.9 继续下一主题：使用DBCP连接池操作数据库
第10章 使用DBCP连接池操作数据库
10.1 数据库连接池基础
10.1.1 数据库连接池的基本概念
10.1.2 数据库连接池的工作原理
10.1.3 Java开源的连接池
10.2 DBCP连接池基础
10.2.1 DBCP数据源的创建过程
10.2.2 在Tomcat中使用DBCP连接池的过程
10.2.3 在Tomcat中使用DBCP连接池的实例
10.3 在Struts中配置DBCP连接池
10.3.1 部署DBCP安装包和MySQL的驱动包
10.3.2 在struts-config.xml中配置DBCP数据源
10.3.3 使用DBCP数据源的方法
10.4 在Struts中使用DBCP连接池
10.4.1 LoginAction中验证用户登录函数
10.4.2 RegisterAction中检查用户是否存在函数
10.4.3 RegisterAction中用户注册函数
10.5 继续下一主题：使用Log4j记录日志
第11章 使用Log4j记录日志
11.1 Log4j的基本概念
11.1.1 日志记录器Logger
11.1.2 输出源Appender
11.1.3 布局器Layout
11.2 Log4j的配置与使用
11.2.1 通过程序配置
11.2.2 通过Property文件配置
11.2.3 通过XML文件配置
11.3 Log4j 与CommonsLogging联合使用
11.3.1 Commons Logging通用日志组件
11.3.2 Commons Logging+Log4j
11.4 为Action添加日志代码
11.4.1 在LoginAction中添加日志记录代码
11.4.2 在LogoutAction中添加日志记录代码
11.4.3 在RegisterAction中添加日志记录代码
11.5 继续下一主题：使用Struts标签进行 页面国际化
第12章 使用Struts标签进行页面国际化
12.1 软件国际化与本地化
12.1.1 I18N和L10N的由来
12.1.2 软件国际化的实现目标
12.1.3 软件本地化的设置方法
12.1.4 软件编码问题
12.2 Struts应用的国际化
12.2.1 Java对国际化的支持
12.2.2 Struts对国际化的支持
12.2.3 Struts页面国际化的过程
12.3 Struts HTML标签
12.3.1 用于生成基本的HTML元素的标签
12.3.2 用于生成HTML表单的标签
12.3.3 用于显示错误或正常消息的标签
12.4 Struts Bean标签
12.4.1 用于访问HTTP请求信息或JSP隐含对象
12.4.2 用于访问Web应用资源
12.4.3 用于定义或输出JavaBean的Bean标签
12.5 Struts Logic标签
12.5.1 进行比较运算的Logic标签
12.5.2 进行字符串匹配的Logic标签
12.5.3 判断指定内容是否存在的Logic标签
12.5.4 进行循环遍历的Logic标签
12.5.5 进行请求转发或重定向的Logic标签
12.6 标签化JSP页面中的文字
12.6.1 登录页面login.jsp
12.6.2 注册页面register.jsp
12.6.3 欢迎页面welcome.jsp
12.7 创建资源文件
12.7.1 新建中文资源文件ApplicationResources_temp.properties
12.7.2 转换资源文件编码ApplicationResources_zh_CN.properties
12.7.3 建立英文与默认资源文件
12.7.4 运行项目进行本地化访问
12.8 继续下一主题：Struts表单验证
第13章 进行Struts数据验证
13.1 两种表单验证方法
13.1.1 使用Validator校验器组件
13.1.2 在ActionForm中检验合法性
13.2 第一步：为ActionForm添加表单验证功能
13.2.1 添加登录时的表单检验功能—LoginForm
13.2.2 添加注册时的表单检验功能—RegisterForm
13.3 第二步：为Action添加逻辑验证功能
13.3.1 登录时检查是否登录成功—LoginAction
13.3.2 注册时检查用户名是否存在—RegisterAction
13.4 第三步：验证出错时维持表单输入
13.4.1 维持登录页面的表单输入—login.jsp
13.4.2 维持注册页面的表单输入—register.jsp
13.5 继续下一主题：使用Sitemesh进行框架布局
第14章 使用Sitemesh进行站点布局
14.1 Sitemesh框架基础
14.1.1 Sitemesh功能概述
14.1.2 Sitemesh比Struts Tiles更加优秀
14.1.3 Sitemesh的工作原理
14.2 使用Sitemesh框架
14.2.1 安装Sitemesh框架
14.2.2 配置Sitemesh框架
14.2.3 建立装饰器描述文件decorators.xml
14.2.4 建立装饰器页面/decorators/frame.jsp
14.3 查看装饰后的站点
14.3.1 登录页面login.jsp—不含登录菜单
14.3.2 注册页面register.jsp—不含登录菜单
14.3.3 欢迎页面welcome.jsp—包含登录菜单
14.4 架构4：demo(Struts).zip
14.4.1 程序结构图
14.4.2 系统架构图
14.4.3 如何在该架构上开发新的功能
14.5 继续下一主题：在Struts中集成Hibernate 314
第4部分 Hibernate架构篇
第15章 Hibernate核�
)