Java设计模式实战指南：构建企业级应用的基石

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

"《实用Java设计模式》是一本由Stephen Stelting和Olav Maassen合著的专业书籍，于2001年12月首次出版，由Prentice Hall PTR出版社发行，ISBN号为0-13-093538-7，共计598页。本书针对软件开发的全生命周期，提供了30个设计模式实例，其中包括了用于Sun Certified Enterprise Architect考试的核心23种模式。这些模式旨在帮助开发者创建出更加健壮、可扩展、可靠且易于维护的Java应用程序。在内容上，作者首先对设计模式的基本概念进行了简短回顾，强调了它们在Java平台上的应用价值。接着，书中详尽地展示了如何有效地将模式应用于各种商业系统，无论是系统架构的设计，还是单个类的实现，都提供了实用的方法和技术。整个模式库被组织成四大主要类别：创建（Creational）、结构（Structural）、行为（Behavioral）和并发（Concurrent），以便读者能够根据具体需求选择合适的模式。书中不仅理论与实践并重，而且通过实际案例深入浅出地展示了模式的使用过程，使读者能够理解和掌握如何在实际项目中运用设计模式解决问题。这是一本极具实用性的指南，对于Java开发者来说，无论是初学者还是经验丰富的专业人士，都能从中获益匪浅，提升软件开发的质量和效率。阅读这本书，开发者不仅能了解到设计模式的基本原理，还能学习到如何灵活运用这些模式，以应对不断变化的业务需求和技术挑战，从而推动项目的成功实施和长远发展。《实用Java设计模式》是一本值得所有Java开发者珍藏的参考书，是提高编程技能和项目管理能力的重要资源。"

9. }

Example 1.5 USAddress.java

1. public class USAddress extends Address{

2. private static final String COUNTRY = "UNITED STATES";

3. private static final String COMMA = ",";

5. public String getCountry(){ return COUNTRY; }

7. public String getFullAddress(){

8. return getStreet() + EOL_STRING +

9. getCity() + COMMA + SPACE + getRegion() +

10. SPACE + getPostalCode() + EOL_STRING +

11. COUNTRY + EOL_STRING;

12. }

13. }

Example 1.6 USPhoneNumber.java

1. public class USPhoneNumber extends PhoneNumber{

2. private static final String COUNTRY_CODE = "01";

3. private static final int NUMBER_LENGTH = 10;

5. public String getCountryCode(){ return COUNTRY_CODE; }

7. public void setPhoneNumber(String newNumber){

8. if (newNumber.length() == NUMBER_LENGTH){

9. super.setPhoneNumber(newNumber);

10. }

11. }

12. }

The generic framework from AddressFactory, Address, and PhoneNumber makes it easy to extend the system to

support additional countries. With each additional country, define an additional Concrete Factory class and a

matching Concrete Product class. These are files for French address information.

Example 1.7 FrenchAddressFactory.java

1. public class FrenchAddressFactory implements AddressFactory{

2. public Address createAddress(){

3. return new FrenchAddress();

4. }

6. public PhoneNumber createPhoneNumber(){

7. return new FrenchPhoneNumber();

8. }

9. }

Example 1.8 FrenchAddress.java

1. public class FrenchAddress extends Address{

2. private static final String COUNTRY = "FRANCE";

4. public String getCountry(){ return COUNTRY; }

6. public String getFullAddress(){

7. return getStreet() + EOL_STRING +

8. getPostalCode() + SPACE + getCity() +

9. EOL_STRING + COUNTRY + EOL_STRING;

10. }

11. }

Example 1.9 FrenchPhoneNumber.java

1. public class FrenchPhoneNumber extends PhoneNumber{

2. private static final String COUNTRY_CODE = "33";

3. private static final int NUMBER_LENGTH = 9;

5. public String getCountryCode(){ return COUNTRY_CODE; }

7. public void setPhoneNumber(String newNumber){

8. if (newNumber.length() == NUMBER_LENGTH){

9. super.setPhoneNumber(newNumber);

10. }

11. }

12. }

Builder

Pattern Properties

Type: Creational, Object

Level: Component

Purpose

To simplify complex object creation by defining a class whose purpose is to build instances of another class. The

Builder produces one main product, such that there might be more than one class in the product, but there is

always one main class.

Introduction

In a Personal Information Manager, users might want to manage a social calendar. To do this, you might define a

class called

Appointment to the information for a single event, and track information like the following:

Starting and ending dates

A description of the appointment

A location for the appointment

Attendees for the appointment

Naturally, this information is passed in by a user when he or she is setting up the appointment, so you define a

constructor that allows you to set the state of a new

Appointment object.

What exactly is needed to create an appointment, though? Different kinds of information are required depending

on the specific type of the appointment. Some appointments might require a list of attendees (the monthly Monty

Python film club meeting). Some might have start and end dates (JavaOne conference) and some might only have

a single date—a plan to visit the art gallery for the M.C. Escher exhibit. When you consider these options, the

task of creating an Appointment object is not trivial.

There are two possibilities for managing object creation, neither of them particularly attractive. You create

constructors for every type of appointment you want to create, or you write an enormous constructor with a lot of

functional logic. Each approach has its drawbacks—with multiple constructors, calling logic becomes more

complex; with more functional logic built into the constructor, the code becomes more complex and harder to

debug. Worse still, both approaches have the potential to cause problems if you later need to subclass

Appointment.

Instead, delegate the responsibility of Appointment creation to a special AppointmentBuilder class, greatly

simplifying the code for the Appointment itself. The AppointmentBuilder contains methods to create the parts

of the Appointment, and you call the AppointmentBuilder methods that are relevant for the appointment type.

Additionally, the AppointmentBuilder can ensure that the information passed in when creating the

Appointment is valid, helping to enforce business rules. If you need to subclass Appointment, you either create a

new builder or subclass the existing one. In either case, the task is easier than the alternative of managing object

initialization through constructors.

Applicability

Use the Builder pattern when a class:

Has complex internal structure (especially one with a variable set of related objects).

Has attributes that depend on each other. One of the things a Builder can do is enforce staged construction of a

complex object. This would be required when the Product attributes depend on one another. For instance, suppose

you’re building an order. You might need to ensure that you have a state set before you move on to “building” the

shipping method, because the state would impact the sales tax applied to the Order itself.

Uses other objects in the system that might be difficult or inconvenient to obtain during creation.

Description

Because this pattern is concerned with building a complex object from possibly multiple different sources, it is

called the Builder. As object creation increases in complexity, managing object creation from within the

constructor method can become difficult. This is especially true if the object does not depend exclusively on

resources that are under its own control.

Business objects often fall into this category. They frequently require data from a database for initialization and

might need to associate with a number of other business objects to accurately represent the business model.

Another example is that of composite objects in a system, such as an object representing a drawing in a visual

editing program. Such an object might need to be related to an arbitrary number of other objects as soon as it’s

created.

In cases like this, it is convenient to define another class (the Builder) that is responsible for the construction. The

Builder coordinates the assembly of the product object: creating resources, storing intermediate results, and

providing functional structure for the creation. Additionally, the Builder can acquire system resources required for

construction of the product object.

Implementation

The Builder class diagram is shown in Figure 1.2.

Figure 1.2. Builder class diagram

To implement the Builder pattern, you need:

Director – Has a reference to an AbstractBuilder instance. The Director calls the creational methods on its

builder instance to have the different parts and the Builder build.

AbstractBuilder – The interface that defines the available methods to create the separate parts of the product.

ConcreteBuilder – Implements the AbstractBuilder interface. The ConcreteBuilder implements all the

methods required to create a real Product. The implementation of the methods knows how to process information

from the Director and build the respective parts of a Product. The ConcreteBuilder also has either a

getProduct method or a creational method to return the Product instance.

Product – The resulting object. You can define the product as either an interface (preferable) or class.

Benefits and Drawbacks

The Builder pattern makes it easier to manage the overall flow during the creation of complex objects. This

manifests itself in two ways:

For objects that require phased creation (a sequence of steps to make the object fully active), the Builder acts as a

higher-level object to oversee the process. It can coordinate and validate the creation of all resources and if

necessary provide a fallback strategy if errors occur.

For objects that need existing system resources during creation, such as database connections or existing business

objects, the Builder provides a convenient central point to manage these resources. The Builder also provides a

single point of creational control for its product, which other objects within the system can use. Like other

creational patterns, this makes things easier for clients in the software system, since they need only access the

Builder object to produce a resource.

The main drawback of this pattern is that there is tight coupling among the Builder, its product, and any other

creational delegates used during object construction. Changes that occur for the product created by the Builder

often result in modifications for both the Builder and its delegates.

Pattern Variants

At the most fundamental level, it is possible to implement a bare-bones Builder pattern around a single Builder

class with a creational method and its product. For greater flexibility, designers often extend this base pattern with

one or more of the following approaches:

Create an abstract Builder. By defining an abstract class or interface that specifies the creational methods, you

can produce a more generic system that can potentially host many different kinds of builders.

Define multiple create methods for the Builder. Some Builders define multiple methods (essentially, they

overload their creational method) to provide a variety of ways to initialize the constructed resource.

Develop creational delegates. With this variant, a Director object holds the overall Product create method and

calls a series of more granular create methods on the

Builder object. In this case, the Director acts as the

manager for the Builder’s creation process.

Related Patterns

Related patterns include Composite (page 157). The Builder pattern is often used to produce Composite objects,

since they have a very complex structure.

Example

Note:

For a full working example of this code example, with additional supporting classes and/or a RunPattern class,

see “ Builder ” on page 343 of the “ Full Code Examples ” appendix.

This code example shows how to use the Builder pattern to create an appointment for the PIM. The following list

summarizes each class’s purpose:

AppointmentBuilder, MeetingBuilder – Builder classes

Scheduler – Director class

Appointment – Product

Address, Contact – Support classes, used to hold information relevant to the Appointment

InformationRequiredException – An Exception class produced when more data is required

For the base pattern, the AppointmentBuilder manages the creation of a complex product, an Appointment here.

The AppointmentBuilder uses a series of build methods—buildAppointment, buildLocation, buildDates, and

buildAttendees—to create an Appointment and populate it with data.

Example 1.10 AppointmentBuilder.java

1. import java.util.Date;

2. import java.util.ArrayList;

4. public class AppointmentBuilder{

6. public static final int START_DATE_REQUIRED = 1;

7. public static final int END_DATE_REQUIRED = 2;

8. public static final int DESCRIPTION_REQUIRED = 4;

9. public static final int ATTENDEE_REQUIRED = 8;

10. public static final int LOCATION_REQUIRED = 16;

11.

12. protected Appointment appointment;

13.

14. protected int requiredElements;

15.

16. public void buildAppointment(){

17. appointment = new Appointment();

18. }

19.

20. public void buildDates(Date startDate, Date endDate){

21. Date currentDate = new Date();

22. if ((startDate != null) && (startDate.after(currentDate))){

23. appointment.setStartDate(startDate);

24. }

25. if ((endDate != null) && (endDate.after(startDate))){

26. appointment.setEndDate(endDate);

27. }

28. }

29.

30. public void buildDescription(String newDescription){

31. appointment.setDescription(newDescription);

32. }

33.

34. public void buildAttendees(ArrayList attendees){

35. if ((attendees != null) && (!attendees.isEmpty())){

36. appointment.setAttendees(attendees);

37. }

38. }

39.

40. public void buildLocation(Location newLocation){

41. if (newLocation != null){

42. appointment.setLocation(newLocation);

43. }

44. }

45.

46. public Appointment getAppointment() throws InformationRequiredException{

47. requiredElements = 0;

48.

49. if (appointment.getStartDate() == null){

50. requiredElements += START_DATE_REQUIRED;

51. }

52.

53. if (appointment.getLocation() == null){

54. requiredElements += LOCATION_REQUIRED;

55. }

56.

57. if (appointment.getAttendees().isEmpty()){

58. requiredElements += ATTENDEE_REQUIRED;

59. }

60.

61. if (requiredElements > 0){

62. throw new InformationRequiredException(requiredElements);

63. }

64. return appointment;

65. }

66.

67. public int getRequiredElements(){ return requiredElements; }

68. }

Example 1.11 Appointment.java

1. import java.util.ArrayList;

2. import java.util.Date;

3. public class Appointment{

4. private Date startDate;

5. private Date endDate;

6. private String description;

7. private ArrayList attendees = new ArrayList();

8. private Location location;

9. public static final String EOL_STRING =

10. System.getProperty("line.separator");

11.

12. public Date getStartDate(){ return startDate; }

13. public Date getEndDate(){ return endDate; }

14. public String getDescription(){ return description; }

15. public ArrayList getAttendees(){ return attendees; }

剩余368页未读，继续阅读

bluerain841

粉丝: 0
资源: 2

Java设计模式实战指南：构建企业级应用的基石

java设计模式pdf

JAVA设计模式（java设计）

《java设计模式》课后习题模拟试题解答——刘伟.zip

java 设计模式 jdk

Java设计模式电子书

Java设计模式如何学习

java设计模式书籍推荐

java设计模式课程设计

Java设计模式刘伟

java 设计模式 八股

最新资源

java 设计模式八股