SSM外文文献和翻译(毕设论文精品).doc

附录 1 外文原文

Introducing the Spring Framework

The Spring Framework: a popular open source application framework that

addresses many of the issues outlined in this book. This chapter will introduce the

basic ideas of Spring and dis-cuss the central “bean factory” lightweight Inversion-of-

Control (IoC) container in detail.

Spring makes it particularly easy to implement lightweight, yet extensible, J2EE

archi-tectures. It provides an out-of-the-box implementation of the fundamental

solutions to specific areas of J2EE infrastructure: web frameworks, persistence

solutions, remoting tools, and so on. However, integrating these tools into a

comprehensive architecture can involve significant effort, and can become a burden.

Spring aims to provide an end-to-end solution, integrating spe-cialized frameworks

into a coherent overall infrastructure. Spring also addresses some areas that other

frameworks don’t. For example, few frameworks address generic transaction

management, data access object implementation, and gluing all those things together

into an application, while still allowing for best-of-breed choice in each area. Hence

we term Spring an application framework, rather than a web framework, IoC or AOP

framework, or even middle tier framework.

simple tasks simple to achieve, without forcing tradeoffs for future complex

requirements (like distributed transactions) on the application developer. It should

allow developers to leverage J2EE services such as JTA where appropriate, but to

avoid dependence on them in cases when they are unnecessarily complex.

To make it easier to apply best practices. Spring aims to reduce the cost of

adhering to best practices such as programming to interfaces, rather than classes,

almost to zero. However, it leaves the choice of architectural style to the developer.

Non-invasiveness. Application objects should have minimal dependence on the

framework. If leveraging a specific Spring feature, an object should depend only on

that particular feature, whether by implementing a callback interface or using the

Ease of testing. Testing either whole applications or individual application

classes in unit tests should be as easy as possible. Replacing resources or application

objects with mock objects should be straightforward.

To allow for extensibility. Because Spring is itself based on interfaces, rather

than classes, it is easy to extend or customize it. Many Spring components use

strategy interfaces, allowing easy customization.

A Layered Application Framework

Chapter 6 introduced the Spring Framework as a lightweight container,

competing with IoC containers such as PicoContainer. While the Spring lightweight

container for JavaBeans is a core concept, this is just the foundation for a solution for

wiring up Java-Beans and most plain Java objects, removing the need for custom

singletons and ad hoc configura-tion. Various out-of-the-box implementations include

an XML-based bean factory. The lightweight IoC container and its Dependency

Injection capabilities will be the main focus of this chapter.

Application context. A Spring application context extends the bean factory

concept by adding support for message sources and resource loading, and providing

hooks into existing environ-ments. Various out-of-the-box implementations include

standalone application contexts and an XML-based web application context.

AOP framework. The Spring AOP framework provides AOP support for method

interception on any class managed by a Spring lightweight container. It supports easy

main use of the Spring AOP framework is to provide declarative enterprise services

for POJOs.

framework and low-level services, which offers similar ease-of-use to .NET within a

J2EE context. In particular, the provision of declarative enterprise services can be

driven by source-level metadata.

rationale and the power and flexibility that it offers.

JDBC support. Spring offers two levels of JDBC abstraction that significantly

package (a template/

callback approach) and the org.springframework.jdbc.object package (modeling

RDBMS operations as reusable objects). Using the Spring JDBC packages can deliver

much greater pro-ductivity and eliminate the potential for common errors such as

leaked connections, compared with direct use of JDBC. The Spring JDBC abstraction

integrates with the transaction and DAO abstractions.

Integration with O/R mapping tools. Spring provides support classes for O/R

Mapping tools like Hibernate, JDO, and iBATIS Database Layer to simplify resource

setup, acquisition, and release, and to integrate with the overall transaction and DAO

abstractions. These integration packages allow applications to dispense with custom

Web MVC framework. Spring provides a clean implementation of web MVC,

consistent with the JavaBean configuration approach. The Spring web framework

enables web controllers to be configured within an IoC container, eliminating the need

to write any custom code to access business layer services. It provides a generic

Remoting support. Spring provides a thin abstraction layer for accessing remote

services without hard-coded lookups, and for exposing Spring-managed application

beans as remote services. Out-of-the-box support is included for RMI, Caucho’s

Hessian and Burlap web service protocols, and WSDL Web Services via JAX-RPC.

Chapter 11 discusses lightweight remoting.

While Spring addresses areas as diverse as transaction management and web

configuration style, you will be able to apply it in many areas. Resources, middle tier

objects, and web components are all set up using the same bean configuration

mechanism. You can combine your entire configuration in one single bean definition

file or split it by application modules or layers; the choice is up to you as the

application developer. There is no need for diverse configuration files in a variety of

formats, spread out across the application.

Spring on J2EE

Although many parts of Spring can be used in any kind of Java environment, it is

primarily a J2EE application framework. For example, there are convenience classes

for linking JNDI resources into a bean factory, such as JDBC DataSources and EJBs,

and integration with JTA for distributed transaction management. In most cases,

application objects do not need to work with J2EE APIs directly, improving

reusability and meaning that there is no need to write verbose, hard-to-test, JNDI

lookups.

where it makes sense for your application, and choose lighter-weight solutions if there

consistent abstraction avoids any need to change application code.

as codeless client-side business delegates means that Spring can make using a local