Spring 4实战指南：从入门到高级应用

5星 · 超过95%的资源需积分: 9 20 浏览量更新于2024-07-22 1 收藏 3.34MB PDF 举报

"Apress.Pro.Spring.4th.Edition"是一本详尽的Spring框架指南，专为IT专业人士设计，旨在帮助读者深入理解和应用Spring框架在软件开发中的核心功能。本书共分为18章，涵盖了Spring框架的多个关键领域，便于读者从入门到进阶，全面掌握。第1章"Introducing Spring"为读者介绍了Spring框架的基本概念和设计理念，包括其在企业级应用中的作用和优势。通过本章，读者将建立起对Spring框架的整体认识。第2章"Getting Started"引导读者进行实际操作，逐步设置环境并完成第一个Spring项目，以便快速上手。这一章节将涵盖Spring的基本配置和应用启动流程。第3章和第4章分别深入探讨了依赖注入（IoC）和依赖倒置原则（DI），它们是Spring的核心特性，有助于解耦组件，提高代码可维护性和可扩展性。第5章"Introducing Spring AOP"讲解了面向切面编程（AOP），它是Spring的一个强大工具，用于处理横切关注点如事务管理、日志记录等，从而简化代码逻辑。第6章至第8章围绕数据库支持展开，包括Spring JdbcTemplate（第6章）、Hibernate集成（第7章）以及使用Java Persistence API (JPA) 2进行数据访问（第8章），展示了如何利用Spring进行数据操作。第9章"Transaction Management"详细阐述了Spring如何管理和协调跨多个服务的事务，确保数据一致性。第10章关注验证、类型转换和格式化，这些功能在用户输入处理和数据校验中至关重要。第11章"Task Scheduling in Spring"探讨了如何使用Spring进行任务调度，提高系统的自动化水平。第12章"Using Spring Remoting"介绍远程过程调用（RPC）在Spring中的应用，让开发者能够构建分布式系统。第13章"Spring Testing"涉及单元测试和集成测试，提供了Spring测试框架的使用方法，保证代码质量。第14章"Scripting Support in Spring"展示了如何利用Spring与脚本语言（如Groovy或JavaScript）结合，增强应用灵活性。第15章"Spring Application Monitoring"讲解了如何使用Spring进行应用程序监控，帮助诊断和优化性能。第16章和第17章进一步深化到Web应用程序和WebSocket技术，Spring在前后端分离和实时通信方面的应用。最后一章"Spring"可能是本书的一个总结或者对未来版本Spring框架的概述，或者包含了一些前沿的最佳实践和展望。这本书不仅适合初学者系统学习Spring，也适合经验丰富的开发者查阅和更新他们的Spring知识库。无论你是希望通过Spring构建高效的企业级应用，还是希望深入了解其最新的功能，这本书都将是你不可或缺的参考资料。

CHAPTER 1 ■ INTRODUCING SPRING

Remoting Support

Accessing or exposing remote components in Java has never been the simplest of jobs. Using Spring, you can take

advantage of extensive support for a wide range of remoting techniques to quickly expose and access remote services.

Spring provides support for a variety of remote access mechanisms, including Java Remote Method Invocation

(RMI), JAX-WS, Caucho Hessian and Burlap, JMS, Advanced Message Queuing Protocol (AMQP), and REST. In

addition to these remoting protocols, Spring also provides its own HTTP-based invoker that is based on standard Java

serialization. By applying Spring’s dynamic proxying capabilities, you can have a proxy to a remote resource injected

as a dependency into one of your classes, thus removing the need to couple your application to a specific remoting

implementation and also reducing the amount of code you need to write for your application. We discuss remote

support in Spring in Chapter 12.

Mail Support

Sending e-mail is a typical requirement for many kinds of applications and is given first-class treatment within the

Spring Framework. Spring provides a simplified API for sending e-mail messages that fits nicely with the Spring DI

capabilities. Spring supports the standard JavaMail API.

Spring provides the ability to create a prototype message in the DI container and uses this as the base for all

messages sent from your application. This allows for easy customization of mail parameters such as the subject and

sender address. In addition, for customizing the message body, Spring integrates with template engines, such as

Apache Velocity, which allow the mail content to be externalized from the Java code.

Job Scheduling Support

Most nontrivial applications require some kind of scheduling capability. Whether this is for sending updates to

customers or performing housekeeping tasks, the ability to schedule code to run at a predefined time is an invaluable

tool for developers.

Spring provides scheduling support that can fulfill most common scenarios. A task can be scheduled either for a

fixed interval or by using a Unix cron expression.

On the other hand, for task execution and scheduling, Spring integrates with other scheduling libraries as well.

For example, in the application server environment, Spring can delegate execution to the CommonJ library that is

used by many application servers. For job scheduling, Spring also supports libraries including the JDK Timer API and

Quartz, a commonly used open source scheduling library.

The scheduling support in Spring is covered in full in Chapter 11.

Dynamic Scripting Support

Starting with JDK 6, Java introduced dynamic language support, in which you can execute scripts written in other

languages in a JVM environment. Examples include Groovy, JRuby, and JavaScript.

Spring also supports the execution of dynamic scripts in a Spring-powered application, or you can define a

Spring bean that was written in a dynamic scripting language and injected into other JavaBeans. Spring-supported

dynamic scripting languages include Groovy, JRuby, and BeanShell. In Chapter 14, we discuss the support of dynamic

scripting in Spring in detail.

Simplified Exception Handling

One area where Spring really helps reduce the amount of repetitive, boilerplate code you need to write is in exception

handling. The core of the Spring philosophy in this respect is that checked exceptions are overused in Java and that a

framework should not force you to catch any exception from which you are unlikely to be able to recover—a point of

view that we agree with wholeheartedly.

CHAPTER 1 ■ INTRODUCING SPRING

In reality, many frameworks are designed to reduce the impact of having to write code to handle checked

exceptions. However, many of these frameworks take the approach of sticking with checked exceptions but artificially

reducing the granularity of the exception class hierarchy. One thing you will notice with Spring is that because of

the convenience afforded to the developer from using unchecked exceptions, the exception hierarchy is remarkably

granular.

Throughout the book, you will see examples in which the Spring exception-handling mechanisms can reduce the

amount of code you have to write and, at the same time, improve your ability to identify, classify, and diagnose errors

within your application.

The Spring Project

One of the most endearing things about the Spring project is the level of activity present in the community and the

amount of cross-pollination between Spring and other projects such as CGLIB, Apache Geronimo, and AspectJ. One

of the most touted benefits of open source is that if the project folded tomorrow, you would be left with the code; but

let’s face it—you do not want to be left with a code base the size of Spring to support and improve. For this reason, it is

comforting to know how well established and active the Spring community is.

Origins of Spring

As noted earlier in this chapter, the origins of Spring can be traced back to Expert One-to-One: J2EE Design and

Development. In this book, Rod Johnson presented his own framework, called the Interface 21 Framework, which he

developed to use in his own applications. Released into the open source world, this framework formed the foundation

of the Spring Framework as we know it today.

Spring proceeded quickly through the early beta and release candidate stages, and the first official 1.0 release was

made available March 24, 2004. Since then, Spring has undergone dramatic growth, and at the time of this writing, the

latest major version of Spring Framework is 4.0.

The Spring Community

The Spring community is one of the best in any open source project we have encountered. The mailing lists and

forums are always active, and progress on new features is usually rapid. The development team is truly dedicated to

making Spring the most successful of all the Java application frameworks, and this shows in the quality of the code

that is reproduced.

As we mentioned already, Spring also benefits from excellent relationships with other open source projects, a fact

that is extremely beneficial when you consider the large amount of dependency the full Spring distribution has.

From a user’s perspective, perhaps one of the best features of Spring is the excellent documentation and test suite

that accompany the distribution. Documentation is provided for almost all the features of Spring, making it easy for

new users to pick up the framework. The test suite Spring provides is impressively comprehensive—the development

team writes tests for everything. If they discover a bug, they fix that bug by first writing a test that highlights the bug

and then getting the test to pass.

Fixing bugs and creating new features is not limited just to the development team! You can contribute

code through pull requests against any portfolio of Spring projects through the official GitHub repositories

(http://github.com/spring-projects). Additionally, issues can be created and tracked by way of the official Spring

JIRA (https://jira.springsource.org/secure/Dashboard.jspa).

What does all this mean to you? Well, put simply, it means you can be confident in the quality of the Spring

Framework and confident that, for the foreseeable future, the Spring development team will continue to improve what

is already an excellent framework.

CHAPTER 1 ■ INTRODUCING SPRING

The Spring Tool Suite

To ease the development of Spring-based applications in Eclipse, Spring created the Spring IDE project. Soon after

that, SpringSource, the company behind Spring founded by Rod Johnson, created an integrated tool called the Spring

Tool Suite (STS), which can be downloaded from www.spring.io/tools. Although it used to be a paid-for product,

the tool is now freely available. The tool integrates the Eclipse IDE, Spring IDE, Mylyn (a task-based development

environment in Eclipse), Maven for Eclipse, AspectJ Development Tools, and many other useful Eclipse plug-ins into

a single package. In each new version, more features are being added, such as Groovy scripting language support,

a graphical Spring configuration editor, visual development tools for projects such as Spring Batch and Spring

Integration, and support for the Pivotal tc Server application server.

Note ■ SpringSource was bought by VMWare and incorporated into Pivotal Software, Inc.

In addition to the Java-based suite, a Groovy/Grails Tool Suite is available with similar capabilities but targeted at

Groovy and Grails development (www.spring.io/tools).

The Spring Security Project

The Spring Security project (http://projects.spring.io/spring-security), formerly known as the Acegi Security

System for Spring, is another important project within the Spring portfolio. Spring Security provides comprehensive

support for both web application and method-level security. It tightly integrates with the Spring Framework and other

commonly used authentication mechanisms, such as HTTP basic authentication, form-based login, X.509 certificate,

and single sign-on (SSO) products (for example, CA SiteMinder). It provides role-based access control to application

resources, and in applications with more-complicated security requirements (for example, data segregations), use of

an access control list (ACL) is supported. However, Spring Security is mostly used in securing web applications, which

we discuss in detail in Chapter 16.

Spring Batch and Integration

Needless to say, batch job execution and integration are common use cases in applications. To cope with this need

and to make it easy for developers in these areas, Spring created the Spring Batch and Spring Integration projects.

Spring Batch provides a common framework and various policies for batch job implementation, reducing a lot of

boilerplate code. By implementing the Enterprise Integration Patterns (EIP), Spring Integration can make integrating

Spring applications with external systems easy. We discuss the details in Chapter 20.

Many Other Projects

We’ve covered the core modules of Spring and some of the major projects within the Spring portfolio, but there are

many other projects that have been driven by the need of the community for different requirements. Some examples

include Spring Boot, Spring XD, Spring for Android, Spring Mobile, Spring Social, and Spring AMQP. Some of these

projects are discussed further in Chapter 20. For additional details, you can refer to the Spring by Pivotal web site

(www.spring.io/projects).

CHAPTER 1 ■ INTRODUCING SPRING

Alternatives to Spring

Going back to our previous comments on the number of open source projects, you should not be surprised to

learn that Spring is not the only framework offering Dependency Injection features or full end-to-end solutions for

building applications. In fact, there are almost too many projects to mention. In the spirit of being open, we include

a brief discussion of several of these frameworks here, but it is our belief that none of these platforms offers quite as

comprehensive a solution as that available in Spring.

JBoss Seam Framework

Founded by Gavin King (the creator of the Hibernate ORM library), the Seam Framework (www.seamframework.org)

is another full-blown DI-based framework. It supports web application front-end development (JSF), business logic

layer (EJB 3), and JPA for persistence. As you can see, the main difference between Seam and Spring is that the Seam

Framework is built entirely on JEE standards. JBoss also contributes the ideas in the Seam Framework back to the JCP

and has become JSR-299, “Contexts and Dependency Injection for the Java EE Platform” (CDI).

Google Guice

Another popular DI framework is Google Guice (http://code.google.com/p/google-guice). Led by the search

engine giant Google, Guice is a lightweight framework that focuses on providing DI for application configuration

management. It was also the reference implementation of JSR-330, “Dependency Injection for Java”.

PicoContainer

PicoContainer (http://picocontainer.com) is an exceptionally small DI container that allows you to use DI for your

application without introducing any dependencies other than PicoContainer. Because PicoContainer is nothing more

than a DI container, you may find that as your application grows, you need to introduce another framework, such as

Spring, in which case you would have been better off using Spring from the start. However, if all you need is a tiny DI

container, then PicoContainer is a good choice, but since Spring packages the DI container separately from the rest of

the framework, you can just as easily use that and keep the flexibility for the future.

JEE 7 Container

As discussed previously, the concept of DI was widely adopted and also realized by JCP. When you are developing

an application for application servers compliant with JEE 7 (JSR-342) , you can use standard DI techniques across all

layers.

Summary

In this chapter, we gave you a high-level view of the Spring Framework, complete with discussions of all the major

features, and we guided you to the relevant sections of the book where these features are discussed in detail. After

reading this chapter, you should understand what Spring can do for you; all that remains is to see how it can do it.

In the next chapter, we discuss all the information you need to know to get up and running with a basic Spring

application. We show you how to obtain the Spring Framework and discuss the packaging options, the test suite, and

the documentation. Also, Chapter 2 introduces some basic Spring code, including the time-honored “Hello World!”

example in all its DI-based glory.

Chapter 2

Getting Started

Often the hardest part of coming to grips with any new development tool is figuring out where to begin. Typically,

this problem is worse when the tool offers as many choices as Spring. Fortunately, getting started with Spring isn’t that

hard if you know where to look first. In this chapter, we present you with all the basic knowledge you need to get off to

a flying start. Specifically, you will look at the following:

• Obtaining Spring: The first logical step is to obtain or build the Spring JAR files. If you want to

get up and running quickly, simply use the dependency management snippets in your build

system with the provided examples located at http://projects.spring.io/spring-framework.

However, if you want to be on the cutting edge of Spring development, check out the latest

version of the source code from Spring’s GitHub repository

(http://github.com/spring-projects/spring-framework).

• Spring packaging options: Spring packaging is modular; it allows you to pick and choose which

components you want to use in your application and to include only those components when

you are distributing your application. Spring has many modules, but you need only a subset of

these modules depending on your application’s needs. Each module has its compiled binary

code in a JAR file along with corresponding Javadoc and source JARs.

• Spring guides: The new Spring web site includes a Guides section located at

www.spring.io/guides. The guides are meant to be quick, hands-on instructions for building

the “Hello World” of any development task with Spring. These guides also reflect the latest

Spring project releases and techniques, providing you with the most up-to-date samples

available.

• Test suite and documentation: One of the things members of the Spring community are most

proud of is their comprehensive test suite and documentation set. Testing is a big part of

what the team does. The documentation set provided with the standard distribution is also

excellent.

• Putting a spring into “Hello World” All bad punning aside, we think the best way to get started

with any new programming tool is to dive right in and write some code. We present a simple

example, which is a full DI-based implementation of everyone’s favorite, “Hello World!”

Don’t be alarmed if you don’t understand all the code right away; full discussions follow later

in the book.

If you are already familiar with the basics of the Spring Framework, feel free to proceed straight to Chapter 3 to

dive into IoC and DI in Spring. However, even if you are familiar with the basics of Spring, you may find some of the

discussions in this chapter interesting, especially those on packaging and dependencies.

剩余712页未读，继续阅读

daisuo2599

粉丝: 4
资源: 115

Spring 4实战指南：从入门到高级应用

Apress.Pro.CSharp.2010.and.the.dotNET.4.Platform.5th.Edition.May.2010

Apress.Pro.JSP.2.4th.Edition.Dec.2005.pdf

Apress.Pro.JPA.2.2nd.Edition.Oct.2013

关于springboot的英文文献

列举几个SpringBoot相关的技术文献,以文献引用的格式展示

spring boot项目英文文献

springboot的参考文献

springboot框架外文参考文献列表

springboot参考文献

springboot外文文献

最新资源