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.
Friday, January 29, 2010
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)