良子

[转]主数据管理(MDM)的成熟度

xiong2009 — Mon, 17 Aug 2009 10:52:00 +0800

主数据管理(MDM)的成熟度

MDM全写Master Data Management，翻译为主数据管理或元数据管理。

　　什么是MDM

企业主数据是用来描述企业核心业务实体的数据，比如客户、合作伙伴、员工、产品、物料单、账户等；它是具有高业务价值的、可以在企业内跨越各个业务部门被重复使用的数据，并且存在于多个异构的应用系统中。

主数据和主数据管理的概念

企业主数据可以包括很多方面，除了常见的客户主数据之外，不同行业的客户还可能拥有其他各种类型的主数据，例如：对于电信行业客户而言，电信运营商提供的各种服务可以形成其产品主数据；对于航空业客户而言，航线、航班是其企业主数据的一种。对于某一个企业的不同业务部门，其主数据也不同，例如市场销售部门关心客户信息，产品研发部门关心产品编号、产品分类等产品信息，人事部门关心员工机构，部门层次关系等信息。

数据管理的范畴和主数据管理的概念

　　如图所示，企业数据管理的内容及范畴通常包括交易数据、主数据以及元数据。

l 交易数据：用于纪录业务事件，如客户的订单，投诉记录，客服申请等，它往往用于描述在某一个时间点上业务系统发生的行为。

l 主数据：主数据则定义企业核心业务对象，如客户、产品、地址等，与交易流水信息不同，主数据一旦被记录到数据库中，需要经常对其进行维护，从而确保其时效性和准确性；主数据还包括关系数据，用以描述主数据之间的关系，如客户与产品的关系、产品与地域的关系、客户与客户的关系、产品与产品的关系等。

l 元数据：即关于数据的数据，用以描述数据类型、数据定义、约束、数据关系、数据所处的系统等信息。

主数据管理是指一整套的用于生成和维护企业主数据的规范、技术和方案，以保证主数据的完整性、一致性和准确性 ( “ The set of disciplines, technologies, and solutions used to create and maintain consistent, complete, contextual and accurate business data for all stakeholders (users, applications, data warehouses, processes, companies, trading partners, customers, etc.) across and beyond the enterprise ” ) 。主数据管理的典型应用有 Customer Data Integration —客户数据管理和 Product Information Integraiton —产品数据管理。

图 2. 主数据管理的信息流

一般来说，主数据管理系统从 IT 建设的角度而言都会是一个相对复杂的系统，它往往会和企业数据仓库 / 决策支持系统以及企业内的各个业务系统发生关系，技术实现上也会涉及到 ETL、EAI、EII 等多个方面，如图 2 所示，一个典型的主数据管理的信息流为：

1. 某个业务系统触发对企业主数据的改动；

2. 主数据管理系统将整合之后完整、准确的主数据分发给所有有关的应用系统；

3. 主数据管理系统为决策支持和数据仓库系统提供准确的数据源。

因此对于主数据管理系统的建设，要从建设初期就考虑整体的平台框架和技术实现。

　　MDM的意义

如图 3 所示：集成、共享、数据质量、数据治理是主数据管理的四大要素，主数据管理要做的就是从企业的多个业务系统中整合最核心的、最需要共享的数据（主数据），集中进行数据的清洗和丰富，并且以服务的方式把统一的、完整的、准确的、具有权威性的主数据分发给全企业范围内需要使用这些数据的操作型应用和分析型应用，包括各个业务系统、业务流程和决策支持系统等。

主数据管理使得企业能够集中化管理数据，在分散的系统间保证主数据的一致性，改进数据合规性、快速部署新应用、充分了解客户、加速推出新产品的速度。从 IT 建设的角度，主数据管理可以增强 IT 结构的灵活性，构建覆盖整个企业范围内的数据管理基础和相应规范，并且更灵活地适应企业业务需求的变化。

以客户主数据为例，客户主数据是目前企业级客户普遍面临的一个问题，在大多数企业中，客户信息通常分散于 CRM 等各个业务系统中，而每个业务系统中都只有客户信息的片断，即不完整的客户信息，但却缺乏企业级的完整、统一的单一客户视图，结果导致企业不能完全了解客户，无法协调统一的市场行为，导致客户满意度下降，市场份额减少。因此，建立客户主数据系统的目的在于：

l 整合并存储所有业务系统和渠道的客户及潜在客户的信息：一方面从相关系统中抽取客户信息，并完成客户信息的清洗和整合工作，建立企业级的客户统一视图；另一方面，客户主数据管理系统将形成的统一客户信息以广播的形式同步到其他各个系统，从而确保客户信息的一致；

l 为相关的应用系统提供联机交易支持，提供客户信息的唯一访问入口点，为所有应用系统提供及时和全面的客户信息；服务于 OCRM 系统，充分利用数据的价值，在所有客户接触点上提供更多具有附加价值的服务；

l 实现 SOA 的体系结构：建立客户主数据系统之前，数据被锁定在每一个应用系统和流程中，建立主数据管理系统之后，数据从应用系统中被释放出来，并且被处理成为一组可重用的服务，被各个应用系统调用。

　　MDM的模式

　　元数据管理涉及到各个层次的元数据，管理的内容包括元数据的获取、元数据的更新、使用和面向应用项目的元数据使用处理等多个方面。

　　元数据的管理涉及数据库、数据处理软件、数据使用系统、面向应用的数据分析等各个环节。下面给出了一种普通意义的以元数据信息系统为基础的元数据管理模式：

　　通常意义上的元数据管理是指元数据通过各种途径形成后，对其内容的添加、删除、更新等涉及内容改变的操作和元数据内容检索、查询、放置、组织等常规性元数据操作，从这种意义上元数据的管理可以通过两种方式实现，即系统管理模式和用户管理模式。系统管理模式是面向数据库的，由数据库管理系统专业人员完成，数据用户只有使用权，没有元数据的操作权，数据应用项目中新生成的数据集的元数据也有应用系统传递给数据库管理员，然后由数据库管理员统一管理。

　　这种方式中，数据在处理过程中形成的动态元数据很难及时记录下来。另一种管理方式是用户管理模式，它是面向应用项目的，即允许某些数据用户在数据应用元数据的变动信息直接反馈给元数据库，这样则能保证元数据的动态更新和新生成数据集元数据的及时捕获及写入元数据文件。

　　但这种模式中数据用户的权限要适当的控制，以避免数据库的破坏。通常对元数据的管理是采用两者结合的模式。

主数据（MD Master Data）指系统间共享数据（例如，客户、供应商、账户和组织部门相关数据）。与记录业务活动，波动较大的交易数据相比，主数据（也称基准数据）变化缓慢。在正规的关系数据模型中，交易记录（例如，订单行项）可通过关键字（例如，订单头或发票编号和产品代码）调出主数据。主数据必须存在并加以正确维护，才能保证交易系统的参照完整性。

从报告或维度建模角度看，主数据指基于其组织或配置指标的维度或层次，而不是实际情况或其自身测量结果。例如，收入、成本和利润是实际情况，而时间、地点、客户和供应商是维度。应根据以下因素或更多因素综合考虑主数据：企业绩效管理报告（如利润或收入计划随产品、客户、账户等产生的变化）要求综合多个系统的主数据。遵从报告要求一致性主数据。同步交易系统处理特定客户（如提供具体报价）或供应商（如指定采购的首选供应商）。

主数据管理(MDM)的成熟度

　　根据主数据管理实施的复杂程度，参照Jill Dyche, Evan Levy的观点大体可以把主数据管理可以分为五个层次，从低到高反映了主数据管理(MDM)的不同成熟度。下面我们简单介绍一下这五个层次：

　　Level 0 ：没有实施任何主数据管理(MDM)

　　在Level 0的情况下，意味着企业的各个应用之间没有任何的数据共享，整个企业没有数据定义元素存在。比如，一个公司销售很多产品，对这些产品的生产和销售由多个独立的系统来处理，各个系统独立处理产品数据并拥有自己独立的产品列表，各个系统之间不共享产品数据。在Level 0, 每个独立的应用负责管理和维护自己的关键数据(比如产品列表、客户信息等)，各个系统间不共享这些信息，这些数据是不连通的。

　　Level 1 ：提供列表

　　不管公司大还是小，列表管理是我们常用的一种方式。在公司内部，会通过手工的方式维护一个逻辑或物理的列表。当各个异构的系统和用户需要某些数据的时候，就可以索取该列表了。对于这个列表的维护，包括数据添加、删除、更新以及冲突处理，都是由各个部门的工作人员通过一系列的讨论和会议进行处理的。业务规则(Business Rules)是用来反映价值的一致性，当业务规则发生改变或者出现类似的情况时，这样高度手工管理的流程容易发生错误。由于列表管理是通过手工管理的，其列表维护的质量取决于谁参加了变更管理流程，一旦某人缺席，将会影响列表的维护。

　　MDM Level 1比MDM Level 0的不同就是，各个部门虽然还是独立维护各自的关键数据，但会通过列表管理维护一个松散的主数据列表，能够向其他各个部门提供其需要的数据。在MDM Level 1中，数据变更决定以及数据变更操作都是由人来决定的，因此，只有人完成数据变更决定后才会变更数据。在实际情况中，虽然数据变更流程有严格的规定，但是由于缺乏集中的、基于规则的数据管理，当数据量比较大时，数据维护的成本会变的很高，效率也会很低。当主数据，比如客户信息、产品目录信息等数量比较少时，列表管理的方式是可行的，但是当产品目录或客户列表出现爆炸式增长以后，列表管理的变更流程将变得困难起来。MDM Level 1 依赖于人的协作。如果产品经理需要更新过后的产品价格列表，那需要联系ERP系统所有者，让其发送邮件给她。在企业范围内实现客户或产品列表就如同维护不同部门之间人们的关系一样。如果客户或产品存在层次或分组，列表将很难提供，并且通常在Level 1因为过于复杂难以被管理。

　　Level 2 ：同等访问(通过接口的方式，各个系统与主数据主机之间直接互联)

　　MDM Level 2与MDM Level 1相比，引入了对主数据的(自动)管理。通过建立数据标准，定义对存储在中央知识库(Central Repository)中详细数据的访问和共享，为各个系统间共享使用数据提供了严密的支持。中央知识库(Central Repository)通常会被称为“主数据主机(Master Data Host)”。这个知识库可以是一个数据库或者一个应用系统，通过在线的方式支持数据的访问和共享。

　　创建、读取、更新和删除 (CRUD)是处理基本功能的典型编程术语。即便在MDM中，CRUD处理也是基本功能。你的数据库如果仅仅支持CRUD处理并不意味着你实现了MDM。 MDM Level 2引入了“同等访问”(peer-based access)，也就是说一个应用可以调用另一个应用来更新或刷新需要的数据。当CRUD处理规则定义完成后，MDM Level 2 需要客户或“同等”应用格式化请求(和数据)，以便和MDM知识库保持一致。MDM知识库提供集中的数据存储和供应(provisioning)。在这个阶段，规则管理、数据质量和变更管理必须在企业范围内作为附加功能定制构建。

　　比如，一个数据库或一个打包应用(比如一个销售自动化系统)对外部应用提供数据访问功能。当一个外部应用(比如呼叫中心应用)需要增加一个客户，这个外部应用将提交一个事务，请求数据所有者增加一个客户条目。主数据主机(Master Data Host)将增加数据并告知外部应用。CRUD处理方式比纸上办公有了很大提高，其是基于会话的数据管理。在MDM Level 1，数据变更是基于手工的方式。在MDM Level 2，数据变更是自动完成的—通过由具体技术实现的标准流程，允许多应用系统修改数据。MDM Level 2可以支持不同的应用使用和变更单一、共享的数据知识库。MDM Level 2 需要每个同等应用理解基本的业务规则以便访问主列表、与主列表进行交互。因此，每个同等应用必须正确恰当地创建、增加、更新和删除数据。授权应用有责任坚持数据管理原则和约束。

　　Level 3 ：集中总线处理

　　与MDM Level 2相比，MDM Level 3打破了各个独立应用的组织边界，使用各个系统都能接受的数据标准统一建立和维护主数据(MDM Level 2的主数据主机上存储的数据还是按照各个系统分开存储的，没有真正的整合在一起)。

　　集中处理意味着为MDM构建了一个通用的、基于目标构建的平台。大多数公司发现MDM正在挑战他们现有的IT架构：他们拥有太多的独立平台处理主数据。 MDM Level 3 集中数据访问、控制跨不同应用和系统使用数据。这极大的降低了应用数据访问的复杂性，大大简化了面向数据规则的管理，使MDM比一个分散环境具有更多的功能和特点。企业主数据面临一致性的挑战。数据在不同的地方存在，数据所代表的含义也是不同的，数据的规则各个系统之间也是不一样的。集中MDM处理-通过一个公共的平台作为一个总线(HUB)-说明一个共识，从多个系统整合主题域数据，意味着使用集中、标准化的方法转换异构操作数据，不管其在源系统中是什么样子，都会被整合起来。在MDM Level 3，公司对主题域内容采用集中管理方式。这意味着应用系统，作为消费者或使用主数据，拥有一个共识就是数据是主题数据内容的映像，打破了各个独立应用的组织边界。MDM Level 3支持分布主参考数据的存在。

　　MDM的核心之一就是保证所有系统都能接受数据表示的唯一公认方法。这有点类似于语言翻译，通过其他语言的翻译，英语已经称为一个全球性的语言。在MDM Level 3，一个公司可以让任意两个系统共享数据和说对方的语言。MDM Level 3还降低了等同访问的复杂性。"消费"应用不再需要支持系统定位和操作逻辑。任何与源系统数据相关的分布式细节都会被MDM总线集中处理。在MDM Level 3自动数据标准意味着：建立目标数据值表示和通过必要的步骤提供精确的主数据值捕获。在所有的分类中从MDM Level 3开始第一次支持一致性的企业数据视图。数据质量规则在这里进行数据清洗和错误纠正。

　 Level 4 ：业务规则和政策支持

　　一旦数据从多个数据源整合在一起，主题域视图超越单独的应用并表现为一个企业视图，你将获得事实的单一版本。当事实的单一版本已经能够提供出来时，来自业务主管和执行人员的必然反应经常是：“证明它”。MDM Level 4可以保证主数据反映一个公司业务规则和流程，并证实其正确性。MDM Level 4通过引入主数据来支持规则，并对MDM总线以及其它外部系统进行完整性检查。由于多数公司相对比较复杂，影响业务数据访问和操作的规则以及策略 (rules and policies)相对也比较复杂。假定任何一个单一系统可以包含并管理与主参考数据相关的各种类型的规则是不切实际的。因此，如果一个MDM总线真正打算提供企业范围内数据的精确性，工作流和流程整合的支持是必不可少的。

　　举例来说，在一个HMO内，需要多个应用来支持一个病人的护理。一个单一的访问(visit)可能包括入院、房间和床位分配、监控设备、化验、身体检查以及其他程序等。一旦一个病人准备离开医院，出院流程需要确保和这个病人相关的所有活动、资源都被结清。MDM技术在召集多个应用系统一起保证病人辨识方面是十分有效的，处理是正确的。虽然病人辨识很重要，业务规则整合同样重要。临床系统依靠一系列的业务流程和数据规则来辨别所有显著的病人详细资料。这包括返回所有基于房间的资源(监护设备、床位等)以得到有用的详细目录，当病人要出院时分解其所有的费用。MDM保证当John Smith出院时，正确的房间和设备放入到该John Smith的详细目录中，而不是其他的John Smith(正在另一个楼层做身体治疗)。

　　MDM系统必须不仅支持基于规则的整合，还要能够整合外部的工作流。这些规则可能包括通过总线与临床系统交互或等待另一个系统或者人(有权限做出改变的人)审批。通过一个MDM总线，规则定义可以不仅局限在逻辑上，还可以依赖于其他系统的输入。当然，协调和审计数据意味着可以回退其他系统(或业务流程)来保证数据变化经过严格的审批，这样错误可以被发现并且事务在需要的时候可以被回滚。MDM Level 4提出对规则和策略扩展性的支持。通过总线以一个灵活可持续的方式支持任何面向业务的规则集合这很重要。

　　比如，如果一个商店经理更新一个产品的价格，总线系统需要能够和一个可信系统(比如，商品管理系统)进行协商以便使规则生效。详细规则将支持另一个系统中存在产品价格的变更—总线需要能够理解能够处理和批准变更的权限系统或方法。这些规则可能涉及到复杂性或隐私限制，禁止它们直接在总线上存在。在MDM Level 4，一个企业可以支持一套步骤或任务，在一个特殊的创建、读取、更新和删除任务被允许之前这些步骤或任务必须遵守。工作流自动化经常用来支持发生在总线上的事件或活动的授权。但是变更管理远远不仅仅是工作流：它可以包括基于逻辑的流程和基于人的决策。变更管理的存在可以支持动态业务，允许变更。举例说明，在 911之前，任何人都可以在美国国内的航空公司运载货物。没有规定以外的其他某种形式的鉴定和付款方式。911之后，美国联邦航空协会(FAA)指导建立了一个更加全面的规定，指示一个人是否被允许运载货物。在这个特殊的例子中，要求各个系统都部署FAA对托运人的要求是不现实的。部署一个规则管理系统，为所有的系统(包括MDM总线)集中托运人批准规则，更加容易实现(也更现实)。集中数据定义和标准化在MDM Level 2就已经引入，与MDM Level 4的集中规则管理相比，相对简单。业务流程越复杂、业务流程越多，对总线的需求就越多，以便对针对共同数据的跨职能、异构规则进行更好的支持。重要的是 MDM Level 4支持集中规则管理，但是规则本身和相关的处理是可以分开的。换句话说，MDM总线需要保证规则是集中应用的，即便这个规则是在总线外居住的。

　　Level 5 ：企业数据集中

　　在MDM Level 5 ，总线和相关的主数据被集成到独立的应用中。主数据和应用数据之间没有明显的分隔。他们是一体的。当主数据记录详细资料被修改后，所有应用的相关数据元素都将被更新。这意味着所有的消费应用和源系统访问的是相同的数据实例。这本质上是一个闭环的MDM：所有的应用系统通过统一管理的主数据集成在一起。在这个级别，所有在系统看起来都是事实的同一个版本。操作应用系统和MDM内容是同步的，所以当变更发生时，操作应用系统都将更新。在那些熟悉的MDM架构风格中，持久总线架构，当一个总线更新所有的操作应用系统将体现这种变更，形成改变的直接操作视图。在注册环境中，当数据数据更新时，总线将通过Web服务连接相关系统应用事务更新。因此，MDM Level 5提供一个集成的，同步的架构，当一个有权限的系统更新一个数据值时，公司内所有的系统将反映这个变更。系统更新完数据值后不要单选其他系统中相应值的更新：MDM将使这种更新变的透明。

　　从MDM Level 4到MDM Level 5意味着MDM功能性不是在一个应用内被特殊设计或编码的。这还意味着主数据传播和供应不需要源系统专门的开发或支持。所有的应用清楚的知道他们并不拥有或控制主数据。他们仅仅使用数据来支持他们自己的功能和流程。由于MDM总线和支持的IT基础架构，所有的应用可以访问主参考数据。一个公司在完成MDM Level 5后将使他们所有的应用连在一起—既包括操作的也包括分析的—所有访问主数据是透明的。举例说明，当一个客户更新她的状态—不要管注册该变更的系统—数据变更将被广播到所有的应用平台(因此一致起来)。MDM Level 5是把数据概念作为一种service来实现。MDM Level 5保证了一个一致的主数据主题域企业映像。定义“客户”和其他应用接受客户主数据业务规则变化实际上是一回事。MDM Level 5移走了主数据的最后一个障碍：统一采用数据定义、授权使用和变更传播

作者：xiong2009 发表于2009-8-17 10:52:00 原文链接

阅读：769 评论：0 查看评论

[原]PowerDesigner中概念数据模型2

xiong2009 — Wed, 17 Oct 2007 23:40:00 +0800

目标：
本节主要介绍数据项、新增数据项、数据项的唯一性代码选项和重用选项等。

一、数据项
数据项（Data Item）是信息存储的最小单位，它可以附加在实体上作为实体的属性。
注意：模型中允许存在没有附加至任何实体上的数据项。

二、新建数据项
1）使用“Model”---> Data Items 菜单，在打开的窗口中显示已有的数据项的列表，点击 “Add a Row”按钮，创建一个新数据项，如图所示

2）当然您可以继续设置具体数据项的Code、DataType、Length等等信息。这里就不再详细说明了。

三、数据项的唯一性代码选项和重用选项
使用Tools--->Model Options->Model Settings。在Data Item组框中定义数据项的唯一性代码选项(Unique Code)与重用选项（Allow Reuse）。
注意：
如果选择Unique Code复选框，每个数据项在同一个命名空间有唯一的代码，而选择Allow reuse ，一个数据项可以充当多个实体的属性。

四、在实体中添加数据项
1）双击一个实体符号，打开该实体的属性窗口。
2）单击Attributes选项卡，打开如下图所示窗口

注意：
Add a DataItem 与 Reuse a DataItem的区别在于
Add a DataItem 情况下，选择一个已经存在的数据项，系统会自动复制所选择的数据项。如果您设置了UniqueCode选项，那系统在复制过程中，新数据项的Code会自动生成一个唯一的号码，否则与所选择的数据项完全一致。

Reuse a DataItem情况下，只引用不新增，就是引用那些已经存在的数据项，作为新实体的数据项。

------------------------------------------------------------------------------------------

目标：本节主要介绍联系的定义及使用。

一、联系
联系（Relationship）是指实体集这间或实体集内部实例之间的连接。

实体之间可以通过联系来相互关联。与实体和实体集对应，联系也可以分为联系和联系集，联系集是实体集之间的联系，联系是实体之间的联系，联系是具有方向性的。联系和联系集在含义明确的情况之下均可称为联系。

按照实体类型中实例之间的数量对应关系，通常可将联系分为4类，即一对一（ONE TO ONE）联系、一对多（ONE TO MANY）联系、多对一（MANY TO ONE）联系和多对多联系（MANY TO MANY）。

二、建立联系
在CDM工具选项板中除了公共的工具外，还包括如下图所示的其它对象产生工具。

在图形窗口中创建两个实体后，单击“实体间建立联系”工具，单击一个实体，在按下鼠标左键的同时把光标拖至别一个实体上并释放鼠标左键，这样就在两个实体间创建了联系，右键单击图形窗口，释放Relationship工具。如下图所示

三、四种基本的联系
即一对一（ONE TO ONE）联系、一对多（ONE TO MANY）联系、多对一（MANY TO ONE）联系和多对多联系（MANY TO MANY）。如图所示

四、其他几类特殊联系

除了4种基本的联系之外，实体集与实体集之间还存在标定联系（Identify Relationship）、非标定联系（Non-Identify RelationShip）和递归联系（Recursive Relationship）。

标定联系：
每个实体类型都有自己的标识符，如果两个实体集之间发生联系，其中一个实体类型的标识符进入另一个实体类型并与该实体类型中的标识符共同组成其标识符时，这种联系则称为标定联系，也叫依赖联系。反之称为非标定联系，也叫非依赖联系。
注意：
在非标定联系中，一个实体集中的部分实例依赖于另一个实例集中的实例，在这种依赖联系中，每个实体必须至少有一个标识符。而在标定联系中，一个实体集中的全部实例完全依赖于另个实体集中的实例，在这种依赖联系中一个实体必须至少有一个标识符，而另一个实体却可以没有自己的标识符。没有标识符的实体用它所依赖的实体的标识符作为自己的标识符。

换句话来理解，在标定联系中，一个实体（选课）依赖一个实体（学生），那么（学生）实体必须至少有一个标识符，而（选课）实体可以没有自己的标识符，没有标标识符的实体可以用实体（学生）的标识符作为自己的标识符。

递归联系：
递归联系是实体集内部实例之间的一种联系，通常形象地称为自反联系。同一实体类型中不同实体集之间的联系也称为递归联系。

例如：在“职工”实体集中存在很多的职工，这些职工之间必须存在一种领导与被领导的关系。又如“学生”实体信中的实体包含“班长”子实体集与“普通学生”子实体集，这两个子实体集之间的联系就是一种递归联系。创建递归联系时，只需要单击“实体间建立联系”工具从实体的一部分拖至该实体的别一个部分即可。如图

五、定义联系的特性

在两个实体间建立了联系后，双击联系线，打开联系特性窗口，如图所示。

六、定义联系的角色名
在联系的两个方向上各自包含有一个分组框，其中的参数只对这个方向起作用，Role Name为角色名，描述该方向联系的作用，一般用一个动词或动宾组表。
如：“学生 to 课目 ” 组框中应该填写“拥有”，而在“课目To 学生”组框中填写“属于”。（在此只是举例说明，可能有些用词不太合理）。

七、定义联系的强制性
Mandatory 表洋这个方向联系的强制关系。选中这个复选框，则在联系线上产生一个联系线垂直的竖线。不选择这个复选框则表示联系这个方向上是可选的，在联系线上产生一个小圆圈。

八、有关联系的基数
联系具有方向性，每个方向上都有一个基数。

举例，
“系”与“学生”两个实体之间的联系是一对多联系，换句话说“学生”和“系”之间的联系是多对一联系。而且一个学生必须属于一个系，并且只能属于一个系，不能属于零个系，所以从“学生”实体至“系”实体的基数为“1,1”，从联系的另一方向考虑，一个系可以拥有多个学生，也可以没有任何学生，即零个学生，所以该方向联系的基数就为“0,n”,如图所示

作者：xiong2009 发表于2007-10-17 23:40:00 原文链接

阅读：513 评论：0 查看评论

[原]PowerDesigner中概念数据模型1

xiong2009 — Wed, 17 Oct 2007 23:36:00 +0800

一、概念数据模型概述
数据模型是现实世界中数据特征的抽象。数据模型应该满足三个方面的要求：
1）能够比较真实地模拟现实世界
2）容易为人所理解
3）便于计算机实现

概念数据模型也称信息模型，它以实体－联系(Entity-RelationShip,简称E-R)理论为基础，并对这一理论进行了扩充。它从用户的观点出发对信息进行建模，主要用于数据库的概念级设计。

通常人们先将现实世界抽象为概念世界，然后再将概念世界转为机器世界。换句话说，就是先将现实世界中的客观对象抽象为实体(Entity)和联系(Relationship),它并不依赖于具体的计算机系统或某个DBMS系统，这种模型就是我们所说的CDM;然后再将CDM转换为计算机上某个DBMS所支持的数据模型，这样的模型就是物理数据模型,即PDM。

CDM是一组严格定义的模型元素的集合，这些模型元素精确地描述了系统的静态特性、动态特性以及完整性约束条件等，其中包括了数据结构、数据操作和完整性约束三部分。
1）数据结构表达为实体和属性;
2）数据操作表达为实体中的记录的插入、删除、修改、查询等操作;
3）完整性约束表达为数据的自身完整性约束（如数据类型、检查、规则等）和数据间的参照完整性约束（如联系、继承联系等）;

二、实体、属性及标识符的定义
实体（Entity），也称为实例，对应现实世界中可区别于其他对象的“事件”或“事物”。例如，学校中的每个学生，医院中的每个手术。
每个实体都有用来描述实体特征的一组性质，称之为属性，一个实体由若干个属性来描述。如学生实体可由学号、姓名、性别、出生年月、所在系别、入学年份等属性组成。

实体集（Entity Set）是具体相同类型及相同性质实体的集合。例如学校所有学生的集合可定义为“学生”实体集，“学生”实体集中的每个实体均具有学号、姓名、性别、出生年月、所在系别、入学年份等性质。

实体类型（Entity Type）是实体集中每个实体所具有的共同性质的集合，例如“患者”实体类型为：患者｛门诊号，姓名，性别，年龄，身份证号.............｝。实体是实体类型的一个实例，在含义明确的情况下，实体、实体类型通常互换使用。

实体类型中的每个实体包含唯一标识它的一个或一组属性，这些属性称为实体类型的标识符（Identifier），如“学号”是学生实体类型的标识符，“姓名”、“出生日期”、“信址”共同组成“公民”实体类型的标识符。

有些实体类型可以有几组属性充当标识符，选定其中一组属性作为实体类型的主标识符，其他的作为次标识符。

三、实体、属性及标识符的表达

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

目标：
下节主要介绍PowerDesigner概念数据模型以及实体、属性创建。

一、新建概念数据模型
1）选择File-->New,弹出如图所示对话框，选择CDM模型（即概念数据模型）建立模型。

2）完成概念数据模型的创建。以下图示，对当前的工作空间进行简单介绍。（以后再更详细说明）

3）选择新增的CDM模型，右击，在弹出的菜单中选择“Properties”属性项，弹出如图所示对话框。在“General”标签里可以输入所建模型的名称、代码、描述、创建者、版本以及默认的图表等等信息。在“Notes”标签里可以输入相关描述及说明信息。当然再有更多的标签，可以点击 "More>>"按钮，这里就不再进行详细解释。

二、创建新实体
1）在CDM的图形窗口中，单击工具选项版上的Entity工具，再单击图形窗口的空白处，在单击的位置就出现一个实体符号。点击Pointer工具或右击鼠标，释放Entitiy工具。如图所示

2）双击刚创建的实体符号，打开下列图标窗口，在此窗口“General”标签中可以输入实体的名称、代码、描述等信息。

三、添加实体属性
1）在上述窗口的“Attribute”选项标签上可以添加属性，如下图所示。

注意：
数据项中的“添加属性”和“重用已有数据项”这两项功能与模型中Data Item的Unique code 和Allow reuse选项有关。
P列表示该属性是否为主标识符;D列表示该属性是否在图形窗口中显示;M列表示该属性是否为强制的，即该列是否为空值。

如果一个实体属性为强制的，那么，这个属性在每条记录中都必须被赋值，不能为空。

2）在上图所示窗口中，点击插入属性按钮，弹出属性对话框，如下图所示。

注意：这里涉及到域的概念，即一种标准的数据结构，它可应用至数据项或实体的属性上。在以下的教程中将另立章节详细说明。

-----------------------------------------------------------------------------------

目标：
本节主要介绍属性的标准检查约束、如何定义属性的附加检查。

一、定义属性的标准检查约束
标准检查约束是一组确保属性有效的表达式。在实体属性的特性窗口，打开如图所示的检查选项卡。

在这个选项卡可以定义属性的标准检查约束，窗口中每项的参数的含义，如下

参数	说明
Minimum	属性可接受的最小数
Maximum	属性可接受的最大数
Default	属性不赋值时，系统提供的默认值
Unit	单位，如公里、吨、元
Format	属性的数据显示格式
Lowercase	属性的赋值全部变为小写字母
Uppercase	属性的赋值全部变为大写字母
Cannot modify	该属性一旦赋值不能再修改
List Of Values	属性赋值列表，除列表中的值，不能有其他的值
Label	属性列表值的标签

二、定义属性的附加检查
当Standard checks 或Rules 不能满足检查的要求时，可以在Additional Checks选项卡的Server子页上，通过SQL语句中使用%MINMAX%、%LISTVAL%、%RULES%、%UPPER%、%LOWER%几个变量来定义Standard和Rule,如图所示

%MINMAX%、%LISTVAL%、%UPPER%、%LOWER%
在Standard Check中定义的Minimum 和Maximum、List values 、uppervalues、lowervalues

%RULES%
在Rules特性窗口Expression选项卡中定义的有效性规则表达式

---------------------------------------------------------------------------

目标：
本节主要介绍如何定义实体的主、次标识符。

一、标识符
标识符是实体中一个或多个属性的集合，可用来唯一标识实体中的一个实例。要强调的是，CDM中的标识符等价于PDM中的主键或候选键。
每个实体都必须至少有一个标识符。如果实体只有一个标识符，则它为实体的主标识符。如果实体有多个标识符，则其中一个被指定为主标识符，其余的标识符就是次标识符了。

二、如果定义主、次标识符
1）选择某个实体双击弹出实体的属性对话框。在Identifiers选项卡上可以进行实体标识符的定义。如下图所示

2）选择第一行“主标识符”，点击属性按钮或双击第一行“主标识符”，弹出属性对话框，如图所示

3）选择"Attributes"选项卡，再点击“Add Attributes”工具，弹出如图所示窗口，选择某个属性作为标识符就行了。

作者：xiong2009 发表于2007-10-17 23:36:00 原文链接

阅读：714 评论：0 查看评论

[原]appFuse2.x第八篇--Maven2

xiong2009 — Tue, 28 Aug 2007 19:17:00 +0800

Knowledge of Maven is not required to use AppFuse because the tutorials explain how to use it. If you're interested in learning Maven in-depth, please download the book Better Builds with Maven or Maven: The Definitive Guide (zip). Both books are free - the first requires registration, the second is available without registration.

For a brief introduction to Maven see Building Web Applications with Maven 2 or The Maven 2 POM demystified. Other articles are available from the Articles on Maven page.

See Maven Plugins for information on plugins used in AppFuse.

Below is a list of commonly-used helpful Maven commands.

Command	Description
mvn clean	Deletes all files in target directory or directories (for multi-module projects)
mvn jetty:run-war	Packages and deploys your application to Jetty, reachable at http://localhost:8080
mvn -Dcargo.wait=true	Packages and deploys your application to active Cargo profile (Tomcat 5.5.x by default), reachable at http://localhost:8080/yourapp-version
mvn test	Runs all tests in src/test/java. Use "-Dtest=ClassName" (not fully-qualified) to run individual tests.
	Use -Dsurefire.useFile=false if you want to see test failures in your console (like Ant) and -Dmaven.surefire.debug if you want to open a debugger on port 5005 w/ suspend=y.
mvn package	Creates a WAR or JAR depending on your project type
mvn integration-test	Runs UI tests in Tomcat using Cargo
mvn install	Installs generated artifacts in your local repository
mvn site	Creates project site and reports
mvn -U	Checks for updated plugins and downloads if they exist
mvn -o	Work offline
mvn --help	See full list of optional commands

Ant vs. Maven

If you used AppFuse 1.x in the past and have taken the time to memorize its useful Ant commands, the following table should help you convert to using Maven.

Ant command	Maven command	Description
ant setup-db	mvn hibernate3:hbm2ddl dbunit:operation	Creates and populates your database
ant test-all	mvn integration-test	Runs unit and integration tests
ant clean	mvn clean	Deletes the target directory
ant compile	mvn compile	Compiles all source files
ant war	mvn package	Creates a WAR file
ant deploy	mvn jetty:run-war	Deploys a WAR to embedded instance of Jetty and starts it
ant test-dao	mvn test -Dtest=*DaoTest	Runs all DAO tests
ant test-service	mvn test -Dtest=*ManagerTest	Runs all Manager tests

Installing a local Maven Repository

If you're using Maven 2 in your organization on multiple projects, it's often a good idea to setup a local Maven repository on your intranet. There's a few different strategies for doing this:

Artifactory - a Maven2 proxy repository based on JSR-170. Started with maven-proxy's codebase. See Setting up a Maven repository with Artifactory for installation instructions.
Dead Simple Maven Proxy - DSMP is a proxy. It can be used as a repository server but it's main purposs it to act as a filter when Maven accesses the internet. If you need a repository server, use Archiva.
Maven Archiva - still under development.
Maven Proxy - See Sanjiv's blog entry titled Using maven-proxy to setup an internal maven repository for more information.
Proximity - Proximity functions somewhere between http-proxy and proactive-mirror. One of its primary uses is as Java web application to serve as a Maven proxy on your company's intranet.

<!-- <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http:/

作者：xiong2009 发表于2007-8-28 19:17:00 原文链接

阅读：1432 评论：0 查看评论

[原]appFuse2.x第七篇--Maven Plugins

xiong2009 — Tue, 28 Aug 2007 19:07:00 +0800

There are a number of Maven Plugins that AppFuse uses to simplify the development process (listed in alphabetical order).

AppFuse Maven Plugin: This plugin is a replacement for AppGen in AppFuse 1.x. It's used for code generation, as well as other AppFuse-related tasks. See the list below for current enhancement ideas.
Cargo Maven Plugin: Used to start and stop containers before and after running integration tests (i.e. with Canoo WebTest or Selenium).
DbUnit Maven Plugin: This plugin is a wrapper around DbUnit and is used to populate the database with sample data before running tests.
Hibernate3 Maven Plugin: Used to create the database schema when using Hibernate or JPA for the DAO framework.
Maven Jetty Plugin: Used to run an embedded Jetty instance from Maven.
Maven WarPath Plugin: Used to provide features to Maven so WARs can have dependencies.
Native2Ascii Maven Plugin: Converts i18n bundles from native to ascii format.
SQL Maven Plugin: Used to create the database schema when using iBATIS for the DAO framework.
Tomcat Maven Plugin: Similar to the Maven Jetty Plugin - can start an embedded Tomcat instance to deploy your project or manage a remote instance.

For more plugins, see available Maven plugins and the Maven 2 Plugins Project (also known as Mojo).

About the AppFuse Maven Plugin

This release marks the first release of the AppFuse Maven Plugin (AMP). This plugin currently does two things: 1) code generation for CRUD and 2) allows you to convert your project to use AppFuse's source instead of using its binary dependencies. For more information on this plugin, see http://static.appfuse.org/plugins/appfuse-maven-plugin.

Generating CRUD with AMP

In the AppFuse 2.0 M5 release, you can run the following command to generate CRUD screens/classes for a POJO:

appfuse:gen -Dentity=Name

If you don't specify the entity name, you're prompted for it. After generating the code, you can install it using:

appfuse:install -Dentity=Name

Your entity must be defined in your hibernate.cfg.xml file for this to work. In a modular project, these commands must be run in the "core" and "web" modules. The plugin is smart enough to figure out when it should/should not generate stuff based on the packaging type (jar vs. war). In a future release, we hope to combine "gen" and "install" into a single command.

There's also a goal that allows you to generate model objects from database tables:

appfuse:gen-model

This goal does not install the generated files into your source tree, so you'll need to manually copy it. If you want to generate CRUD for the object, you'll also want to add it to your hibernate.cfg.xml.

We hope to combine these commands in a future release.

Installing AppFuse's source into your project

The good news is creating an "old style" project is now pretty easy. If you create a new project using 2.0-m5-SNAPSHOT, you can now use:

mvn appfuse:full-source

This goal will convert your project to use all of AppFuse's source and remove all dependencies on AppFuse. Known issues with "full-source" include:

It only supports basic archetypes. It will likely only take a couple of hours to add modular project support, so this feature will be in the next release.
It doesn't do package renaming. We plan to add this as part of the next release.

What the full-source plugin does:

Exports all sources from Subversion into your project. It reads the dao.framework and web.framework properties to determine what you need.
Removes warpath plugin from pom.xml.
Calculates dependencies by reading pom.xml files form the various AppFuse modules. It replaces your dependencies with these new ones. The order of the dependencies added is alphabetical based on groupId.
Reads properties from the root AppFuse pom.xml and adds the ones that don't exist to your project. Since these are stored in a java.util.Properties, I was unable to sort them alphabetically.

Goals available:

Goal	Description
appfuse:gen-core	Generates Java classes for DAOs and Managers from set of annotated POJOs
appfuse:gen-web	Generates Java classes for DAOs and Managers from set of annotated POJOs
appfuse:gen	Generates Java classes from set of annotated POJOs
appfuse:hbmtemplate	Generic exporter that can be controlled by a user provided template or class.
appfuse:gen-model	Generates Java classes from set of *.hbm.xml files
appfuse:install	This mojo is used to "install" generated artifacts (Java files, XML files) into an AppFuse project.
appfuse:full-source	This mojo is used to "install" source artifacts from Subversion into an AppFuse project.

作者：xiong2009 发表于2007-8-28 19:07:00 原文链接

阅读：1762 评论：0 查看评论

[原]appFuse2.x第六篇--Using Struts 2

xiong2009 — Thu, 23 Aug 2007 19:07:00 +0800

This tutorial will show you how to create master/detail screens with Struts 2. The list (master) screen will have the ability to sort columns, as well as page 25 records at a time. The form (detail) screen will use an elegant CSS form layout (courtesy of Wufoo). You will also configure client and server-side validation to improve your users' experience.

This tutorial assumes you've created a project with the appfuse-basic-struts archetype and have already completed the Persistence and Services tutorials. If you're using the appfuse-modular-struts archetype, please morph your mind into using the web module as the root directory. If you created your project with a different web framework than Struts, you're likely to be confused and nothing will work in this tutorial.

Source Code

The code for this tutorial is located in the "tutorial-struts2" module of the appfuse-demos project on Google Code. Use the following command to check it out from Subversion:

svn checkout http://appfuse-demos.googlecode.com/svn/trunk/tutorial-struts2

Introduction to Struts 2

Struts 2 (formerly WebWork) is a web framework designed with simplicity in mind. It's built on top of XWork, which is a generic command framework. XWork also has an IoC container, but it isn't as full-featured as Spring and won't be covered in this section. Struts 2 controllers are called Actions, mainly because they must implement the Action interface. The ActionSupport class implements this interface, and it is most common parent class for Struts 2 actions.

The figure below shows how Struts 2 fits into a web application's architecture.

Struts 2 actions typically contain methods for accessing model properties and methods for returning strings. These strings are matched with "result" names in a struts.xml configuration file. Actions typically have a single execute() method, but you can easily add multiple methods and control execution using URLs and button names.

Struts 2 uses interceptors to intercept the request and response process. This is much like Servlet Filters, except you can talk directly to the action. Struts 2 uses interceptors in the framework itself. A number of them initialize the Action, prepare it for population, set parameters on it and handle any conversion errors.

Create a PersonActionTest

Testing is an important part of any application, and testing a Struts application is easier than most. The generic command pattern provided by XWork doesn't depend on the Servlet API at all. This makes it easy to use JUnit to test your Actions.

Create a PersonActionTest.java class in src/test/java/**/webapp/action.

package org.appfuse.tutorial.webapp.action;

import com.opensymphony.xwork2.ActionSupport;

import org.appfuse.service.GenericManager;

import org.appfuse.tutorial.model.Person;

import org.appfuse.webapp.action.BaseActionTestCase;

public class PersonActionTest extends BaseActionTestCase {

private PersonAction action;

@Override

protected void onSetUpBeforeTransaction() throws Exception {

super.onSetUpBeforeTransaction();

action = new PersonAction();

GenericManager personManager = (GenericManager) applicationContext.getBean("personManager");

action.setPersonManager(personManager);

// add a test person to the database

Person person = new Person();

person.setFirstName("Jack");

person.setLastName("Raible");

personManager.save(person);

}

public void testSearch() throws Exception {

assertEquals(action.list(), ActionSupport.SUCCESS);

assertTrue(action.getPersons().size() >= 1);

}

package org.appfuse.tutorial.webapp.action;
import com.opensymphony.xwork2.ActionSupport;
import org.appfuse.service.GenericManager;
import org.appfuse.tutorial.model.Person;
import org.appfuse.webapp.action.BaseActionTestCase;
public class PersonActionTest extends BaseActionTestCase {
private PersonAction action;
@Override
protected void onSetUpBeforeTransaction() throws Exception {
super.onSetUpBeforeTransaction();
action = new PersonAction();
GenericManager personManager = (GenericManager) applicationContext.getBean("personManager");
action.setPersonManager(personManager);
// add a test person to the database
Person person = new Person();
person.setFirstName("Jack");
person.setLastName("Raible");
personManager.save(person);
}
public void testSearch() throws Exception {
assertEquals(action.list(), ActionSupport.SUCCESS);
assertTrue(action.getPersons().size() >= 1);
}
}

This class won't compile yet; you must first create the PersonAction class.

Create a PersonAction that will fetch people

Create a PersonAction.java class (that extends AppFuse's BaseAction) in src/main/java/**/webapp/action:

package org.appfuse.tutorial.webapp.action;

import org.appfuse.webapp.action.BaseAction;

import org.appfuse.tutorial.model.Person;

import org.appfuse.service.GenericManager;

import java.util.List;

public class PersonAction extends BaseAction {

private GenericManager<Person, Long> personManager;

private List persons;

public void setPersonManager(GenericManager<Person, Long> personManager) {

this.personManager = personManager;

}

public List getPersons() {

return persons;

}

public String list() {

persons = personManager.getAll();

return SUCCESS;

}

package org.appfuse.tutorial.webapp.action;
import org.appfuse.webapp.action.BaseAction;
import org.appfuse.tutorial.model.Person;
import org.appfuse.service.GenericManager;
import java.util.List;
public class PersonAction extends BaseAction {
private GenericManager<Person, Long> personManager;
private List persons;
public void setPersonManager(GenericManager<Person, Long> personManager) {
this.personManager = personManager;
}
public List getPersons() {
return persons;
}
public String list() {
persons = personManager.getAll();
return SUCCESS;
}
}

Struts 2 actions are typically both the controller and the model. In this example, the list() method acts as the controller, and the getPersons() method retrieves data from the model. This simplification of the MVC paradigm makes this web framework very easy to program with.

Run the PersonActionTest using your IDE or mvn test -Dtest=PersonActionTest.

Zero Configuration

Struts' Zero Configuration feature is turned on by default. If you want to configure your Actions as Spring beans, you can do that by using class="beanId" in your Action definition, and then defining the bean in applicationContext.xml. Otherwise, they will automatically be wired up by name with Spring dependencies. All you need to do is add a setter to your Action to get a Spring bean injected into it.

Create personList.jsp to show search results

Create a src/main/webapp/WEB-INF/pages/personList.jsp page to display the list of people:

<%@ include file="/common/taglibs.jsp"%>

<head>

</head>

<c:set var="buttons">

<input type="button" style="margin-right: 5px"

onclick="location.href='<c:url value="/editPerson.html"/>'"

value="<fmt:message key="button.add"/>"/>

<input type="button" onclick="location.href='<c:url value="/mainMenu.html"/>'"

value="<fmt:message key="button.done"/>"/>

</c:set>

<c:out value="${buttons}" escapeXml="false" />

<s:set name="persons" value="persons" scope="request"/>

<display:table name="persons" class="table" requestURI="" id="personList" export="true" pagesize="25">

<display:column property="id" sortable="true" href="editPerson.html"

paramId="id" paramProperty="id" titleKey="person.id"/>

<display:column property="firstName" sortable="true" titleKey="person.firstName"/>

<display:column property="lastName" sortable="true" titleKey="person.lastName"/>

<display:setProperty name="paging.banner.item_name" value="person"/>

<display:setProperty name="paging.banner.items_name" value="people"/>

<display:setProperty name="export.excel.filename" value="Person List.xls"/>

<display:setProperty name="export.csv.filename" value="Person List.csv"/>

<display:setProperty name="export.pdf.filename" value="Person List.pdf"/>

</display:table>

<c:out value="${buttons}" escapeXml="false" />

highlightTableRows("personList");

</script>

<%@ include file="/common/taglibs.jsp"%>
<head>
<title><fmt:message key="personList.title"/></title>
<meta name="heading" content="<fmt:message key='personList.heading'/>"/>
</head>
<c:set var="buttons">
<input type="button" style="margin-right: 5px"
onclick="location.href='<c:url value="/editPerson.html"/>'"
value="<fmt:message key="button.add"/>"/>
<input type="button" onclick="location.href='<c:url value="/mainMenu.html"/>'"
value="<fmt:message key="button.done"/>"/>
</c:set>
<c:out value="${buttons}" escapeXml="false" />
<s:set name="persons" value="persons" scope="request"/>
<display:table name="persons" class="table" requestURI="" id="personList" export="true" pagesize="25">
<display:column property="id" sortable="true" href="editPerson.html"
paramId="id" paramProperty="id" titleKey="person.id"/>
<display:column property="firstName" sortable="true" titleKey="person.firstName"/>
<display:column property="lastName" sortable="true" titleKey="person.lastName"/>
<display:setProperty name="paging.banner.item_name" value="person"/>
<display:setProperty name="paging.banner.items_name" value="people"/>
<display:setProperty name="export.excel.filename" value="Person List.xls"/>
<display:setProperty name="export.csv.filename" value="Person List.csv"/>
<display:setProperty name="export.pdf.filename" value="Person List.pdf"/>
</display:table>
<c:out value="${buttons}" escapeXml="false" />
<script type="text/javascript">
highlightTableRows("personList");
</script>

The most important line in this file is just above the <display:table> tag. This is the <s:set> tag. This tag calls PersonAction.getPersons() and sets the resulting List into the request scope, where the <display:table> tag can grab it. This is necessary because the Display Tag doesn't have any knowledge of the ValueStack used by Struts 2.

Open the struts.xml file in the src/main/resources directory. Define an <action> (at the bottom of this file) and set its class attribute to match the fully-qualified class name of the PersonAction class.

<result>/WEB-INF/pages/personList.jsp</result>

</action>

<action name="persons" class="org.appfuse.tutorial.webapp.action.PersonAction" method="list">
<result>/WEB-INF/pages/personList.jsp</result>
</action>

The default result type is "dispatcher" and its name is "success". This configured result type simply forwards you to the personList.jsp file when "success" is returned from PersonAction.list(). Other result types include redirect and chain. Redirect performs a client-side redirect and chain forwards you to another action. For a full list of result types, see Struts 2's Result Types documentation.

The "method" attribute of this action has a list attribute, which calls the list() method when the "persons.html" URL is invoked. If you exclude the method attribute, it calls the execute() method.

Open src/main/resources/ApplicationResources.properties and add i18n keys/values for the various "person" properties:

# -- person form --

person.id=Id

person.firstName=First Name

person.lastName=Last Name

person.added=Person has been added successfully.

person.updated=Person has been updated successfully.

person.deleted=Person has been deleted successfully.

# -- person list page --

personList.title=Person List

personList.heading=Persons

# -- person detail page --

personDetail.title=Person Detail

personDetail.heading=Person Information

# -- person form --
person.id=Id
person.firstName=First Name
person.lastName=Last Name
person.added=Person has been added successfully.
person.updated=Person has been updated successfully.
person.deleted=Person has been deleted successfully.
# -- person list page --
personList.title=Person List
personList.heading=Persons
# -- person detail page --
personDetail.title=Person Detail
personDetail.heading=Person Information

Run mvn jetty:run-war and open http://localhost:8080/persons.html in your browser. Login with admin/admin and you should see a screen similar to the figure below.

Security settings for AppFuse specify that all *.html url-patterns should be protected (except for /signup.html and /passwordHint.html). This guarantees that clients must go through an Action to get to a JSP (or at least the ones in WEB-INF/pages).

CSS Customization
If you want to customize the CSS for a particular page, you can add <body id="pageName"/> to the top of the file. This will be slurped up by SiteMesh and put into the final page. You can then customize your CSS on a page-by-page basis using something like the following:

body#pageName element.class { background-color: blue }

Modify PersonActionTest and PersonAction for edit(), save() and delete() method

To create the detail screen, add edit(), save(), and delete() methods to the PersonAction class. Before doing this, create tests for these methods.

Open src/test/java/**/webapp/action/PersonActionTest.java and add test methods for edit, save, and delete operations:

public void testEdit() throws Exception {

log.debug("testing edit...");

action.setId(1L);

assertNull(action.getPerson());

assertEquals("success", action.edit());

assertNotNull(action.getPerson());

assertFalse(action.hasActionErrors());

}

public void testSave() throws Exception {

MockHttpServletRequest request = new MockHttpServletRequest();

ServletActionContext.setRequest(request);

action.setId(1L);

assertEquals("success", action.edit());

assertNotNull(action.getPerson());

// update last name and save

action.getPerson().setLastName("Updated Last Name");

assertEquals("input", action.save());

assertEquals("Updated Last Name", action.getPerson().getLastName());

assertFalse(action.hasActionErrors());

assertFalse(action.hasFieldErrors());

assertNotNull(request.getSession().getAttribute("messages"));

}

public void testRemove() throws Exception {

MockHttpServletRequest request = new MockHttpServletRequest();

ServletActionContext.setRequest(request);

action.setDelete("");

Person person = new Person();

person.setId(2L);

action.setPerson(person);

assertEquals("success", action.delete());

assertNotNull(request.getSession().getAttribute("messages"));

}

public void testEdit() throws Exception {
log.debug("testing edit...");
action.setId(1L);
assertNull(action.getPerson());
assertEquals("success", action.edit());
assertNotNull(action.getPerson());
assertFalse(action.hasActionErrors());
}
public void testSave() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
ServletActionContext.setRequest(request);
action.setId(1L);
assertEquals("success", action.edit());
assertNotNull(action.getPerson());
// update last name and save
action.getPerson().setLastName("Updated Last Name");
assertEquals("input", action.save());
assertEquals("Updated Last Name", action.getPerson().getLastName());
assertFalse(action.hasActionErrors());
assertFalse(action.hasFieldErrors());
assertNotNull(request.getSession().getAttribute("messages"));
}
public void testRemove() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
ServletActionContext.setRequest(request);
action.setDelete("");
Person person = new Person();
person.setId(2L);
action.setPerson(person);
assertEquals("success", action.delete());
assertNotNull(request.getSession().getAttribute("messages"));
}

This class will not compile yet because you need to update your src/main/java/**/action/PersonAction.java class. The cancel and delete properties capture the click of the Cancel and Delete buttons. The execute() method routes the different actions on the form to the appropriate method.

private Person person;

private Long id;

public void setId(Long id) {

this.id = id;

}

public Person getPerson() {

return person;

}

public void setPerson(Person person) {

this.person = person;

}

public String delete() {

personManager.remove(person.getId());

saveMessage(getText("person.deleted"));

return SUCCESS;

}

public String edit() {

if (id != null) {

person = personManager.get(id);

} else {

person = new Person();

}

return SUCCESS;

}

public String save() throws Exception {

if (cancel != null) {

return "cancel";

}

if (delete != null) {

return delete();

}

boolean isNew = (person.getId() == null);

person = personManager.save(person);

String key = (isNew) ? "person.added" : "person.updated";

saveMessage(getText(key));

if (!isNew) {

return INPUT;

} else {

return SUCCESS;

}

private Person person;
private Long id;
public void setId(Long id) {
this.id = id;
}
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
public String delete() {
personManager.remove(person.getId());
saveMessage(getText("person.deleted"));
return SUCCESS;
}
public String edit() {
if (id != null) {
person = personManager.get(id);
} else {
person = new Person();
}
return SUCCESS;
}
public String save() throws Exception {
if (cancel != null) {
return "cancel";
}
if (delete != null) {
return delete();
}
boolean isNew = (person.getId() == null);
person = personManager.save(person);
String key = (isNew) ? "person.added" : "person.updated";
saveMessage(getText(key));
if (!isNew) {
return INPUT;
} else {
return SUCCESS;
}
}

If you look at your PersonActionTest, all the tests depend on having a record with id=1 in the database (and testRemove depends on id=2), so let's add those records to our sample data file (src/test/resources/sample-data.xml). Adding it at the bottom should work - order is not important since it (currently) does not relate to any other tables. If you already have this table, make sure the 2nd record exists so testRemove() doesn't fail.

<column>first_name</column>

<row>

<value>Raible</value>

</row>

<row>

<value>Johnson</value>

</row>

</table>

<table name='person'>
<column>id</column>
<column>first_name</column>
<column>last_name</column>
<row>
<value>1</value>
<value>Matt</value>
<value>Raible</value>
</row>
<row>
<value>2</value>
<value>Bob</value>
<value>Johnson</value>
</row>
</table>

DbUnit loads this file before you run any tests, so this record will be available to your Action test.

Save all your files and run the tests in PersonActionTest using the command mvn test -Dtest=PersonActionTest.

BUILD SUCCESSFUL
Total time: 31 seconds

Create personForm.jsp to edit a person's information

Create a src/main/webapp/WEB-INF/pages/personForm.jsp page to display the form:

<%@ include file="/common/taglibs.jsp"%>

<head>

</head>

<s:form id="personForm" action="savePerson" method="post" validate="true">

<s:hidden name="person.id" value="%{person.id}"/>

<s:textfield key="person.firstName" required="true" cssClass="text medium"/>

<s:textfield key="person.lastName" required="true" cssClass="text medium"/>

<s:submit cssClass="button" method="save" key="button.save" theme="simple"/>

<c:if test="${not empty person.id}">

<s:submit cssClass="button" method="delete" key="button.delete" onclick="return confirmDelete('person')" theme="simple"/>

</c:if>

<s:submit cssClass="button" method="cancel" key="button.cancel" theme="simple"/>

</li>

</s:form>

Form.focusFirstElement($("personForm"));

</script>

<%@ include file="/common/taglibs.jsp"%>
<head>
<title><fmt:message key="personDetail.title"/></title>
<meta name="heading" content="<fmt:message key='personDetail.heading'/>"/>
</head>
<s:form id="personForm" action="savePerson" method="post" validate="true">
<s:hidden name="person.id" value="%{person.id}"/>
<s:textfield key="person.firstName" required="true" cssClass="text medium"/>
<s:textfield key="person.lastName" required="true" cssClass="text medium"/>
<li class="buttonBar bottom">
<s:submit cssClass="button" method="save" key="button.save" theme="simple"/>
<c:if test="${not empty person.id}">
<s:submit cssClass="button" method="delete" key="button.delete" onclick="return confirmDelete('person')" theme="simple"/>
</c:if>
<s:submit cssClass="button" method="cancel" key="button.cancel" theme="simple"/>
</li>
</s:form>
<script type="text/javascript">
Form.focusFirstElement($("personForm"));
</script>

Struts reduces the amount of HTML you have to write for a form. The <s:form> tag writes the <form> and structure tags for you. The <s:textfield> tag writes the whole row, including the <ul> and <li> tags to hold the input field's label.

Next, update the src/main/resources/struts.xml file to include the "editPerson" and "savePerson" actions.

<result>/WEB-INF/pages/personForm.jsp</result>

<result name="error">/WEB-INF/pages/personList.jsp</result>

</action>

<result name="input">/WEB-INF/pages/personForm.jsp</result>

<result name="cancel" type="redirect">persons.html</result>

<result name="delete" type="redirect">persons.html</result>

<result name="success" type="redirect">persons.html</result>

</action>

<action name="editPerson" class="org.appfuse.tutorial.webapp.action.PersonAction" method="edit">
<result>/WEB-INF/pages/personForm.jsp</result>
<result name="error">/WEB-INF/pages/personList.jsp</result>
</action>
<action name="savePerson" class="org.appfuse.tutorial.webapp.action.PersonAction" method="save">
<result name="input">/WEB-INF/pages/personForm.jsp</result>
<result name="cancel" type="redirect">persons.html</result>
<result name="delete" type="redirect">persons.html</result>
<result name="success" type="redirect">persons.html</result>
</action>

Run mvn jetty:run-war, open your browser to http://localhost:8080/persons.html, and click on the Add button.

Fill in the first name and last name fields and click the Save button. This should route you to the list screen, where a success message flashes and the new person displays in the list.

Displaying success messages
The src/main/webapp/common/messages.jsp file in AppFuse renders the success message in this screen. This file is included in decorators/default.jsp. It also handles displaying validation errors:

<s:if test="hasActionErrors()">
    <div class="error" id="errorMessages">
      <s:iterator value="actionErrors">
        <img src="<c:url value="/images/iconWarning.gif"/>"
            alt="<fmt:message key="icon.warning"/>" class="icon" />
        <s:property escape="false"/><br />
      </s:iterator>
   </div>
</s:if>

<%-- FieldError Messages - usually set by validation rules --%>
<s:if test="hasFieldErrors()">
    <div class="error" id="errorMessages">
      <s:iterator value="fieldErrors">
          <s:iterator value="value">
            <img src="<c:url value="/images/iconWarning.gif"/>"
                alt="<fmt:message key="icon.warning"/>" class="icon" />
             <s:property escape="false"/><br />
          </s:iterator>
      </s:iterator>
   </div>
</s:if>

Configure Validation

Struts 2 allows two types of validation: per-action and model-based. Since you likely want the same rules applied for the person object across different actions, this tutorial will use model-based.

Create a new file named Person-validation.xml in the src/main/resources/**/model directory (you'll need to create this directory). It should contain the following XML:

<!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.2//EN"

"http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">

<field-validator type="requiredstring">

</field-validator>

</field>

<field-validator type="requiredstring">

</field-validator>

</field>

</validators>

<!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.2//EN"
"http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">
<validators>
<field name="person.firstName">
<field-validator type="requiredstring">
<message key="errors.required"/>
</field-validator>
</field>
<field name="person.lastName">
<field-validator type="requiredstring">
<message key="errors.required"/>
</field-validator>
</field>
</validators>

The "errors.message" key in ApplicationResources*.properties (listed below) will use the field's "name" attribute to do internationalization. You can also give the <message> element a body if you don't need i18n.

errors.required=${getText(fieldName)} is a required field.

errors.required=${getText(fieldName)} is a required field.

Now you need to configure PersonAction to know about visitor validation. To do this, create a PersonAction-validation.xml file in src/main/resources/**/webapp/action (you'll need to create this directory). Fill it with the following XML:

<!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.2//EN"

"http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">

<field-validator type="visitor">

<param name="appendPrefix">false</param>

</field-validator>

</field>

</validators>

<!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.2//EN"
"http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">
<validators>
<field name="person">
<field-validator type="visitor">
<param name="appendPrefix">false</param>
<message/>
</field-validator>
</field>
</validators>

Unfortunately, Struts doesn't have a transparent mechanism for reading from the Person-validation.xml file and marking fields as required on the UI. AppFuse's Spring MVC implementation use a LabelTag that makes this possible, but it also both use Commons Validator. It is my hope to someday provide this same functionality for Struts. In the meantime, the JSP tags "required" attribute has nothing to with the validation rules you specify. Rather, they simply add an asterisk to the label with no further functionality.

Client-side validation
Client-side validation of model-based validation rules doesn't work with the Struts setup that AppFuse uses. Furthermore, I believe that Struts's client-side validation needs some additional features, namely: allow cancelling and showing all errors in one dialog. Because of this, only server-side validation works in Struts+AppFuse. If you'd like, you can read more about my frustrations with client-side validation.

As a workaround, you can use per-action validation. Just copy the Person-validation.xml file to the "webapp.action" package and rename it to PersonAction-validation.xml.

Struts' validation interceptor is enabled by default, so you don't need to configure anything for validation to work.

After saving all your files and running mvn jetty:run-war, validation should kick in when you try to save this form. To test, go to http://localhost:8080/editPerson.html?id=1. If you erase the values in the firstName and lastName fields and click the Save button, you should see the following:

AppFuse is configured so that methods cancel, execute, delete, edit, list, and start are not validated. This allows you to go back from a form with errors on (like above) by pressing the Cancel button.

Create a Canoo WebTest to test browser-like actions

The next (optional) step in this tutorial is to create a Canoo WebTest to test the JSPs. This step is optional, because you can run the same tests manually through your browser. Regardless, it's a good idea to automate as much of your testing as possible.

You can use the following URLs to test the different actions for adding, editing and saving a user.

Add - http://localhost:8080/editPerson.html.
Edit - http://localhost:8080/editPerson.html?id=1.
Delete - Use the edit link above and click on the Delete button.
Save - Click edit and then click the Save button.

WebTest Recorder
There is a WebTest Recorder Firefox plugin that allows you to record your tests, rather than manually writing them.

Canoo tests are pretty slick in that they're simply configured in an XML file. To add tests for add, edit, save and delete, open src/test/resources/web-tests.xml and add the following XML. You'll notice that this fragment has a target named ''PersonTests'' that runs all the related tests.

<target name="PersonTests"

depends="SearchPeople,EditPerson,SavePerson,AddPerson,DeletePerson"

description="Call and executes all person test cases (targets)">

<echo>Successfully ran all Person UI tests!</echo>

</target>

&config;

<steps>

&login;

<verifytitle description="we should see the personList title"

text=".*${personList.title}.*" regex="true"/>

</steps>

</webtest>

</target>

<target name="EditPerson"

description="Tests editing an existing Person's information">

&config;

<steps>

&login;

<verifytitle description="we should see the personDetail title"

text=".*${personDetail.title}.*" regex="true"/>

</steps>

</webtest>

</target>

<target name="SavePerson"

description="Tests editing and saving a user">

&config;

<steps>

&login;

<verifytitle description="we should see the personDetail title"

text=".*${personDetail.title}.*" regex="true"/>

<verifytitle description="Page re-appears if save successful"

text=".*${personDetail.title}.*" regex="true"/>

</steps>

</webtest>

</target>

<target name="AddPerson"

description="Adds a new Person">

&config;

<steps>

&login;

<verifytitle description="we should see the personDetail title"

text=".*${personDetail.title}.*" regex="true"/>

<verifytitle description="Person List appears if save successful"

text=".*${personList.title}.*" regex="true"/>

</steps>

</webtest>

</target>

<target name="DeletePerson"

description="Deletes existing Person">

&config;

<steps>

&login;

</steps>

</webtest>

</target>

<!-- runs person-related tests -->
<target name="PersonTests"
depends="SearchPeople,EditPerson,SavePerson,AddPerson,DeletePerson"
description="Call and executes all person test cases (targets)">
<echo>Successfully ran all Person UI tests!</echo>
</target>
<!-- Verify the people list screen displays without errors -->
<target name="SearchPeople" description="Tests search for and displaying all people">
<webtest name="searchPeople">
&config;
<steps>
&login;
<invoke description="click View People link" url="/persons.html"/>
<verifytitle description="we should see the personList title"
text=".*${personList.title}.*" regex="true"/>
</steps>
</webtest>
</target>
<!-- Verify the edit person screen displays without errors -->
<target name="EditPerson"
description="Tests editing an existing Person's information">
<webtest name="editPerson">
&config;
<steps>
&login;
<invoke description="click Edit Person link" url="/editPerson.html?id=1"/>
<verifytitle description="we should see the personDetail title"
text=".*${personDetail.title}.*" regex="true"/>
</steps>
</webtest>
</target>
<!-- Edit a person and then save -->
<target name="SavePerson"
description="Tests editing and saving a user">
<webtest name="savePerson">
&config;
<steps>
&login;
<invoke description="click Edit Person link" url="/editPerson.html?id=1"/>
<verifytitle description="we should see the personDetail title"
text=".*${personDetail.title}.*" regex="true"/>
<setinputfield description="set lastName" name="person.lastName" value="Canoo"/>
<clickbutton label="${button.save}" description="Click Save"/>
<verifytitle description="Page re-appears if save successful"
text=".*${personDetail.title}.*" regex="true"/>
<verifytext description="verify success message" text="${person.updated}"/>
</steps>
</webtest>
</target>
<!-- Add a new Person -->
<target name="AddPerson"
description="Adds a new Person">
<webtest name="addPerson">
&config;
<steps>
&login;
<invoke description="click Add Button" url="/editPerson.html"/>
<verifytitle description="we should see the personDetail title"
text=".*${personDetail.title}.*" regex="true"/>
<setinputfield description="set firstName" name="person.firstName" value="Abbie"/>
<setinputfield description="set lastName" name="person.lastName" value="Raible"/>
<clickbutton label="${button.save}" description="Click button 'Save'"/>
<verifytitle description="Person List appears if save successful"
text=".*${personList.title}.*" regex="true"/>
<verifytext description="verify success message" text="${person.added}"/>
</steps>
</webtest>
</target>
<!-- Delete existing person -->
<target name="DeletePerson"
description="Deletes existing Person">
<webtest name="deletePerson">
&config;
<steps>
&login;
<invoke description="click Edit Person link" url="/editPerson.html?id=1"/>
<prepareDialogResponse description="Confirm delete" dialogType="confirm" response="true"/>
<clickbutton label="${button.delete}" description="Click button 'Delete'"/>
<verifyNoDialogResponses/>
<verifytitle description="display Person List" text=".*${personList.title}.*" regex="true"/>
<verifytext description="verify success message" text="${person.deleted}"/>
</steps>
</webtest>
</target>

After adding this, you should be able to run mvn integration-test -Dtest=PersonTests and have these tests execute. If this command results in "BUILD SUCCESSFUL" - nice work!

To include the PersonTests when all Canoo tests are run, add it as a dependency to the "run-all-tests" target in src/test/resources/web-test.xml.

<target name="run-all-tests"

depends="Login,Logout,PasswordHint,Signup,UserTests,FlushCache,FileUpload,PersonTests"

description="Call and executes all test cases (targets)"/>

<target name="run-all-tests"
depends="Login,Logout,PasswordHint,Signup,UserTests,FlushCache,FileUpload,PersonTests"
description="Call and executes all test cases (targets)"/>

Add link to menu

The last step is to make the list, add, edit and delete functions visible to the user. The simplest way is to add a new link to the list of links in src/main/webapp/WEB-INF/pages/mainMenu.jsp. Since this file doesn't exist in your project, you can copy it from target/projectname-version/WEB-INF/pages/mainMenu.jsp to your project with the following command:

cp target/projectname-version/WEB-INF/pages/mainMenu.jsp src/main/webapp/WEB-INF/pages

Then add the following link:

<li>

</li>

<li>
<a href="<c:url value="/persons.html"/>"><fmt:message key="menu.viewPeople"/></a>
</li>

Where menu.viewPeople is an entry in src/main/resources/ApplicationResources.properties.

menu.viewPeople=View People

menu.viewPeople=View People

Modifying AppFuse core files
You can run also run war:inplace to get the mainMenu.jsp file in your project. You'll want to check your project into source control before you do this so you can delete files you don't modify.

The other (more likely) alternative is that you'll want to add it to the menu. To do this, add the following to src/main/webapp/WEB-INF/menu-config.xml:

<Menu name="PeopleMenu" title="menu.viewPeople" page="/persons.html"/>

Make sure the above XML is inside the <Menus> tag, but not within another <Menu>. Then create src/main/webapp/common/menu.jsp and add the following code to it:

<%@ include file="/common/taglibs.jsp"%>

<menu:useMenuDisplayer name="Velocity" config="cssHorizontalMenu.vm" permissions="rolesAdapter">

<c:if test="${empty pageContext.request.remoteUser}">

<li><a href="<c:url value="/login.jsp"/>" class="current">

<fmt:message key="login.title"/></a></li>

</c:if>

<menu:displayMenu name="MainMenu"/>

<menu:displayMenu name="UserMenu"/>

<menu:displayMenu name="PeopleMenu"/>

<menu:displayMenu name="AdminMenu"/>

<menu:displayMenu name="Logout"/>

</ul>

</menu:useMenuDisplayer>

<%@ include file="/common/taglibs.jsp"%>
<menu:useMenuDisplayer name="Velocity" config="cssHorizontalMenu.vm" permissions="rolesAdapter">
<ul id="primary-nav" class="menuList">
<li class="pad">&nbsp;</li>
<c:if test="${empty pageContext.request.remoteUser}">
<li><a href="<c:url value="/login.jsp"/>" class="current">
<fmt:message key="login.title"/></a></li>
</c:if>
<menu:displayMenu name="MainMenu"/>
<menu:displayMenu name="UserMenu"/>
<menu:displayMenu name="PeopleMenu"/>
<menu:displayMenu name="AdminMenu"/>
<menu:displayMenu name="Logout"/>
</ul>
</menu:useMenuDisplayer>

Now if you run mvn jetty:run-war and go to http://localhost:8080/mainMenu.html, you should see something like the screenshot below.

Notice that there is a new link in your main screen (from mainMenu.jsp) and on the top in your menu bar (from menu.jsp).

That's it!
You've completed the full lifecycle of developing a set of master-detail pages with AppFuse and Struts 2 - Congratulations! Now the real test is if you can run all the tests in your app without failure. To test, run mvn integration-test. This will run all the unit and integration tests within your project.

Happy Day!

BUILD SUCCESSFUL
Total time: 1 minute 30 seconds

作者：xiong2009 发表于2007-8-23 19:07:00 原文链接

阅读：2192 评论：0 查看评论

[原]appFuse2.x第五篇--Services

xiong2009 — Thu, 23 Aug 2007 19:06:00 +0800

This tutorial will show you how to create a Business Facade class (and a JUnit Test) to talk to the DAO you created in the Persistence Tutorial.

In the context of AppFuse, this is called a Manager class. Its main responsibility is to act as a bridge between the persistence (DAO) layer and the web layer. It's also useful for de-coupling your presentation layer from your database layer (i.e. for Swing apps and web services). Managers should also be where you put any business logic for your application.

You will learn two things:

You don't need to write Managers if you just need generic CRUD functionality.
How to write Managers when you need custom functionality.

Source Code

The code for this tutorial is located in the "tutorial-service" module of the appfuse-demos project on Google Code. Use the following command to check it out from Subversion:

svn checkout http://appfuse-demos.googlecode.com/svn/trunk/tutorial-service

Register a personManager bean definition

AppFuse 2.x doesn't require you to write a Manager or DAO to persist a POJO. You can use one of the pre-existing manager interfaces/implementations if all you need is CRUD on an object:

GenericManager: A generics-based class that requires you to create a Spring bean definition.
UniversalManager: A class that requires you to cast to the specific object type.

The UniversalManagerImpl class is already registered as a "manager" bean, so you can easily use it without any additional configuration. However, many developers prefer the generics-based Manager because it provides type safety. To register a personManager bean, its best to wrap the personDao bean.

Transactions
All service.*Manager beans will automatically be configured by Spring to wrap PROPOGATION_REQUIRED transactions around their method executions. This is done by the following Spring AOP configuration in appfuse-service.jar.

<aop:config>     
    ...     
    <aop:advisor id="managerTx" advice-ref="txAdvice"          
        pointcut="execution(* *..service.*Manager.*(..))" order="2"/> 
</aop:config>

Open your src/main/webapp/WEB-INF/applicationContext.xml and replace the personDao bean with the following:

Hibernate:

<constructor-arg>

<constructor-arg value="org.appfuse.tutorial.model.Person"/>

</bean>

</constructor-arg>

</bean>

<bean id="personManager" class="org.appfuse.service.impl.GenericManagerImpl">
<constructor-arg>
<bean class="org.appfuse.dao.hibernate.GenericDaoHibernate" autowire="byType">
<constructor-arg value="org.appfuse.tutorial.model.Person"/>
</bean>
</constructor-arg>
</bean>

iBATIS and JPA Configuration
For iBATIS and JPA, you'll need to change the nested DAO that gets injected into GenericManagerImpl:

iBATIS: <bean class="org.appfuse.dao.ibatis.GenericDaoiBatis" ...
JPA: <bean class="org.appfuse.dao.jpa.GenericDaoJpa" ...

If you wrote the PersonDao interface and implementation in the previous tutorial, you'll want to use the following for your personManager bean definition. If you don't, your PersonDaoTest will fail because there's no longer an exposed personDao bean.

<constructor-arg ref="personDao"/>

</bean>

<bean id="personManager" class="org.appfuse.service.impl.GenericManagerImpl">
<constructor-arg ref="personDao"/>
</bean>

Once you've created a personManager bean definition, you can use this bean on an object by adding the following setter method:

public void setPersonManager(GenericManager<Person, Long> personManager) {

this.personManager = personManager;

}

public void setPersonManager(GenericManager<Person, Long> personManager) {
this.personManager = personManager;
}

If you'd prefer to use the UniversalManager, you simply need to declare your set method as follows:

public void setManager(UniversalManager manager) {

this.manager = manager;

}

public void setManager(UniversalManager manager) {
this.manager = manager;
}

No futher XML configuration is required when using this class.

The Spring Framework
To learn more about how Spring works, please see the Spring Reference Guide.

That's it! To persist an object with AppFuse 2.x, all you need to do is:

Create a POJO with annotations
Register it with your persistence framework
Write some XML to register a type-safe class to persist it, or write no XML to use the Universal* classes.

Not only did you write data access code, you also used interfaces to abstract your implementation. This means that it should be possible to replace your persistence framework at any time.

We hope to eliminate many of these steps in 2.2. For the final 2.0 release, you should be able to perform all 3 steps with the AppFuse Maven Plugin.

If you need more than just CRUD functionality, you'll want to continue reading below. If not, you can continue to writing your web application.

Create a Manager Interface

First off, create a PersonManager interface (in the src/main/java/**/service directory - you may need to create this first) and specify the finder method for any implementation classes.

package org.appfuse.tutorial.service;

import org.appfuse.service.GenericManager;

import org.appfuse.tutorial.model.Person;

import java.util.List;

public interface PersonManager extends GenericManager<Person, Long> {

public List<Person> findByLastName(String lastName);

}

package org.appfuse.tutorial.service;
import org.appfuse.service.GenericManager;
import org.appfuse.tutorial.model.Person;
import java.util.List;
public interface PersonManager extends GenericManager<Person, Long> {
public List<Person> findByLastName(String lastName);
}

Create a Manager Test to test finder functionality

Now you know what you want your manager to do, so it's time to write the tests. In this example, you will use mock objects to isolate your tests from external dependencies. This means you do not need a database set up to run these tests, and it will be easier to test different scenarios. In a large project, you could even test your Manager class before someone else finished writing the DAO implementation.

You can write your own mock objects, but here you are going to use jMock. Another widely use Mock Object library is EasyMock.

Create PersonManagerImplTest in src/test/java/**/service/impl:

package org.appfuse.tutorial.service.impl;

import java.util.ArrayList;

import java.util.List;

import org.appfuse.tutorial.dao.PersonDao;

import org.appfuse.tutorial.model.Person;

import org.appfuse.service.impl.BaseManagerMockTestCase;

import org.jmock.Mock;

public class PersonManagerImplTest extends BaseManagerMockTestCase {

private PersonManagerImpl manager = null;

private Mock dao = null;

private Person person = null;

protected void setUp() throws Exception {

dao = new Mock(PersonDao.class);

manager = new PersonManagerImpl((PersonDao) dao.proxy());

}

protected void tearDown() throws Exception {

manager = null;

}

public void testGetPerson() {

log.debug("testing getPerson");

Long id = 7L;

person = new Person();

// set expected behavior on dao

dao.expects(once()).method("get")

.with(eq(id))

.will(returnValue(person));

Person result = manager.get(id);

assertSame(person, result);

dao.verify();

}

public void testGetPersons() {

log.debug("testing getPersons");

List people = new ArrayList();

// set expected behavior on dao

dao.expects(once()).method("getAll")

.will(returnValue(people));

List result = manager.getAll();

assertSame(people, result);

dao.verify();

}

public void testFindByLastName() {

log.debug("testing findByLastName");

List people = new ArrayList();

String lastName = "Smith";

// set expected behavior on dao

dao.expects(once()).method("findByLastName")

.with(eq(lastName))

.will(returnValue(people));

List result = manager.findByLastName(lastName);

assertSame(people, result);

dao.verify();

}

public void testSavePerson() {

log.debug("testing savePerson");

person = new Person();

// set expected behavior on dao

dao.expects(once()).method("save")

.with(same(person))

.will(returnValue(person));

manager.save(person);

dao.verify();

}

public void testRemovePerson() {

log.debug("testing removePerson");

Long id = 11L;

person = new Person();

// set expected behavior on dao

dao.expects(once()).method("remove")

.with(eq(id))

.isVoid();

manager.remove(id);

dao.verify();

}

package org.appfuse.tutorial.service.impl;
import java.util.ArrayList;
import java.util.List;
import org.appfuse.tutorial.dao.PersonDao;
import org.appfuse.tutorial.model.Person;
import org.appfuse.service.impl.BaseManagerMockTestCase;
import org.jmock.Mock;
public class PersonManagerImplTest extends BaseManagerMockTestCase {
private PersonManagerImpl manager = null;
private Mock dao = null;
private Person person = null;
protected void setUp() throws Exception {
dao = new Mock(PersonDao.class);
manager = new PersonManagerImpl((PersonDao) dao.proxy());
}
protected void tearDown() throws Exception {
manager = null;
}
public void testGetPerson() {
log.debug("testing getPerson");
Long id = 7L;
person = new Person();
// set expected behavior on dao
dao.expects(once()).method("get")
.with(eq(id))
.will(returnValue(person));
Person result = manager.get(id);
assertSame(person, result);
dao.verify();
}
public void testGetPersons() {
log.debug("testing getPersons");
List people = new ArrayList();
// set expected behavior on dao
dao.expects(once()).method("getAll")
.will(returnValue(people));
List result = manager.getAll();
assertSame(people, result);
dao.verify();
}
public void testFindByLastName() {
log.debug("testing findByLastName");
List people = new ArrayList();
String lastName = "Smith";
// set expected behavior on dao
dao.expects(once()).method("findByLastName")
.with(eq(lastName))
.will(returnValue(people));
List result = manager.findByLastName(lastName);
assertSame(people, result);
dao.verify();
}
public void testSavePerson() {
log.debug("testing savePerson");
person = new Person();
// set expected behavior on dao
dao.expects(once()).method("save")
.with(same(person))
.will(returnValue(person));
manager.save(person);
dao.verify();
}
public void testRemovePerson() {
log.debug("testing removePerson");
Long id = 11L;
person = new Person();
// set expected behavior on dao
dao.expects(once()).method("remove")
.with(eq(id))
.isVoid();
manager.remove(id);
dao.verify();
}
}

This will not compile, as you have not created the PersonManagerImpl class it tests.

Create a Manager Implementation

The next step is to create a PersonManagerImpl class that implements the methods in PersonManager.

Create PersonManagerImpl.java in src/main/java/**/service/impl.

package org.appfuse.tutorial.service.impl;

import org.appfuse.tutorial.dao.PersonDao;

import org.appfuse.tutorial.model.Person;

import org.appfuse.tutorial.service.PersonManager;

import org.appfuse.service.impl.GenericManagerImpl;

import java.util.List;

public class PersonManagerImpl extends GenericManagerImpl<Person, Long> implements PersonManager {

PersonDao personDao;

public PersonManagerImpl(PersonDao personDao) {

super(personDao);

this.personDao = personDao;

}

public List<Person> findByLastName(String lastName) {

return personDao.findByLastName(lastName);

}

package org.appfuse.tutorial.service.impl;
import org.appfuse.tutorial.dao.PersonDao;
import org.appfuse.tutorial.model.Person;
import org.appfuse.tutorial.service.PersonManager;
import org.appfuse.service.impl.GenericManagerImpl;
import java.util.List;
public class PersonManagerImpl extends GenericManagerImpl<Person, Long> implements PersonManager {
PersonDao personDao;
public PersonManagerImpl(PersonDao personDao) {
super(personDao);
this.personDao = personDao;
}
public List<Person> findByLastName(String lastName) {
return personDao.findByLastName(lastName);
}
}

Now before you run your tests, review your test class to make sure that it will test all possible conditions.

I would put any complicated code in protected methods and go back and add extra test cases at this stage.

Run the Manager Test

Save all your edited files and try running mvn test -Dtest=PersonManagerImplTest.

Register your Manager Implementation

Open your src/main/webapp/WEB-INF/applicationContext.xml file and replace the personDao bean with the following:

<constructor-arg ref="personDao"/>

</bean>

<bean id="personManager" class="org.appfuse.tutorial.service.impl.PersonManagerImpl">
<constructor-arg ref="personDao"/>
</bean>

The Web application tutorials assume that you will be using the GenericManager. If you follow them after making this change, you will need to change all the references in their code from the GenericManager to your new PersonManager interface. For example:

private PersonManager personManager;

public void setPersonManager(PersonManager personManager) {
    this.personManager = personManager;
}

That's it. If you want to see how to use EasyMock instead of JMock, then carry on reading. If not, you can continue to writing your web application.

Using EasyMock instead of JUnit in Unit Tests

Sooner or later, you will want to add extra dependencies into your project.

AppFuse currently ships with JMock, but not EasyMock, so this section will show you how to add EasyMock as a project dependency.

Edit your pom.xml file in your project's top level directory. Add EasyMock as a dependency in the <dependencies> element:

...

<groupId>org.easymock</groupId>

<artifactId>easymock</artifactId>

</dependency>

</dependencies>

<dependencies>
...
<dependency>
<groupId>org.easymock</groupId>
<artifactId>easymock</artifactId>
<version>2.2</version>
<scope>test</scope>
</dependency>
</dependencies>

EasyMock is only required during testing, and you don't want it packaged in your application, so it's restricted it to a scope of test.

To remove jMock and add EasyMock to references regenerate project with mvn install eclipse:eclipse for Eclipse or mvn idea:idea for IDEA.

Edit the PersonManagerImplTest class you wrote above so it looks as follows:

package org.appfuse.tutorial.service.impl;

import java.util.ArrayList;

import java.util.List;

import org.appfuse.tutorial.dao.PersonDao;

import org.appfuse.tutorial.model.Person;

import static org.easymock.EasyMock.*;

import org.apache.commons.logging.LogFactory;

import org.apache.commons.logging.Log;

import junit.framework.TestCase;

public class PersonManagerImplTest extends TestCase {

private final Log log = LogFactory.getLog(PersonManagerImplTest.class);

private PersonManagerImpl manager = null;

private PersonDao dao = null;

private Person person = null;

protected void setUp() throws Exception {

log.debug("setUpDao for PersonManagerImplTest");

dao = createStrictMock(PersonDao.class);

manager = new PersonManagerImpl((PersonDao) dao);

}

public void testGetPerson() {

log.debug("testing getPerson");

Long id = 7L;

person = new Person();

// set expected behavior on dao

expect(dao.get(id)).andReturn(person);

replay(dao);

Person result = manager.get(id);

assertSame(person, result);

verify(dao);

}

public void testGetPersons() {

log.debug("testing getPersons");

List people = new ArrayList();

// set expected behavior on dao

expect(dao.getAll()).andReturn(people);

replay(dao);

List result = manager.getAll();

assertSame(people, result);

verify(dao);

}

public void testGetByLastName() {

log.debug("testing getByLastName");

List people = new ArrayList();

String lastName = "Smith";

// set expected behavior on dao

expect(dao.findByLastName(lastName)).andReturn(people);

replay(dao);

List result = manager.findByLastName(lastName);

assertSame(people, result);

verify(dao);

}

public void testSavePerson() {

log.debug("testing savePerson");

person = new Person();

// set expected behavior on dao

expect(dao.save(person)).andReturn(person);

replay(dao);

manager.save(person);

verify(dao);

}

public void testRemovePerson() {

log.debug("testing removePerson");

Long id = 11L;

person = new Person();

// set expected behavior on dao

dao.remove(id);

replay(dao);

manager.remove(id);

verify(dao);

}

package org.appfuse.tutorial.service.impl;
import java.util.ArrayList;
import java.util.List;
import org.appfuse.tutorial.dao.PersonDao;
import org.appfuse.tutorial.model.Person;
import static org.easymock.EasyMock.*;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.logging.Log;
import junit.framework.TestCase;
public class PersonManagerImplTest extends TestCase {
private final Log log = LogFactory.getLog(PersonManagerImplTest.class);
private PersonManagerImpl manager = null;
private PersonDao dao = null;
private Person person = null;
protected void setUp() throws Exception {
log.debug("setUpDao for PersonManagerImplTest");
dao = createStrictMock(PersonDao.class);
manager = new PersonManagerImpl((PersonDao) dao);
}
public void testGetPerson() {
log.debug("testing getPerson");
Long id = 7L;
person = new Person();
// set expected behavior on dao
expect(dao.get(id)).andReturn(person);
replay(dao);
Person result = manager.get(id);
assertSame(person, result);
verify(dao);
}
public void testGetPersons() {
log.debug("testing getPersons");
List people = new ArrayList();
// set expected behavior on dao
expect(dao.getAll()).andReturn(people);
replay(dao);
List result = manager.getAll();
assertSame(people, result);
verify(dao);
}
public void testGetByLastName() {
log.debug("testing getByLastName");
List people = new ArrayList();
String lastName = "Smith";
// set expected behavior on dao
expect(dao.findByLastName(lastName)).andReturn(people);
replay(dao);
List result = manager.findByLastName(lastName);
assertSame(people, result);
verify(dao);
}
public void testSavePerson() {
log.debug("testing savePerson");
person = new Person();
// set expected behavior on dao
expect(dao.save(person)).andReturn(person);
replay(dao);
manager.save(person);
verify(dao);
}
public void testRemovePerson() {
log.debug("testing removePerson");
Long id = 11L;
person = new Person();
// set expected behavior on dao
dao.remove(id);
replay(dao);
manager.remove(id);
verify(dao);
}
}

Note that this class extends junit.framework.TestCase and not an EasyMock class. This makes EasyMock a good choice for annotation based test frameworks such as JUnit 4 and TestNG. Unfortunately (at the time of writing) Maven does not work properly with these frameworks.

Now check everything works by running mvn test -Dtest=PersonManagerImplTest again.

That's it, you can continue to writing your web application.

作者：xiong2009 发表于2007-8-23 19:06:00 原文链接

阅读：1020 评论：0 查看评论

[原]appFuse2.x第四篇--Using Hibernate

xiong2009 — Thu, 23 Aug 2007 19:03:00 +0800

This tutorial will show you two things:

You don't need to write DAOs if you just need generic CRUD functionality.
How to write DAOs when you need custom functionality.

If you're new to Hibernate, you might want to read the Hibernate Reference Guide before starting this tutorial.

Source Code

The code for this tutorial is located in the "tutorial-hibernate" module of the appfuse-demos project on Google Code. Use the following command to check it out from Subversion:

svn checkout http://appfuse-demos.googlecode.com/svn/trunk/tutorial-hibernate

Register a personDao bean definition

AppFuse 2.x doesn't require you to write a DAO to persist a POJO. You can use one of the pre-existing classes if all you need is CRUD on an object:

GenericDaoHibernate: A generics-based class that requires you to create a Spring bean definition.
UniversalDaoHibernate: A class that requires you to cast to the specific object type.

The UniversalDaoHibernate class is already registered as a "dao" bean, so you can easily use it without any additional configuration. However, many developers prefer the generics-based DAO because it provides type safety. To register a personDao bean, create src/main/webapp/WEB-INF/applicationContext.xml (or core/src/main/resources/applicationContext.xml for a modular archetype) and add the following to it:

The applicationContext.xml file should already exist if you're using AppFuse 2.0 M5+.

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

<constructor-arg value="org.appfuse.tutorial.model.Person"/>

</bean>

</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
<bean id="personDao" class="org.appfuse.dao.hibernate.GenericDaoHibernate">
<constructor-arg value="org.appfuse.tutorial.model.Person"/>
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
</beans>

After doing this, you can use this bean on an object by adding the following setter method:

public void setPersonDao(GenericDao<Person, Long> personDao) {

this.personDao = personDao;

}

public void setPersonDao(GenericDao<Person, Long> personDao) {
this.personDao = personDao;
}

If you need more than just CRUD functionality, you'll want to continue reading below. If not, you can continue to Creating new Managers. This is a tutorial for creating Business Facades, which are similar to Session Facades, but don't use EJBs. These facades are used to provide communication from the front-end to the DAO layer.

Create a DAO Test to test finder functionality

Now you'll create a DaoTest to test that your DAO works. "Wait a minute," you say, "I haven't created a DAO!" You are correct. However, I've found that Test-Driven Development breeds higher quality software. For years, I thought write your test before your class was hogwash. It just seemed stupid. Then I tried it and I found that it works great. The only reason I do test-driven stuff now is because I've found it rapidly speeds up the process of software development.

To start, create a PersonDaoTest.java class in your src/test/java/**/dao directory (or core/src/test/java/**/dao directory for a modular archetype). This class should extend org.appfuse.dao.BaseDaoTestCase, a subclass of Spring's AbstractTransactionalDataSourceSpringContextTests. This parent class is used to load Spring's ApplicationContext (since Spring binds interfaces to implementations), and for (optionally) loading a .properties file that has the same name as your *Test.class. In this example, if you put a PersonDaoTest.properties file in src/test/resources/org/appfuse/tutorial/dao, this file's properties will be available via an "rb" variable.

package org.appfuse.tutorial.dao;

import java.util.List;

import org.appfuse.dao.BaseDaoTestCase;

import org.appfuse.tutorial.model.Person;

import org.springframework.dao.DataAccessException;

public class PersonDaoTest extends BaseDaoTestCase {

private PersonDao personDao = null;

public void setPersonDao(PersonDao personDao) {

this.personDao = personDao;

}

package org.appfuse.tutorial.dao;
import java.util.List;
import org.appfuse.dao.BaseDaoTestCase;
import org.appfuse.tutorial.model.Person;
import org.springframework.dao.DataAccessException;
public class PersonDaoTest extends BaseDaoTestCase {
private PersonDao personDao = null;
public void setPersonDao(PersonDao personDao) {
this.personDao = personDao;
}
}

The code you see above is what you need for a basic Spring integration test that initializes and configures an implementation of PersonDao. Spring will use autowiring by name to call the setPersonDao() method and set the "personDao" bean as a dependency of this class.

Now you need test that the finder method works in your DAO. To do this, create a method that begin with "test" (all lower case). As long as this method is public, has a void return type and take no arguments, it invoked and run by JUnit. Add the following method to your PersonDaoTest.java file:

public void testFindPersonByLastName() throws Exception {

List<Person> people = personDao.findByLastName("Raible");

assertTrue(people.size() > 0);

}

public void testFindPersonByLastName() throws Exception {
List<Person> people = personDao.findByLastName("Raible");
assertTrue(people.size() > 0);
}

You'll notice that this method relies on pre-existing data in order to pass. The DbUnit Maven Plugin is used to populate the database with test data before the tests are run, so you can simply add the new table/record to the src/test/resources/sample-data.xml file (or core/src/test/resources/sample-data.xml for a modular archetype).

<column>first_name</column>

<row>

<value>Raible</value>

</row>

</table>

<table name='person'>
<column>id</column>
<column>first_name</column>
<column>last_name</column>
<row>
<value>1</value>
<value>Matt</value>
<value>Raible</value>
</row>
</table>

Since the PersonDao you're about to write includes CRUD functionality, you can also write a test to verify CRUD works properly.

import org.springframework.dao.DataAccessException;

public void testAddAndRemovePerson() throws Exception {

Person person = new Person();

person.setFirstName("Country");

person.setLastName("Bry");

person = personDao.save(person);

flush();

person = personDao.get(person.getId());

assertEquals("Country", person.getFirstName());

assertNotNull(person.getId());

log.debug("removing person...");

personDao.remove(person.getId());

flush();

try {

personDao.get(person.getId());

fail("Person found in database");

} catch (DataAccessException dae) {

log.debug("Expected exception: " + dae.getMessage());

assertNotNull(dae);

}

import org.springframework.dao.DataAccessException;
public void testAddAndRemovePerson() throws Exception {
Person person = new Person();
person.setFirstName("Country");
person.setLastName("Bry");
person = personDao.save(person);
flush();
person = personDao.get(person.getId());
assertEquals("Country", person.getFirstName());
assertNotNull(person.getId());
log.debug("removing person...");
personDao.remove(person.getId());
flush();
try {
personDao.get(person.getId());
fail("Person found in database");
} catch (DataAccessException dae) {
log.debug("Expected exception: " + dae.getMessage());
assertNotNull(dae);
}
}

In the above example, you can see that person.set*(value) is being called to populate the Person object before saving it. This is easy in this example, but it could get quite cumbersome if you're persisting an object with 10 required fields. This is why a ResourceBundle exists in BaseDaoTestCase. Simply create a PersonDaoTest.properties file in the same directory as PersonDaoTest.java and define your property values inside it:

firstName=Matt

lastName=Raible

firstName=Matt
lastName=Raible

I tend to just hard-code test values into Java code - but the .properties file is an option that works great for large objects.

Then, rather than calling person.set* to populate your objects, you can use the BaseDaoTestCase.populate(java.lang.Object) method:

Person person = new Person();

person = (Person) populate(person);

Person person = new Person();
person = (Person) populate(person);

At this point, the PersonDaoTest class won't compile yet because there is no PersonDao.class in your classpath, you need to create it.

Create a DAO Interface and implementation

Create a PersonDao.java interface in the src/main/java/**/dao (or core/src/main/java/**/dao for a modular archetype) directory and specify the finder method for any implementation classes.

package org.appfuse.tutorial.dao;

import org.appfuse.dao.GenericDao;

import org.appfuse.tutorial.model.Person;

import java.util.List;

public interface PersonDao extends GenericDao<Person, Long> {

public List<Person> findByLastName(String lastName);

}

package org.appfuse.tutorial.dao;
import org.appfuse.dao.GenericDao;
import org.appfuse.tutorial.model.Person;
import java.util.List;
public interface PersonDao extends GenericDao<Person, Long> {
public List<Person> findByLastName(String lastName);
}

Notice in the class above there is no exception on the method signature. This is due to the power of Spring and how it wraps Exceptions with RuntimeExceptions. At this point, you should be able to compile all your code using your IDE or mvn test-compile. However, if you try to run mvn test -Dtest=PersonDaoTest, you will get an error:

Running org.appfuse.tutorial.dao.PersonDaoTest

INFO - AbstractSingleSpringContextTests.loadContextLocations(179) | Loading context for: classpath*:/applicationContext-*.xml

Tests run: 2, Failures: 0, Errors: 2, Skipped: 0, Time elapsed: 0.449 sec <<< FAILURE!

Running org.appfuse.tutorial.dao.PersonDaoTest
INFO - AbstractSingleSpringContextTests.loadContextLocations(179) | Loading context for: classpath*:/applicationContext-*.xml
Tests run: 2, Failures: 0, Errors: 2, Skipped: 0, Time elapsed: 0.449 sec <<< FAILURE!

Unfortunately, this doesn't tell you much about what went wrong. To find the real problem, you need to open target/surefire-reports/org.appfuse.tutorial.dao.PersonDaoTest.txt (or core/target/surefire-reports/org.appfuse.tutorial.dao.PersonDaoTest.txt for a modular archetype). In this file, the real problem is shown:

-------------------------------------------------------------------------------

Test set: org.appfuse.tutorial.dao.PersonDaoTest

-------------------------------------------------------------------------------

Tests run: 2, Failures: 0, Errors: 2, Skipped: 0, Time elapsed: 0.444 sec <<< FAILURE!

testFindPersonByLastName(org.appfuse.tutorial.dao.PersonDaoTest) Time elapsed: 0.401 sec <<< ERROR!

org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean

with name 'org.appfuse.tutorial.dao.PersonDaoTest': Unsatisfied dependency expressed

through bean property 'personDao': Set this property value or disable dependency

checking for this bean.

-------------------------------------------------------------------------------
Test set: org.appfuse.tutorial.dao.PersonDaoTest
-------------------------------------------------------------------------------
Tests run: 2, Failures: 0, Errors: 2, Skipped: 0, Time elapsed: 0.444 sec <<< FAILURE!
testFindPersonByLastName(org.appfuse.tutorial.dao.PersonDaoTest)  Time elapsed: 0.401 sec  <<< ERROR!
org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean
with name 'org.appfuse.tutorial.dao.PersonDaoTest': Unsatisfied dependency expressed
through bean property 'personDao': Set this property value or disable dependency
checking for this bean.

Showing errors in your console
To show testing errors in your console, append -Dsurefire.useFile=false to your mvn test command.

This is an error message from Spring - indicating that you need to specify a bean named "personDao" in a Spring context file. Before you do that, you need to create the PersonDao implementation.

Create a PersonDaoHibernate class that implements the finder method in PersonDao. To do this, create a new class in src/main/java/**/dao/hibernate (or core/src/main/java/**/dao/hibernate for the modular archetype) and name it PersonDaoHibernate.java. It should extend GenericDaoHibernate and implement PersonDao. Javadocs eliminated for brevity.

package org.appfuse.tutorial.dao.hibernate;

import java.util.List;

import org.appfuse.dao.hibernate.GenericDaoHibernate;

import org.appfuse.tutorial.model.Person;

import org.appfuse.tutorial.dao.PersonDao;

public class PersonDaoHibernate extends GenericDaoHibernate<Person, Long> implements PersonDao {

public PersonDaoHibernate() {

super(Person.class);

}

public List<Person> findByLastName(String lastName) {

return getHibernateTemplate().find("from Person where lastName=?", lastName);

}

package org.appfuse.tutorial.dao.hibernate;
import java.util.List;
import org.appfuse.dao.hibernate.GenericDaoHibernate;
import org.appfuse.tutorial.model.Person;
import org.appfuse.tutorial.dao.PersonDao;
public class PersonDaoHibernate extends GenericDaoHibernate<Person, Long> implements PersonDao {
public PersonDaoHibernate() {
super(Person.class);
}
public List<Person> findByLastName(String lastName) {
return getHibernateTemplate().find("from Person where lastName=?", lastName);
}
}

Now, if you try to run mvn test -Dtest=PersonDaoTest, you will get the same error. You need to configure Spring so it knows that PersonDaoHibernate is the implementation of PersonDao.

Create an applicationContext.xml file in src/main/webapp/WEB-INF (or core/src/main/resources for a modular archetype) and add the following XML to it:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

</bean>

</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
<bean id="personDao" class="org.appfuse.tutorial.dao.hibernate.PersonDaoHibernate">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
</beans>

Run the DAO Test

Save all your edited files and try running mvn test -Dtest=PersonDaoTest one more time.

Yeah Baby, Yeah:

BUILD SUCCESSFUL
Total time: 9 seconds

Next Up: Part II: Creating new Managers - A HowTo for creating Business Facades, which are similar to Session Facades, but don't use EJBs. These facades are used to provide communication from the front-end to the DAO layer.

作者：xiong2009 发表于2007-8-23 19:03:00 原文链接

阅读：916 评论：0 查看评论

[原]appFuse2.x第三篇--Persistence

xiong2009 — Thu, 23 Aug 2007 19:01:00 +0800

This tutorial will show you how to create a new database table and the Java code to access that table.

You will create an object and then some more classes to persist (save/retrieve/delete) that object from the database. In Java speak, this object is called a Plain Old Java Object (POJO). This object basically represents a database table. With AppFuse 1.x, you typically created a DAO and JUnit Test to persist this POJO. However, with AppFuse 2.x, there is a Generics-based DAO and Manager that will CRUD all objects for you. The only time you'll need to create DAOs is when you want custom behavior or if you need finders.

AppFuse uses Hibernate for its default persistence layer. Hibernate is an Object/Relational (O/R) Framework that allows you to relate your Java Objects to database tables. It allows you to very easily perform CRUD (Create, Retrieve, Update, Delete) on your objects.

iBATIS and JPA
You can also use iBATIS or JPA as a persistence framework option. To use iBATIS with AppFuse, see the using iBATIS tutorial. To use JPA implementation, see the using JPA tutorial.

To get started creating a new Object and table in AppFuse's project structure, please complete the instructions below.

Create a new POJO and add JPA Annotations

The first thing you need to do is create an object to persist. Create a simple "Person" object (in the src/main/java/**/model directory for the basic archetypes or the core/src/main/java/**/model directory for the modular archetypes) that has an id, a firstName and a lastName (as properties). For recommend package-naming conventions, see the FAQ. These tutorials use "org.appfuse.tutorial" as the root package name.

package org.appfuse.tutorial.model;

import org.appfuse.model.BaseObject;

import javax.persistence.Entity;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import javax.persistence.GeneratedValue;

import javax.persistence.Column;

public class Person extends BaseObject {

private Long id;

private String firstName;

private String lastName;

Generate your getters and setters using your favorite IDE:

In Eclipse:

Right-click -> Source -> Generate Getters and Setters

}

package org.appfuse.tutorial.model;
import org.appfuse.model.BaseObject;
import javax.persistence.Entity;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.Column;
public class Person extends BaseObject {
private Long id;
private String firstName;
private String lastName;
/*
Generate your getters and setters using your favorite IDE:
In Eclipse:
Right-click -> Source -> Generate Getters and Setters
*/
}

Extending BaseObject is optional, but recommended as a good practice to force creation of toString(), equals() and hashCode() methods. If you plan to put this object into the user's session, or expose it through a web service, you should implement java.io.Serializable as well.

To generate toString(), equals() and hashCode() methods, you can use Commonclipse. More information on using this tool can be found on Lee Grey's site. Another Eclipse Plugin you can use is Commons4E. When generating or writing equals() and hashCode() methods, you don't want to include your object's primary key. See Hibernate's Equals and Hascode for more information.

IntelliJ Users
If you're using IntelliJ IDEA, you can generate equals() and hashCode(), but not toString(). There is a ToStringPlugin that works reasonably well.

Now that you have this POJO created, you need to add JPA annotations. These annotations are used by Hibernate to map objects → tables and properties (variables) → columns.

If you're new to Hibernate and Annotations, you might want to read An Introduction to Hibernate 3 Annotations by John Ferguson Smart.

First of all, add an @Entity annotation that signifies what table this object relates to. The "name" is optional; the class name is used if it's not specified. Make sure you import annotations from javax.persistence.* rather than from Hibernate.

@Entity

public class Person extends BaseObject {

@Entity
public class Person extends BaseObject {

If you specify a name value for your @Entity annotation (for example @Entity(name="person")), this will be the alias for HQL queries. If you don't specify this value, the name will match the short name of your class (Person). If you want to change the table name that's generated, use the @Table annotation with a "name" value.

You also have to add an @Id annotation to signify the primary key. The @GeneratedValue annotation should also be specified to indicate the primary key generation strategy.

@Id @GeneratedValue(strategy = GenerationType.AUTO)

public Long getId() {

return this.id;

}

@Id @GeneratedValue(strategy = GenerationType.AUTO)
public Long getId() {
return this.id;
}

For the rest of the fields, you aren't required to annotate them unless you want to 1) exclude them from being persisted (with @Transient) or 2) want to change their column name or other attributes. To change the column names, use the @Column annotation. Add the @Column annotation to both the getFirstName() and getLastName() methods.

@Column(name="first_name", length=50)

public String getFirstName() {

return this.firstName;

}

...

@Column(name="last_name", length=50)

public String getLastName() {

return this.lastName;

}

@Column(name="first_name", length=50)
public String getFirstName() {
return this.firstName;
}
...
@Column(name="last_name", length=50)
public String getLastName() {
return this.lastName;
}

Annotations on fields
You can also put JPA annotations on fields instead of getters. However, you should be aware that if you add field-level annotations, method-level annotations will be ignored.

Create a new database table from the object using Maven

Open src/main/resources/hibernate.cfg.xml for the basic archetypes (or core/src/main/resources/hibernate.cfg.xml for the modular archetypes) and register your Person object with the following XML:

<mapping class="org.appfuse.tutorial.model.Person"/>

Save the file and run mvn test-compile hibernate3:hbm2ddl from the command line. For modular projects, make sure you run this command from the "core" directory. This will generate your database schema with the "person" table included.

create table person (id bigint not null auto_increment, first_name varchar(50), primary key (id)) type=InnoDB;

create table person (id bigint not null auto_increment, first_name varchar(50), primary key (id)) type=InnoDB;

After you've created a POJO and generated a schema from it, how do you persist that object? AppFuse ships with GenericDao implementations that makes it possible CRUD any object. In addition to this Generics-based class, there is a UniversalDao that does the same thing. The major difference between the two is you'll need to cast to your specified type for the UniversalDao. However, it also doesn't require you to define any new Spring beans, so there's a benefits and drawbacks. For these tutorials, you will learn how to program using the GenericDao.

Please choose the persistence framework you'd like to use to continue:

If you don't know which is better for your project, please read Hibernate vs. iBATIS.

作者：xiong2009 发表于2007-8-23 19:01:00 原文链接

阅读：818 评论：0 查看评论

[原]appFuse2.x第二篇

xiong2009 — Thu, 23 Aug 2007 18:59:00 +0800

Tutorials for AppFuse 2.x are a work in progress. To develop an application with AppFuse, you generally create POJOs and configure how they work with Spring. Follow the steps below to create a master/detail screens that CRUD a Person object. You should create a project using the QuickStart Guide and setup your development environment before starting these tutorials.

Create a Person Entity.
Create a PersonDao in Hibernate, iBATIS or JPA.
Create a PersonManager to act as a service facade to PersonDao.
Create the web tier using JSF, Struts 2, Spring MVC or Tapestry.

Where's the source?
One of the most commonly asked questions about AppFuse 2.x is where's the source? If you'd like to convert your project so it doesn't rely on AppFuse dependencies and includes AppFuse's source instead, run mvn appfuse:full-source. This feature is only available in 2.0 M5+ and currently only works with basic archetypes.

CRUD Generation
AppFuse has a Maven Plugin that allows you to generate all the code in these tutorials. However, we recommend you complete these tutorials before using it so you're familiar with all the code that's being generated.

One of the nice features of AppFuse 2.x is you no longer need to create a DAO or Manager for type-safe CRUD functionality. You merely need to create Spring bean definitions. This means you should be able to easily develop a front-end without worrying about writing code for the backend (until you need customized functionality of course).

Having trouble choosing a web framework?
If you're having trouble choosing a web framework, read What Web Application framework should you use? and Java Web Framework Sweet Spots. More information on comparing web frameworks can be found at https://appfuse-light.dev.java.net/framework-comparison.

作者：xiong2009 发表于2007-8-23 18:59:00 原文链接

阅读：946 评论：0 查看评论

良子

[转]主数据管理(MDM)的成熟度

[原]PowerDesigner中概念数据模型2

[原]PowerDesigner中概念数据模型1

[原]appFuse2.x第八篇--Maven2

Ant vs. Maven

Installing a local Maven Repository

[原]appFuse2.x第七篇--Maven Plugins

About the AppFuse Maven Plugin

[原]appFuse2.x第六篇--Using Struts 2

Table of Contents

Introduction to Struts 2

Create a PersonActionTest

Create a PersonAction that will fetch people

Create personList.jsp to show search results

Modify PersonActionTest and PersonAction for edit(), save() and delete() method

Create personForm.jsp to edit a person's information

Configure Validation

Create a Canoo WebTest to test browser-like actions

Add link to menu

[原]appFuse2.x第五篇--Services

Table of Contents

Register a personManager bean definition

Create a Manager Interface

Create a Manager Test to test finder functionality

Create a Manager Implementation

Run the Manager Test

Register your Manager Implementation

Using EasyMock instead of JUnit in Unit Tests

[原]appFuse2.x第四篇--Using Hibernate

Table of Contents

Register a personDao bean definition

Create a DAO Test to test finder functionality

Create a DAO Interface and implementation

Run the DAO Test

[原]appFuse2.x第三篇--Persistence

Table of Contents

Create a new POJO and add JPA Annotations

Create a new database table from the object using Maven

[原]appFuse2.x第二篇