使用Spring, Hibernate和Eclipse进行敏捷Java开发

需积分: 10 97 浏览量更新于2024-07-26 3 收藏 25.75MB PDF 举报

"Agile Java Development with Spring, Hibernate and Eclipse" 是一本由 Anil Hemrajani 撰写的书籍，出版于2006年5月，由 Sams 出版社出版，ISBN-10 为 0-672-32896-8，ISBN-13 为 978-0-672-32896-1，共360页。本书主要探讨了如何通过使用Spring、Hibernate和Eclipse等技术，以敏捷的方式进行企业级Java开发。在本书中，作者深入讨论了Spring框架、Hibernate持久化框架以及Eclipse集成开发环境（IDE）这三大关键技术，它们显著降低了企业Java开发的复杂性。Spring框架提供了一种模块化和依赖注入的方式来管理应用程序的组件，简化了代码的编写和维护。Hibernate作为流行的ORM（对象关系映射）工具，使得Java对象可以直接与数据库交互，避免了传统的EJB容器带来的繁重性。 Eclipse作为一个强大的开源IDE，为开发者提供了丰富的功能，包括代码编辑、调试、构建工具等，极大地提升了开发效率。此外，书中还涵盖了Ant构建工具、JUnit测试框架、JSP标签库，以及日志记录、基于GUI的调试、使用JMX进行监控、计划任务调度、电子邮件发送等辅助开发的技术。除了技术层面的讲解，本书还涉及了敏捷开发方法，如极限编程（XP）和敏捷模型驱动开发（AMDD）。这些方法论强调快速迭代、持续集成和用户反馈，有助于缩短软件开发周期，提高产品质量。同时，书中也介绍了重构这一关键实践，旨在通过改进代码结构来提升软件的可维护性和可读性。 "Agile Java Development with Spring, Hibernate and Eclipse" 是一本全面介绍如何利用敏捷方法和技术进行高效Java开发的指南，适合希望提升开发效率和代码质量的Java开发者阅读。

Who This Book Is For

This book assumes that you have some working knowledge of Java and relational databases (including SQL) as well as experience

working on the command line. Aside from prerequisites mentioned here, the following types of people can use it:

Software Developers/Architects Developers and architects can gain value from this book because it includes a high-level

software development process, application design, and an in-depth and complete inspection of the Java and related files of a

fully functional, sample enterprise web application.

Technical Leads/Managers Technical leads and managers with a programming background, preferably in Java or similar

language, can get an in-depth look at how applications are built using a variety of Java technologies. This knowledge might

help during project planning or with staff troubleshooting technical problems (perhaps just for moral support during frustrating

times). Alternatively, technical managers can dive into a specific chapter (for example, Chapter 5 , "Using Hibernate for

Persistent Objects") to understand how that specific technology works and fits into the big picture.

In addition, as a reader, you might gain some insight from this book on alternatives to JEE that you can use for building a robust

enterprise-class application. Furthermore, if you are not familiar with Agile Modeling or Extreme Programming or are looking for a nimble

software development process, this book might have just enough to get you going with a complete process for developing software

applications iteratively and incrementally.

Goals of This Book

The goals of this book are as follows:

Agile development The first and foremost goal of this book is to show you how to do rapid enterprise Java development. This

is achieved by combining multiple facets: a nimble/minimal software development process, a simple design (moderate use of

design patterns or layers of abstraction), convenience technologies (such as Spring and Hibernate), working with POJOs

versus remote objects, and in general, leveraging stable open source technologies whenever possible. In short, the idea is to

make Java simpler and faster to work with for developing enterprise-ready applications.

Complete solution A close second goal of this book is to provide you with a complete solution, from a technical and process

perspective. After reading this book, you should be able to build an entire application, not just technically, but also using the

process outlined in this book. In addition, when I cannot cover a given technology in depth, I provide references to resources

(websites) for further investigation of the technology. The cool thing about the technologies covered in this book is that you

can have a complete system, from the user interface to an embedded database along with the capability to schedule jobs

(thanks to the Spring Framework), all self-contained in a single web application archive (.war) file! However, you can always

replace the technologies mentioned in here with some other technology of your choice (for example, using an Oracle

database instead of HSQLDB). In summary, you will have the complete solution to do thisprocess and technologies!

Using an open source only solution is not a goal of this book Although I have based this book entirely on open source

frameworks, tools, and products, preaching an open source only solution isn't a goal of this book. For instance, you can

leverage Java's vendor portability and replace one of the products covered in here with a commercial product. However, open

source has come a very long way, and I'm thoroughly impressed by how robust these technologies are and how well

documented they are. For example, technologies such as the Eclipse SDK and Hibernate are arguably better than some of

their commercial counterparts. You could just as well use all the technologies mention in this book for an enterprise solution

and rest assured that they will perform as advertised. In fact, I recently implemented an enterprise solution for a large

company using the Spring Framework, Hibernate, Eclipse, JUnit, Ant, and other tools mentioned in this book! However, we

also used commercial products such as BEA's WebLogic Server and an Oracle database server. The same company (and

several others I know of) are basing their enterprise solutions on the open source technologies I mentioned.

Quick read This book is intentionally smaller than the typical 600+ page books you find on Java. This was done to enable you

to get through the book quickly and begin using the solutions in the real world. In light of this, I have tried to keep the content

in this book streamlined and more to the point. The one downside of not writing an extremely thick book is that I had to make

some tough decisions about which material to forego; however, I have tried hard to include all the important process- and

This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks .

technology-related material you will need for agile Java development (as explained in the previous goal of providing a

complete solution).

Simplicity Whenever possible, I take the simpler approach to accomplishing the same objective over a complex solution. For

example, the sample application covered in this book uses minimal layers of abstraction to accomplish our objective. By

layers of abstraction, I am referring to the excessive use of design patterns, interfaces, and application partitioning. Each of

these makes enormous sense, but using everything in moderation is a good practice and one I like to follow when I am

working with a software development process and artifacts produced from such a process. Furthermore, I believe simplicity

should also extend to designing, in that I tend to use UML when appropriate, but lean toward simpler, free-form diagrams

using tools such as OpenOffice.org, PowerPoint, or Visio versus something heavy like Rational Rose.

Tips and tricks As you might already know, when working with tools and technologies, tips and tricks not only make the

product work more effectively for you, but also make it more fun to use. I provide tips and tricks for some of the technologies

covered in this book. However, the appendixes also contain some goodies such as useful cheat sheets and a list of cool

tools.

Alternatives Throughout this book (although not in detail), I try to provide alternatives to the solution I am proposing. I realize

that one solution does not fit everyone's need. For example, you might be using Sun Microsystems's NetBeans or JetBrains's

IntelliJ as your IDE and do not want to switch to Eclipse. This type of scenario is to be expected and is completely

understandable. The organization of this book takes this into consideration; you should still be able to gain value from the

remainder of the book and replace a technology covered in this book with the technology of your choice (for example, JDO

versus Hibernate).

What Is Not Covered

This book assumes that you have working knowledge of Java and a relatively good understanding of JEE. It also largely assumes that

you have a reasonable understanding of software development processes, relational databases, n-tier architectures, and so on. Given

this assumption, I delve right into the specifics required to build our sample application. Furthermore, I refer you to the respective

websites for setup (and advance features) instructions instead of duplicating this information in this book and risk having it become

out-of-date.

On the flip side, this book assumes that you have no working knowledge of the key technologies covered here, such as the Spring

Framework, Hibernate, Eclipse, and so on. Given this view, this book provides the basics on these technologies to get them to work

together; this book also goes one step further to provide you with a brief introduction to some of the advanced features offered by these

technologies. Anything beyond what is mentioned here is beyond the scope of this book because there are literally entire books

dedicated to many of the technologies mentioned in this book.

What Is Covered (Technologies and Process)

The focus of this book is more on development and less on infrastructure. In other words, I've focused more on the application

development technologies such as Spring, Hibernate, and Eclipse than on products such as an application server (for example, JBoss)

or database (for example, MySQL). When in doubt, I went with the one easiest to set up. Also, I'm a big believer in getting the

functionality implemented in an application first and then optimizing later in the form of refactoring and optimization techniques. What I

have presented in this book has been tried in real-world applications that are running successfully in production (some in a clustered

application server environment), so I don't want to give you the impression that we are ignoring infrastructure altogether. One of the

goals of this book was to keep it short and to the point, so I have chosen to focus almost entirely on a well-designed application that

scales well.

Given the operating system (OS) and vendor portability benefits of Java, in theory, when your application is ready to be deployed, you

can deploy it to a more robust web application server and database combination. For instance, you could use the low-end products used

in this book (Apache's Tomcat and HSQLDB), upgrade to a JBoss Application Server and a MySQL database combination, or further

upgrade to a BEA WebLogic Server and Oracle's database server combination, for example. This is the beauty of Java; it is not only OS

portable, but also vendor portable.

This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks .

One more note about the core technologies covered in this booknamely, Spring, Hibernate, and Eclipse. Although these are the

technologies I've worked with recently and use in this book, I have provided alternative and competitive technologies in the industry,

which I encourage you to look at. For example, if you choose to use JDO rather than Hibernate, you can still gain and apply the

knowledge from all chapters, except perhaps the one on Hibernate.

How This Book Is Organized

The chapters in this book are organized so that each chapter builds on the previous one. Furthermore, because the chapters are logically

segregated, you could jump into a chapter directly (for example, Chapter 6 , "Overview of the Spring Framework") and learn about just

that chapter's content. Also, you might want to skip a chapter if you are not interested in using that technology (for example, you might

want to use NetBeans instead of Eclipse; therefore, you would skip Chapter 8 , "The Eclipse Phenomenon!").

Chapter 1 , "Introduction to Agile Java Development," gives you an overview and a preview of the technologies and process we will use in

this book. Chapter 2 , "The Sample Application: An Online Timesheet System," is primarily dedicated to defining the business

requirements for our sample application; however, it also provides a nice overview of AMDD and XP methodologies. Chapter 3 , "XP and

AMDD-Based Architecture and Design Modeling," covers the design of our sample application. Chapter 4 , "Environment Setup: JDK,

Ant, and JUnit," covers the environment setup. From here, we enter the world of Java coding at a rapid pace, when we look at

programming with Hibernate in Chapter 5 . Chapters 6 and 7 are dedicated to the Spring Framework. Chapter 7 , "The Spring Web MVC

Framework," and Chapter 8 are what I call the "wow!" chapters, because everything converges in these chapters and you will see and

appreciate why we went through the earlier chapters in the way we did. You will know what happens underneath the covers and hence

have a solid foundation of the technologies such as Spring, Hibernate, Ant, and JUnit. From there, we will cover some advanced

concepts and wrap up the book with some goodies in the appendixes.

One other note is in regard to command-line development versus GUI (for example, using the Eclipse SDK). The earlier chapters

intentionally use the command line so that you can get some fundamental understanding of how these Java tools work. Then, when you

use these tools (for example, Ant and JUnit) in an IDE such as Eclipse, you will know exactly what is going on behind the scenes. This

becomes particularly important if the IDE does not meet your needs.

About the Code For This Book

This book is about Java coding and there is a lot of code related to the sample application we will build in this book. This completely

functional sample application with all the source code and related files can be downloaded from the publisher's website. Having the code

in electronic form versus printed in the book enables you to browse and test-drive the code/application for yourself.

The code itself is referenced and explained throughout the book using notable snippets/excerpts from the complete code. Furthermore,

there are two conventions used for this code:

In certain places, long single line of code (that is, more than 82 characters) have been split into two lines for readability in this

book

The code itself appears in monospace font.

Note

All the book's code is available for download at the publisher's website. For convenient access to this book's example

files and source code, as well as any possible updates or corrections, be sure to register your book at

www.samspublishing.com/register .

This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks .

About The Figures For This Book

A picture truly says a thousand words, so you will find many diagrams and screenshots in this book. While I have provided some UML

diagrams in this book, I tend to lean towards quick free-form diagrams and instead generate UML diagrams by reverse engineering an

application. I don't spend a lot of time on formal diagrams because many of these are throw-away diagrams after they have served their

purpose and most projects aren't able to keep these diagrams up-to-date anyways. I'm a big believer that the code and database are the

final and most important artifacts.

In summary, I believe diagrams should do the following:

Be developed only when they will be effective.

Be self-explanatory (for example, use words versus confusing notations, use legends).

Be simple, to the point, and really get across the intended message.

Conform to a standard notation (for example, UML) either if required by your organization, for a handover of a system to

another person or group, for code generation, or because you prefer to use a standard notation

One additional note about the figures in this book. In a few chapters, I have repeated/reused figures from previous chapters. This was

done for the following reasons:

To set context for the chapter or section that is about to be discussed

I did not want to inconvenience you by requiring you to flip back to a previous chapter where the figure was first introduced.

Personal Opinion Sidebars

Throughout this book, you will notice sidebars labeled "Personal Opinion," which is exactly what the content in these sidebar is. I have

tried hard to separate this subjective material from the objective material in the book. However, I hope you will find the viewpoints

expressed in these sections useful, as they are little nuggets of my experience from various perspectives: as a software engineer,

consultant, trainer, author, community builder, and even CEO of an IT services company.

XP and AMDD-Based Comics

You will see an illustration at the top of each chapter that makes up a fictional story throughout the book about an eight-week project

using AMDD. The four main characters in this story, also fictional, include a customer (Susan), a Project Manager (Ron), and two

programmers (Steve and Raj). The idea behind these illustrations is simple: to add a bit of humor to this book while teaching you about

AMDD and XP along the way. Also, the relaxed style of these illustrations is based on my interest in writing books for children (early

readers). I must warn you, these get a bit corny, but I hope you will find some humor and knowledge in them.

If you like the style of these illustrations and want to see more of these, please visit visualpatterns.com .

This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks .

剩余488页未读，继续阅读

arispendragon

粉丝: 17
资源: 8

使用Spring, Hibernate和Eclipse进行敏捷Java开发

Agile Java

Agile Java Development with Spring, Hibernate and Eclipse-code

Agile Java Development with Spring Hibernate and Eclipse part2

agile java

What are the most significant differences among structured, object-oriented, and agile methods? What do they have in common?

springboot毕设外文翻译

Test-Driven Development

历年北京联合大学软件工程英语口语复试题目

推荐的代码规范学习资料

最新资源