數(shù)據(jù)庫設(shè)計外文翻譯

1、<p>　　畢 業(yè) 設(shè) 計（論 文）</p><p><b>　　外文文獻(xiàn)翻譯</b></p><p>　　系 別： XXXXXXXXXXXX </p><p>　　專 業(yè)： XXXXXXXXXXXX </p><p>　　班

2、 級： XXXXXXXXXXXX </p><p>　　學(xué)生姓名： XXX </p><p>　　導(dǎo)師姓名： XXXX 職稱： XXXX </p><p>　　起止時間：2009年 3月2日 至 2009年 6月12 日</p>&

3、lt;p><b>　　英文原文</b></p><p>　　Spring contains a lot of functionality and features, which are well-organized in seven modules shown in the diagram below. This section discusses each the of module

4、s in turn.</p><p>　　The Core package is the most fundamental part of the framework and provides the Dependency Injection features allowing you to manage bean container functionality. The basic concept here i

5、s the BeanFactory, which provides a factory pattern removing the need for programmatic singletons and allowing you to decouple the configuration and specification of dependencies from your actual program logic. </p>

6、;<p>　　On top of the Core package sits the Context package, providing a way to access beans in a framework-style manner, somewhat resembling a JNDI-registry. The context package inherits its features from the bean

7、s package and adds support for text messaging using e.g. resource bundles, event-propagation, resource-loading and transparent creation of contexts by, for example, a servlet container. </p><p>　　The DAO pac

8、kage provides a JDBC-abstraction layer that removes the need to do tedious JDBC coding and parsing of database-vendor specific error codes. Also, the JDBC package provides a way to do programmatic as well as declarative

9、transaction management, not only for classes implementing special interfaces, but for all your POJOs (plain old java objects). </p><p>　　The ORM package provides integration layers for popular object-relatio

10、nal mapping APIs, including JDO, Hibernate and iBatis. Using the ORM package you can use all those O/R-mappers in combination with all the other features Spring offers, like simple declarative transaction management ment

11、ioned before. </p><p>　　Spring's AOP package provides an AOP Alliance compliant aspect-oriented programming implementation allowing you to define, for example, method-interceptors and pointcuts to cleanl

12、y decouple code implementing functionality that should logically speaking be separated. Using source-level metadata functionality you can incorporate all kinds of behavioral information into your code, a little like .NET

13、 attributes. </p><p>　　Spring's Web package provides basic web-oriented integration features, such as multipart functionality, initialization of contexts using servlet listeners and a web-oriented applic

14、ation context. When using Spring together with WebWork or Struts, this is the package to integrate with. </p><p>　　Spring's Web MVC package provides a Model-View-Controller implementation for web-applica

15、tions. Spring's MVC implementation is not just any implementation, it provides a clean separation between domain model code and web forms and allows you to use all the other features of the Spring Framework like vali

16、dation. </p><p>　　Spring's web MVC framework is designed around a DispatcherServlet that dispatches requests to handlers, with configurable handler mappings, view resolution, locale and theme resolution

17、as well as support for upload files. 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, b

18、ut you will prefer the included implementation hierarchy, consisting of, for example AbstractCo</p><p>　　You can use any object as a command or form object - there's no need to implement an interface or

19、derive from a base class. Spring's data binding is highly flexible, for example, it treats type mismatches as validation errors that can be evaluated by the application, not as system errors. So you don't need to

20、 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 is often preferab</p><p>　　Com

21、pared 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 com

22、mand 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 only by

23、making them bean properties of the respective Action clas</p><p>　　Spring's view resolution is extremely flexible. A Controller implementation can even write a view directly to the response, returning nu

24、ll 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, containing reference data). View name reso

25、lution is highly configurable, either via bean names, via a properties file, or via your own ViewResolver implementation. The abstract model Map</p><p>　　Pluggability of other MVC implementations</p>

26、<p>　　There are several reasons why some projects will prefer to use other MVC implementations. Many teams expect to leverage their existing investment in skills and tools. In addition, there is a large body of know

27、ledge and experience avalailable for the Struts framework. 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 MVC fram

28、eworks.</p><p>　　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 MVC framework of your choice with Spring easily. Simpl

29、y 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 ther

30、e aren't any "plugins" involved, so no dedicated integration is necessary. From the web layer's point </p><p>　　All your registered beans and all of Spring's services can be at your fin

31、gertips even without Spring's web MVC. Spring doesn't compete with Struts or WebWork in this scenario, it just addresses the many areas that the pure web MVC frameworks don't, from bean configuration to data

32、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 use, for example, the transaction abstraction with JDBC or Hibernat&

33、lt;/p><p>　　Features of Spring MVC</p><p>　　Spring's web module provides a wealth of unique web support features, including:</p><p>　　Clear separation of roles - controller, valida

34、tor, command object, form object, model object, DispatcherServlet, handler mapping, view resolver, etc. Each role can be fulfilled by a specialized object.</p><p>　　Powerful and straightforward configuration

35、 of both framework and application classes as JavaBeans, including easy referencing across contexts, such as from web controllers to business objects and validators.</p><p>　　Adaptability, non-intrusiveness.

36、 Use whatever controller subclass you need (plain, command, form, wizard, multi-action, or a custom one) for a given scenario instead of deriving from a single controller for everything.</p><p>　　Reusable bu

37、siness code - no need for duplication. You can use existing business objects as command or form objects instead of mirroring them in order to extend a particular framework base class.</p><p>　　Customizable b

38、inding 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

39、to business objects.</p><p>　　Customizable handler mapping and view resolution - handler mapping and view resolution strategies range from simple URL-based configuration, to sophisticated, purpose-built reso

40、lution strategies. This is more flexible than some web MVC frameworks which mandate a particular technique.</p><p>　　Flexible model transfer - model transfer via a name/value Map supports easy integration wi

41、th any view technology.</p><p>　　Customizable locale and theme resolution, support for JSPs with or without Spring tag library, support for JSTL, support for Velocity without the need for extra bridges, etc.

42、</p><p>　　A simple but powerful tag library that avoids HTML generation at any cost, allowing for maximum flexibility in terms of markup code.</p><p>　　Data Access using O/R Mappers</p>&

43、lt;p>　　Spring provides integration with Hibernate, JDO, Oracle TopLink, Apache OJB and iBATIS SQL Maps: in terms of resource management, DAO implementation support, and transaction strategies. For example for Hibernat

44、e, there is first-class support with lots of IoC convenience features, addressing many typical Hibernate integration issues. All of these support packages for O/R mappers comply with Spring's generic transaction and

45、DAO exception hierarchies. There are usually two integration styles: eithe</p><p>　　Spring's adds significant support when using the O/R mapping layer of your choice to create data access applications. F

46、irst of all, you should know that once you started using Spring's support for O/R mapping, you don't have to go all the way. No matter to what extent, you're invited to review and leverage the Spring approach

47、, before deciding to take the effort and risk of building a similar infrastructure in-house. Much of the O/R mapping support, no matter what technology you're using may be u</p><p>　　Some of the the bene

48、fits of using Spring to create your O/R mapping DAOs include:</p><p>　　Ease of testing. Spring's inversion of control approach makes it easy to swap the implementations and config locations of Hibernate

49、SessionFactory instances, JDBC DataSources, transaction managers, and mapper object implementations (if needed). This makes it much easier to isolate and test each piece of persistence-related code in isolation.</p>

50、;<p>　　Common data access exceptions.Spring can wrap exceptions from you O/R mapping tool of choice, converting them from proprietary (potentially checked) exceptions to a common runtime DataAccessException hierar

51、chy. This allows you to handle most persistence exceptions, which are non-recoverable, only in the appropriate layers, without annoying boilerplate catches/throws, and exception declarations. You can still trap and handl

52、e exceptions anywhere you need to. Remember that JDBC exceptions (includin</p><p>　　General resource management. Spring application contexts can handle the location and configuration of Hibernate SessionFact

53、ory instances, JDBC DataSources, iBATIS SQL Maps configuration objects, and other related resources. This makes these values easy to manage and change. Spring offers efficient, easy and safe handling of persistence resou

54、rces. For example: Related code using Hibernate generally needs to use the same Hibernate Session for efficiency and proper transaction handling. Spring make</p><p>　　Integrated transaction management. Sprin

55、g allows you to wrap your O/R mapping code with either a declarative, AOP style method interceptor, or an explicit 'template' wrapper class at the Java code level. In either case, transaction semantics are handle

56、d for you, and proper transaction handling (rollback, etc) in case of exceptions is taken care of. As discussed below, you also get the benefit of being able to use and swap various transaction managers, without your Hib

57、ernate/JDO related code bein</p><p>　　To avoid vendor lock-in, and allow mix-and-match implementation strategies. While Hibernate is powerful, flexible, open source and free, it still uses a proprietary API.

58、 Furthermore one could argue that iBATIS is a bit lightweight, although it's excellent for use in application that don't require complex O/R mapping strategies. Given the choice, it's usually desirable to imp

59、lement major application functionality using standard or abstracted APIs, in case you need to switch to another implementat</p><p>　　The Spring transaction abstraction</p><p>　　Spring provides a

60、 consistent abstraction for transaction management. This abstraction is one of the most important of Spring's abstractions, and delivers the following benefits:</p><p>　　Provides a consistent programming

61、 model across different transaction APIs such as JTA, JDBC, Hibernate, iBATIS Database Layer and JDO.</p><p>　　Provides a simpler, easier to use, API for programmatic transaction management than most of thes

62、e transaction APIs</p><p>　　Integrates with the Spring data access abstraction</p><p>　　Supports Spring declarative transaction management</p><p>　　Traditionally, J2EE developers ha

63、ve had two choices for transaction management: to use global or local transactions. Global transactions are managed by the application server, using JTA. Local transactions are resource-specific: for example, a transacti

64、on associated with a JDBC connection. This choice had profound implications. Global transactions provide the ability to work with multiple transactional resources. (It's worth noting that most applications use a sing

65、le transaction resource) With l</p><p>　　Global transactions have a significant downside. Code needs to use JTA: a cumbersome API to use (partly due to its exception model). Furthermore, a JTA UserTransactio

66、n normally needs to be obtained from JNDI: meaning that we need to use both JNDI and JTA to use JTA. Obviously all use of global transactions limits the reusability of application code, as JTA is normally only available

67、in an application server environment.</p><p>　　The preferred way to use global transactions was via EJB CMT (Container Managed Transaction): a form of declarative transaction management (as distinguished fro

68、m programmatic transaction management). EJB CMT removes the need for transaction-related JNDI lookups--although of course the use of EJB itself necessitates the use of JNDI. It removes most--not all--need to write Java c

69、ode to control transactions. The significant downside is that CMT is (obviously) tied to JTA and an application server e</p><p>　　Local transactions may be easier to use, but also have significant disadvanta

70、ges: They cannot work across multiple transactional resources, and tend to invade the programming model. For example, code that manages transactions using a JDBC connection cannot run within a global JTA transaction.<

71、/p><p>　　Spring resolves these problems. It enables application developers to use a consistent programming model in any environment. You write your code once, and it can benefit from different transaction manag

72、ement strategies in different environments. Spring provides both declarative and programmatic transaction management. Declarative transaction management is preferred by most users, and recommended in most cases.</p>

73、;<p>　　With programmatic transaction management developers work with the Spring transaction abstraction, which can run over any underlying transaction infrastructure. With the preferred declarative model developer

74、s typically write little or no code related to transaction management, and hence don't depend on Spring's or any other transaction API.</p><p><b>　　中文譯文</b></p><p>　　Core包是框架

75、的最基礎(chǔ)部分， 并提供依賴注入（Dependency Injection）特性來使你可管理Bean容器功能。 這里的基礎(chǔ)概念是BeanFactory，它提供Factory模式來消除對程序性單例的需要， 并允許你從程序邏輯中分離出依賴關(guān)系的配置和描述。 </p><p>　　構(gòu)建于Beans包上Context包，提供了一種框架式的Bean訪問方式， 有些象JNDI注冊。Context包的特性得自Beans包，并添加

76、了文本消息的發(fā)送，通過比如資源串， 事件傳播，資源裝載的方式和Context的透明創(chuàng)建，如通過Servlet容器。 </p><p>　　DAO包提供了JDBC的抽象層，它可消除冗長的JDBC編碼和解析數(shù)據(jù)庫廠商特有的錯誤代碼。 該包也提供了一種方法實(shí)現(xiàn)編程性和聲明性事務(wù)管理，不僅僅是針對實(shí)現(xiàn)特定接口的類， 而且對所有的POJO。 </p><p>　　ORM包為流行的關(guān)系－對象映射API

77、s提供了集成層，包括JDO，Hibernate和iBatis。 通過ORM包，你可與所有Spring提供的其他特性相結(jié)合來使用這些對象/關(guān)系映射， 如前邊提到的簡單聲明性事務(wù)管理。 </p><p>　　Spring的AOP包提供與AOP聯(lián)盟兼容的面向方面編程實(shí)現(xiàn)，允許你定義， 如方法攔截器和切點(diǎn)，來干凈地給從邏輯上說應(yīng)該被分離的功能實(shí)現(xiàn)代碼解耦。 使用源碼級的元數(shù)據(jù)功能，你可將各種行為信息合并到你的代碼中，有點(diǎn)

78、象.Net的attribute。 </p><p>　　Spring的Web包提供了基本的面向Web的綜合特性，如Multipart功能， 使用Servlet監(jiān)聽器的Context的初始化和面向Web的Applicatin Context。 當(dāng)與WebWork或Struts一起使用Spring時，這個包使Spring可與其他框架結(jié)合。 </p><p>　　Spring的Web MVC包提

79、供了面向Web應(yīng)用的Model-View-Controller實(shí)現(xiàn)。 Spring的MVC實(shí)現(xiàn)不僅僅是一種實(shí)現(xiàn)，它提供了一種domain model代碼和web form的清晰分離， 這使你可使用Spring框架的所有其他特性，如校驗(yàn).</p><p>　　Spring的web框架是圍繞分發(fā)器（DispatcherServlet）設(shè)計的，DispatcherServlet將請求分發(fā)到不同的處理器，框架還包括可配置

80、的處理器映射，視圖解析，本地化，主題解析，還支持文件上傳。缺省的處理器是一個簡單的控制器（Controller）接口，這個接口僅僅定義了ModelAndView handleRequest(request,response)方法。你可以實(shí)現(xiàn)這個接口生成應(yīng)用的控制器，但是使用Spring提供的一系列控制器實(shí)現(xiàn)會更好一些，比如AbstractController，AbstractCommandController，和SimpleFormCo

81、ntroller。應(yīng)用控制器一般都從它們繼承。注意你需要選擇正確的基類：如果你沒有表單，你就不需要一個FormController。這是和Structs的一個主要區(qū)別。</p><p>　　你可以使用任何對象作為命令對象或表單對象：不必實(shí)現(xiàn)某個接口或從某個基類繼承。Spring的數(shù)據(jù)綁定相當(dāng)靈活，例如，它認(rèn)為類型不匹配這樣的錯誤應(yīng)該是應(yīng)用級的驗(yàn)證錯誤，而不是系統(tǒng)錯誤。所以你不需要為了處理無效的表單提交，或者正確地

82、轉(zhuǎn)換字符串，在你的表單對象中用字符串類型重復(fù)定義你的業(yè)務(wù)對象屬性。你應(yīng)該直接綁定表單到業(yè)務(wù)對象上。這是和Struts的另一個重要不同，Struts是圍繞象Action和ActionForm這樣的基類構(gòu)建的，每一種行為都是它們的子類。</p><p>　　和WebWork相比，Spring將對象細(xì)分成不同的角色：它支持的概念有控制器（Controller），可選的命令對象（Command Object）或表單對象（

83、Form Object），以及傳遞到視圖的模型（Model）。模型不僅包含命令對象或表單對象，而且也包含任何引用數(shù)據(jù)。但是，WebWork的Action將所有的這些角色都合并在一個單獨(dú)的對象里。WebWork允許你在表單中使用現(xiàn)有的業(yè)務(wù)對象，但是只能把它們定義成不同Action類的bean屬性。更重要的是，在運(yùn)算和表單賦值時，使用的是同一個處理請求的Action實(shí)例。因此，引用數(shù)據(jù)也需要被定義成Action的bean屬性。這樣在一個對象

84、就承擔(dān)了太多的角色。</p><p>　　對于視圖：Spring的視圖解析相當(dāng)靈活。一個控制器實(shí)現(xiàn)甚至可以直接輸出一個視圖作為響應(yīng)，這需要使用null返回ModelAndView。在一般的情況下，一個ModelAndView實(shí)例包含視圖名字和模型映射表，模型映射表提供了bean的名字及其對象（比如命令對象或表單對象，引用數(shù)據(jù)等等）的對應(yīng)關(guān)系。視圖名解析的配置是非常靈活的，可以通過bean的名字，屬性文件或者你自己

85、的ViewResolver來實(shí)現(xiàn)。抽象的模型映射表完全抽象了表現(xiàn)層，沒有任何限制：JSP，Velocity，或者其它的技術(shù)——任何表現(xiàn)層都可以直接和Spring集成。模型映射表僅僅將數(shù)據(jù)轉(zhuǎn)換成合適的格式，比如JSP請求屬性或者Velocity模版模型。</p><p>　　MVC實(shí)現(xiàn)的可擴(kuò)展性</p><p>　　許多團(tuán)隊(duì)努力爭取在技術(shù)和工具方面能使他們的投入更有價值，無論是現(xiàn)有的項(xiàng)目還是

86、新的項(xiàng)目都是這樣。具體地說，Struts 不僅有大量的書籍和工具，而且有許多開發(fā)者熟悉它。因此，如果你能忍受Struts的架構(gòu)性缺陷，它仍然是web層一個很好的選擇。WebWork和其它web框架也是這樣。</p><p>　　如果你不想使用Spring的web MVC框架，而僅僅想使用Spring提供的其它功能，你可以很容易地將你選擇的web框架和Spring結(jié)合起來。只要通過Spring的ContextLoa

87、dListener啟動一個Spring的根應(yīng)用上下文，并且通過它的ServletContext屬性（或者Spring的各種幫助方法）在Struts或WebWork的Action中訪問。注意到現(xiàn)在沒有提到任何具體的“plugins”，因此這里也沒有提及如何集成：從web層的角度看，你可以僅僅把Spring作為一個庫使用，根應(yīng)用上下文實(shí)例作為入口。</p><p>　　所有你注冊的bean和Spring的服務(wù)可以在沒

88、有Spring的web MVC下被訪問。Spring并沒有在使用方法上和Struts或WebWork競爭，它只是提供單一web框架所沒有的功能，從bean的配置到數(shù)據(jù)訪問和事務(wù)處理。所以你可以使用Spring的中間層和（或者）數(shù)據(jù)訪問層來增強(qiáng)你的應(yīng)用，即使你只是使用象JDBC或Hibernate事務(wù)抽象這樣的功能。</p><p>　　Spring MVC框架的特點(diǎn)</p><p>　　如

89、果僅僅關(guān)注于web方面的支持，Spring有下面一些特點(diǎn)：</p><p>　　清晰的角色劃分：控制器，驗(yàn)證器，命令對象，表單對象和模型對象；分發(fā)器，處理器映射和視圖解析器；等等。</p><p>　　直接將框架類和應(yīng)用類都作為JavaBean配置，包括通過應(yīng)用上下文配置中間層引用，例如，從web控制器到業(yè)務(wù)對象和驗(yàn)證器的引用。</p><p>　　可適應(yīng)性，但不具

90、有強(qiáng)制性：根據(jù)不同的情況，使用任何你需要的控制器子類（普通控制器，命令，表單，向?qū)?，多個行為，或者自定義的），而不是要求任何東西都要從Action/ActionForm繼承。</p><p>　　可重用的業(yè)務(wù)代碼，而不需要代碼重復(fù)：你可以使用現(xiàn)有的業(yè)務(wù)對象作為命令對象或表單對象，而不需要在ActionForm的子類中重復(fù)它們的定義。</p><p>　　可定制的綁定和驗(yàn)證：將類型不匹配作為

91、應(yīng)用級的驗(yàn)證錯誤，這可以保存錯誤的值，以及本地化的日期和數(shù)字綁定等，而不是只能使用字符串表單對象，手動解析它并轉(zhuǎn)換到業(yè)務(wù)對象。</p><p>　　可定制的處理器映射，可定制的視圖解析：靈活的模型可以根據(jù)名字/值映射，處理器映射和視圖解析使應(yīng)用策略從簡單過渡到復(fù)雜，而不是只有一種單一的方法。</p><p>　　可定制的本地化和主題解析，支持JSP，無論有沒有使用Spring標(biāo)簽庫，支持J

92、STL，支持不需要額外過渡的Velocity，等等。</p><p>　　簡單而強(qiáng)大的標(biāo)簽庫，它盡可能地避免在HTML生成時的開銷，提供在標(biāo)記方面的最大靈活性。</p><p>　　使用ORM工具進(jìn)行數(shù)據(jù)訪問 </p><p>　　Spring在資源管理，DAO實(shí)現(xiàn)支持以及實(shí)物策略等方面提供了與Hibernate, JDO和iBATIS SQL映射的集成。 對Hib

93、ernate，Spring使用了很多IoC的方便的特性提供了一流的支持，幫助你處理很多典型的Hibernate整合的問題。所有的這些都遵守Spring通用的事務(wù)和DAO異常體系.。</p><p>　　當(dāng)您選擇使用O/R映射來創(chuàng)建數(shù)據(jù)訪問應(yīng)用程序的時候，Spring的增加部分就會向您提供重要的支持。首先你應(yīng)該了解的是，一旦你使用了Spring對O/R映射的支持，你不需要親自作所有的事情。在決定花費(fèi)力氣，冒著風(fēng)險建

94、造類似的內(nèi)部底層結(jié)構(gòu)之前，我們都建議您考慮和利用Spring的解決方案。不管你使用的是何種技術(shù)，大部分的O/R映射支持都可以以library樣式被使用，因?yàn)樗械臇|西都是被設(shè)計成一組可重復(fù)利用的JavaBeans。在ApplicationContext和BeanFactory中使用更是提供了配置和部署簡單的好處，因此，這一章里的大多數(shù)例子都是在ApplicationContext中配置。 </p><p>　　使

95、用Spring構(gòu)建你的ORM應(yīng)用的好處包括: </p><p>　　測試簡單. Spring的IoC使得很容易替換掉不同的實(shí)現(xiàn)，Hibernate SessionFacotory的位置，datasource, 事務(wù)管理, 映射對象的實(shí)現(xiàn)。這樣就很容易隔離測試持久化相關(guān)代碼的各個部分。 </p><p>　　異常包裝。 Spring能夠包裝Hibernate異常，把它們從專有的，checke

96、d exception變?yōu)橐唤M抽象的runtime exception。這樣你就可以僅僅在恰當(dāng)?shù)膶犹幚泶蟛糠值牟豢苫謴?fù)的異常，使你避免了很多討厭的catch/throw以及異常聲明。你還是可以在你需要的地方捕捉和處理異常。回想一下JDBC異常（包括與DB相關(guān)的方言）被轉(zhuǎn)變?yōu)橥瑯拥漠惓ｓw系，這就意味著你可以在一致的編程模型中處理JDBC操作。</p><p>　　通用的資源管理。 Spring的applicatio

97、n context能夠處理諸如Hibernate 的SessionFactory， JDBC的datasource，iBatis的SQLMaps配置對象以及其他相關(guān)資源的定位和配置。這使得這些配置的值很容易被管理和修改。Spring提供了有效，簡單和安全的Hibernate Session處理。一般的使用Hibernate的代碼則需要使用同一個Hibernate Session對象以確保有效和恰當(dāng)?shù)厥聞?wù)處理。而Spring讓我們可以很容

98、易透明地創(chuàng)建和綁定一個session到當(dāng)前線程；你可以使用以下兩種辦法之一：聲明式的AOP方法攔截器，或通過使用一個外部的template包裝類在Java代碼層次實(shí)現(xiàn)。這樣，Spring就解決了在很多Hibernate論壇上出現(xiàn)的使用問題。</p><p>　　綜合的事務(wù)管理 。 Spring允許你包裝你的ORM代碼，通過使用聲明式的AOP方法攔截器或者在代碼級別使用外部的template包裝類。不管使用哪一種，