1.TestURLConn.java
------------------
package com;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class TestURLConn {
HttpServletRequest req;
HttpServletResponse resp;
public TestURLConn(HttpServletRequest req,HttpServletResponse resp){
this.req=req;
this.resp=resp;
}
public void getControl(){
try {
this.req.setAttribute("name","sriRama");
req.getRequestDispatcher("TestURLConn.jsp").forward(req, resp);
} catch (ServletException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
---------------------------------------------------------------------------
2. index.jsp
-------------
<% request.setAttribute("val","srirama navami sadsad");
TestURLConn tuc=new TestURLConn(request,response);
tuc.getControl();
%>
---------------------------------------------------------------------------
3.TestURLConn.jsp
-----------------
this is TestURLConn.jsp
<%if(request.getAttribute("val").toString()!=null){
System.out.println(request.getAttribute("val").toString());
out.println(request.getAttribute("val").toString());
}%>
<%if(request.getAttribute("name").toString()!=null){
System.out.println(request.getAttribute("name").toString());
out.println(request.getAttribute("name").toString());
}
%>
----------------------------------------------------
out put
-------
srirama navami
sriRama
Wednesday, March 24, 2010
Monday, March 8, 2010
MySQL -JDBC connection Syntax
Connecting to the MySQL Server
import java.sql.*;
public class Connect
{
public static void main (String[] args)
{
Connection conn = null;
try
{
String userName = "testuser";
String password = "testpass";
String url = "jdbc:mysql://localhost/test";
Class.forName ("com.mysql.jdbc.Driver").newInstance ();
conn = DriverManager.getConnection (url, userName, password);
System.out.println ("Database connection established");
}
catch (Exception e)
{
System.err.println ("Cannot connect to database server");
}
finally
{
if (conn != null)
{
try
{
conn.close ();
System.out.println ("Database connection terminated");
}
catch (Exception e) { /* ignore close errors */ }
}
}
}
}
import java.sql.*;
public class Connect
{
public static void main (String[] args)
{
Connection conn = null;
try
{
String userName = "testuser";
String password = "testpass";
String url = "jdbc:mysql://localhost/test";
Class.forName ("com.mysql.jdbc.Driver").newInstance ();
conn = DriverManager.getConnection (url, userName, password);
System.out.println ("Database connection established");
}
catch (Exception e)
{
System.err.println ("Cannot connect to database server");
}
finally
{
if (conn != null)
{
try
{
conn.close ();
System.out.println ("Database connection terminated");
}
catch (Exception e) { /* ignore close errors */ }
}
}
}
}
Database Connection Pooling in Tomcat using dbcp with Eclipse
Database Connection Pooling is a great technique used by lot of application servers to optimize the performance. Database Connection creation is a costly task thus it impacts the performance of application. Hence lot of application server creates a database connection pool which are pre initiated db connections that can be leverage to increase performance.
Apache Tomcat also provide a way of creating DB Connection Pool. Let us see an example to implement DB Connection Pooling in Apache Tomcat server. We will create a sample web application with a servlet that will get the db connection from tomcat db connection pool and fetch the data using a query. We will use Eclipse as our development environment. This is not a prerequisite i.e. you may want to use any IDE to create this example.
Step 1: Create Dynamic Web Project in Eclipse
Create a Dynamic Web Project in Eclipse by selecting:
File - New -Project - Dynamic Web Project.
Step 2: Create context.xml
Apache Tomcat allow the applications to define the resource used by the web application in a file called context.xml (from Tomcat 5.x version onwards). We will create a file context.xml under META-INF directory.
Copy following content in the context.xml file.
In above code snippet, we have specify a database connection pool. The name of the resource is jdbc/testdb. We will use this name in our application to get the data connection. Also we specify db username and password and connection URL of database. Note that I am using Oracle as the database for this example. You may want to change this Driver class with any of other DB Providers (like MySQL Driver Class).
Step 3: Create Test Servlet and WEB xml entry
Create a file called TestServlet.java. I have created this file under package: net.viralpatel.servlet. Copy following code into it.
package net.viralpatel.servlet;
02
03 import java.io.IOException;
04 import java.sql.Connection;
05 import java.sql.ResultSet;
06 import java.sql.SQLException;
07 import java.sql.Statement;
08
09 import javax.naming.Context;
10 import javax.naming.InitialContext;
11 import javax.naming.NamingException;
12 import javax.servlet.ServletException;
13 import javax.servlet.http.HttpServlet;
14 import javax.servlet.http.HttpServletRequest;
15 import javax.servlet.http.HttpServletResponse;
16 import javax.sql.DataSource;
17
18 public class TestServlet extends HttpServlet {
19
20 private DataSource dataSource;
21 private Connection connection;
22 private Statement statement;
23
24 public void init() throws ServletException {
25 try {
26 // Get DataSource
27 Context initContext = new InitialContext();
28 Context envContext = (Context)initContext.lookup("java:/comp/env");
29 dataSource = (DataSource)envContext.lookup("jdbc/testdb");
30
31 } catch (NamingException e) {
32 e.printStackTrace();
33 }
34 }
35
36 public void doGet(HttpServletRequest req, HttpServletResponse resp)
37 throws ServletException, IOException {
38
39 ResultSet resultSet = null;
40 try {
41 // Get Connection and Statement
42 connection = dataSource.getConnection();
43 statement = connection.createStatement();
44 String query = "SELECT * FROM STUDENT";
45 resultSet = statement.executeQuery(query);
46 while (resultSet.next()) {
47 System.out.println(resultSet.getString(1) + resultSet.getString(2) + resultSet.getString(3));
48 }
49 } catch (SQLException e) {
50 e.printStackTrace();
51 }finally {
52 try { if(null!=resultSet)resultSet.close();} catch (SQLException e)
53 {e.printStackTrace();}
54 try { if(null!=statement)statement.close();} catch (SQLException e)
55 {e.printStackTrace();}
56 try { if(null!=connection)connection.close();} catch (SQLException e)
57 {e.printStackTrace();}
58 }
59 }
60 }
note : copy the jar file in the %catalina%/lib folder
Apache Tomcat also provide a way of creating DB Connection Pool. Let us see an example to implement DB Connection Pooling in Apache Tomcat server. We will create a sample web application with a servlet that will get the db connection from tomcat db connection pool and fetch the data using a query. We will use Eclipse as our development environment. This is not a prerequisite i.e. you may want to use any IDE to create this example.
Step 1: Create Dynamic Web Project in Eclipse
Create a Dynamic Web Project in Eclipse by selecting:
File - New -Project - Dynamic Web Project.
Step 2: Create context.xml
Apache Tomcat allow the applications to define the resource used by the web application in a file called context.xml (from Tomcat 5.x version onwards). We will create a file context.xml under META-INF directory.
Copy following content in the context.xml file.
In above code snippet, we have specify a database connection pool. The name of the resource is jdbc/testdb. We will use this name in our application to get the data connection. Also we specify db username and password and connection URL of database. Note that I am using Oracle as the database for this example. You may want to change this Driver class with any of other DB Providers (like MySQL Driver Class).
Step 3: Create Test Servlet and WEB xml entry
Create a file called TestServlet.java. I have created this file under package: net.viralpatel.servlet. Copy following code into it.
package net.viralpatel.servlet;
02
03 import java.io.IOException;
04 import java.sql.Connection;
05 import java.sql.ResultSet;
06 import java.sql.SQLException;
07 import java.sql.Statement;
08
09 import javax.naming.Context;
10 import javax.naming.InitialContext;
11 import javax.naming.NamingException;
12 import javax.servlet.ServletException;
13 import javax.servlet.http.HttpServlet;
14 import javax.servlet.http.HttpServletRequest;
15 import javax.servlet.http.HttpServletResponse;
16 import javax.sql.DataSource;
17
18 public class TestServlet extends HttpServlet {
19
20 private DataSource dataSource;
21 private Connection connection;
22 private Statement statement;
23
24 public void init() throws ServletException {
25 try {
26 // Get DataSource
27 Context initContext = new InitialContext();
28 Context envContext = (Context)initContext.lookup("java:/comp/env");
29 dataSource = (DataSource)envContext.lookup("jdbc/testdb");
30
31 } catch (NamingException e) {
32 e.printStackTrace();
33 }
34 }
35
36 public void doGet(HttpServletRequest req, HttpServletResponse resp)
37 throws ServletException, IOException {
38
39 ResultSet resultSet = null;
40 try {
41 // Get Connection and Statement
42 connection = dataSource.getConnection();
43 statement = connection.createStatement();
44 String query = "SELECT * FROM STUDENT";
45 resultSet = statement.executeQuery(query);
46 while (resultSet.next()) {
47 System.out.println(resultSet.getString(1) + resultSet.getString(2) + resultSet.getString(3));
48 }
49 } catch (SQLException e) {
50 e.printStackTrace();
51 }finally {
52 try { if(null!=resultSet)resultSet.close();} catch (SQLException e)
53 {e.printStackTrace();}
54 try { if(null!=statement)statement.close();} catch (SQLException e)
55 {e.printStackTrace();}
56 try { if(null!=connection)connection.close();} catch (SQLException e)
57 {e.printStackTrace();}
58 }
59 }
60 }
note : copy the jar file in the %catalina%/lib folder
Friday, March 5, 2010
JSP Response Object
In this JSP tutorial, you will learn about JSP Response object, Methods of response Object, setContentType(), addCookie(Cookie cookie), containsHeader(String name), setHeader(String name, String value), sendRedirect(String) and sendError(int status_code).
The response object denotes the HTTP Response data. The result or the information of a request is denoted with this object. The response object handles the output of the client. This contrasts with the request object. The class or the interface name of the response object is http.HttpServletResponse.
The response object is written: Javax.servlet.http.httpservletresponse.
The response object is generally used by cookies.
The response object is also used with HTTP Headers.
Methods of response Object:
There are numerous methods available for response object. Some of them are:
* setContentType()
* addCookie(Cookie cookie)
* addHeader(String name, String value)
* containsHeader(String name)
* setHeader(String name, String value)
* sendRedirect(String)
* sendError(int status_code)
List below details the usage with syntax, example and explanation of each of these methods.
setContentType():
setContentType() method of response object is used to set the MIME type and character encoding for the page.
General syntax of setContentType() of response object is as follows:
response.setContentType();
For example:
response.setContentType("text/html");
The above statement is used to set the content type as text/html dynamically.
addCookie(Cookie cookie):
addCookie() method of response object is used to add the specified cookie to the response. The addcookie() method is used to write a cookie to the response. If the user wants to add more than one cookie, then using this method by calling it as many times as the user wants will add cookies.
General syntax of addCookie() of response object is as follows:
response.addCookie(Cookie cookie)
For example:
response.addCookie(Cookie exforsys);
The above statement adds the specified cookie exforsys to the response.
addHeader(String name, String value):
addHeader() method of response object is used to write the header as a pair of name and value to the response. If the header is already present, then value is added to the existing header values.
General syntax of addHeader() of response object is as follows:
response.addHeader(String name, String value)
Here the value of string is given as second parameter and this gets assigned to the header given in first parameter as string name.
For example:
response.addHeader("Author", "Exforsys");
The output of above statement is as below:
Author: Exforsys
containsHeader(String name):
containsHeader() method of response object is used to check whether the response already includes the header given as parameter. If the named response header is set then it returns a true value. If the named response header is not set, the value is returned as false. Thus, the containsHeader method is used to test the presence of a header before setting its value. The return value from this method is a Boolean value of true or false.
General syntax of containsHeader() of response object is as follows:
response.containsHeader(String name)
Return value of the above containsHeader() method is a Boolean value true or false.
setHeader(String name, String value):
setHeader method of response object is used to create an HTTP Header with the name and value given as string. If the header is already present, then the original value is replaced by the current value given as parameter in this method.
General syntax of setHeader of response object is as follows:
response.setHeader(String name, String value)
For example:
response.setHeader("Content_Type","text/html");
The above statement would give output as
Content_Type: text/html
sendRedirect(String):
sendRedirect method of response object is used to send a redirect response to the client temporarily by making use of redirect location URL given in parameter. Thus the sendRedirect method of the response object enables one to forward a request to a new target. But one must note that if the JSP executing has already sent page content to the client, then the sendRedirect() method of response object will not work and will fail.
General syntax of sendRedirect of response object is as follows:
response.sendRedirect(String)
In the above the URL is given as string.
For example:
response.sendRedirect("http://xxx.test.com/error.html");
The response object denotes the HTTP Response data. The result or the information of a request is denoted with this object. The response object handles the output of the client. This contrasts with the request object. The class or the interface name of the response object is http.HttpServletResponse.
The response object is written: Javax.servlet.http.httpservletresponse.
The response object is generally used by cookies.
The response object is also used with HTTP Headers.
Methods of response Object:
There are numerous methods available for response object. Some of them are:
* setContentType()
* addCookie(Cookie cookie)
* addHeader(String name, String value)
* containsHeader(String name)
* setHeader(String name, String value)
* sendRedirect(String)
* sendError(int status_code)
List below details the usage with syntax, example and explanation of each of these methods.
setContentType():
setContentType() method of response object is used to set the MIME type and character encoding for the page.
General syntax of setContentType() of response object is as follows:
response.setContentType();
For example:
response.setContentType("text/html");
The above statement is used to set the content type as text/html dynamically.
addCookie(Cookie cookie):
addCookie() method of response object is used to add the specified cookie to the response. The addcookie() method is used to write a cookie to the response. If the user wants to add more than one cookie, then using this method by calling it as many times as the user wants will add cookies.
General syntax of addCookie() of response object is as follows:
response.addCookie(Cookie cookie)
For example:
response.addCookie(Cookie exforsys);
The above statement adds the specified cookie exforsys to the response.
addHeader(String name, String value):
addHeader() method of response object is used to write the header as a pair of name and value to the response. If the header is already present, then value is added to the existing header values.
General syntax of addHeader() of response object is as follows:
response.addHeader(String name, String value)
Here the value of string is given as second parameter and this gets assigned to the header given in first parameter as string name.
For example:
response.addHeader("Author", "Exforsys");
The output of above statement is as below:
Author: Exforsys
containsHeader(String name):
containsHeader() method of response object is used to check whether the response already includes the header given as parameter. If the named response header is set then it returns a true value. If the named response header is not set, the value is returned as false. Thus, the containsHeader method is used to test the presence of a header before setting its value. The return value from this method is a Boolean value of true or false.
General syntax of containsHeader() of response object is as follows:
response.containsHeader(String name)
Return value of the above containsHeader() method is a Boolean value true or false.
setHeader(String name, String value):
setHeader method of response object is used to create an HTTP Header with the name and value given as string. If the header is already present, then the original value is replaced by the current value given as parameter in this method.
General syntax of setHeader of response object is as follows:
response.setHeader(String name, String value)
For example:
response.setHeader("Content_Type","text/html");
The above statement would give output as
Content_Type: text/html
sendRedirect(String):
sendRedirect method of response object is used to send a redirect response to the client temporarily by making use of redirect location URL given in parameter. Thus the sendRedirect method of the response object enables one to forward a request to a new target. But one must note that if the JSP executing has already sent page content to the client, then the sendRedirect() method of response object will not work and will fail.
General syntax of sendRedirect of response object is as follows:
response.sendRedirect(String)
In the above the URL is given as string.
For example:
response.sendRedirect("http://xxx.test.com/error.html");
Friday, January 29, 2010
Reset the Root Password of MySQL Server
By default, MySQL Server will be installed with root superuser without any password. You can connect to MySQL server as root without requiring password or by keying in blank password. However, if you have set the password for root and forget or unable to recall the password, then you will need to reset the root password for MySQL.
MySQL Reference Manual has detail steps on how to reset password for root which are as below:
The procedure under Windows:
1. Log on to the Windows system where MySQL is running as Administrator.
2. Stop the MySQL server if it is running. For a server that is running as
a Windows service, go to the Services manager:
Start Menu -> Control Panel
-> Administrative Tools -> Services
Then find the MySQL service in the list, and stop it.
If your server is not running as a service, you may need to use the Task
Manager to force it to stop.
3. Create a text file and place the following command within it on a single line:
SET PASSWORD FOR ‘root’@'localhost’ = PASSWORD(‘MyNewPassword’);
Save the file with any name. For this example the file will be
C:\mysql-init.txt.
4. Open a console window to get to the DOS command prompt:
Start Menu -> Run -> cmd
5. If MySQL is installed in C:\mysql. If MySQL is installed in another location,
adjust the following commands accordingly.
At the DOS command prompt, execute this command:
C:\> C:\mysql\bin\mysqld-nt –init-file=C:\mysql-init.txt
The contents of the file named by the –init-file option are executed at
server startup, changing the root password. After the server has started
successfully, you should delete C:\mysql-init.txt.
If you installed MySQL using the MySQL Installation Wizard, you may need to
specify a –defaults-file option:
C:\> “C:\Program Files\MySQL\MySQL Server 5.0\bin\mysqld-nt.exe”
–defaults-file=”C:\Program Files\MySQL\MySQL Server 5.0\my.ini”
–init-file=C:\mysql-init.txt
The appropriate –defaults-file setting can be found using the Services
Manager:
Start Menu -> Control Panel -> Administrative Tools -> Services
Find the MySQL service in the list, right-click on it, and choose the
Properties option. The Path to executable field contains the –defaults-file setting. Be sure to supply the –init-file argument with the full system path to the file, regardless of your current working directory
6. Stop the MySQL server, then restart it in normal mode again. If the MySQL server is ran as a service, start it from the Windows Services window. If you start the server manually, use whatever command you normally use.
7. Connect to MySQL server by using the new password.
For Unix environment, the procedure for resetting the root password is as follows:
1. Log on to the Unix system as either the Unix root user or as the same user that the mysqld server runs as.
2. Locate the .pid file that contains the server’s process ID. The exact location and name of this file depend on your distribution, hostname, and configuration. Common locations are /var/lib/mysql/, /var/run/mysqld/, and /usr/local/mysql/data/. Generally, the filename has the extension of .pid and begins with either mysqld or the system’s hostname.
Stop the MySQL server by sending a normal kill (not kill -9) to the mysqld process, using the pathname of the .pid file in the following command:
shell> kill `cat /mysql-data-directory/host_name.pid`
Note the use of backticks rather than forward quotes with the cat command; these cause the output of cat to be substituted into the kill command.
3. Create a text file and place the following command within it on a single line:
SET PASSWORD FOR ‘root’@'localhost’ = PASSWORD(‘MyNewPassword’);
Save the file with any name. For this example the file will be ~/mysql-init.
4. Restart the MySQL server with the special –init-file=~/mysql-init option:
shell> mysqld_safe –init-file=~/mysql-init &
The contents of the init-file are executed at server startup, changing the root password. After the server has started successfully you should delete ~/mysql-init.
5. Connect to MySQL server by using the new password.
Alternatively, on any platform, mysql client can be used to set the new password, althought it’s less secure way of resetting the password (detailed instruction here):
1. Stop mysqld and restart it with the –skip-grant-tables –user=root options (Windows users omit the –user=root portion).
2. Connect to the mysqld server with this command:
shell> mysql -u root
3. Issue the following statements in the mysql client:
mysql> UPDATE mysql.user SET Password=PASSWORD(‘newpwd’)
-> WHERE User=’root’;
mysql> FLUSH PRIVILEGES;
Replace ‘newpwd’ with the actual root password that you want to use.
4. You should be able to connect using the new password.
MySQL Reference Manual has detail steps on how to reset password for root which are as below:
The procedure under Windows:
1. Log on to the Windows system where MySQL is running as Administrator.
2. Stop the MySQL server if it is running. For a server that is running as
a Windows service, go to the Services manager:
Start Menu -> Control Panel
-> Administrative Tools -> Services
Then find the MySQL service in the list, and stop it.
If your server is not running as a service, you may need to use the Task
Manager to force it to stop.
3. Create a text file and place the following command within it on a single line:
SET PASSWORD FOR ‘root’@'localhost’ = PASSWORD(‘MyNewPassword’);
Save the file with any name. For this example the file will be
C:\mysql-init.txt.
4. Open a console window to get to the DOS command prompt:
Start Menu -> Run -> cmd
5. If MySQL is installed in C:\mysql. If MySQL is installed in another location,
adjust the following commands accordingly.
At the DOS command prompt, execute this command:
C:\> C:\mysql\bin\mysqld-nt –init-file=C:\mysql-init.txt
The contents of the file named by the –init-file option are executed at
server startup, changing the root password. After the server has started
successfully, you should delete C:\mysql-init.txt.
If you installed MySQL using the MySQL Installation Wizard, you may need to
specify a –defaults-file option:
C:\> “C:\Program Files\MySQL\MySQL Server 5.0\bin\mysqld-nt.exe”
–defaults-file=”C:\Program Files\MySQL\MySQL Server 5.0\my.ini”
–init-file=C:\mysql-init.txt
The appropriate –defaults-file setting can be found using the Services
Manager:
Start Menu -> Control Panel -> Administrative Tools -> Services
Find the MySQL service in the list, right-click on it, and choose the
Properties option. The Path to executable field contains the –defaults-file setting. Be sure to supply the –init-file argument with the full system path to the file, regardless of your current working directory
6. Stop the MySQL server, then restart it in normal mode again. If the MySQL server is ran as a service, start it from the Windows Services window. If you start the server manually, use whatever command you normally use.
7. Connect to MySQL server by using the new password.
For Unix environment, the procedure for resetting the root password is as follows:
1. Log on to the Unix system as either the Unix root user or as the same user that the mysqld server runs as.
2. Locate the .pid file that contains the server’s process ID. The exact location and name of this file depend on your distribution, hostname, and configuration. Common locations are /var/lib/mysql/, /var/run/mysqld/, and /usr/local/mysql/data/. Generally, the filename has the extension of .pid and begins with either mysqld or the system’s hostname.
Stop the MySQL server by sending a normal kill (not kill -9) to the mysqld process, using the pathname of the .pid file in the following command:
shell> kill `cat /mysql-data-directory/host_name.pid`
Note the use of backticks rather than forward quotes with the cat command; these cause the output of cat to be substituted into the kill command.
3. Create a text file and place the following command within it on a single line:
SET PASSWORD FOR ‘root’@'localhost’ = PASSWORD(‘MyNewPassword’);
Save the file with any name. For this example the file will be ~/mysql-init.
4. Restart the MySQL server with the special –init-file=~/mysql-init option:
shell> mysqld_safe –init-file=~/mysql-init &
The contents of the init-file are executed at server startup, changing the root password. After the server has started successfully you should delete ~/mysql-init.
5. Connect to MySQL server by using the new password.
Alternatively, on any platform, mysql client can be used to set the new password, althought it’s less secure way of resetting the password (detailed instruction here):
1. Stop mysqld and restart it with the –skip-grant-tables –user=root options (Windows users omit the –user=root portion).
2. Connect to the mysqld server with this command:
shell> mysql -u root
3. Issue the following statements in the mysql client:
mysql> UPDATE mysql.user SET Password=PASSWORD(‘newpwd’)
-> WHERE User=’root’;
mysql> FLUSH PRIVILEGES;
Replace ‘newpwd’ with the actual root password that you want to use.
4. You should be able to connect using the new password.
Friday, January 8, 2010
Using the Singleton pattern in Java
The Java Singleton pattern belongs to the family of design patterns that governs the instantiation process. A Singleton is an object that cannot be instantiated.
This design pattern suggests that at any time there can only be one instance of a Singleton (object) created by the JVM. You implement the pattern by creating a class with a method that creates a new instance of the class if one does not exist. If an instance of the class exists, it simply returns a reference to that object.
How the Singleton pattern works
Here's a typical example of Singleton:
public class Singleton {
private final static Singleton INSTANCE = new Singleton();
// Private constructor suppresses generation of
// a (public) default constructor
private Singleton() {}
public static Singleton getInstance() {
return INSTANCE;
}
}
The classic Singleton does not use direct instantiation of a static variable with declaration -- it instantiates a static instance variable in the constructor without checking to see if it already exists:
public class ClassicSingleton {
private static ClassicSingleton INSTANCE = null;
private ClassicSingleton() {
// Exists only to defeat instantiation.
}
public static ClassicSingleton getInstance() {
if(INSTANCE == null) {
INSTANCE = new ClassicSingleton();
}
return INSTANCE;
}
}
The Singleton class's default constructor is made private, which prevents the direct instantiation of the object by other classes using the new keyword. A static modifier is applied to the instance method that returns the Singleton object; it makes this a class level method that can be accessed without creating an object.
When you need Singleton
Singletons are truly useful when you need only one instance of a class, and it is undesirable to have more than one instance of a class.
When designing a system, you usually want to control how an object is used and prevent users (including yourself) from making copies of it or creating new instances. For example, you can use it to create a connection pool. It's not wise to create a new connection every time a program needs to write something to a database; instead, a connection or a set of connections that are already a pool can be instantiated using the Singleton pattern.
The Singleton pattern is often used in conjunction with the factory method pattern to create a systemwide resource whose specific type is not known to the code that uses it. An example of using these two patterns together is the Abstract Windowing Toolkit (AWT). In GUI applications, you often need only one instance of a graphical element per application instance, like the Print dialog box or the OK button.
Watch out for potential problems
Although the Singleton design pattern is one of the simplest design patterns, it presents a number of pitfalls.
Construct in multi-threaded applications
You must carefully construct the Singleton pattern in multi-threaded applications. If two threads are to execute the creation method at the same time when a Singleton does not exist, both must check for an instance of the Singleton, but only one thread should create the new object. The classic solution to this problem is to use mutual exclusion on the class that indicates that the object is being instantiated. This is a thread-safe version of a Singleton:
public class Singleton
{
// Private constructor suppresses generation
// of a (public) default constructor
private Singleton() {}
private static class SingletonHolder
{
private final static Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance()
{
return SingletonHolder.INSTANCE;
}
}
For an alternative solution, you can add the synchronized keyword to the getInstance() method declaration:
public static synchronized Singleton getInstance()
Think ahead about cloning prevention
You can still create a copy of the Singleton object by cloning it using the Object's clone() method. To forbid this, you need to override the Object's clone method, which throws a CloneNotSupportedException exception:
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
Consider making the singleton class final
You may want to make the Singleton class final to avoid sub classing of Singletons that may cause other problems.
Remember about garbage collection
Depending on your implementation, your Singleton class and all of its data might be garbage collected. This is why you must ensure that there must be a live reference to the Singleton class when the application is running.
Conclusion
The Singleton pattern is widely used and has proved its usability in designing software. Although the pattern is not specific to Java, it has become a classic in Java programming. Despite its simplicity, remember the limitations of the Singleton pattern that I describe in this article.
This design pattern suggests that at any time there can only be one instance of a Singleton (object) created by the JVM. You implement the pattern by creating a class with a method that creates a new instance of the class if one does not exist. If an instance of the class exists, it simply returns a reference to that object.
How the Singleton pattern works
Here's a typical example of Singleton:
public class Singleton {
private final static Singleton INSTANCE = new Singleton();
// Private constructor suppresses generation of
// a (public) default constructor
private Singleton() {}
public static Singleton getInstance() {
return INSTANCE;
}
}
The classic Singleton does not use direct instantiation of a static variable with declaration -- it instantiates a static instance variable in the constructor without checking to see if it already exists:
public class ClassicSingleton {
private static ClassicSingleton INSTANCE = null;
private ClassicSingleton() {
// Exists only to defeat instantiation.
}
public static ClassicSingleton getInstance() {
if(INSTANCE == null) {
INSTANCE = new ClassicSingleton();
}
return INSTANCE;
}
}
The Singleton class's default constructor is made private, which prevents the direct instantiation of the object by other classes using the new keyword. A static modifier is applied to the instance method that returns the Singleton object; it makes this a class level method that can be accessed without creating an object.
When you need Singleton
Singletons are truly useful when you need only one instance of a class, and it is undesirable to have more than one instance of a class.
When designing a system, you usually want to control how an object is used and prevent users (including yourself) from making copies of it or creating new instances. For example, you can use it to create a connection pool. It's not wise to create a new connection every time a program needs to write something to a database; instead, a connection or a set of connections that are already a pool can be instantiated using the Singleton pattern.
The Singleton pattern is often used in conjunction with the factory method pattern to create a systemwide resource whose specific type is not known to the code that uses it. An example of using these two patterns together is the Abstract Windowing Toolkit (AWT). In GUI applications, you often need only one instance of a graphical element per application instance, like the Print dialog box or the OK button.
Watch out for potential problems
Although the Singleton design pattern is one of the simplest design patterns, it presents a number of pitfalls.
Construct in multi-threaded applications
You must carefully construct the Singleton pattern in multi-threaded applications. If two threads are to execute the creation method at the same time when a Singleton does not exist, both must check for an instance of the Singleton, but only one thread should create the new object. The classic solution to this problem is to use mutual exclusion on the class that indicates that the object is being instantiated. This is a thread-safe version of a Singleton:
public class Singleton
{
// Private constructor suppresses generation
// of a (public) default constructor
private Singleton() {}
private static class SingletonHolder
{
private final static Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance()
{
return SingletonHolder.INSTANCE;
}
}
For an alternative solution, you can add the synchronized keyword to the getInstance() method declaration:
public static synchronized Singleton getInstance()
Think ahead about cloning prevention
You can still create a copy of the Singleton object by cloning it using the Object's clone() method. To forbid this, you need to override the Object's clone method, which throws a CloneNotSupportedException exception:
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
Consider making the singleton class final
You may want to make the Singleton class final to avoid sub classing of Singletons that may cause other problems.
Remember about garbage collection
Depending on your implementation, your Singleton class and all of its data might be garbage collected. This is why you must ensure that there must be a live reference to the Singleton class when the application is running.
Conclusion
The Singleton pattern is widely used and has proved its usability in designing software. Although the pattern is not specific to Java, it has become a classic in Java programming. Despite its simplicity, remember the limitations of the Singleton pattern that I describe in this article.
Subscribe to:
Posts (Atom)