Spring的web-MVC构架模式大学毕业论文外文文献翻译及原文

毕 业 设 计（论文）

外 文 文 献 翻 译

文献、资料中文题目：Spring的web MVC 构架模式

文献、资料英文题目：Web MVC with the Spring Framework

文献、资料来源：

文献、资料发表（出版）日期：

院 （部）：

专 业：

班 级：

姓 名：

学 号：

指导教师：

翻译日期： 2017.02.14

翻译文稿1、

Spring的web MVC 构架模式

Juergen Hoeller

1.介绍：Spring 应用构架

当你第一次看到Spring的时候，你一定会说:"哦不，又一种web 构架".这篇文章将告诉你Spring明显区别于其他轻量级application framework, 它将专注于web的支持，与struts 和 webwork有着明显的区别。

在和struts 和 webwork的对比上,Spring是一个服务于所有层面的application framework:提供了bean的配置基础，AOP的支持，JDBC的提取框架，抽象事务支持，等等。它有一个非常显著的特点：在某个层面上如果你不需要Spring的支持，你就可以不使用String的class，只使用它的某一部分的功能。 从它的设计理念，你可以看到String 帮助你实现了真正的逻辑层和web层的分离：例如。一个校验应用将不用依靠controllers，就可以实现。这样的目标是 更好的重用和易测：过分依靠不必要的容器和框架将不能实现这一点。

当然,Spring 的自己的web支持和通常框架模式的细致完整.然而，Spring替换struts,webwork或者其他的web方案非常的容易.对于Spring的web支持或者不同的地方，Spring 允许你在web容器里面建立一个中间层，在测试环境或者标准独立的应用里面来设置重用你的商务逻辑.还有在J2EE环境里面，你的商务逻辑不必依靠容器提供的服务，像JTA ,EJB的支持.良好的构架的web应用可以运行在任何容器上，如，Tomcat 或者 Resin. 值得注意的是，Spring 不是和已经存在的解决方案进行竞争. 我们鼓励结合标准的技术，如， Servlet, JSP,

JTA, JNDI, JDBC, and JDO, 和非常匹配的工具，如，Hibernate, Velocity, Log4J,

and Caucho's Hessian/Burlap.这个框架的的设计思想是在你的应用需要改良的时候，你将会做一些技术的选择:例如,如果你需要分布式事务处理，你可能需要用Spring的Jta TransactionManager 来实现JTA服务.或者，用DataSourceTransactionManager or HibernateTransactionManager 来实现美妙完美的单个数据库交换。

2. Web MVC:Spring web 框架的设计思想

Spring 框架通过配置操作mappings,展示resolution,本地化和模版集成围绕着分派请求操作的servlet - DispatcherServlet设计的.缺省的操作是一个非常简单的控制接口, 他只提供了ModelAndView

handleRequest(request,response)方法.这将用于一个应用的控制,但是,如果你想包含多个层次的控制，AbstractController, AbstractCommandController,

MultiActionController, SimpleFormController,

AbstractWizardFormController 将帮助你完成.应用控制将代表那些子系统.注意，你可以选择一个适当的基类:如果你没有 web form,你就不必用FormController.这就是和Struts最大的不同. 你可以通过命令或者form对象来操作任何对象:这不需要接口工具或者一个基础类的驱动.Spring的数据邦定是非常的灵活的.举例来说,它描述了具有在应用范围内的校验错误的输入机制,但不是系统错误.所以在你的form对象里面你不必复制你的业务对象的string属性,只操作出错的子任务,或者适当地转换string.换句话说,它通常可以很好的直接邦定你的业务对象. 这也是和struts围绕请求基础类Action 和

ActionForm (每个action操作类型) 建立主要的不同之一. 对比WebWork,Sping更多的区别在于对象角色:Sping支持控制器的感念,一个操作命令或者form对象,和得到数据传递给视图的模式.这个模式通常包含命令和form对象,但有时也包含任意的参考数据.换句话说,一个WebWork Action联合所有这些角色到一个单独的对象.WebWork 允许你用已经存在的业务对象作为你 form

的一部分,但是只生成各自Action 的 bean 属性. 最后,操作请求的Action 实例在一个视图里面获得付值和form population. 然而,参考数据也需要作为Action 的属性被模拟. 一个类里面有太多的角色是值得讨论的. 关于视图:Spring的视图方案非常的灵活. 一个控制器执行可以通过response 返回ModelAndView对象null,就可以直接写到一个视图.在通常的状况下,一个ModelAndView实例结合了 一个view 和一个 model Map,包含了bean name 和

通讯对象(像命令或者form,参考数据等等). View名称是非常高端的的配置，不是通过bean name, 一个properties 文件就是通过你自己的ViewResolver.这个抽象的model Map 允许你在视图层面完成提取,没有任何的争辩JSP/Velocity

或者其他,每一种都可以直接完整使用.这个model Map 还可以简单得得到适当的格式化数据的转换,像JSP 请求属性或者Velocity 模版模式.

3.集成:用Spring一个不同web 框架

许多开发团队将为他们已有的项目或者新的项目已经获得的期限和工具进行投资.这里没有像Struts那样大量的图书和工具，但是同样我们有大量的拥有Spring开发技巧的开发人员.然而,如果你愿意生活在Struts的构架瑕疵中的话，他将是你在web层开发不错的选择.当然，其他应用也是一样. 如果你不想用Spring的 web MVC ，但是想借用Spring嫁接其他的解决方案,你可以非常简单地通过Spring 继承你自己的web 框架.你可以非常简单地通过ContextLoaderListener 启动一个Spring root application context, 并且,通过Struts 或者WebWork 的action 利用ServletContext 属性(或者Spring

的helper方法)存取它. 值得注意的是, 这里没有任何的 "plugins"被调用,因此没有专门的集成:来自web层的视图, 你可以简单的将Spring作为一个管理application context 实例入口点的类库. 所有你注册bean和Spring服务都可以在不需要Spring的web MVC的情况下都可以被你轻松掌握.Spring 不是和Struts ,WebWork这些应用进行竞争,它将作为一个纯web框架应用于 很多领域,因为它不需要配置数据存储和事务操作.所以,你可以利用Spring提供的中间层和数据存储层来丰富你的应用,甚至,你想用JDBC或者Hibernate进行事务抽象.

4.特点核对列表

如果聚焦于web 支持,Spring的一些显著特点是: 清楚地角色分离:controller , validator , command object , form object , model object,和 DispatcherServlet , handler mapping vs view resolver, 等等 强大而且直接的框架和作为JavaBeans的应用配置,包括简单的参照和应用内容,例如,从web控制器到业务对象和数据校验. 适应性,外挂:无论什么样的控制器你都需要得到代替Action/ActionForm所做的每件事情的方案(简单,命令,form,范例,多重action,或者定制一个) 重用业务逻辑代码,不需要复制:你可以用已经有的业务逻辑对象作为命令或则form对象代替反射特定的ActionForm子类. 可订制的邦定和数据校验:作为应用级的输入机制的错误校验,固定日期和数字邦定,例如,通过手动检查和转换业务对象来替换单个的string。 可订制的操作,可订

制的视图方案:通过name/value Map灵活的模型传送,用一个简单的方法从简单到复杂操作映射和视图方案策略.

本地定制和主题方案:Spring没有taglib,完全支持于JSPs，JSTL,不需要额外的连接就可以支持Velocity,等等. 简单但是强大的tag library避免了HTML产生的混乱,最大限度的灵活扩展了标记代码.

翻译文稿2、

一种基于Hibernate和Struts的J2EE应用开发策略

本文分析了Hibernate和Struts的机制，提出了一种基于Hibernate和Struts的J2EE应用开发策略。在这种策略中，模型层用Hibernate实现，视图和控制器则用Struts框架实现。这样可大大降低代码的耦合性以及提高系统的开发效率。

关键字 Hibernate，Struts，MVC，持久层

1 引言

随着Java技术的逐渐成熟与完善，作为建立企业级应用的标准平台，J2EE平台得到了长足的发展。借助于J2EE规范中包含的多项技术：Enterprise

JavaBean(EJB)、Java Servlets(Servlet)、Java Server Pages(JSP)、Java

Message Service(JMS)等，开发出了许多应用系统。但是，在传统J2EE应用的开发过程中也出现了一些问题：

1）数据模型和逻辑模型之间的矛盾。目前使用的数据库基本上都是关系型数据库，而Java本质上是一种面向对象的语言，对象在存储和读取时使用SQL和JDBC进行数据库操作，降低了编程的效率以及系统的可维护性；

2）传统的J2EE应用多采用基于EJB的重量级框架，这种框架适合于开发大型企业应用，但是使用EJB容器进行开发和调试需要耗费大量时间。为了降低代码的耦合性，提高系统的开发效率，本文提出了一种基于Struts框架和Hibernate框架的J2EE应用开发策略。

2 数据持久层及Hibernate Hibernate是一个数据持久层框架，是一种实现对象和关系之间映射（O/R Mapping）的工具，它对JDBC进行了轻量级的对象封装，使程序员可以使用对象编程思想来操作数据库。它不仅提供了从Java类到数据表的映射，也提供了数据查询和恢复机制。相对于使用JDBC和SQL来操作数据库，使用Hibernate能大大的提高实现的效率。Hibernate框架用配置文件的形式来定义Java对象和数据表之间的映射关系，同时在更深的层面将数据表之间的关系解释为Java对象之间的继承及包含等关系。通过使用HQL语句将复杂的关系算

法用对象的方式描述，在很大程度上简化了对数据的查询，加快了开发的效率。在Hibernate中有一个简单而直观的API，用于对数据库所表示的对象执行查询。要创建或修改这些对象，只需在程序中与它们进行交互，然后告诉Hibernate保存即可。这样，大量封装持久化操作的业务逻辑不再需要编写烦琐的JDBC语句，从而使数据持久层得到了极大的简化。

3 用Struts实现MVC架构 MVC（Model-View-Controller）由Trygve

Reenskaug提出，首先被应用在SmallTalk-80环境中，是许多交互和界面系统的构成基础。根据界面设计可变性的需求，MVC把交互系统的组成分解成模型、视图、控制器三部分。 模型（Model）是软件所处理问题逻辑在独立于外在显示内容和形式情况下的内在抽象，封装了问题的核心数据、逻辑和功能的计算关系，独立于具体的界面表达和I/O操作。视图（View）把表示模型数据及逻辑关系和状态的信息及特定形式展示给用户。它从模型获得显示信息，对于相同的信息可以有多个不同的显示形式或视图。控制器（Controller）是处理用户与软件的交互操作的，其职责是控制提供模型中任何变化的传播，确保用户界面于模型间的对应联系；它接受用户的输入，将输入反馈给模型，进而实现对模型的计算控制，是使模型和视图协调工作的部件。通常一个视图对应一个控制器。模型、视图与控制器的分离，使得一个模型可以具有多个显示视图。如果用户通过某个视图的控制器改变了模型的数据，所有其它依赖于这些数据的视图都应反映到这些变化。因此，无论何时发生了何种数据变化，控制器都会将变化通知所有的视图，导致显示的更新。这实际上是一种模型的变化-传播机制。

Struts框架最早是作为Apache Jakarta项目的组成部分问世运做，它继承了MVC的各项特性，并根据J2EE的特点，做了相应的变化与扩展。Struts框架很好的结合了Jsp，Java Servlet，Java Bean，Taglib等技术。在Struts中，承担MVC中控制器角色的是ActionServlet。ActionServlet是一个通用的控制组件。这个控制组件提供了处理所有发送到Struts的HTTP请求的入口点。它截取和 分发这些请求到相应的动作类（这些动作类都是Action类的子类）。另外控制组件也负责用相应的请求参数填充Action Form（FromBean），并传给动作类（ActionBean）。动作类访问核心商业逻辑，即访问Java Bean或调用EJB。最后动作类把控制权传

给后续的JSP文件，由JSP文件生成视图。所有这些控制逻辑利用文件来配置。在Struts框架中，视图主要由JSP生成页面完成，Struts提供丰富的JSP标签库，这有利于分开表现逻辑和程序逻辑。模型以一个或多个Java Bean的形式存在。在Struts中，主要存在三种Bean，分别是：Action，ActionForm，EJB或者Java Bean。 Struts框架没有具体定义模型层的实现，在实际开发中，模型层通常是和业务逻辑紧密相连的，并且要对底层数据进行操作。下面介绍一种开发策略，将Hibernate引入到Struts框架的模型层中，使用它来进行数据封装和映射，提供持久化的支持。

4 运用Hibernate和Struts开发J2EE应用

以在J2EE应用中非常普遍的用户登录过程为例，来说明上述体系结构是如何具体运用的。登录的流程非常清晰：用户从登录页面输入登录信息，系统对登录信息进行验证，如果正确则成功登录，否则提示相应错误信息。 在开发过程中，使用Eclipse做为开发环境，同时加载了对Struts及Hibernate提供更好的控制和支持的第三方插件MyEclipse，Web服务器使用Tomcat，数据库选用了Mysql。 首先对Hibernate进行配置，只需要对系统自动生成的进行修改，配置好数据库连接的各种参数以及定义数据映射文件。由于Hibernate所带的连接池主要用于测试，性能不是很好，可以通过JNDI将其修改为使用Tomcat的连接池。

原文1（复印稿）

Web MVC with the Spring Framework

Juergen Hoeller

1. Introduction: Spring the Application Framework

When first confronted with the Spring Framework, one might be tempted to think:

"Oh no, not yet another web framework". This article will outline why Spring isn't

particularly a web framework but a generic lightweight application framework with

dedicated web support, and show the architectural differences to Struts and WebWork

In contrast to Struts or WebWork, Spring is an application framework for all layers: It

offers a bean configuration foundation, AOP support, a JDBC abstraction framework,

abstract transaction support, etc. It is a very non-intrusive effort: Your application

classes do not need to depend on any Spring classes if not necessary, and you can

reuse every part on its own if you like to. From its very design, the framework

encourages clean separation of tiers, most importantly web tier and business logic: e.g.

the validation framework does not depend on web controllers. Major goals are

reusability and testability: Unnecessary container or framework dependencies can be

considered avoidable evils.

Of course, Spring's own web support is nicely integrated with the framework's general

patterns. Nevertheless, replacing the web solution with Struts, WebWork, or the like

is easy. Both with Spring's web support or a different one, Spring allows for building

a true dedicated middle tier in the web container, with the option to reuse exactly the

same business logic in test environments or standalone applications. And within J2EE,

your business logic will not unnecessarily depend on container services like JTA or

EJB - allowing complex, well-architected web applications to run in a "simple"

container like Tomcat or Resin.

Note that Spring doesn't generally aim to compete with existing solutions. It rather

fosters seamless integration with standards like Servlet, JSP, JTA, JNDI, JDBC, and

JDO, and well-suited tools like Hibernate, Velocity, Log4J, and Caucho's

Hessian/Burlap. The framework is designed to grow with the needs of your

applications, in terms of technology choice: For example, you will probably use JTA

via Spring's JtaTransactionManager if you need distributed transactions - but only

then, as there are perfect replacements for single databases, like

DataSourceTransactionManager or HibernateTransactionManager.

2. Web MVC: The Design of Spring's Web Framework

Spring's web framework is designed around a DispatcherServlet that dispatches

requests to handlers, with configurable handler mappings, view resolution, and locale

and theme resolution. The default handler is a very simple Controller interface, just

offering a "ModelAndView handleRequest(request,response)" method. This can

already be used for application controllers, but you will prefer the included

implementation hierarchy, consisting of AbstractController,

AbstractCommandController, MultiActionController, SimpleFormController,

AbstractWizardFormController. Application controllers will typically be subclasses of

those. Note that you can choose an appropriate base class: If you don't have a form,

you don't need a FormController. This is a major difference to Struts.

You can take any object as command or form object: There's no need to implement an

interface or derive from a base class. Spring's data binding is highly flexible, e.g. it

treats type mismatches as validation errors that can be evaluated by the application,

not as system errors. So you don't need to duplicate your business objects' properties

as Strings in your form objects, just to be able to handle invalid submissions, or to

convert the Strings properly. Instead, it's often preferable to bind directly to your

business objects. This is another major difference to Struts which is built around

required base classes like Action and ActionForm - for every type of

action. Compared to WebWork, Spring has more differentiated object roles: It

supports the notion of a Controller, an optional command or form object, and a model

that gets passed to the view. The model will normally include the command or form

object but also arbitrary reference data. Instead, a WebWork Action combines all

those roles into one single object. WebWork does allow you to use existing business

objects as part of your form, but just by making them bean properties of the respective

Action class. Finally, the same Action instance that handles the request gets used for

evaluation and form population in the view. Thus, reference data needs to be

modelled as bean properties of the Action too. These are arguably too many roles in

one object.

Regarding views: Spring's view resolution is extremely flexible. A Controller

implementation can even write a view directly to the response, returning null as

ModelAndView. In the normal case, a ModelAndView instance consists of a view

name and a model Map, containing bean names and corresponding objects (like a

command or form, reference data, etc). View name resolution is highly configurable,

either via bean names, via a properties file, or via your own ViewResolver

implementation. The abstract model Map allows for complete abstraction of the view

technology, without any hassle: Be it JSP, Velocity, or anything else - every renderer

can be integrated directly. The model Map simply gets transformed into an

appropriate format, like JSP request attributes or a Velocity template model.

3. Integration: Using a Different Web Framework with Spring

Many teams will try to leverage their investments in terms of know-how and tools,

both for existing projects and for new ones. Concretely, there are not only a large

number of books and tools for Struts but also a lot of developers that have experience

with it. Thus, if you can live with Struts' architectural flaws, it can still be a viable

choice for the web layer. The same applies to WebWork and other web frameworks.

If you don't want to use Spring's web MVC but intend to leverage other solutions that

Spring offers, you can integrate the web framework of your choice with Spring easily.

Simply start up a Spring root application context via its ContextLoaderListener, and

access it via its ServletContext attribute (or Spring's respective helper method) from

within a Struts or WebWork action. Note that there aren't any "plugins" involved,

therefore no dedicated integration: From the view of the web layer, you'll simply use

Spring as a library, with the root application context instance as entry point. All your

registered beans and all of Spring's services can be at your fingertips even without

Spring's web MVC. Spring doesn't compete with Struts or WebWork in this usage, it

just addresses the many areas that the pure web frameworks don't, from bean

configuration to data access and transaction handling. So you are able to enrich your

application with a Spring middle tier and/or data access tier, even if you just want to

the transaction abstraction with JDBC or Hibernate.

4. Feature Check List

If just focussing on the web support, some of Spring's unique features are: .Clear

separation of roles: controller vs validator vs command object vs form object vs

model object, DispatcherServlet vs handler mapping vs view resolver, etc. .Powerful

and straightforward configuration of both framework and application classes as

JavaBeans, including easy in-between referencing via an application context, e.g.

from web controllers to business objects and validators. .Adaptability,

non-intrusiveness: Use whatever Controller subclass you need (plain, command, form,

wizard, multi action, or a custom one) for a given scenario instead of deriving from

Action/ActionForm for everything. .Reusable business code, no need for duplication:

You can use existing business objects as command or form objects instead of

mirroring them in special ActionForm subclasses. .Customizable binding and

validation: type mismatches as application-level validation errors that keep the

offending value, localized date and number binding, etc instead of String-only form

objects with manual parsing and conversion to business objects. Customizable handler

mapping, customizable view resolution: flexible model transfer via name/value Map,

handler mapping and view resolution strategies from simple to sophisticated instead

of one single way. Customizable locale and theme resolution, support for JSPs with

and without Spring tag library, support for JSTL, support for Velocity without the

need for extra bridges, etc. Simple but powerful tag library that avoids HTML

generation at any cost, allowing for maximum flexibility in terms of markup code.

原文2（复印稿）

A Development Strategy Application Based on the Hibernate and

the Struts J2EE

This text analysis the mechanism of Hibernate and Struts, put forward 1 kind EE

according to the J2 of the Hibernate and the Struts application development

this kind of strategy, the model layer use a Hibernate realization and see

diagram and controller to then use a Struts frame a can consumedly

lower the development efficiency that the Ou of code match sex and exaltation

system.

The key word : Hibernate, Struts, the MVC, hold out for long time

preface along with the Java technique of gradual mature and perfect, Be

establishment business enterprise class application of standard terrace, the J2 EE

terrace got substantial of development .Several technique asked for help from to

include in the J2 EE norm : Enterprise JavaBean (EJB), Java Servlets (Servlet), Java

Server Pages(JSP), Java Message Service(JMS)...etc., development many application

, also appeared some problem in the tradition J2 the EE the application of

the development the process:

1)the antinomy of of data model and logic model. Currently the database of

usage basically and all is relation type database, but the Java be essentially a kind of

the language which face to object, object at saving with read usage SQL and JDBC

carry on a database operation and lowered plait distance of efficiency and system of

can maintenance;

2)tradition of J2 EE application much the adoption is according to the EJB heavy

weight frame, this kind of frame suitable for develop a large business enterprise

application, but usage the EJB container carry on development and adjust to try to

need to be waste a great deal of lowering the Ou of code to match sex,

exaltation system of development efficiency, this text put forward 1 kind EE

according to the J2 of the Struts frame and the Hibernate frame application

development strategy.

2 Data's holding out for long time layer and Hibernate is one piece according to

hold out for long time layer frame, is a kind of realization object and relation of the

tool which reflect to shoot(O/R Mapping), it carried on the object of the lightweight to

pack to the JDBC and make procedure member can usage object plait distance

thought to operation database. It not only provided to shoot from Java to reflect of

data form, but also provided a data a search and instauration mechanism. Opposite in

usage JDBC and SQL to operation database, use Hibernate ability consumedly of

exaltation realization of efficiency. The Hibernate frame use allocation document of

the form come to the reflect of the definition Java object and data form to shoot

relation, in the meantime at more deep of level of data form of relation explanation for

the relations such as inherit of and containment etc. of Java object. Pass the usage

HQL language sentence complications of relation the calculate way use the way of

object description, to a large extent simplification logarithms according to of search,

speed development of efficiency. Have in the Hibernate a simple but keep the API of

view, used for to the database mean of object performance search. Want to establish

or the modification be these objects, need in the procedure carry on with them to hand

over with each other, then tell Hibernate to keep. So, a great deal of pack hold out for

long time turn operation of business logic no longer demand write a trivial JDBC

language sentence, make data last long thus the layer got biggest of simplification.

3 use the Struts realization MVC structure MVC(Model-View-Controller) is put

forward by the Trygve Reenskaug, first drive application in the environment

SmallTalk-80, is many to hand over with each other with interface system of

constitute foundation. According to the need of variable of the interface design, MVC

hand over with each other constitute of system to resolve into model and see diagram,

controller three part. Model(Model) is software processing problem logic at

independence in outside manifestation under contents and form circumstance of inside

abstract, packed the core data, logic of problem and function of calculation relation,

independence in concrete of interface expression and I/O operation. See

diagram(View) mean information and particular form demonstration of model data

and logic relation and appearance to the customer. It acquire a manifestation

information from the model, there can be many for homology of information

dissimilarity of manifestation form or see diagram. The controller(Controller) is a

processing the customer hand over with software with each other operation of, its job

is control provide model in any variety of dissemination, insure a customer interface

among the model of rightness should contact; It accept a customer of importation,

give° the importation feedback model, then realization compute model control, is

make model and see diagram to moderate work of parts. Usually 1 see a diagram

rightness should a controller. Model, see separate of diagram and controller, make a

model be able to have many manifestation to see diagram. If the customer pass a

certain see the controller of diagram change the data of model, all other dependence in

these see of data diagram all should reflection arrive these variety. When therefore

and regardless occurrence what data variety, controller all would variety notice ally

see diagram, cause manifestation of renewal. This is actually a kind of variety of

model-dissemination mechanism.

The Struts frame is to be the item of Apache Jakarta to constitute part to publish

luck to do at the earliest stage, it inherited MVC of each item characteristic, and did

according to the characteristics of J2 EE correspond of variety with expand. The

Struts frame was good to combine Jsp , Java Servlet , Java Bean, Talia etc. technique.

In the Struts, what to undertake the controller role in the MVC be an ActionServlet.

The ActionServlet is an in general use control module. This control module provided

a processing all HTTP claim which send out Struts of entrance point. Its interception

with distribute these claim to arrive correspond of action type.(these action all of type

is Action son type)Moreover the control module is also responsible for using to

correspond of claim the parameter fill Action Form(FromBean), and pass action

type(ActionBean).Action type the business logic of the interview core, then interview

Java Bean or adjust to use EJB. End action type control the power pass follow-up of

JSP document, from JSP document born see diagram. All these control logic make

use of the document come to allocation. See diagram in the Struts

frame main from JSP born page completion, the Struts provide abundant of JSP label

database, this is advantageous to separating performance logic and procedure

model is with 1 or the form existence of several Java Bean. In the Struts,

main existence three kinds of Bean, respectively BE: Action, ActionForm, EJB

perhaps Java Bean. The Struts frame have no concrete definition model layer of

realization, in actually the development, model layer usually is close with business

logic connect with each other, and want to carry on operation to the first floor data.

The underneath's introduction is a kind of development strategy, lead the Hibernate

into the model layer of Struts frame, usage it to carry on a data to pack with reflect to

shoot, provide hold out for long time turn of support. 4 usage Hibernate and the Struts

development J2 EE application 4.1 system structure diagram 3 manifestation

according to Hibernate and Struts development strategy of system structure diagram.

4.2 Development practice underneath combine a development practice, with in

the J2 the EE the application very widespread customer register process for example,

elucidation above-mentioned system structure is how concrete usage. The process of

register is very clear: Customer from register page importation register

information, system to register the information carry on verification, if exactitude

success register, otherwise hint correspond mistake information. In the development

process, the usage Eclipse be used as development environment and added to carry to

provide to the Struts and the Hibernate in the meantime better control and support of

three square plug-in MyEclipse, Web server usage Tomcat, the database chose to use

Mysql. Carry on an allocation to the Hibernate first, need to the system auto the born

. xml carry on modification, allocation good database conjunction of

various parameter and definition the data reflect to shoot a document. Because the

Hibernate take of conjunction pond main used for test, the function isn't very good,

can pass JNDI will it modification is usage Tomcat of conjunction pond.