The Bucket @ Utropicmedia » Java

Asymmetric Cryptography in Java

Utropicmedia — Sat, 04 Sep 2010 02:52:23 +0000

Asymmetric Cryptography in Java

Security plays a significant role in our day to day life. So far software applications are concerned, security of data is required for authentication and for several validations. Normally while developing the applications, we use the concept of cryptography for password encryption and decryption. Some applications require more security, so they go for high end security system like trusted security certificates. The security mainly focuses on the integrity of the data at the several ends.

Technicalities For data security Java Cryptography provides a suitable framework to implement several kinds of cryptography. However there are basically two types of cryptography. Once is Symmetric Cryptography and Asymmetric Cryptography. When both the ends communicate the secured data with a common key for encryption and decryption, it is called the Symmetric Cryptography. In this case a shared key is used by both the parties to encrypt and decrypt the data. However there is a problem relating to exchange of key for symmetric cryptography. To overcome this problem java provides another approach for the cryptography called Asymmetric Cryptography. In case of Asymmetric cryptography, there will be two keys unlike one key in case of symmetric cryptography. One key is called Private key and other is called Public key. These two keys are generated together and can be used for encryption and decryption. In this case the Public key is used by anyone who wishes to communicate securely with the owner of the Private key. The Private key is used by the main owner and the owner gives the Public key so that they can decrypt the data. In this article I will give you the example on Asymmetric cryptography. You can find more tutorials and concept on Sun’s JCE(Java Cryptography Extension). In my next article, I will provide you the example on Symmetric cryptography.

Complete Example This example is only meant for learning and not for any specific use. You can take the piece of code to test in your system to learn the above concept.

The following class is used to create the Public key and Private key. This class contains generic methods to generate the Public and Private key. If you run the testharness class, you will find the two files called “Public.key” and “Private.key”. Please go through the java docs mentioned in the methods.

Class Name : – KeyCreator.java

package com.dds.security;

import java.io.FileOutputStream;

import java.io.IOException;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.PrivateKey;

import java.security.PublicKey;

/**This class is used to generate the Private and Public key file.

* The Public.key file and Private.key file will be generated in the

* current directory.

* @author Debadatta Mishra(PIKU)

public class KeyCreator

{

/**

* Object of type {@link PublicKey}

private PublicKey publicKey = null;

/**

* Object of type {@link PrivateKey}

private PrivateKey privateKey = null;

/**Default constructor.

* Here KeyPair object is initialized and

* thereby public key and private key objects

* are created.

* @throws Exception

public KeyCreator() throws Exception

{

super();

* The following line is used to

* generate the Public and Private

* key.

KeyPair keyPair = KeyPairGenerator

.getInstance(“RSA”)

.generateKeyPair();

publicKey = keyPair.getPublic();

privateKey = keyPair.getPrivate();

}

/**Method to return the {@link PublicKey}

* @return the {@link PublicKey}

public PublicKey getPublicKey() {

return publicKey;

}

/**Method to return the {@link PrivateKey}

* @return the {@link PrivateKey}

public PrivateKey getPrivateKey() {

return privateKey;

}

/**Method used to write the Public or Private

* key file.

* @param filename of type String indicating

* the name of Public or Private key

* @param contents of the key

public void writeKey(String filename, byte[] contents)

{

try

{

FileOutputStream fos = new FileOutputStream(filename);

fos.write(contents);

fos.flush();

fos.close();

}

catch (IOException e)

{

e.printStackTrace();

}

The following class is used to read the “Public.key” and “Private.key” generated by the above program. If you are the owner you can have the “Private.key” file based upon which you have to encrypt the data and give your “Public.key” file to other end who wants to decrypt the data. In this following class, you can read both the “Public.key” and “Private.key” files.

Class Name:- KeyReader.java

package com.dds.security;

import java.io.ByteArrayOutputStream;

import java.io.FileInputStream;

import java.io.IOException;

import java.security.KeyFactory;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

/**

* This class is used to read the Private and Public key

* files generated using the Java’s Asysmmetric Security

* system.

* @author Debadatta Mishra(PIKU)

public class KeyReader

{

/**

* Object of type {@link KeyFactory}

private KeyFactory keyFactory = null;

/**

* Default constructor to initialize the

* keyFactory.

public KeyReader()

{

super();

try

{

keyFactory = KeyFactory.getInstance(“RSA”);

}

catch( Exception e )

{

e.printStackTrace();

}

/**This method is used to read the bytes from the file.

* The file can be a Public key file or a Private key

* file. In this file, you have stored the security key,

* based upon which encryption and decryption can be

* performed.

* @param fileName of type String indicating the file name

* @return the bytes from the file

* @throws Exception

private byte[] getKeyData( String fileName ) throws Exception

{

FileInputStream fis = new FileInputStream(fileName);

ByteArrayOutputStream baos = new ByteArrayOutputStream();

int b;

try

{

while ((b = fis.read()) != -1)

{

baos.write(b);

}

fis.close();

baos.flush();

baos.close();

} catch (IOException e) {

e.printStackTrace();

}

return baos.toByteArray();

}

/**This method is used to return the object of type

* {@link PrivateKey}. In this method you have to pass

* the file name of the Private.key file.

* @param filename of type String indicating the

* file name.

* @return the object of type {@link PrivateKey}

* @throws Exception

public PrivateKey getPrivateKey( String filename ) throws Exception

{

PrivateKey privateKey = null;

try

{

byte[] keydata = getKeyData(filename);

PKCS8EncodedKeySpec encodedPrivateKey = new PKCS8EncodedKeySpec(keydata);

privateKey = keyFactory.generatePrivate(encodedPrivateKey);

}

catch( Exception e )

{

e.printStackTrace();

}

return privateKey;

}

/**This method is used to return the object of type

* {@link PublicKey}. In this method you have to pass

* the file name of the Public.key file.

* @param filename of type String indicating the

* file name.

* @return the object of type {@link PublicKey}

* @throws Exception

public PublicKey getPublicKey( String filename ) throws Exception

{

PublicKey publicKey = null;

try

{

byte[] keydata = getKeyData(filename);

X509EncodedKeySpec encodedPublicKey = new X509EncodedKeySpec(keydata);

publicKey = keyFactory.generatePublic(encodedPublicKey);

}

catch( Exception e )

{

e.printStackTrace();

}

return publicKey;

}

The following class is a utility class which is used to encrypt and decrypt the data.

ClassName :- SecurityUtil.java

package com.dds.security;

import java.security.PrivateKey;

import java.security.PublicKey;

import javax.crypto.Cipher;

/**This is a utility class to provide

* encryption and decryption based upon

* the key. The key can be your either

* Public or Private .

* @author Debadatta Mishra(PIKU)

public class SecurityUtil

{

/**

* Object of type {@link Cipher}

private static Cipher cipher = null;

* The following static is used to

* initialize the Cipher object

static

{

try

{

cipher = Cipher.getInstance(“RSA”);

}

catch( Exception e )

{

e.printStackTrace();

}

/**Method used to encrypt the string and return as bytes.

* Here the input parameter will be your Private key.

* You have to encrypt the string using your private

* key at your end.

* @param messsageBytes , it is the bytes from the

* string to encrypt

* @param privateKey of type {@link PrivateKey}

* @return encrypted bytes

* @throws Exception

public static byte[] getEncryptedBytes( byte[] messsageBytes , PrivateKey privateKey) throws Exception

{

byte[] encryptedBytes = null;

cipher.init(Cipher.ENCRYPT_MODE , privateKey );

encryptedBytes = cipher.doFinal(messsageBytes);

return encryptedBytes;

}

/**Method used to decrypt the string and return as bytes.

* Here the input parameter will be your Public key.

* You have to decrypt the string using your Public

* key at the destination end.

* @param messsageBytes , it is the bytes from the

* string to encrypt

* @param publicKey of type {@link PublicKey}

* @return decrypted bytes

* @throws Exception

public static byte[] getDecryptedBytes( byte[] messsageBytes , PublicKey publicKey)throws Exception

{

byte[] decryptedBytes = null;

cipher.init(Cipher.DECRYPT_MODE , publicKey );

decryptedBytes = cipher.doFinal( messsageBytes );

return decryptedBytes;

}

The following is test harness class to test the functionality of the above program. Please go through the comments and java docs of the above and below programs.

Class Name :- SecurityTestHarness.java

package com.security.testharness;

import java.security.PrivateKey;

import java.security.PublicKey;

import com.dds.security.KeyCreator;

import com.dds.security.KeyReader;

import com.dds.security.SecurityUtil;

/**This is a test harness class used to

* encrypt and decrypt the string based

* upon the Public and Private key.

* This class also helps to test how

* Public and Private key can be created.

* @author Debadatta Mishra(PIKU)

public class SecurityTestHarness

{

public static void main(String[] args)

{

try

{

* The following lines will generate the

* PublicKey and PrivateKey files.

KeyCreator keyCreator = new KeyCreator();

PublicKey publicKey = keyCreator.getPublicKey();

PrivateKey privateKey = keyCreator.getPrivateKey();

* Generate two files named Public.key and Private.key

keyCreator.writeKey(“Public.key”, publicKey.getEncoded());

keyCreator.writeKey(“Private.key”, privateKey.getEncoded());

* Get the public and private key

KeyReader keyReader = new KeyReader();

PublicKey publicKey2 = keyReader.getPublicKey(“Public.key”);

System.out.println(“Public Key—-”+publicKey2);

PrivateKey privateKey2 = keyReader.getPrivateKey(“Private.key”);

System.out.println(“Private Key—-”+privateKey2);

String str = “Hi, Hello World, Welcome to the World of Java”;

byte[] stringBytes = str.getBytes();

byte[] encryptedBytes = SecurityUtil.getEncryptedBytes(

stringBytes, privateKey2);

String encryptedString = new String(encryptedBytes);

System.out.println(“EncryptedString—-”+encryptedString);

byte[] decryptedBytes = SecurityUtil.getDecryptedBytes(encryptedBytes, publicKey2);

System.out.println(“Decrypted String—-”+new String(decryptedBytes));

}

catch( Exception e )

{

e.printStackTrace();

}

To test the above programs, please create the appropriate package as mentioned in the program. You can also create your own package and modify the package name in the above programs. You can all the code in your favorable java editor.

Conclusion I hope that you will enjoy my article. If you find any problems or errors, please feel free to send me a mail in the address debadattamishra@aol.com . This article is only meant for those who are new to java development. This article does not bear any commercial significance. Please provide me the feedback about this article.

Use of Hibernate With Java Persistence Api

Utropicmedia — Fri, 27 Aug 2010 11:31:52 +0000

Use of Hibernate With Java Persistence Api

Before we start any discussion about Persistence technologies, we need to understand what exactly Persistence is in computer science. Persistence, in simple terms is the ability to retain data structures between various program executions. A perfect example of this would be a word processor saving undo history. In practice, this is achieved by storing the data in non- volatile storage such as a file system or a relational database or an object database.

The popularity of databases has increased manifold in the past few years. Java has become the preferred choice of developers for developing secure, flexible, and scalable database driven web applications. These web applications require objects to be associated with appropriate databases. Hibernate, along with other persistence technologies associate’s objects with the appropriate database in a simple, straight forward and natural way.

Hibernate is one such effort from the Java community to develop many object oriented solutions to data persistence. Any kind of Java persistence solution includes two main elements i.e. ORM (Object Relational Mapping) and OOM (Object Oriented Modeling).

Hibernate has become immensely popular amongst the developer community as it is a free, powerful, high performance open source object – relational mapping persistence Java package that makes it easier to work with relational databases for Java Applications.

Apart from Hibernate, other popular open source Java persistence technologies include JDBC, abates, JDO, Top Link and CMP Entity Beans. These technologies provide a standardized object-relational mapping mechanism.

Java persistence application programming Interface or JAVA Persistence API is the latest version of the Java Data Objects (JDO) technology which was the earlier persistent technology used by developers. JPA or the Java Persistence API is the latest Java Specification standard for java enterprise applications. The Java Persistence API is a java programming language framework that allows developers to manage relational data in Java standard edition and Enterprise Edition applications. Java Persistence API originated as part of the work of the JSR 220 expert group.

The java persistence API’s has been developed after drawing upon the best ideas from other prevalent persistence technologies like Top link, JDO, Hibernate etc. In simple words, Java Persistence API is a Plain Old Java Object API for object /relational mapping and supports a rich, SQL –like query language for both static and dynamic queries.Vendors involved in application development have found that the use of Hibernate technology with Java persistence API’s helps build flexible, database driven web applications that are highly scalable and involve complex business processes.

The Java Persistence API is the standard object/relational mapping and persistence management interface of the Java EE 5.0 platform and Java Web Services Development . As part of the EJB 3.0 specification effort, it is supported by all major vendors of the Java industry for improving Java Web Development in India and Globe.

Encryption Using Rsa Algorithm in Java

Utropicmedia — Fri, 27 Aug 2010 01:39:56 +0000

Encryption Using Rsa Algorithm in Java

Encryption using RSA algorithm in java

Introduction

In this article I will provide you an approach of using RSA algorithm for long String. As you know that RSA algorithm is limited 117 bytes, long strings can not be encrypted or decrypted. However it is possible to break the bytes into several chunks and then to encrypt or decrypt the contents. This algorithm is used for asymmetric cryptography. For asymmetric cryptography, you can click this link.

Technicalities

In this article I provide below the complete example for encryption and decryption of long strings. If you use the method of Cipher class ie.doFinal( byte[] bytesString), it will throw exception that it can be encrypted for more than 117 bytes for RSA. But in the real application, you may not be sure about the length of the String you want to encrypt or decrypt. In this case you have to break the bytes and then to encrypt it. Please refer to the

Following complete example.

Complete example

Class name : SecurityUtil.java

package com.dds.core.security;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.Security;

import java.security.spec.EncodedKeySpec;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

import sun.misc.BASE64Decoder;

import sun.misc.BASE64Encoder;

import com.sun.crypto.provider.SunJCE;

/**This is a utility class which provides

* convenient method for security. This

* class provides the way where you can

* encrypt and decrypt the String having

* more than 117 bytes for RSA algorithm

* which is an asymmetric one.

* @author Debadatta Mishra(PIKU)

public class SecurityUtil {

/**

* Object of type {@link KeyPair}

private KeyPair keyPair;

/**

* String variable which denotes the algorithm

private static final String ALGORITHM = “RSA”;

/**

* varibale for the keysize

private static final int KEYSIZE = 1024;

/**

* Default constructor

public SecurityUtil() {

super();

Security.addProvider(new SunJCE());

}

/**

* This method is used to generate

* the key pair.

public void invokeKeys() {

try {

KeyPairGenerator keypairGenerator = KeyPairGenerator

.getInstance(ALGORITHM);

keypairGenerator.initialize(KEYSIZE);

keyPair = keypairGenerator.generateKeyPair();

} catch (Exception e) {

e.printStackTrace();

}

/**This method is used to obtain the String

* representation of the PublicKey.

* @param publicKey of type {@link PublicKey}

* @return PublicKey as a String

public String getPublicKeyString(PublicKey publicKey) {

return new BASE64Encoder().encode(publicKey.getEncoded());

}

/**This method is used to obtain the String

* representation of the PrivateKey.

* @param privateKey of type {@link PrivateKey}

* @return PrivateKey as a String

public String getPrivateKeyString(PrivateKey privateKey) {

return new BASE64Encoder().encode(privateKey.getEncoded());

}

/**This method is used to obtain the

* {@link PrivateKey} object from the

* String representation.

* @param key of type String

* @return {@link PrivateKey}

* @throws Exception

public PrivateKey getPrivateKeyFromString(String key) throws Exception {

PrivateKey privateKey = null;

try {

KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);

EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(

new BASE64Decoder().decodeBuffer(key));

privateKey = keyFactory.generatePrivate(privateKeySpec);

} catch (Exception e) {

e.printStackTrace();

}

return privateKey;

}

/**This method is used to obtain the {@link PublicKey}

* from the String representation of the Public Key.

* @param key of type String

* @return {@link PublicKey}

* @throws Exception

public PublicKey getPublicKeyFromString(String key) throws Exception {

PublicKey publicKey = null;

try {

KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);

EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(

new BASE64Decoder().decodeBuffer(key));

publicKey = keyFactory.generatePublic(publicKeySpec);

} catch (Exception e) {

e.printStackTrace();

}

return publicKey;

}

/**This method is used to obtain the

* encrypted contents from the original

* contents by passing the {@link PublicKey}.

* This method is useful when the byte is more

* than 117.

* @param text of type String

* @param key of type {@link PublicKey}

* @return encrypted value as a String

* @throws Exception

public String getEncryptedValue(String text, PublicKey key)

throws Exception {

String encryptedText;

try {

byte[] textBytes = text.getBytes(“UTF8″);

Cipher cipher = Cipher.getInstance(“RSA/ECB/PKCS1Padding”);

cipher.init(Cipher.ENCRYPT_MODE, key);

int textBytesChunkLen = 100;

int encryptedChunkNum = (textBytes.length – 1) / textBytesChunkLen

+ 1;

// RSA returns 128 bytes as output for 100 text bytes

int encryptedBytesChunkLen = 128;

int encryptedBytesLen = encryptedChunkNum * encryptedBytesChunkLen;

System.out.println(“Encrypted bytes length——-”

+ encryptedBytesChunkLen);

// Define the Output array.

byte[] encryptedBytes = new byte[encryptedBytesLen];

int textBytesChunkIndex = 0;

int encryptedBytesChunkIndex = 0;

for (int i = 0; i

if (i

encryptedBytesChunkIndex = encryptedBytesChunkIndex

+ cipher.doFinal(textBytes, textBytesChunkIndex,

textBytesChunkLen, encryptedBytes,

encryptedBytesChunkIndex);

textBytesChunkIndex = textBytesChunkIndex

+ textBytesChunkLen;

} else {

cipher.doFinal(textBytes, textBytesChunkIndex,

textBytes.length – textBytesChunkIndex,

encryptedBytes, encryptedBytesChunkIndex);

}

encryptedText = new BASE64Encoder().encode(encryptedBytes);

} catch (Exception e) {

throw e;

}

return encryptedText;

}

/**This method is used to decrypt the contents.

* This method is useful when the size of the

* bytes is more than 117.

* @param text of type String indicating the

* encrypted contents.

* @param key of type {@link PrivateKey}

* @return decrypted value as a String

public String getDecryptedValue(String text, PrivateKey key) {

String result = null;

try {

byte[] encryptedBytes = new BASE64Decoder().decodeBuffer(text);

Cipher cipher = Cipher.getInstance(“RSA/ECB/PKCS1Padding”);

cipher.init(Cipher.DECRYPT_MODE, key);

int encryptedByteChunkLen = 128;

int encryptedChunkNum = encryptedBytes.length

/ encryptedByteChunkLen;

int decryptedByteLen = encryptedChunkNum * encryptedByteChunkLen;

byte[] decryptedBytes = new byte[decryptedByteLen];

int decryptedIndex = 0;

int encryptedIndex = 0;

for (int i = 0; i

if (i

decryptedIndex = decryptedIndex

+ cipher.doFinal(encryptedBytes, encryptedIndex,

encryptedByteChunkLen, decryptedBytes,

decryptedIndex);

encryptedIndex = encryptedIndex + encryptedByteChunkLen;

} else {

decryptedIndex = decryptedIndex

+ cipher.doFinal(encryptedBytes, encryptedIndex,

encryptedBytes.length – encryptedIndex,

decryptedBytes, decryptedIndex);

}

result = new String(decryptedBytes).trim();

} catch (Exception e) {

e.printStackTrace();

}

return result;

}

/**This method is used obtain the

* {@link PublicKey}

* @return {@link PublicKey}

public PublicKey getPublicKey() {

return keyPair.getPublic();

}

/**This method is used to obtain

* the {@link PrivateKey}

* @return {@link PrivateKey}

public PrivateKey getPrivateKey() {

return keyPair.getPrivate();

}

The above class provides several useful methods for generation of Private key , Public Key and encryption of String and decryption of String.

Please refer to the following subordinate classes for the above class.

Class name : KeyGenerator.java

package com.dds.core.security;

import java.io.File;

import java.io.FileOutputStream;

import java.io.OutputStream;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.util.Properties;

/**This class is used to generate the

* Private and Public key and stores

* them in files.

* @author Debadatta Mishra(PIKU)

public class KeyGenerator {

/**This method is used to obtain the

* path of the keys directory where

* Private and Public key files are

* stored.

* @return path of the keys directory

private static String getKeyFilePath() {

String keyDirPath = null;

try {

keyDirPath = System.getProperty(“user.dir”) + File.separator

+ “keys”;

File keyDir = new File(keyDirPath);

if (!keyDir.exists())

keyDir.mkdirs();

} catch (Exception e) {

e.printStackTrace();

}

return keyDirPath;

}

/**

* This method is used to generate the

* Private and Public keys.

public static void generateKeys() {

Properties publicProp = new Properties();

Properties privateProp = new Properties();

try {

OutputStream pubOut = new FileOutputStream(getKeyFilePath()

+ File.separator + “public.key”);

OutputStream priOut = new FileOutputStream(getKeyFilePath()

+ File.separator + “private.key”);

SecurityUtil secureUtil = new SecurityUtil();

secureUtil.invokeKeys();

PublicKey publicKey = secureUtil.getPublicKey();

PrivateKey privateKey = secureUtil.getPrivateKey();

String publicString = secureUtil.getPublicKeyString(publicKey);

String privateString = secureUtil.getPrivateKeyString(privateKey);

publicProp.put(“key”, publicString);

publicProp.store(pubOut, “Public Key Info”);

privateProp.put(“key”, privateString);

privateProp.store(priOut, “Private Key Info”);

} catch (Exception e) {

e.printStackTrace();

}

The above class is used to generate the Public and Private keys. It generates and stores them in different files called Public.key and Private.key. Please refer the test harness class for the above class.

Class name: TestKeyGenerator

import com.dds.core.security.KeyGenerator;

/**This is a testharness class

* for the KeyGenerator class.

* @author Debadatta Mishra(PIKU)

public class TestKeyGenerator {

public static void main(String[] args) {

KeyGenerator.generateKeys();

}

If you run the above class, you will find a directory called keys in your root path of your application folder. In this folder you will find two files one is for Private Key information and another is for Public Key.

There is another class which is used to obtain the Private key and Public key information stored in the files.

Class name: KeyReader.java

package com.dds.core.security;

import java.io.File;

import java.io.FileInputStream;

import java.io.InputStream;

import java.security.PublicKey;

import java.util.Properties;

/**This class is used to read the

* keys from the file.

* @author Debadatta Mishra(PIKU)

public class KeyReader {

/**This method is used to obtain the

* string value of the Public Key

* from the file.

* @return String of {@link PublicKey}

public static String getPublicKeyString() {

String publicString = null;

try {

Properties prop = new Properties();

String publicKeyPath = System.getProperty(“user.dir”)

+ File.separator + “keys” + File.separator + “public.key”;

InputStream in = new FileInputStream(publicKeyPath);

prop.load(in);

publicString = prop.getProperty(“key”);

} catch (Exception e) {

e.printStackTrace();

}

return publicString;

}

/**This method is used to obtain the

* String of Private Key from the file.

* @return String of private key

public static String getPrivateKeyString() {

String publicString = null;

try {

Properties prop = new Properties();

String publicKeyPath = System.getProperty(“user.dir”)

+ File.separator + “keys” + File.separator + “private.key”;

InputStream in = new FileInputStream(publicKeyPath);

prop.load(in);

publicString = prop.getProperty(“key”);

} catch (Exception e) {

e.printStackTrace();

}

return publicString;

}

This is a utility class to read the Public and Private keys from the files.

Now refer to the test harness class which makes encryption and decryption of String.

import java.security.PrivateKey;

import java.security.PublicKey;

import com.dds.core.security.KeyReader;

import com.dds.core.security.SecurityUtil;

/**

* This is a test harness class for encryption and decryption.

* @author Debadatta Mishra(PIKU)

public class TestEncryption {

public static void main(String[] args) {

String privateKeyString = KeyReader.getPrivateKeyString();

SecurityUtil securityUtil = new SecurityUtil();

String publicKeyString = KeyReader.getPublicKeyString();

try {

PublicKey publicKey = securityUtil

.getPublicKeyFromString(publicKeyString);

PrivateKey privateKey = securityUtil

.getPrivateKeyFromString(privateKeyString);

String originalValue = “provide some very long string”;

String encryptedValue = securityUtil.getEncryptedValue(

originalValue, publicKey);

System.out.println(“EncryptedValue—–” + encryptedValue);

String decryptedValue = securityUtil.getDecryptedValue(

encryptedValue, privateKey);

System.out.println(“Original Value——” + decryptedValue);

} catch (Exception e) {

e.printStackTrace();

}

This test harness class is used to encrypt and decrypt the long string contents. You can also use the same method for file encryption and decryption. First you have to read the contents of a file as String and then you can apply method to encrypt it.

Conclusion

I hope that you will enjoy my article for this asymmetric cryptography for RSA. For asymmetric cryptography please refer to the link http://www.articlesbase.com/information-technology-articles/asymmetric-cryptography-in-java-438155.html. If you find any problems or errors, please feel free to send me a mail in the address debadattamishra@aol.com . This article is only meant for those who are new to java development. This article does not bear any commercial significance. Please provide me the feedback about this article

Use of Hibernate With Java Persistence Api

Utropicmedia — Sat, 21 Aug 2010 13:31:29 +0000

Use of Hibernate With Java Persistence Api

Vendors involved in application development have found that the use of Hibernate technology with Java persistence API’s helps build flexible, database driven web applications that are highly scalable and involve complex business processes.

Hot Or Not? Developing Applications With Java Programming

Utropicmedia — Wed, 18 Aug 2010 20:17:33 +0000

Hot Or Not? Developing Applications With Java Programming

Java is a general purpose programming language similar to C++ and was developed by Sun Microsystems to take advantage of the flourishing World Wide Web. Java programming language is well designed to develop effective web based applications and offers many advantages over other languages like C++. Technically, Java source code files (.java files) are compiled into bytecode (.class files). This complied java code is then executed by a Java interpreter. Since Java interpreters and Runtime environments called Java Virtual Machines exist for most operating systems (Windows OS, UNIX and Macintosh), you can run java based applications on almost every computer!

Portability

As explained Java is platform independent language which means you can write your application on one computer and can run that application on all computers. Java support is built into all major OS and popular web browsers, making it available on virtually every Internet-connected computer worldwide. Even electronic devices like mobile phones, set-top boxes and PDAs nowadays come with inbuilt Java applications.

Efficient Programming and Timeliness

Java is designed to remove common programming errors and comes with excellent set of APIs making it easier for programmers to write bug free code than in other languages. This in turn reduces development time and cost of any application.

Dynamic Characteristic of Programs

Java is object oriented language and the source code is organized in small units called classes. Programs written with Java code automatically call and load these classes whenever it is required to run the application. This means applications written in Java can dynamically expand their functionality by loading these classes anytime from the Java interpreter.

Security

Fortunately, Java programming and platform community is prompt enough in fixing security related bugs. Any new security bug on Java platform immediately catches eye of media because of the promises given by Java community for security!

Like any other programming language, Java is not spared of snags and hitches. Java is an interpreted language and hence programs written in Java language runs comparatively slow. But with availability of faster processors at competitive prices, this barrier should be only a temporary one.

In India, there are many Java web development companies having experienced team of Java programmers to develop quality Java applications with best feasible solutions. They are capable of developing highly interactive web solutions for your business with effective project management support. If you want expert programmers to create competitive Java web applications at affordable rates then India is the best destination. You just need to find right offshore development partner that best suit your business needs and budget. Outsourcing your Java web development projects can save you significant amount of time and money.

Improve your programming knowledge through Java Training courses

Utropicmedia — Mon, 16 Aug 2010 18:33:55 +0000

Improve your programming knowledge through Java Training courses

Java Training

Importance of java

Java is an object-oriented programming language developed by Sun Microsoft.It is one of the development programming language. Java was chosen as the programming language for network computers. It can be trianed by good Java Training center.Java has distributed, secure, architecture, robust, multi threaded and dynamic language. The program can be written once, and run anywhere”. One of the most significant advantages of Java is that, it has the ability to move easily from one computer to another. It also has the ability to run the same program on many different operating systems.

Java Training applications are designed to be compiled and then interpreted at runtime, unlike the conventional programming languages, which can either compile source code to native code or interpret the source code. The language itself has borrowed the syntax from C and C++. Java considers security as a part of its design. The Java language, its compiler, interpreter, and runtime environment are all developed with security. Writing network programs in Java is similar to sending and receiving data to and from a file.

The Java Training programming language was developed and re-designed for use on the Internet. In the internet domain, Java’s popularity has increased tremendously, especially on the server side of the Internet. Nowadays, there are a large number of Java experts who strive for the enhancement and improvement of Java development. For beginners who are interested in learning Java, the numerous Java tutorials or Java Training available online are good to start with. Java tutorials or Java Training and Java tips are the best resources for learning and improvising in Java.

Java Training Development experts are trying to enhance their programming skills for writing secure Java applications. In order to write a secure code in Java you need to be aware of various things such as data handling techniques, user authentication rules, access controls etc. JavaScript is a scripting language which shares a similar name and has the same syntax, but is in no way related to the core Java language..

Java Training

Improve your programming knowledge through Java Training courses

Java Training

Java is an object-oriented programming language developed by Sun Microsoft.It is one of the development programming language. Java was chosen as the programming language for network computers. It can be trianed by good Java Training center.Java has distributed, secure, architecture, robust, multi threaded and dynamic language.The Java Training programming language was developed and re-designed for use on the Internet. In the internet domain, Java’s popularity has increased tremendously, especially on the server side of the Internet. Nowadays, there are a large number of Java experts who strive for the enhancement and improvement of Java development. For beginners who are interested in learning Java, the numerous

Fresherlab.com is a young organization, based at India’s IT hub, Bangalore.
It’s a dynamic and competitive world with full of ups and downs in IT sector and therefore; the fresh engineers require just more than theoretical knowledge to get themselves ready for the industry. Academic institutions across the world provide the basic and conceptual fundamentals covering multiple areas in computer science. With increasing number of graduating engineers, but with constant number of companies, it becomes difficult for fresh engineers to compete with their unpolished skills because they need more effective and specialized quality training.

Java 2 Platform Enterprise Edition (j2ee) Three-tier Model

Utropicmedia — Fri, 13 Aug 2010 06:31:40 +0000

Java 2 Platform Enterprise Edition (j2ee) Three-tier Model

Enterprise edition of J2EE is used for developing modular enterprise request. It can be easily used on J2EE are distributed over 3 different locations, namely, J2EE server & database server, client machine, and at legacy system. The main advantages of using J2EE platform are:

* High Performance

* Lightweight Constant objects

* High amount of flexibility in operation platform and configuration

* Extensibility and maintainability

* Interoperability

* Focus on implementing business logic

* It should be easy to add and maintain new functionality.

Application logic used in Java 2 Platform Enterprise Edition us divided into different components depending on the function. They are differently installed on various machines totally depending on application it belongs to. For instance in Client machine, J2 EE server is divided into 2 main categories: Web Based Clients & application clients. Web based clients executes on a standard web browser. They do not typically execute intricate business rules, and database query. Usually heavy weights are offloaded to Enterprise java beans that help in controlling security, reliability and speed of J2EE server side technology. Whereas application clients run on Java Virtual machines that help in handling the richer user interface conveniently. Further they have the facility to access EJB on business tier as well. Similarly for other tier locations, there are assorted components.

If you like to take the advantages of J2EE Three-Tier Model then contact a software development company now. They will give you the necessary information (including both advantages and disadvantages of this technology).

Java Web Services India

2 Platform Enterprise Edition

All about “JAVA”

Utropicmedia — Fri, 06 Aug 2010 06:31:00 +0000

All about “JAVA”

Java is basically a programming language,which was originally developed by James Gosling (best known as the father of the Java programming language) at Sun microsystems which is now a subsidiary of Oracle Corporation. It was first released by Sun in 1995. In short, it is the underlying technology that powers state-of-the-art programs including utilities, games, and business applications. Java runs on more than 850 million personal computers worldwide, and on billions of devices worldwide, including mobile and TV devices.

Why do people need JAVA?

There are lots of applications and websites that won’t work unless you have Java installed, and more are created every day. Java is fast, secure, and reliable. From laptops to datacenters, game consoles to scientific supercomputers, cell phones to the Internet, Java is everywhere!

Characteristics of JAVA

The programs you create are portable in a network
The code is robust, here meaning that, unlike programs written in C++ and perhaps some other languages, the Java objects can contain no references to data external to themselves or other known objects.
Java is object-oriented, which means that, among other characteristics, an object can take advantage of being part of a class of objects and inherit code that is common to the class.
In addition to being executed at the client rather than the server, a Java applet has other characteristics designed to make it run fast.
Relative to C++, Java is easier to learn. (However, it is not a language you’ll pick up in an evening!)

Difference between JAVA and JAVASCRIPT

JavaScript should not be confused with Java. JavaScript, which originated at Netscape, is interpreted at a higher level and is easier to learn than Java, but lacks some of the portability of Java and the speed of bytecode. Because Java applets will run on almost any operating system without requiring recompilation and because Java has no operating system-unique extensions or variations, Java is generally regarded as the most strategic language in which to develop applications for the Web. (However, JavaScript can be useful for very small applications that run on the Web client or server.)

Editions

Sun has defined and supports four editions of Java targeting different application environments and segmented many of its APIs so that they belong to one of the platforms. The platforms are:

Java Card for smartcards.
Java Platform, Micro Edition (Java ME) — targeting environments with limited resources.
Java Platform, Standard Edition (Java SE) — targeting workstation environments.
Java Platform, Enterprise Edition (Java EE) — targeting large distributed enterprise or Internet environments.

Download

Java is free to download. You can get the latest version at http://java.com.

If you are building an embedded or consumer device and would like to include Java, please contact Oracle for more information on including Java in your device.

Why must you stay updated?

The latest Java version contains important enhancements to improve performance, stability and security of the Java applications that run on your machine. Installing this free update will ensure that your Java applications continue to run safely and efficiently.

Overall JAVA is a must for internet users to ensure a rich and wonderful experience on the web !

The Java Virtual Machine

Utropicmedia — Thu, 05 Aug 2010 09:30:24 +0000

The Java Virtual Machine

The Java virtual machine is called “virtual” because it is an abstract computer defined by a specification. To run a Java program,
you need a concrete implementation of the abstract specification. This chapter describes primarily the abstract specification of the Java virtual machine.
To illustrate the abstract definition of certain features, however, this chapter also discusses various ways in which those features could be implemented.

What ‘s the Java Virtual Machine?

To understand the Java virtual machine you must first be aware that you may be talking about any of three different things
when you say “Java virtual machine.” You may be speaking of the abstract specification, a concrete implementation, or a runtime instance.

The abstract specification is a concept, described in detail in the book: The Java Virtual Machine Specification, by Tim Lindholm and Frank Yellin.
Concrete implementations, which exist on many platforms and come from many vendors, are either all software or a combination of hardware and software.
A runtime instance hosts a single running Java application.
Each Java application runs inside a runtime instance of some concrete implementation of the abstract specification of the Java virtual machine.
In this book, the term “Java virtual machine” is used in all three of these senses. Where the intended sense is not clear from the context,
one of the terms “specification,” “implementation,” or “instance” is added to the term “Java virtual machine”.

The lifetime of a Java Virtual Machine

A runtime instance of the Java virtual machine has a clear mission in life: to run one Java application.
When a Java application starts, a runtime instance is born. When the application completes, the instance dies.
If you start three Java applications at the same time, on the same computer, using the same concrete implementation,
you’ll get three Java virtual machine instances. Each Java application runs inside its own Java virtual machine.
A Java virtual machine instance starts running its solitary application by invoking the method of some initial class.
The method must be public, static, return , and accept one parameter.
Any class with such a method can be used as the starting point for a Java application.

For example, consider an application that prints out its command line arguments:

// On CD-ROM in file jvm/ex1/Echo.javaclass Echo
{ public static void main(String[] args)
{
int len = args.length;
for (int i = 0; i {
System.out.print(args[i] + ” “);
}
System.out.println();
}
}

You must in some implementation-dependent way give a Java virtual machine the name of the initial class that has the method that
will start the entire application. One real world example of a Java virtual machine implementation is the program from Sun’s Java 2 SDK.
If you wanted to run the application using Sun’s on Window98, for example, you would type in a command such as:
java Echo Greetings, Planet.

The first word in the command, indicates that the Java virtual machine from Sun’s Java 2 SDK should be run by the operating system.
The second word, is the name of the initial class.must have a public static method named that returns and takes a array as its only parameter.
The subsequent words, are the command line arguments for the application.
These are passed to the method in the array in the order in which they appear on the command line.
So, for the previous example, the contents of the array passed to main,
The method of an application’s initial class serves as the starting point for that application’s initial thread.
The initial thread can in turn fire off other threads.
Inside the Java virtual machine, threads come in two flavors: daemon and non- daemon.
A daemon thread is ordinarily a thread used by the virtual machine itself, such as a thread that performs garbage collection.
The application, however, can mark any threads it creates as daemon threads.
The initial thread of an application–the one that begins at –is a non- daemon thread.
A Java application continues to execute (the virtual machine instance continues to live) as long as any non-daemon threads are still running.
When all non-daemon threads of a Java application terminate, the virtual machine instance will exit.
If permitted by the security manager, the application can also cause its own demise by invoking the method of class or .
In the application previous, the method doesn’t invoke any other threads. After it prints out the command line arguments, returns.
This terminates the application’s only non-daemon thread, which causes the virtual machine instance to exit.

The Architecture of the Java Virtual Machine

In the Java virtual machine specification, the behavior of a virtual machine instance is described in terms of subsystems, memory areas, data types,
and instructions. These components describe an abstract inner architecture for the abstract Java virtual machine.
The purpose of these components is not so much to dictate an inner architecture for implementations.
It is more to provide a way to strictly define the external behavior of implementations.
The specification defines the required behavior of any Java virtual machine implementation in terms of these abstract components and their interactions.
When a Java virtual machine runs a program, it needs memory to store many things, including bytecodes and other information
it extracts from loaded class files, objects the program instantiates, parameters to methods, return values, local variables,
and intermediate results of computations. The Java virtual machine organizes the memory it needs to execute a program into several runtime data areas.
Although the same runtime data areas exist in some form in every Java virtual machine implementation,
their specification is quite abstract. Many decisions about the structural details of the runtime data areas are left to the
designers of individual implementations.
Different implementations of the virtual machine can have very different memory constraints.
Some implementations may have a lot of memory in which to work, others may have very little.
Some implementations may be able to take advantage of virtual memory, others may not.
The abstract nature of the specification of the runtime data areas helps make it easier to implement the Java virtual machine on a wide
variety of computers and devices.
Some runtime data areas are shared among all of an application’s threads and others are unique to individual threads.
Each instance of the Java virtual machine has one method area and one heap. These areas are shared by all threads running inside the virtual machine.
When the virtual machine loads a class file, it parses information about a type from the binary data contained in the class file.
It places this type information into the method area. As the program runs, the virtual machine places all objects the program instantiates onto the heap.
As each new thread comes into existence, it gets its own pc register (program counter) and Java stack.
If the thread is executing a Java method (not a native method), the value of the pc register indicates the next instruction to execute.
A thread’s Java stack stores the state of Java (not native) method invocations for the thread.
The state of a Java method invocation includes its local variables, the parameters with which it was invoked,
its return value (if any), and intermediate calculations. The state of native method invocations is stored in an implementation-dependent way
in native method stacks, as well as possibly in registers or other implementation-dependent memory areas.
The Java stack is composed of stack frames (or frames). A stack frame contains the state of one Java method invocation. When a thread invokes a method,
the Java virtual machine pushes a new frame onto that thread’s Java stack. When the method completes, the virtual machine pops and discards
the frame for that method.
The Java virtual machine has no registers to hold intermediate data values. The instruction set uses the Java stack for storage of intermediate data values. This approach was taken by Java’s designers to keep the Java virtual machine’s instruction set compact and to facilitate implementation on architectures with few or irregular general purpose registers. In addition, the stack-based architecture of the Java virtual machine’s instruction set facilitates the code optimization work done by just-in-time and dynamic compilers that operate at run-time in some virtual machine implementations.

Aghreni Technologies Educational Services – Trainings on Open Source Technologies ( Perl, Php, Java, Ruby, Linux, Mysql)

Utropicmedia — Wed, 04 Aug 2010 12:29:14 +0000

Aghreni Technologies Educational Services – Trainings on Open Source Technologies ( Perl, Php, Java, Ruby, Linux, Mysql)

Aghreni offers skill enhancement courses in

· PErL, PHP, Ruby & java/J2ee

· Unix/linux

· Mysql

· Web development

· User interface design

· Veritas

· Usability engineering

· Project management

· Leadership

· Software development techniques

· Software testing techniques

Accessing Ms Access Using Java

Utropicmedia — Tue, 03 Aug 2010 15:29:44 +0000

Accessing Ms Access Using Java

Step by step guide:

1.Create a database in ms access and add a table

2.Add columns to the table.

3.Go to control panel->Administrative Tools

->JDBC-> System DSN

4.In System DSN tab click on add ,choose

Microsoft access driver ,then you will get a

dialog box opened ODBC Microsoft access setup

mention the data source name in it and in

databases click on select button and choose

your .mdb file that is created in step1.

5.Register the driver using

Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);

6.Connect to the database

Connection con = DriverManager.getConnection

(URL,userid,password);

url=” Jdbc:Odbc:”

userid and password are empty in case of MS access.if it oracle default userid is “scott” password is “tiger”.

Ex: Connection con = DriverManager.getConnection

( “Jdbc:Odbc:msac”, “”,”");

Source Code

import java.sql.*;

import java.io.*;

class JdbcDemo1

{

Connection con;

Statement stmt;

ResultSet rs;

JdbcDemo1(){

try{

Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);

con = DriverManager.getConnection( “Jdbc:Odbc:msac”, “”,”");

stmt = con.createStatement();

rs = stmt.executeQuery(“SELECT * FROM Table1″);

while (rs.next()) {

String x = rs.getString(“name”);

int s = rs.getInt(“age”);

System.out.println(“x:”+x+”s”+s);

}

}catch(SQLException e){

System.out.println(“Hello World!”+e);

}catch(ClassNotFoundException e){

System.out.println(“purni”+e);

}

class JdbcDemo

{

public static void main(String args[]){

new JdbcDemo1();

}

Java Mobile Phone Games: Best of 2006!

Utropicmedia — Mon, 02 Aug 2010 18:29:18 +0000

Java Mobile Phone Games: Best of 2006!

The year 2006 was an amazing year for mobile gaming fanatics as the gaming industry came up with few amazing games that had a heady mix of action-adventures to puzzlers to racers to just about everything! These latest mobile phone games developed by companies like Player One, Real, Gameloft, Glu, Digital Chocolate, THQ Wireless amongst others are selling like hotcakes in the market! People used to download free Java games till few years back but nowadays Mobile Games are mainly sold through Network Carriers/Operators portals.

With Java games going out of vogue these high octane games have started tempting the gaming community to come out and enjoy thrills dished out by them! These latest mobile phone games use platforms and technologies like Windows Mobile, Palm OS, Symbian OS, Macromedia’s Flash Lite, DoCoMo’s DoJa, Sun’s J2ME that have limited these exciting games to high end handsets only.

Few of the best games that won over people in UK are Tornado Mania, Stranded, NFS Carbon and host of other games. The original concept Tornado Mania of controlling a Tornado to wreck havoc on the city made it instant success with all of us, the slowly unfolding plot of Stranded, inspired from Channel 4’s Lost, kept us all hanging on the tenterhooks of excitement unparalleled. NFS Carbon is a hardcore urban racing game with full of ‘twists’ and turns with steep ravines adding an extra bit of excitement for the gamer!

These are just to name a few of the mobile games who finished the year on the pinnacle but there were others like Asphalt 3: Street Rules, 2006 Real Football, Mafia Wars Yakuza, Turbo Camels: Circus Extreme were few other games that enthralled us during the year that just went by. With games like Voodoo Kart, Age of Heroes III – Orc’s Retribution, America’s Army: Special Operations, Rodland and many others set to invade our mobile phones, the year 2007 is looking good!

Utropicmedia — Sun, 01 Aug 2010 21:31:03 +0000

It isn’t just about simple redecoration; Java Mosaic Tiles remodeling is about bringing a different style and natural atmosphere into your home design. If you wish to bring the contemporary, yet natural look into your home’s interior and exterior design, you should explore the countless opportunities provided by these unique panels. The following review will show you how you can easily remodel any room setting by using one of the most popular tiling techniques.

Basic introduction

The difference between this tiling method and other methods is the fact that Java Mosaic Tiles redecoration is actually based on a collection of unified smooth stones carefully sorted and then mounted onto a seamless mesh backed tile. Among thousands of seashores around the globe it seems like the South East Asian beaches provide the largest variety natural rock panels. Where can you use it? Practically anywhere inside and outside your home: Bathroom surfaces, kitchens, backsplash covering, patio floors, decks, pools, and even wine cellars.

What are the main benefits?

Let’s quickly examine what is in it for us:

* Durable to most common home detergents.
* Can be used for virtually unlimited applications at home, in the office, in restaurants, hotels, etc.
* Easy to be replaced if needed.

Useful advices!

* Order a small sample of the desired tiles prior to making a complete order – just to make sure it answers your expectations.

* Most recommended grout is sanded grout – it is suitable for both internal and external use.

* Upon completion, it is important to wait the adhesive’s recommended drying time before you begin on grouting.

There are probably many other benefits provided by this trendy redesigning technique simply because most people find it extremely easy to install and maintain.

On the bottom line

Many home-makers find this Java Mosaic Tiles technique quite effective due to the fact that it provides numerous opportunities and applications that easily enable you to transform any room setting modern and appealing. It is advised to keep the above advices before you begin with installation.

Utropicmedia — Sun, 01 Aug 2010 00:29:23 +0000

Did you ever consider remodeling home surfaces by yourself? Have you already tried using do-it-yourself Java Pebble Tiles remodeling? It seems like no other tiling technique can be used for so many applications as provided by these stone panels. Find out how to quickly and easily decorate any surface.

Getting some basics

This unique Java Pebble Tiles redecoration method is made of a set of identical beach-stones manually and carefully attached onto a mesh backing of 12′ by 12′ size. Among thousands of seashores around the globe it seems like the South East Asian beaches provide the largest variety natural rock panels. You can practically tile anywhere and for any purpose: a) Bathrooms b) Kitchens c) Internal and external flooring (patios for example) d) all types of backsplashes etc.

Benefits

Let’s quickly summarize the main advantages and benefits of this unique technique:

* Can be used inside as well as in the outside.
* Impervious to water and other liquids.
* Durable to any extreme temperatures such as around fireplaces and stoves for example.

Free valuable tips!

* Upon completion, it is important to wait the adhesive’s recommended drying time before you begin on grouting.

* When you prepare the grout avoid adding too much water in the initial mix – that additional water can result in weak grout that can flake.

* Order a small sample of the desired tiles prior to making a complete order – just to make sure it answers your expectations.

There are probably many other great benefits provided by this fashionable home redesigning technique simply because any home-maker can use it at minimal effort.

Quick summary

This affordable Java Pebble Tiles technique is probably one of the easiest and most effective coating choices available today. Should it be your first time installation, it is recommended to go over the above tips before installation.

Mount Bromo East Java Indonesia

Utropicmedia — Sat, 31 Jul 2010 03:30:52 +0000

Mount Bromo East Java Indonesia

There were 30 bikers from HTML Jakarta and 10 bikers from HTML Jogja who joined with HTML Honda Tiger Mailing List in order to participated “Tour d’Bromo”.

One of the touring purposes is the endurance from Jakarta to Bromo East Java (vice versa) but this event called as “Road to Unity for Tiger Community” with long distance at least 2,050 km.

Mount Bromo 3392 M and Mount Semeru 3676 M (photographer bro Dondee)

Saturday 8 April 2006 at 07.00 AM all bikers from Jakarta should stand-by in the meeting point in Jl. Sabang Jakarta Pusat where this place also known as the central meeting point of all HTML members on weekly basis.

This program said as a part of recreation touring but it was also included endurance test the engine oil of “Pertamina Enduro 4T”.

On the other hand, “Safety Riding Campaign” as the major program and prior should be practiced into HTML member. The campaigns as the commitment between HTML and Pertamina were supported safety riding on the national program.

“Pertamina Enduro 4T” also provides a free jacket, pin and T’shirt which to be used for all HTML Bikers and we wore a same uniform.

As usual before start all motorbike in physically and gear apparel bikers should be checked and screened in details following to the HTML Standard Operating Procedures (SOP). It was very details, professionally screening where all riders could not avoid this procedure in order to make sure everything warranted must safe, and participants are ready to go.

Following to HTML rules that each group should be divided into 3 groups maximum 8 riders. This small group a part of new rule from HSRT (HTML Safety Riding Team).

All bikers who start from Jakarta would met friends with HTML Jogja in Semarang City Central Java and thereafter the journey continued to Batu, Malang East Java.

Due to the a long distance journey, there were a good opportunity for all bikers who wants to develop his riding skill, especially to perform the individual skills, for instance how to become the Road Captain, VO, Sweeper, Technical Officer and Group Leader. Here everybody can enjoy with the replacement position after their finish at least for one or two sections trip.

It was 7 (seven) days spent the journey and it was really very tight schedule.

Day 1: Jakarta – Pamanukan – Cirebon – Tegal – Semarang.

Day 2: Semarang – Salatiga – Suruh – Gemolong – Sragen – Ngawi – Caruban – Nganjuk – Kertosono – Pare – Kandangan – Pujon – Batu – Malang.

Day 3: Malang – Lawang – Pasuruan – Probolinggo and Bromo.

Day 4: Bromo – Pasuruan – Madiun – Magetan – Karanganyar – Solo – Jogja.

Day 5: Jogja stay for one day.

Day 6: Jogja – Magelang – Weleri – Pemalang.

Day 7: Pemalang – Cirebon – Subang – Cikampek – Karawang – Bekasi – Jakarta.

Photos are exclusive taken by Bro Dondee and Fajar Is: Bro Dondee

Around Bromo

An early morning waiting Sunrise in Bromo

Sunrise coming in Bromo

Background the Mount Semeru (3676 M)

Photo with tourist from UK with background the Mount Semeru (3676 M)

Photo with the group of HTML Member who joined touring to Bromo

The HTML Bikers

In Top of Mount Bromo (3392 M)

Stairs to reach the Top of Mount Bromo (3392 M)

Group HTML Member

HTML Bikers Action in Bromo sand

My style with Honda Tiger 200cc in Bromo sand

Bro Dondee

Return To Jakarta

The End.

Techniques For Integrating Hibernate Into Legacy Java Code – Part 1

Utropicmedia — Fri, 30 Jul 2010 06:29:19 +0000

Techniques For Integrating Hibernate Into Legacy Java Code – Part 1

If you’re like me, you spend a lot of time dealing with legacy code that, for whatever reason, does not take advantage of modern methodologies and libraries. I’ve taken over Java projects that contain hundreds of thousands of lines of code and not a single third-party jar other than a JDBC driver! One of the most common examples of this is the implementation of the data access layer. These days, the de facto methodology involves Hibernate and DAOs, usually managed by Spring.

This article will detail the steps I recently took to covert a large application from custom-written data access to Hibernate and Spring using the refactoring facilities in Eclipse. The key with this refactorization is to get the existing business logic code (Struts Actions, JSPs, Delegate classes, Business Service classes, etc.) to access the datastore using Hibernate, managed by Spring, without manually changing any of that code directly. Part 1 will include creating the Hibernate data object classes, DAOs, and refactoring the existing code to work with these newly created types. Part 2 will conclude the project with integration of the Hibernate DAOs and wiring everything up with Spring.

First of all, we need to create our Hibernate model and DAO classes. Obviously, since we’re dealing with a legacy application and data structure, we will want to use a bottom-up approach to building our data access layer. This just means that we’re going to generate the Java code and appropriate Hibernate config files from the existing database. There are many tools freely available to make this process very painless. I recommend an Eclipse Plugin for creating and maintaining the Hibernate artifacts (Google “Hibernate Eclipse Plugin” to get started). The structure and requirements for creating Hibernate classes and config files are well documented elsewhere, so I won’t go into detail here. However, in this particular project, the Hibernate DAO lifecycles are managed by Spring, so the DAO classes should all extend HibernateDAOSupport.

Now we have java classes (POJOs) which map to our database tables, but none of the existing code uses these new data object classes. This is where the refactoring tools of Eclipse comes in really handy. For example, say we have a legacy class called AccountInfo which corresponds to the ACCOUNT database table. Right-click the class and select Refactor -> Extract Interface. On the dialogue box, call the new interface IAccount and make sure you select “Use the extracted interface type where possible.” Choose the other options according to your preferences. Click OK and kick back while Eclipse changes every occurence of AccountInfo references to IAccount references and recompiles. Of course, do this with each object model class.

If you never realized why OOP languages are so great, you’re about to. Now we’re going to refactor the code so that all of the existing legacy can be hooked into the new Hibernate model classes instead of the legacy ones. Continuing with the AccountInfo example, create a new class – you’ll probably want to create a new package for this step – called Account that extends the Hibernate POJO for Account and implements the new IAccount interface.

This next part is the most time-consuming, but really isn’t that bad. At this point, the newly created class will probably contain a bunch of empty methods containing only TODO comments. This is because the IAccount interface most likely defies a bunch of methods that are not implemented in the Hibernate Account POJO. To deal with these, we basically want the new Account class to delegate to its generated superclass whenever necessary to satisfy its contract as an IAccount type. As a real world example from the application I was working on, the legacy AccountInfo class defined a getter/setter pair for a property called username, whereas the corresponding column in the ACCOUNT table was actually LOGIN_NAME. To deal with this, you would simply implement the get/setUsername methods in Account to delegate to get/setLoginName (from its superclass). I also had to translate between various data types quite a bit. For example, the legacy code would define many properties as Strings even though the corresponding piece of data in the database was defined as an INT or TIMESTAMP. Again, do this with each object model class.

To finish up the data model layer, edit the appropriate Hibernate and Spring configuration files to refer to these new object model classes. The application now has the ability to map database records to Java objects via Hibernate, and the legacy code which refers to these classes has not required any editing by hand. To finish up this refactorization project, we need to hook in the Spring-supported Hibernate DAOs in a similar way. In Part 2 of this article, I will discuss refactoring the legacy code to read, write, and update data using Hibernate and Spring.

Build Powerful Java Applications Using Soa With New Book From Packt

Utropicmedia — Thu, 29 Jul 2010 09:32:43 +0000

Build Powerful Java Applications Using Soa With New Book From Packt

This book shows how to use SOA and web services to build powerful applications in Java. It teaches the concepts and the implementation with best-practice real-world examples. You will learn to design a sound architecture for successful implementation of any business solution, the different types of architecture, and various tenets of SOA. The book explains the fundamentals and the advantages of using the Service Oriented Architecture in designing your business solution.

In Detail: Service Oriented Architecture provides a way for applications to work together over the Internet. Usually, SOA applications are exposed through web services.

Web services have been around for a while, but complex adoption processes and poor standardization hampered their use at first. However, with the adoption of new, simpler protocols such as REST, and major companies supporting SOA, the time is now right to adopt these standards.

This book will show you how to build SOA, web services-based applications using Java. You will find out when SOA is the best choice for your application, how to design a sound architecture, and then implement your design using Java.

The book covers the important web services protocols: XML-over-HTTP, REST, and SOAP. You will learn how to develop web services at all levels of complexity and for all kinds of business situations.

Approach:This book is an overview of how to implement SOA using Java with the help of real-world examples. It briefly introduces the theory behind SOA and all the case studies are described from scratch.

The book is out now and is available from Packt. For more information, please visit: http://www.packtpub.com/service-oriented-architecture-for-java-applications/book

Java Sockets – You Just Got to Plug Them in

Utropicmedia — Wed, 28 Jul 2010 12:30:51 +0000

Java Sockets – You Just Got to Plug Them in

I realised that programming in Java is quite a fun only after doing it myself. You will be amazed to know that it’s like putting different pieces of puzzle together. You put them relatively in an integrated and coherent manner. The Beauty of it is, that most of the times you dont have to create these pieces yourself. You just customize them according to your need after you get them from an already defined java class or package. It was about programming, now lets talk sumthing about sockets.

Socket is used to establish a point-to-point, bidirectional connection between two entities in a network. Just like a real world socket, it is used to plugin a connection from another source. The connection can be incoming or outgoing or both. Similar is the case at the other end. To understand these sockets properly, you need to learn a bit about Operating System and its Networking Protocols. Sockets are basically of three types: 1)UNIX Domain Sockets; 2) Internet Domain Sockets; 3) NS domain Sockets.

Java being platform independent Programming language, supports only Internet Domain Sockets as only they are platform independent out of three. These internet domain sockets are distinguished on the basis of Internet protocol they work on…

1) TCP/IP(Transfer Control Protocol): The data transfer is reliable, in-order,connection oriented, so takes connection establishment time before the actual data transfer takes place. Sockets based on TCP/IP are known as Stream Sockets.

2) UDP(User Datagram Protocol): It is connectionless,unrealiable and unordered data transfer protocol. Each packet in it has a destination address associated with it and is realeased into the network to make its own way. The sockets based on UDP are called Datagram Sockets.

3) Raw IP: It is a non-formatted protocol. Unlike TCP/IP, UDP protocols, Raw IP is not a core protocol of IP Suite. It’s different from them as its used to receive header information of the packet along with data, which is not the case in TCP/IP, UDP, they just receive data.

In Java Sockets are mainly implemented from already defined classes and pakages. These are:

1) Java.net.package: It contains all the classes that a user require to create a network based application. The below mentioned classes namely ServerSocket and Socket are also its part. This package also contain classes to create Secure Sockets and to connect a Web Server.

2) ServerSocket Class: It Provides sockets for the Server side.These sockets monitor network for requests or simply waits for them. When such request arrives, a server socket performs assigned task based on the request.

3) Socket Class: This class provides the Client side sockets. These sockets connect to the server, send and receive data for the client.

Remember, no socket can work without a port which is identified by a port no. Port is a gateway to a socket connectivity which is on the both sides of network. A socket is mainly identified as per its ports.

Beta Records Bridges the Gap Between Php and Java

Utropicmedia — Tue, 27 Jul 2010 15:30:02 +0000

Beta Records Bridges the Gap Between Php and Java

BETA Records, in anticipation of their upcoming release of Version 3 (V3) of their online music social community, has created a technological innovation that could ultimately allow websites to become more dynamic, creative and sophisticated while enabling companies to cut costs and reduce loads on servers needed in large-scale clusters.

Called “BETACache,” the new technology resulted from BETA’s PHP developers Rock Mutchler, Paul-Anton van Handel, Jon Bauer, Bernhard Schenkenfelder, and Eric Hollander.

“These guys may have devised the ultimate scalability breakthrough for large-scale communities around the world – it’s like taking the performance of a Volkswagen and turning it into a Bentley overnight,” says Chris Honetschlaeger, BETA Records president. “From Facebook down to the world’s 20 million PHP websites, we at BETA are hopeful to finally give back to the PHP community we so admire.”

PHP applications require a means of caching data from remote services, expensive database queries and other performance-killing operations. These problems are greatly magnified by Web 2.0′s heavy reliance on numerous AJAX requests to the web application, and frequent web service calls to partners.

“BETACache could offer a superior alternative to the widely-used memcached, as well as opening up a tremendous amount of other features to PHP application engineers through JCS,” says Rock Mutchler, BETA VP of Technology. “With the BETACache process in place, we can now use the leading technologies to solve the performance issues that developers face. At BETA we have modified Zend Cache in the Zend Framework, by adding our own custom object that makes use of the Zend Platform Java Bridge.”

The Zend Platform PHP/Java Bridge is a PHP module which provides stable and high-performance access to a Java Virtual Machine. “Through this we’re able to use the JCS package to provide an enterprise-class, pluggable and tunable distributed caching system written in Java,” Mutchler states.

BETACache offers a clustered, distributed cache system which automatically caches objects in local memory, local disk, or on remote servers. The Zend Java Bridge allows high-performance enterprise-class integration between the PHP environment and JCS. “We are excited about future enhancements of BETACache to leverage Enterprise Java persistence systems in our clustered PHP application,” Hollander said.

How to Make Java Script Search Engine Friendly

Utropicmedia — Mon, 26 Jul 2010 18:31:12 +0000

How to Make Java Script Search Engine Friendly

Think of the search engines like a child with a short attention span. If they have to crawl through tons of messy code before they get to the body content on your page, there is a chance they will “lose interest” and not continue spidering the page.

Since you want the engines to be able to spider all of your content pages, you should minimize the amount of extraneous code that is on your page. You worked hard to create your content and get your site optimized, so the last thing you want to do is take a chance that the engines won’t want to spider your pages.

One way to clean up the code is to take java script that is on-page and put it in an external .js file.

Java script on your page usually takes up anywhere from 3 – 8+ lines of code. That is all just creates extra code that the spiders have to crawl through before they get to your body text. You are better off calling your java script in from a .js file. This takes what used to be many lines of code on your page and reduces it to one line where you just call the script in.

To create an External JavaScript file:

Copy your script and paste it into Notepad.

Remove the beginning and end script commands. They are:

and

Next, do a SAVE AS command and save the file as “text only” with an extension of .js

Example: java.js

Upload the file to a folder on your server that you name Java. (Or whatever name you wish.)

To call your Java file into your web page, enter into the same place where the script originally was:

Lastly, if you wish to hide the text from JavaScript impaired browsers to avoid error codes, surround the JavaScript with in your java.js file.

This will make for cleaner code, and the functionality will still be the same.

You could also move your script to the bottom of the page – but remember if the page doesn’t fully load then your script may not load, so it could impact the functionality of your page.

Whatever solution you choose to implement – make sure you test it to ensure it works. Once the engines pick up your pages and the traffic to your site increases, you want to be sure the site is fully functional and in tip top shape.

Find More Java Articles

The Bucket @ Utropicmedia » Java

Asymmetric Cryptography in Java

Use of Hibernate With Java Persistence Api

Encryption Using Rsa Algorithm in Java

Use of Hibernate With Java Persistence Api

Hot Or Not? Developing Applications With Java Programming

Improve your programming knowledge through Java Training courses

Java 2 Platform Enterprise Edition (j2ee) Three-tier Model

All about “JAVA”

The Java Virtual Machine

Aghreni Technologies Educational Services – Trainings on Open Source Technologies ( Perl, Php, Java, Ruby, Linux, Mysql)

Accessing Ms Access Using Java

Java Mobile Phone Games: Best of 2006!

Java Mosaic Tiles © – Tips for Getting the Best Results!

Java Pebble Tiles © – Surprising Remodeling Solution!

Mount Bromo East Java Indonesia

Techniques For Integrating Hibernate Into Legacy Java Code – Part 1

Build Powerful Java Applications Using Soa With New Book From Packt

Java Sockets – You Just Got to Plug Them in

Beta Records Bridges the Gap Between Php and Java

How to Make Java Script Search Engine Friendly