how to generate a unique number

[rob morkos]

I want to create a unique number in java, because I need the unique Id before, so that I can insert in many tables within the database simultaneous without making any problems with my tables relations with each other. Is it possible and I would really appreciate any comments or code example. I would of liked to let my database generate it by making my field auto number, but the requirements was that I have the unique number before. Thanks in advance.

[Maulin Vasavada]

hi Rob,
well, the generation of Unique ID depends a lot upon your application, you know. what kind of fields you have, what kind of other constraints you have. how you are going to use the Unique ID in your application etc....
but as far as i remember there isn't a direct way you can generate like GUID using some standard Java Class (please let me know if you don't know what GUID means) EXCEPT one RMI utility which uses IP address and an object reference unique across that IP address (across the JVM running on that machine).
look at,
java.rmi.server.ObjId
for details.
i am not sure if this is useful to you because this depends upon IP address and in RMI the server is usually having Unique IP (please post more questions on RMI at Remote Objects forum on Javaranch as i 'm not at all a wizard of RMI. i just know little bit) but in your case it might not be applicable you know.
just my 2 cents.
maulin

[Greg Brouelette]

The getTime() method of the Date class returns the number of milliseconds since Jan 1st 1970. You could always just construct a date object and ask for it's time to get a unique number (it's a long). As long as you don't have so many users that they're asking for ID's faster than once a millisecond you should be fine.

[Christopher Farnham]

Here is a class that I wrote a while ago... I have used it for several projects.... use it at your own risk.
I have a GlobalUniqueObject interface so that you can use it via inheritance or composition.... if you see any problems with it, i'd appreciate it if you let me know....
Chris

 
package com.cfe.core.util;
import java.net.InetAddress;
import java.security.SecureRandom;
/**
 * <b>Created Thu May 02 15:02:54 2002</b>
 * <p>
 * Comments
 * </p>
 * @author  cfarnham
 * @version 1.0
 * <p>
 * This GUID algorithm was taken from an article on <a href="http://www.theserverside.com." target="_blank" rel="nofollow">www.theserverside.com.</a>
 * See the article
 * <a href="http://theserverside.com/patterns/thread.jsp?thread_id=4976>here</a>.
 * <p>
 * The specification that defines the format of UUIDs can be found 
 * <a href="http://www.webdav.org/specs/draft-leach-uuids-guids-01.txt">here</a>.
 * <P>
 * This object creates a 36-digit alphanumeric (including hyphens) of the format
 * xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.  This String is unique to time, instance, and
 * geography without the use of a Singleton.  The mechanism is detailed below.
 * <p>
 * 1) (1-8 hex characters) use the low 32 bits of System.currentTimeMillis(). We could
 * use the recommended date format by adding 12219292800000L to the
 * system time long before grabbing the low 32 bits but
 * there doesn't seem much point. This gives us a
 * uniqueness of a millisecond - therefore any clashing object will have
 * to be generated within the same millisecond. 
 * <p>
 * But this does not give us a uniqueness in space or complete uniqueness
 * in time.
 * <p>
 * 2) (9-16 hex characters) the IP address
 * of the machine as a hex representation of the 32
 * bit integer underlying IP - gives us a spatial uniqueness to
 * a single machine - guarantees that these characters will be different
 * for machines in a cluster or on a LAN. 
 * <p>
 * We now have machine uniqueness per millisecond - but this does not
 * account for multiple objects on a machine, clock sequence being
 * reset or the same object producing multiple GUIDs per millisecond. 
 * <p>
 * 3) (17-24 hex characters) the hex value of the
 * Stateless Session bean object's hashCode (a 32 bit int)
 * - in the Java language spec - the hashcode value of Object
 * is defined as - ((As much as is reasonably practical, the
 * hashCode method defined by class object does return distinct integers
 * for distinct objects. (This is typically implemented by converting the
 * internal address of the object into an integer, but this
 * implementation technique is not required by the Java programming language.))
 * <p>
 * This removes the need for a singleton object as the
 * Stateless bean uses its own hashCode as part of the
 * GUID - so even if two objects create a value at
 * the same millisecond on the same machine these characters will
 * be different. Remember the hashCode is not over-ridden here
 * so the implementation will be the one for Object. Note
 * - on machines with low RAM the most significant characters will
 * always be 00 in the hashcode sequence. 
 * <p>
 * So we now have a number that is unique to the millisecond, the
 * IP address and the object creating it. There is still
 * the possibility that the same object can produce many GUIDs
 * within the same millisecond or the clock may be reset. 
 * <p>
 * 4) (25-32 hex characters) a random 32 bit integer
 * generated for each method invocation from the SecureRandom java class
 * using SecureRandom.nextInt(). This method produces a cryptographically strong pseudo
 * -random integer. The Java lang defines this as - 
 * ((Returns a pseudo-random, uniformly distributed int value drawn from this random
 * number generator's sequence. The general contract of nextInt is
 * that one int value in the specified range is pseudorandomly
 * generated and returned. All n possible int values are produced
 * with (approximately) equal probability.))
 * <p>
 * By adding a random int to
 * the GUID for each new request we now have a
 * GUID that has a combination of the following four properties
 * <p>
 * 1) is unique to the millisecond <br>
 * 2) is unique to the machine <br>
 * 3) is unique to the object creating it<br>
 * 4) is unique to the method call for the same object <br>
 * 
 **/
public class GlobalUniqueObjectImpl implements GlobalUniqueObject {
//**************************
// Private static variables
//**************************
//GUID stuff
private static String HEX_INET_ADDRESS; //32 bits
//initialize the secure random instance
private static SecureRandom SEEDER = new SecureRandom();
//**************************
// Instance variables
//**************************
//the guid string
private String _guid;
//init to super.hashcode() which becomes
//part of the guid
private int _hashCode = super.hashCode();
//**************************
// Constructors
//**************************
public GlobalUniqueObjectImpl() throws GlobalObjectCreationException {
this._guid = createGUID(this);
_hashCode = this.getGUID().hashCode();
}
//**************************
// Public methods
//**************************
/**
 * Return the GUID
 */
public final String getGUID() {
return this._guid;
}
public void setGUID(String guid) {
this._guid = guid;
}
public boolean equals(Object o) {
boolean returnBoolean = false;
if (o instanceof GlobalUniqueObjectImpl) {
GlobalUniqueObjectImpl guid = (GlobalUniqueObjectImpl) o;
returnBoolean = this.getGUID().equals(guid.getGUID());
}
return returnBoolean;
}
public final int hashCode() {
return _hashCode;
}
public String toString() {
return _guid;
}
/**
 * Creates a guid for the given object
 **/
public static final String createGUID(Object o)
throws GlobalObjectCreationException {
String midValue = initGUID(o.hashCode());
long timeNow = System.currentTimeMillis();
int timeLow = (int) timeNow & 0xFFFFFFFF; //32 bits
int node = SEEDER.nextInt(); //32 bits
String strTimeLow = intToHexString(timeLow, 8);
String strNode = intToHexString(node, 8);
StringBuffer buff =
new StringBuffer(strTimeLow).append(midValue).append(strNode);
return buff.toString().toUpperCase();
}
//**************************
// Private methods
//**************************
/**
 * Creates the  objects that are reused from 
 * instance to instance
 **/
private static final String initGUID(int hashCode)
throws GlobalObjectCreationException {
String returnString;
try {
// get the inet address
InetAddress inet = InetAddress.getLocalHost();
byte[] bytes = inet.getAddress();
HEX_INET_ADDRESS = intToHexString(getInt(bytes), 8);
//get the hashcode as hexvalue at least 8 chars long
String thisHashCode = intToHexString(hashCode, 8);
//set up a cached midValue as this is the same per method
//call as is object specific and is the mid part 
//of the sequence
StringBuffer buff = new StringBuffer();
buff.append("-");
buff.append(HEX_INET_ADDRESS.substring(0, 4));
buff.append("-");
buff.append(HEX_INET_ADDRESS.substring(4));
buff.append("-");
buff.append(thisHashCode.substring(0, 4));
buff.append("-");
buff.append(thisHashCode.substring(4));
returnString = buff.toString();
//load up the randomizer first value
int node = SEEDER.nextInt();
} catch (Exception e) {
e.printStackTrace();
throw new GlobalObjectCreationException(e, "Error creating guid ");
}
return returnString;
}
/**
 * Converts an int to a HexString of a specific length.
 * it pads a string with 0's or snips it as appropriate.
 * @param int n the int that you want converted
 * @param int length the length of the string you want returned
 **/
private static String intToHexString(int n, int length) {
char[] hexArray = Integer.toHexString(n).toCharArray();
char[] returnArray = new char[length];
int lDiff = returnArray.length - hexArray.length;
for (int i = 0; i < returnArray.length; i++) {
if (i < lDiff) {
returnArray[i] = '0';
} else {
//index needs to start from the back
returnArray[i] = hexArray[i - lDiff];
}
}
return new String(returnArray);
}
/**
 * Converts a byte array to an int.
 **/
private static int getInt(byte[] array)
throws GlobalObjectCreationException {
int returnInt = 0;
StringBuffer buff = new StringBuffer();
for (int i = 0; i < array.length; i++) {
int n = array[i] & 0xFF;
buff.append(Integer.toString(n));
}
//cut the string off at 9 digits as any more would be too big
//and throw a NumberFormatException
//System.out.println( buff.toString() );
if (buff.length() > 9) {
returnInt = Integer.parseInt(buff.toString().substring(0, 10));
} else {
returnInt = Integer.parseInt(buff.toString());
}
return returnInt;
}
}
/**
 * GlobalUniqueObjectImpl ends here
 **/