Design patterns in java chapter 8 singleton
Download
1 / 48

Design Patterns in Java Chapter 8 Singleton - PowerPoint PPT Presentation


  • 72 Views
  • Uploaded on

Design Patterns in Java Chapter 8 Singleton. Summary prepared by Kirk Scott. Singleton. Objects in general should be responsible for themselves That means that they should be internally consistent It also means that they are self-sufficient

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Design Patterns in Java Chapter 8 Singleton' - norah


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Design patterns in java chapter 8 singleton

Design Patterns in JavaChapter 8Singleton

Summary prepared by Kirk Scott


Singleton
Singleton

  • Objects in general should be responsible for themselves

  • That means that they should be internally consistent

  • It also means that they are self-sufficient

  • They do not depend (on the whole) on other classes/objects

  • They do not implement their functionality by referring to other classes/objects


Design patterns in java chapter 8 singleton

  • In modeling a real problem domain, it can happen that for a given class there will be only one instance

  • This situation is known as a singleton

  • Whether or not there are one or more instances of a given class sounds like a construction question

  • The book’s justification for categorizing singleton with the responsibility patterns follows


Design patterns in java chapter 8 singleton

  • Accept as a given that whether classes/objects rely on each other for responsibility, all classes/objects in an application are connected to each other in one way or another

  • If there is a singleton, this suggests that responsibility for the singleton is centralized in it

  • By extension, this means that any other class/object that deals with the singleton is dependent on the singleton

  • In other words, in the context of the whole application, responsibility has been centralized


Design patterns in java chapter 8 singleton

  • Book definition other for responsibility, all classes/objects in an application are connected to each other in one way or another:

  • The intent of the Singleton pattern is to ensure that a class has only one instance and to provide a global point of access to it.

  • Comment mode on:

  • Note that this statement of intent doesn’t really include any hint of the justification given earlier for classifying the pattern as a responsibility pattern


Design patterns in java chapter 8 singleton

  • The authors now concede that maybe there is a slight mismatch between this pattern and its classification

  • They state, “The mechanics of Singleton are more memorable than its intent.”

  • Actually, I think what they really mean is that the so-called statement of intent is really a statement of mechanics

  • The claimed intent of centralizing responsibility was a bunch of preceding blah blahblah


Design patterns in java chapter 8 singleton

  • The authors go on to mention that the original Design Patterns book categorized Singleton as a “creational” pattern

  • In other words, other authors, equally competent in the field, have classified patterns more by their structure and syntactical consequences

  • It doesn’t matter how Singleton is classified

  • It would be perfectly legitimate to consider Singleton a “construction” pattern


Design patterns in java chapter 8 singleton

  • It is simply worthwhile to remember the pattern and understand where it might be useful to apply it

  • Incidentally, as with other patterns, it is also worth noting some of the implementation “tricks” that the authors reveal

  • The authors now jump into the nuts and bolts of implementation


Design patterns in java chapter 8 singleton

  • Challenge 8.1 understand where it might be useful to apply it

  • How can you prevent other developers from constructing new instances of your class?


Design patterns in java chapter 8 singleton

  • Solution 8.1 understand where it might be useful to apply it

  • To prevent other developers from instantiating your class, create a single constructor with private access. Note that if you create other, nonprivate constructors or no constructors at all, other objects will be able to instantiate your class


Design patterns in java chapter 8 singleton

  • Comment mode on: understand where it might be useful to apply it

  • The idea of a private constructor has not come up before

  • If you have a private constructor, the question becomes, how and where do you call it from?

  • There is some muddling in the book’s explanation of all this which I will straighten out before finishing with the topic


Design patterns in java chapter 8 singleton

  • The book phrases the question of how and where to construct as, “…when to instantiate the single object…”

  • The authors then propose that there be a SystemStartup class in a software system which contains the following combined instance variable declaration and construction

  • private static Factory factory = new Factory();


Design patterns in java chapter 8 singleton

  • I am convinced the authors have gone slightly off the track here

  • If the constructor for Factory is private, it couldn’t be called in the SystemStartup class code

  • The next statement they make is that “this class” could make its instance variable available through a public getFactory() method


Design patterns in java chapter 8 singleton

  • Ignore the hereSystemStartup class for a moment

  • In skeletal form, the Factory class definition on the following overhead appears to be the solution that the authors are proposing

  • The Factory class contains a default constructor which is declared private


Design patterns in java chapter 8 singleton

  • public class Factory here

  • {

  • private static Factory factory = new Factory();

  • private Factory()

  • {

  • }

  • public static getFactory()

  • {

  • return factory;

  • }

  • }


Design patterns in java chapter 8 singleton

  • The class contains a static instance of itself as an instance variable

  • The variable is constructed (once) in the declaration by a call to the private constructor

  • The class also contains a static getFactory() method which returns a reference to the singleton

  • The call to the get method in a client piece of code would be like any call to a static method:

  • Factory singletonReference = Factory.getFactory();


Design patterns in java chapter 8 singleton

  • The book’s solution works instance variable

  • Not having considered the possibility of private constructors or classes containing instance variables which are instances of themselves, this is not the first solution approach that would have occurred to me

  • I would have been thinking along different lines


Design patterns in java chapter 8 singleton

  • The instance variablefollowing overhead shows a starting approach to solving the problem

  • Notice that it is incomplete

  • You are stopped when you realize that a constructor is a constructor


Design patterns in java chapter 8 singleton


Design patterns in java chapter 8 singleton

  • Within the code for a constructor it is not possible to make the construction conditional like for a method

  • It’s not like a method where you have a choice of either returning a reference or returning null

  • Once the constructor is called, a new object is created and will be returned

  • All that’s taken care of in the body of a constructor is the initialization of the instance variables


Design patterns in java chapter 8 singleton

  • However, this is not the end of the story the construction

  • A constructor, like a method, can be declared to throw an exception

  • Then the code can be written either to run successfully and return a reference to a newly created object

  • Or to throw an exception if the conditions for the Singleton design pattern aren’t met


Design patterns in java chapter 8 singleton

  • public the construction class Factory

  • {

  • private static intinstanceCount = 0;

  • public Factory() throws Exception

  • {

  • if(instanceCount== 0)

  • instanceCount++;

  • else

  • throw new Exception(“Uh-oh”);

  • }

  • }


Design patterns in java chapter 8 singleton


Design patterns in java chapter 8 singleton

  • On the other hand, it’s not necessarily an ideal solution the code compiles

  • The point is that it would be convenient to simply be returned a reference to the one existing instance if one has already been created

  • This solution puts the burden on the client code of keeping track of whether it’s created an instance before

  • If there are >1 client and one creates the instance, then the other client is screwed


Design patterns in java chapter 8 singleton

  • Next, the book introduces what it calls lazy initialization the code compiles

  • The idea is that an instance of the Singleton class is only constructed if some piece of client code requests a reference to it

  • This requires removing the construction from the line declaring the instance variable

  • Construction is then inserted into the getFactory() method

  • This is shown on the next overhead


Design patterns in java chapter 8 singleton

  • public class Factory the code compiles

  • {

  • private static Factory factory;

  • private Factory()

  • {

  • }

  • public static getFactory()

  • {

  • if(factory == null)

  • factory = new Factory();

  • return factory;

  • }

  • }


Design patterns in java chapter 8 singleton

  • Challenge 8.2 the code compiles

  • Why might you decide to lazy-initialize a singleton instance rather than to initialize it in its field declaration?


Design patterns in java chapter 8 singleton

  • Solution 8.2 the code compiles

  • Two reasons for lazy-initializing singletons are as follows.

  • 1. You might not have enough information to instantiate a singleton at static initialization time. For example, a Factory singleton might have to wait for the real factory’s machines to establish communication channels.


Design patterns in java chapter 8 singleton


Design patterns in java chapter 8 singleton

  • Whether you lazy initialize or not requires resources, such as a database connection, especially if there is a chance that the containing application will not need the singleton in a particular session.

  • Construction of the singleton takes place in the singleton’s class

  • And access to the singleton is provided through a public, static method


Singletons and threads
Singletons and Threads requires resources, such as a database connection, especially if there is a chance that the containing application will not need the singleton in a particular session.

  • CS 320 is not a pre-requisite for CS 304

  • This subsection depends on understanding concepts from CS 320, so it is not part of CS 304

  • If you have had CS 320, you should be able to read the section and get the idea


Design patterns in java chapter 8 singleton

  • Suppose that you do lazy initialization requires resources, such as a database connection, especially if there is a chance that the containing application will not need the singleton in a particular session.

  • The goal of the getFactory() method is to construct only one instance

  • Suppose you have two client threads which can call getFactory()

  • If you don’t synchronize on the call to getFactory(), both threads could run the method concurrently, resulting in the construction of two Factory objects

  • This defeats the goal of implementing a singleton


Design patterns in java chapter 8 singleton


Design patterns in java chapter 8 singleton

  • None of that will be pursued concept in Java

  • If you haven’t had CS 320, you can ignore the whole topic

  • It has only been addressed briefly here for the benefit of those who have already taken CS 320


Recognizing singleton
Recognizing Singleton concept in Java

  • In an overall design, classes shouldn’t overlap with each other in their content and functionality

  • In other words, classes are unique

  • On the other hand, you can have multiple instances of one class


Design patterns in java chapter 8 singleton

  • Each of the objects is distinct and unique concept in Java

  • The objects differ according to the contents of their instance variables

  • In general, you can say that the individual objects are only responsible for themselves, based on the code defined in their class


Design patterns in java chapter 8 singleton


Design patterns in java chapter 8 singleton


Design patterns in java chapter 8 singleton

  • Challenge 8.4 singletons, where more than one instance has to be prevented, are rare

  • For each class in Figure 8.1, say whether it appears to be a singleton class, and why.

  • Spoiler mode on:

  • Only one of these classes is a singleton


Design patterns in java chapter 8 singleton

  • Solution 8.4 singletons, where more than one instance has to be prevented, are rare

  • OurBiggestRocket: This class has an inappropriate name. You would normally model attributes, such as “biggest,” with attributes, not with class names. If a developer must sustain this class, perhaps it is a singleton.

  • TopSalesAssociate: This class has the same problem as OurBiggestRocket.


Design patterns in java chapter 8 singleton


Design patterns in java chapter 8 singleton

  • PrintStream singletons, where more than one instance has to be prevented, are rare: Although the System.out object is a PrintStream object with unique responsibilities, it is not a unique instance of PrintStream, which is not a singleton class.

  • PrintSpooler: PrintSpoolers are associated with one or a few printers; it’s unlikely that this is a singleton.

  • PrinterManager: At Oozinoz, you have many printers, and you can look up their addresses through the PrinterManager singleton.


Design patterns in java chapter 8 singleton

  • The authors say that Singleton is probably the best known pattern

  • This may be because it is easy to understand

  • It may also be because, for C style programmers, it makes it easy to get around the requirements of object-oriented programming

  • A singleton object can serve as a global type of variable


Design patterns in java chapter 8 singleton

  • In general, the reason for the existence of a singleton is some restriction in the problem domain

  • A singleton shouldn’t be introduced unless a good reason can be found for having one

  • Client code, if at all possible, should have no interest in special conditions on the creation of instances of other classes (like singletons)

  • If a class is to have subclasses or different versions, singleton won’t work at all

  • The restrictions on construction in the superclass will mess up construction in the subclasses


Summary
Summary some restriction in the problem domain

  • The Singleton pattern means only one object of a given class will be created

  • By definition, this means there is a single, global occurrence of the class

  • Lazy initialization can be a useful feature of the implementation of Singleton

  • In a multi-threaded environment synchronization has to be used in order to make sure that an implementation of singleton works correctly


Design patterns in java chapter 8 singleton

  • Keep in mind that just because there is only one instance of a class in a given application, that doesn’t mean that the singleton pattern is appropriate

  • From a pragmatic point of view, this warning is especially apropos if the class has subclasses

  • The Singleton pattern centralizes responsibility in a single instance of a class by hiding the constructor and providing a single point of access to object creation


The end
The End a class in a given application, that doesn’t mean that the singleton pattern is appropriate