没有合适的资源?快使用搜索试试~ 我知道了~
温馨提示
试读
14页
计算机专业Java外文翻译 中文+英文(Spring框架介绍) Spring框架:这是一个流行的开源应用框架,它可以解决很多问题。这里主要介绍Spring的基本概念,并详细介绍其中以“bean工厂”为核心的轻量级控制反转(IoC)容器。 Spring让开发者更轻松的实现轻量级、可扩展的J2EE架构。对于我们推荐的架构模块,让Spring提供了即时可用的实现。此外,Spring还提供了同意的应用架构方式,以及大量的中间层功能模块,能大大简化了J2EE的开发,并且比传统的开发方式更加灵活。 Spring是一个完整的应用框架,它可以在很懂应用层发挥作用。Spring由多个子框架组成,而且这些框架都是相对独立的。不过,只要你愿意,你就可以将它们无缝集成起来,成为一个全面的应用框架,下面讲解Spring框架的关键概念。
资源推荐
资源详情
资源评论
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 architectural building
blocks we recommend. Spring provides a consistent way of structuring your applications, and
provides numerous middle tier features that can make J2EE development significantly easier and
more flexible than in traditional approaches.
The basic motivations for Spring are:
To address areas not well served by other frameworks. There are numerous good 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.
To allow for easy adoption. A framework should be cleanly layered, allowing the use of
indi-vidual features without imposing a whole world view on the application. Many Spring
features, such as the JDBC abstraction layer or Hibernate integration, can be used in a library style
or as part of the Spring end-to-end solution.
To deliver ease of use. As we’ve noted, J2EE out of the box is relatively hard to use to
solve many common problems. A good infrastructure framework should make 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 framework as a class library. IoC and
AOP are the key enabling technologies for avoiding framework dependence.
Consistent configuration. A good infrastructure framework should keep application
configuration flexible and consistent, avoiding the need for custom singletons and factories. A
single style should be applicable to all configuration needs, from the middle tier to web
controllers.
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 all middleware layers.
Basic Building Blocks
pring is a full-featured application framework that can be leveraged at many levels. It
consists of multi-ple sub-frameworks that are fairly independent but still integrate closely into a
one-stop shop, if desired. The key areas are:
Bean factory. The Spring lightweight IoC container, capable of configuring and 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 proxying of
beans in a bean factory, seamlessly weaving in interceptors and other advice at runtime. Chapter 8
dis-cusses the Spring AOP framework in detail. The main use of the Spring AOP framework is to
provide declarative enterprise services for POJOs.
Auto-proxying. Spring provides a higher level of abstraction over the AOP 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.
Transaction management. Spring provides a generic transaction management infrastructure,
with pluggable transaction strategies (such as JTA and JDBC) and various means for demarcat-ing
transactions in applications. Chapter 9 discusses its rationale and the power and flexibility that it
offers.
JDBC support. Spring offers two levels of JDBC abstraction that significantly ease the effort
of writing JDBC-based DAOs: the org.springframework.jdbc.core 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 ThreadLocal sessions and native transac-tion
handling, regardless of the underlying O/R mapping approach they work with.
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 DispatcherServlet and out-of-the-box controller
classes for command and form handling. Request-to-controller mapping, view resolution, locale
resolution and other important services are all pluggable, making the framework highly extensi-
ble. The web framework is designed to work not only with JSP, but with any view technology,
such as Velocity—without the need for additional bridges. Chapter 13 discusses web tier design
and the Spring web MVC framework in detail.
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 MVC, it uses a
consistent approach everywhere. Once you have learned the basic 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.
Thus Spring allows application code to seamlessly integrate into a J2EE environment
without being unnecessarily tied to it. You can build upon J2EE services where it makes sense for
your application, and choose lighter-weight solutions if there are no complex requirements. For
example, you need to use JTA as transaction strategy only if you face distributed transaction
requirements. For a single database, there are alternative strategies that do not depend on a J2EE
container. Switching between those transac-tion strategies is merely a matter of configuration;
Spring’s consistent abstraction avoids any need to change application code.
Spring offers support for accessing EJBs. This is an important feature (and relevant even in a
book on “J2EE without EJB”) because the use of dynamic proxies as codeless client-side
business delegates means that Spring can make using a local stateless session EJB an
implementation-level, rather than a fundamen-tal architectural, choice. Thus if you want to use
剩余13页未读,继续阅读
资源评论
Q2643365023
- 粉丝: 858
- 资源: 45
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功