Spring AOP实战：构建企业级应用的利器

需积分: 10 19 浏览量更新于2024-07-25 1 收藏 6.8MB PDF 举报

"《Spring AOP实战指南》是一本专注于Java应用程序开发的实用书籍，它结合了Spring框架与面向切面编程(AOP)的强大威力。随着企业级应用对功能丰富、健壮性的需求提升，Spring AOP成为了一种高效且简洁的解决方案。作者Massimiliano Dessì通过本书，引导读者掌握Spring 2.5版本的AOP特性，以及如何利用其核心组件——通知(Advice)、连接点(Pointcut)、切点(Joinpoint)和顾问(Advisor)来构建实际的、基于AOP的应用。书中首先介绍Spring AOP的基础概念，强调其在动态创建复杂企业应用中的作用。随后，详细讲解如何配置和使用Spring AOP的核心类，并配以丰富的示例以便于理解。接着，读者将深入学习Spring对AspectJ的支持，这是一种强大的AOP语言，能够扩展Spring框架的功能。作者还将带领读者通过实践，开发一个采用领域驱动设计(DDD)的三层架构Web应用，同时应用测试驱动开发(TDD)方法论，充分展示AOP在安全、并发控制、缓存和事务管理等领域的潜力。通过这本书，无论是初学者还是经验丰富的开发者都能系统地掌握如何在Spring环境中有效利用AOP技术，从而编写出易于维护、功能强大的代码，提高开发效率和项目质量。版权方面，此材料受Richard Ostheimer在2009年6月6日授权使用，所有内容未经Pacakt Publishing书面许可，不得复制、存储或任何形式传播，除非用于批评性文章或评论。尽管作者和出版社努力确保信息的准确性，但书中的信息不保证无误，也不承担由此产生的任何损失或责任。此外，Pacakt Publishing在书中提供了关于提及公司和产品的商标信息，以尊重知识产权。"

Preface

In software engineering, mostly low-level languages were used for many years,

which were closer to the computer machine code than to human language. In the

70s, Brian Kernighan and Dennis Ritchie created the language C. It was quite similar

to human language, making it easier and faster to write code, while keeping a

high level of abstraction. This allowed the realization of concepts and ideas, which

was not possible for the previous languages as they were forced to focus on the

processor's language. Later, Smalltalk and C++ permitted the shaping of concepts

and ideas through objects‚ providing a new way to structure applications and write

programs. With the object-oriented languages, any system could be created with

increasing complexity in a more manageable way, thanks to the modeling of

entities in the form of types and the collaboration between them. In some cases,

object-oriented programming introduces or causes inefciencies, and aspect-oriented

programming helps in lling these gaps. The aim of Aspect-Oriented Programming

(AOP) is not to replace Object-Oriented Programming (OOP), but to complement it,

allowing you to create clearer and better structured programs. Gregor Kiczales, one

of the founders of AOP, said (an extract from http://www.cs.ubc.ca/~gregor/

papers/kiczales-ECOOP1997-AOP.pdf) "We have found many programming

problems for which neither procedural nor object-oriented programming techniques

are sufcient to clearly capture some of the important design decisions the program

must implement. This forces the implementation of those design decisions to be

scattered throughout the code, resulting in tangled code that is excessively difcult

to develop and maintain." Neither aspect-oriented programming nor object-oriented

programming can make up for a bad design: The rst assumption is that a software

system is well-designed. There is no solution for a badly designed system, and also

none for a badly implemented system. There is only one good strategy: to change

it. The difference between a good and a bad design is the capacity to evolve and

adapt to new requirements without being twisted. Object-oriented programming,

supported by aspect-oriented programming, helps designers and developers

in this direction.

This material is copyright and is licensed for the sole use by Richard Ostheimer on 6th June 2009

2205 hilda ave., , missoula, , 59801

Preface

[ 2 ]

What this book covers

Chapter 1 introduces the ideas that led to Aspect-Oriented Programming. An

overview of main concepts of AOP is used to describe components and features

provided by Spring AOP, while a set of concise yet

clear examples lets the reader discover what can actually be done with AOP.

Chapter 2 describes in detail the fundamentals of AOP in Spring, presenting

interfaces and classes introduced in early 1.x versions of the framework. This

chapter shows how to use AOP programmatically, to let the reader discover the

basis of Spring AOP and the components that implement Aspect-Oriented

Programming in Spring.

Chapter 3 explains how the weaving of AOP components is done using the proxy

pattern and �DK or CGLIB implementations. It describes the purpose of proxies

and how to use them effectively. Some practical examples show how to use the

proxies programmatically, with annotations and with XML; they explain the

ProxyFactoryBean and how to make the programmer's work easier with AutoProxy.

The chapter describes also some smart techniques on target sources.

Chapter 4 explains how Spring AOP is supported by AspectJ. Conguration activity

is made simpler, more exible and more powerful, thanks to annotations and

the syntax of Aspect� on pointcuts (without which those costructs would not be

available). All examples show how to use Aspect� with both annotations and XML.

The chapter contains practical recipes for specic cases, such as the injection of

dependencies on domain objects, the management of aspects' priority, the use of

different life cycles for Aspects and how to use Load Time Weaving. The chapter

ends with some strategies on how to choose different AOP approaches to full

specic requirements.

Chapter 5 describes the design alternatives that can be implemented using AOP.

These alternatives are solutions for common requirements: concurrency, caching,

and security. Using AOP, they can be achieved in a very elegant and easy way,

being at the same time totally transparent for the system where they are applied.

Chapter 6 introduces Domain-Driven Development as a alternative way to

design applications. The prototype example presented in this chapter is a typical

Three-Layer application, where DDD is used for design and AOP is used to inject

the dependencies on domain objects. iBatis is used for persistence to the database.

This material is copyright and is licensed for the sole use by Richard Ostheimer on 6th June 2009

2205 hilda ave., , missoula, , 59801

Preface

[ 3 ]

Chapter 7 completes the prototype application started in Chapter 6, showing the

application layer and the user interface. The latter is implemented with Spring

MVC using annotations. Integration and unit tests are used to verify the correctness

of the classes; DBUnit is used to test persistence classes, while some Mock classes

are used to test the UI. The chapter contains the congurations for the prototype

infrastructure, including autentication and authorization with Spring Security and

the �Unit 4.5 test suite.

Chapter 8 describes the development tools needed to include Spring AOP and

AspectJ in the Eclipse IDE. The reader can nd here detailed istructions on how to

congure Eclipse with the plug-ins for Spring and for the AspectJ Development Tool,

and how to install the PostgreSQL database and the Apache Tomcat servlet engine.

All installation procedures are described for the three main operating systems:

Ubuntu Linux, Apple Mac OS X, and Microsoft Windows XP.

What you need for this book

The book requires a basic knowledge of Spring and it's conguration. It needs

software like �ava Development Kit (�DK) 1.5 or higher, Spring 2.5.6 (at the time

of writing on this book), Eclipse (3.4.1 or higher version), Eclipse plug-ins, Tomcat

Apache (Tomcat 6.x), and PostgreSQL (version 8.3).

Who this book is for

This book is written for software architects, engineers, and developers that want

be able to write applications in a more modular and concise way, without learning

Aspect� or using languages other than �ava and frameworks other than Spring.

Conventions

In this book, you will nd a number of styles of text that distinguish between

different kinds of information. Here are some examples of these styles, and an

explanation of their meaning.

Code words in text are shown as follows: "We can include other contexts through

the use of the include directive."

This material is copyright and is licensed for the sole use by Richard Ostheimer on 6th June 2009

2205 hilda ave., , missoula, , 59801

剩余331页未读，继续阅读

devprox

粉丝: 0
资源: 3

Spring AOP实战：构建企业级应用的利器

spring aop jar 包

Spring AOP 16道面试题及答案.docx

简单spring aop 例子

spring aop面试题

spring aop aopalliance

spring aop常见问题

springaop面试题

spring aop 源码分析

spring aop的重点面试题

Spring AOP实现原理

最新资源