Bu implementasyon Sun JDK bünyesinde bulunan com.sun.tools.corba.se.idl.toJavaPortable.Compile ve IBM JDK bünyesinde bulunan com.ibm.idl.toJavaPortable.Compile sınıflarını kullanarak client sınıflarını oluşturuyor. Bu iki sınıf JDK lib dizini altındaki tools.jar içinde yer alıyor. Sınıfın bulunabilmesi için -Djava.home= parametresinin tanımlanmasi gerekiyor. JDK bin dizininde yer alan idlj komutu ile aynı işlemi gerçekleştirebilirsiniz.

/**
 *
 * @author F520947 Oezcan Acar
 *
 */
public interface IdlToJavaGeneratorService
{
	void generate( String workingDir, String idlFile, String outputDirectroy );
}

import java.io.File;
import java.io.PrintStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;

import org.codehaus.plexus.util.StringOutputStream;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.csg.cs.testing.common.CommonConstants;
import com.csg.cs.testing.generator.GeneratorException;
import com.csg.cs.testing.project.ProjectDirectoryUtils;
import com.csg.cs.testing.service.logger.ILogger;

/**
 *
 * @author F520947 Oezcan Acar
 *
 */
@Component
final class DefaultIdlToJavaGeneratorServiceImpl implements IdlToJavaGeneratorService
{

	@Autowired
	private ILogger logger;

	@Autowired
	private IIdlParserService parser;

	@Override
	public void generate( final String inputDirectory, final String idlFile, final String outputDirectory)
	{

		File idl = new File( ProjectDirectoryUtils.getWorkingDirRoot() + "/" + idlFile );
		List< String > includes = parser.getIdlIncludes( idl );

		List<String> args = new ArrayList< String >();

		args.add( "-emitAll" );
        args.add( "-fclient" );
        args.add( "-pkgPrefix" );

        String interfaceName = parser.getRealInterface( idl );
        args.add( interfaceName );
        args.add( CommonConstants.SERVICE_PACKAGE );

        for (String include : includes)
		{
        	args.add( "-pkgPrefix" );
            args.add( include );
            args.add( CommonConstants.SERVICE_PACKAGE );
		}

        List< String > baseInterfaces = parser.getBaseInterfaces( idl );
        for (String base : baseInterfaces)
		{
        	args.add( "-pkgPrefix" );
            args.add( base );
            args.add( CommonConstants.SERVICE_PACKAGE );
		}

        args.add( "-pkgPrefix" );
        args.add( "CS_Inquiry_0_0" );
        args.add( CommonConstants.SERVICE_PACKAGE );

        args.add( "-pkgPrefix" );
        args.add( "CS_Inquiry_0_0Operations" );
        args.add( CommonConstants.SERVICE_PACKAGE );

        args.add( "-i" );
        args.add( inputDirectory );
        args.add( "-td" );
        args.add( outputDirectory );
        args.add( idlFile );

        Class<?> compilerClass = getCompilerClass();
        invokeCompiler( compilerClass, args );
	}

	private Class<?> getCompilerClass()
	{
		ClassLoader cl = this.getClass().getClassLoader();
		Class<?> idljCompiler;
		try
		{
			idljCompiler = Class.forName(getIDLCompilerClass());
		}
		catch (ClassNotFoundException e)
		{
			try
			{
				File javaHome = new File(System.getProperty("java.home"));
				logger.log("java.home=" + javaHome);
				logger.log("tools.har=" + javaHome+"/lib/tools.jar");

				File toolsJar = new File(javaHome, "/lib/tools.jar");
				URL toolsJarUrl = toolsJar.toURL();
				URLClassLoader urlLoader = new URLClassLoader(new URL[]
				{ toolsJarUrl }, cl);

				// Unfortunately the idlj compiler reads messages using the
				// system class path.
				// Therefore this really nasty hack is required.
				System.setProperty("java.class.path",System.getProperty("java.class.path")+ System.getProperty("path.separator")+ toolsJar.getAbsolutePath());
				if (System.getProperty("java.vm.name").indexOf("HotSpot") != -1)
				{
					urlLoader.loadClass("com.sun.tools.corba.se.idl.som.cff.FileLocator");
				}
				idljCompiler = urlLoader.loadClass(getIDLCompilerClass());
			}
			catch (Exception notUsed)
			{
				throw new GeneratorException(notUsed);
			}
		}
		return idljCompiler;
	}

	private String getIDLCompilerClass()
    {
        String vendor = System.getProperty( "java.vm.vendor" );

        if ( vendor.indexOf( "IBM" ) != -1 )
        {
            return "com.ibm.idl.toJavaPortable.Compile";
        }
        return "com.sun.tools.corba.se.idl.toJavaPortable.Compile";
    }

	private void invokeCompiler( final Class<?> compilerClass, final List<String> args)
	{
		logger.log("Current dir : " + System.getProperty("user.dir"));
		Method compilerMainMethod;
		String arguments[];

		args.add(0, "-verbose");
		arguments = (String[]) args.toArray(new String[args.size()]);
		String command = compilerClass.getName();
		for (int i = 0; i < arguments.length; i++)
		{
			command += " " + arguments[i];
		}
		logger.log(command);

		try
		{
			compilerMainMethod = compilerClass.getMethod("main", new Class[] { String[].class });
		}
		catch (NoSuchMethodException e1)
		{
			throw new GeneratorException("Error: Compiler had no main method");
		}

		int exitCode = 0;
		// Backup std channels
		PrintStream stdErr = System.err;
		PrintStream stdOut = System.out;
		// Local channels
		StringOutputStream err = new StringOutputStream();
		StringOutputStream out = new StringOutputStream();
		System.setErr(new PrintStream(err));
		System.setOut(new PrintStream(out));
		try
		{
			Object retVal = (Object) compilerMainMethod.invoke(compilerClass,new Object[]{ arguments });
			if (retVal != null &amp;amp;amp;amp;&amp;amp;amp;amp; retVal instanceof Integer)
				exitCode = ((Integer) retVal).intValue();

		}
		catch (InvocationTargetException e)
		{
			throw new GeneratorException(e);
		}
		catch (Throwable e)
		{
			e.printStackTrace();
			throw new GeneratorException("IDL compilation failed");
		}
		finally
		{
			if (!"".equals(out.toString()))		logger.log(out.toString());
			if (!"".equals(err.toString()))		logger.log(err.toString());
			// Restore std channels
			System.setErr(stdErr);
			System.setOut(stdOut);
		}
	}

}

EOF ( End Of Fun )
Özcan Acar

java.lang.OutOfMemoryError: Java heap space
        at java.util.Arrays.copyOf(Arrays.java:2882)
        at java.lang.AbstractStringBuilder.expandCapacity(AbstractStringBuilder.java:100)
        at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:515)
        at java.lang.StringBuffer.append(StringBuffer.java:306)
        at java.io.StringWriter.write(StringWriter.java:77)
        at hidden.org.codehaus.plexus.util.IOUtil.copy(IOUtil.java:214)
        at hidden.org.codehaus.plexus.util.IOUtil.toString(IOUtil.java:416)
        at hidden.org.codehaus.plexus.util.IOUtil.toString(IOUtil.java:405)
        at org.apache.maven.project.DefaultMavenProjectBuilder.readModel(DefaultMavenProjectBuilder.java:1595)
        at org.apache.maven.project.DefaultMavenProjectBuilder.readModel(DefaultMavenProjectBuilder.java:1571)
        at org.apache.maven.project.DefaultMavenProjectBuilder.findModelFromRepository(DefaultMavenProjectBuilder.java:562)
        at org.apache.maven.project.DefaultMavenProjectBuilder.buildFromRepository(DefaultMavenProjectBuilder.java:251)
        at org.apache.maven.project.artifact.MavenMetadataSource.retrieveRelocatedProject(MavenMetadataSource.java:163)
        at org.apache.maven.project.artifact.MavenMetadataSource.retrieveRelocatedArtifact(MavenMetadataSource.java:94)
        at org.apache.maven.artifact.resolver.DefaultArtifactCollector.recurse(DefaultArtifactCollector.java:387)
        at org.apache.maven.artifact.resolver.DefaultArtifactCollector.recurse(DefaultArtifactCollector.java:435)
        at org.apache.maven.artifact.resolver.DefaultArtifactCollector.recurse(DefaultArtifactCollector.java:435)
        at org.apache.maven.artifact.resolver.DefaultArtifactCollector.collect(DefaultArtifactCollector.java:74)
        at org.apache.maven.artifact.resolver.DefaultArtifactResolver.resolveTransitively(DefaultArtifactResolver.java:316)
        at org.apache.maven.artifact.resolver.DefaultArtifactResolver.resolveTransitively(DefaultArtifactResolver.java:304)
        at org.apache.maven.plugin.DefaultPluginManager.resolveTransitiveDependencies(DefaultPluginManager.java:1499)
        at org.apache.maven.plugin.DefaultPluginManager.executeMojo(DefaultPluginManager.java:442)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoals(DefaultLifecycleExecutor.java:694)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoalWithLifecycle(DefaultLifecycleExecutor.java:556)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoal(DefaultLifecycleExecutor.java:535)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoalAndHandleFailures(DefaultLifecycleExecutor.java:387)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeTaskSegments(DefaultLifecycleExecutor.java:348)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.execute(DefaultLifecycleExecutor.java:180)
        at org.apache.maven.DefaultMaven.doExecute(DefaultMaven.java:328)
        at org.apache.maven.DefaultMaven.execute(DefaultMaven.java:138)
        at org.apache.maven.cli.MavenCli.main(MavenCli.java:362)
        at org.apache.maven.cli.compat.CompatibleMain.main(CompatibleMain.java:60)
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3 seconds
[INFO] Finished at: Tue Oct 26 11:40:45 EEST 2010
[INFO] Final Memory: 9M/9M
[INFO] ------------------------------------------------------------------------
C:\CCVIEWS\itcs_oacar_UCM_YUKSELIS\CBVOB01\CorebankingAppBuilder>

EAR dosyası birçok JAR ve WAR’dan oluştuğu için doğal olarak büyük bir hacme sahip. Default Maven2 ayarları bu boyuttaki bir EAR dosyasını oluşturmak için yeterli değil.

Bu sorunu aşmak için Maven’in daha fazla hafıza alanını kullanabilmesi gerekiyor. Bunu sağlamak için Windows işletim sistem ile çalışıyorsanız, console altında

set MAVEN_OPTS=-Xmx512m

ya da Linux/Unix altında

export MAVEN_OPTS=-Xmx512m

komutunu girmeniz yeterli. Bir sonraki mvn komutu tanımladığınız şekilde yeni hafıza alanı ile çalşacaktır.

Bilindiği üzere son zamanların en popüler ve talep edilen dili Java. İnternetteki birçok istatiktik Java’nın bir numara olduğunu tastikliyor. Programcı adaylarının da Java’yı seçmeleri doğal.

Java’yi bilenler ve kullananlar iyi ve akıllı programcılardır degil mi? Peki Python ya da piyasası pek fazla olmayan bir başka dili bilen bir programcının sadece Java’ya hakim bir programcıdan daha iyi ve akıllı bir programcı olduğunu söylesem nasıl tepki verirdiniz?

İyi programcı, program yazmayı seven programcıdır. İyi programcı yenilikleri deneyip, ufkunu genişleten programcıdır. İyi programcı programcılık dünyasının sadece Java’dan oluşmadığını bilendir. Peki iyi programcıyı nasıl anlarsınız? Bir sonraki iş görüşmesinde işe alınacak programcı adayına Java haricinde hangi dil ya da dilleri bildiğini sorun. Alacağınız cevap programcının ne kadar iyi olduğunu gösteren indikatördür. Eğer aday sadece Java’yı bildiğini söylerse iyi bir programcı olma ihtimali doğru olabilir. Bunun ispatı edindiği tecrübeler ve bilgi birikimidir. Eğer aday Java’nın yanında Python ya da Groovy dillerine de hakim olduğunu söylerse, bilin ki karşınızda akıllı (smart) bir aday duruyor. Neden? Bunun nedeni çok basit. Piyasası olmayan bir programlama dilini ögrenmiş bir programcı, program yazmayı gerçekten seviyor olmalı ki talebin dışında kalan bir programlama dilini zaman ayırarak öğrenmiş. Bu onun yenilikçi, ögrenmeyi ve program yazmayı seven birisi oldugunu gösterir. Karşınızdaki bu kişi büyük bir ihtimalle sadece Java bilen bir adaydan çok daha akıllı ve programcılık konusunda ileri seviyede.

Yanlış anlaşılmasın; Java’ya hakim olanlarda mutlaka iyi programcılardır. İyileri de var, iyi olmayanları da. Ama piyasının ihtiyacı olmayan bir dili öğrenen bir programcı çok daha fazla potansiyele sahip. Bu bir gercek! Ben böyle bir programcıyı tercih ederdim.

Sadece bir programlama dilinde (bu genelde piyasası olan bir dil olacaktır) takılıp kalmış olanların verdiği cevap hep aynı olacaktır: “Çalıştığım ortamlarda yeni bir programlama dili öğrenme fırsatı bulamadım.” Gerçekten programcılığa gönül vermiş birisi o fırsatı hemen yaratır!

Bu konuda Paul Graham’ın yazısını okumanızı tavsiye ederim.

C:\>javap.exe -verbose tumbler.Story
Compiled from "Story.java"
public interface tumbler.Story extends java.lang.annotation.Annotation
  SourceFile: "Story.java"
  RuntimeVisibleAnnotations: length = 0x1B
   00 02 00 09 00 01 00 04 65 00 0A 00 0B 00 0C 00
   01 00 04 5B 00 01 65 00 0D 00 0E
  minor version: 0
  major version: 50
  Constant pool:
const #1 = class        #15;    //  tumbler/Story
const #2 = class        #16;    //  java/lang/Object
const #3 = class        #17;    //  java/lang/annotation/Annotation
const #4 = Asciz        value;
const #5 = Asciz        ()Ljava/lang/String;;
const #6 = Asciz        SourceFile;
const #7 = Asciz        Story.java;
const #8 = Asciz        RuntimeVisibleAnnotations;
const #9 = Asciz        Ljava/lang/annotation/Retention;;
const #10 = Asciz       Ljava/lang/annotation/RetentionPolicy;;
const #11 = Asciz       RUNTIME;
const #12 = Asciz       Ljava/lang/annotation/Target;;
const #13 = Asciz       Ljava/lang/annotation/ElementType;;
const #14 = Asciz       TYPE;
const #15 = Asciz       tumbler/Story;
const #16 = Asciz       java/lang/Object;
const #17 = Asciz       java/lang/annotation/Annotation;

{
public abstract java.lang.String value();

}

thumbler.Story sınıfı için major number 50, minor number 0 görünmektektedir. Aşağıdaki listeden bu sınıfın hangi Java compiler versiyonu ile derlendiğini anlamak mümkündür.

* Java 1.2 uses major version 46
* Java 1.3 uses major version 47
* Java 1.4 uses major version 48
* Java 5 uses major version 49
* Java 6 uses major version 50

EOF ( End Of Fun)
Özcan Acar

Java’da bulmaca sevenlere; Aşağıda ki kod parçası için çıktı ne olur,
“finalized” yazar mı? Constructor’ýnda exception fırlatmış bir nesnenin
finalize işleminden geçmesini bekler misiniz?

public class FinalizerTest {

<span id="more-1098"></span>

  public FinalizerTest() {
    System.out.println("constructed");
    throw new RuntimeException();
  }

  protected void finalize() throws Throwable {
    System.out.println("finalized");
  }

  public static void main(String[] args) {
    try {
      new FinalizerTest();
    } catch (Exception e) {
      System.out.println("exception");
    }
    System.gc();
  }
}

Benim verdiğim cevap şu şekildedir:

Java’da finalize() kullanılması doğru değildir, çünkü JVM’in finalize metodunu ne zaman koşturacağını kestirmek mümkün değildir. Buna güvenerek örneğin finalize() içinde kullanılan kaynakları serbest bırakmak yapılabilecek en büyük hatalardan birisidir. Pratikte finalize() metodu kesinlikle kullanmamalıdır. Finalizer kullanımı performansı düşürür. Finalizer ile nesnenin yok edilmesi daha uzun zaman alır. Finalize yerine bir terminasyon metodu kullanılmalıdır. gc() metodunun kullanımı da GC nin hemen devreye gireceği garantisini vermez.

Yukarıda yer alan programın konstruktöründe try catch ile hata yakalanarak, daha önce bahsettiğim terminasyon metodu (örneğin myExit()) koşturulmalıdır.

EOF ( End Of Fun)
Özcan Acar

• Final sınıf değişkenleri: Final olan bir sınıf değişkenine sadece bir kere değer ataması yapilabilir ve bu atama sadece sınıf konstrüktöründe gerçekleşebilir.
• Final metot parametreleri: Final olarak tanımlanmış bir metot parametresine sadece bir kere değer atanabilir. Metot parametrelerinin tamamen final olarak tanımlamış olmalarında büyük fayda vardır. Bu şekilde parametrenin metot bünyesinde değişikliğe ugrama tehlikesi ortadan kaldırılmış olur.
• Final metotlar: Final olan bir metot ne alt sınıflarca yeniden yüklenebilir (method overloading) ne de saklı (hidden) tutulabilir.
• Final sınıflar: Final olan bir sınıf genişletilerek bir alt sınıf oluşturulamaz.

Final anahtar kelimesi Java programcılığında en çok göz ardı edilenlerdendir. En son siz ne zaman final anahtar kelimesini kullandınız?
Final anahtar kelimesi programın daha doğru, hatalara dayanıklı ve performanslı çalışmasını sağlar.

Final anahtar kelimesinin kullanımında yapılan en büyük hatalardan birisi final static olarak tanımlanmış olan bir sınıf değişkenine değistirilebilir bir değerin atanmasıdır. Örneğin aşağıdaki tanımlama yanlıştır, çünkü static değişken final olmasına rağmen, bu değişkene atanan değer, kullanıcı tarafından değiştirilebilir.

public class App
{
    public static final String[] LIST = {"1","2","3"};

    public static void main(String[] args)
    {
	String[] list = App.LIST;
	list[0] = "2";
	System.out.println(App.LIST[0]);
    }
}

Yukarda yer alan main() metodunda final olan LIST degiskeninin ihtiva ettiği array değiştirilmektedir. Bu sorunu ortadan kaldırmak için LIST değişkeni private yapılabilir ve bu değişkeni baz alarak içeriğinin değiştirilemeyeceği bir array değerini geri döndüren metot oluşturulabilir. Bunun bir örneği aşağıda yer almaktadır:

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class App
{
    private static final String[] LIST = {"1","2","3"};

    public static final List<String> getList()
    {
	return Collections.unmodifiableList(Arrays.asList(App.LIST));
    }

    public static void main(String[] args)
    {
	List<String> list = App.getList();
	list.remove(0);
	System.out.println(list);
    }
}

Bu program koşturulduğunda alınacak hata şu şekildedır:

Exception in thread “main” java.lang.UnsupportedOperationException
at java.util.Collections$UnmodifiableList.remove(Collections.java:1162)
at test.App.main(App.java:22)

Bu şekilde final olarak tanımladığımız LIST değişkenin ihtiva ettiği değerleri üzerinde oynama yapmak mümkün değildir. getList() metodu bünyesinde Collections.unmodifiableList() ile içeriğinin değiştirilmesi mümkün olmayan bir liste oluşturulmaktadır.

EOF ( End Of Fun)
Özcan Acar

package test.controller;

import java.util.Map;

import test.criteria.Criteria;

public abstract class AbstractController implements Controller
{
    public void executeFilter()
    {
	Map<String, String> map = createCriteria().getCriteriaMap();

    }

    public abstract Criteria createCriteria();
}

Soyut (abstract) olan AbstractController sınıfı bünyesinde, alt sınıflarda implemente edilmek üzere createCriteria() isminde bir metot tanımlıyoruz. AccountTableController sınıfı bu metodu implemente etmektedir.

package test.controller;

import java.util.HashMap;
import java.util.Map;

import test.criteria.MyCriteria;
import test.model.Konto;

public class AccountTableController extends AbstractController
{
    private Account model = new Account();

    public Criteria createCriteria()
    {
	Map<String, String> map = new HashMap<String, String>();
	map.put("kontonr", model.getKontonr());
	map.put("blz", model.getBlz());
	return new Criteria(map);
    }
}

Görüldüğü gibi AccountTableController.createCriteria() metodu Criteria tipinde bir degeri geri döndürmektedir. Bu metodun geri döndürdüğü değerin Java 1.5 öncesi Criteria tipinde olması gerekmektedir, çünkü üst sınıfta tanımlanmış olan bu metodun, üst sınıf bünyesinde geri döndürdüğü değer Criteria tipindedir.

Java 1.5 ile bu durum değişmiştir. Üst sınıfta yer alan bir metot alt sınıfta tekrar reimplement edilirse (method overriding), reimplemente edilen metodun geri döndürdüğü değerin tipi, üst sınıftaki metodun geri döndürdüğü sınıfın bir alt sınıfı olabilir. Bunun bir örneği aşağıda yer almaktadır.

package test.controller;

import java.util.HashMap;
import java.util.Map;

import test.criteria.MyCriteria;
import test.model.Konto;

public class AccountTableController extends AbstractController
{
    private Account model = new Account();

    @Override
    public MyCriteria createCriteria()
    {
	Map<String, String> map = new HashMap<String, String>();
	map.put("kontonr", model.getKontonr());
	map.put("blz", model.getBlz());
	return new MyCriteria(map);
    }
}

MyCriteria, Criteria sınıfının bir alt sınıfıdır ve AccountTableController sınıfı implemente ettiği createCriteria() metodunun MyCriteria tipinde bir değeri geri döndürmesi sağlamıştır. Bu şekilde cast işlemi yapılmadan alt sınıfların daha zengin tipte verileri geri döndürebilmeleri amaçlanmaktadır.

EOF ( End Of Fun)
Özcan Acar

Öncelikle küçük bir örnek üzerinde singleton bir nesnesinin nasıl oluşturulacağına bir göz atalım:

package com.kurumsaljava.com.designpatterns.singleton;

public class MySingleton
{
    private static final MySingleton instance = new MySingleton();

    private MySingleton()
    {
    }

    public void myMethod()
    {

    }
}

MySingleton sınıfının sahip olduğu konstruktör private olduğu için bu sınıftan bir nesne oluşturmamız mümkün değildir. Bu sınıf bünyesinde ve MySingleton tipinde olan instance ismindeki sınıf değişkeni singleton nesnedir. Bu sınıf ilk kullanıldığında private olan konstruktör bir defaya mahsus olarak işlem göreceği için instance degişkeni bir singleton nesne haline gelecektir. Buradaki sorun, reflection yöntemleri kullanılarak private olan konstruktörün birden fazla singleton nesne oluşturmasını sağlayabilmektir. Bunun yanısıra eger MySingleton sınıfı Serializable interface sınıfını implemente ediyorsa, readResolve() metodunun da implemente edilmesi gerekmektedir, aksi taktirde deserializasyon esnasında yeni bir nesne oluşturulur ki, bu da singleton tasarım şablonunun mantığına ters düşer.

Java 1.5 den itibaren kullanıma sunulan Enum sınıfı ile singleton nesneler oluşturmak mümkündür. Bunun bir örneği aşağıda yer almaktadır.

package com.kurumsaljava.com.designpatterns.singleton;

public enum MySingletonEnum
{
    INSTANCE;

    public void myMethod()
    {

    }
}

MySingletionEnum.INSTANCE sadece ve sadece bir kere mevcut olan bir singleton değişkendir. Bunun yanısıra reflection metotları kullanılarak yeni bir singleton olmayan nesne oluşturulamaz. Ayrıca serializasyon işlemlerinde readResolve() kullanılmak zorunda kalmadan enum nesnesinin singletonluğu garanti edilmektedir. Tek elementli olan bir enum sınıfı singleton tasarım şablonunu implemente etmek i.in kullanılabilecek en iyi yöntemdir.

// JDBC Driver
    public static final String DRIVERCLASS      = "org.hsqldb.jdbcDriver";
    // standalone mode
    public static final String CONNECTIONURL    = "jdbc:hsqldb:hsql://localhost:9006/mydb";
    public static final String USERNAME         = "sa";
    public static final String PASSWORD         = "";

public void setUp() throws Exception
	{
		PreparedStatement pstmt = null;

		 try
		 {
			IDatabaseConnection connection = getConnection();
			IDataSet dataSet = getDataSet();
			try
			{
				// REF INTEGRITY MUST BE DISABLED IN ORDER TO IMPORT THE DATA
				// THIS SOLUTION IS ONLY VALID FOR HSQLDB 1.8
				pstmt = connection.getConnection().prepareStatement("set referential_integrity FALSE");
				pstmt.executeUpdate();
				DatabaseOperation.CLEAN_INSERT.execute(connection, dataSet);
				pstmt = connection.getConnection().prepareStatement("set referential_integrity TRUE");
				pstmt.executeUpdate();
			}
			finally
			{
				connection.close();
			}
		}
		catch (Exception e)
		{
		    throw e;
		}
	}

	protected IDatabaseConnection getConnection() throws Exception
	{
		Class.forName(DRIVERCLASS);
		Connection jdbcConnection = DriverManager.getConnection(CONNECTIONURL, USERNAME, PASSWORD);
		IDatabaseConnection con =  new DatabaseConnection(jdbcConnection);
		DatabaseConfig config = con.getConfig();
		config.setProperty(DatabaseConfig.PROPERTY_DATATYPE_FACTORY, new HsqldbDataTypeFactory());
		return con;
	}

protected final IDataSet getDataSet() throws Exception
	{
		final URL url = DatabaseTestCase.class.getResource( "/dbunit-dataset.xml");
	    final File file = new File(url.getPath());
	    return new FlatXmlDataSet(file);
	}