import javax.swing.JTable;
import javax.swing.table.TableColumnModel;

public class TableUtils {
	/**
	 * Zmienia kolejność kolumn w tabeli
	 */
	public static void reorderColumns(JTable table, Object... columnIdentifiers) {
		TableColumnModel model = table.getColumnModel();
		for (int newIndex = 0; newIndex < columnIdentifiers.length; newIndex++) {
			try {
				Object columnIdentifier = columnIdentifiers[newIndex];
				int oldIndex = model.getColumnIndex(columnIdentifier);
				model.moveColumn(oldIndex, newIndex);
			} catch (IllegalArgumentException e) {
				// Identyfikator kolumny jest null lub nie istnieje kolumna o
				// podanym identyfikatorze. W obu przypadkach, po prostu
				// przechodzimy dalej
			}
		}
	}
}

git clone git://github.com/jarek-przygodzki/archetype-hibernate3-derby.git
cd archetype-hibernate3-derby
mvn install

mvn archetype:generate -DarchetypeGroupId=com.wordpress.jarekprzygodzki  -DarchetypeArtifactId=archetype-hibernate3-derby -DgroupId=com.wordpress.jarekprzygodzki.test -DartifactId=hibernate-derby -DinteractiveMode=false

cd hibernate-derby
mvn test

mvn archetype:generate -DgroupId=com.wordpress.jarekprzygodzki -DartifactId=hibernate-derby-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.wordpress.jarekprzygodzki</groupId>
	<artifactId>hibernate-derby-app</artifactId>
	<packaging>jar</packaging>
	<version>1.0-SNAPSHOT</version>
	<name>hibernate-derby-app</name>
	<url>http://maven.apache.org</url>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.8.1</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>3.6.7.Final</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-simple</artifactId>
			<version>1.6.1</version>
		</dependency>
		<dependency>
			<groupId>javassist</groupId>
			<artifactId>javassist</artifactId>
			<version>3.12.0.GA</version>
		</dependency>
		<dependency>
			<groupId>org.apache.derby</groupId>
			<artifactId>derby</artifactId>
			<version>10.8.1.2</version>
		</dependency>
		<dependency>
			<groupId>org.apache.derby</groupId>
			<artifactId>derbytools</artifactId>
			<version>10.8.1.2</version>
		</dependency>
	</dependencies>
</project>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>
		<property name="connection.driver_class">org.apache.derby.jdbc.EmbeddedDriver</property>
		<property name="connection.url">jdbc:derby:db/derby.db;create=true</property>
		<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
		<property name="connection.pool_size">5</property>
		<property name="dialect">org.hibernate.dialect.DerbyDialect</property>
		<property name="hibernate.generate_statistics">true</property>
		<property name="show_sql">true</property>
		<property name="current_session_context_class">thread</property>
	</session-factory>
</hibernate-configuration>

package com.wordpress.jarekprzygodzki;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {
            return new Configuration().configure().buildSessionFactory();
        } catch (Exception e) {
            throw new RuntimeException("Nie udało się utworzyć fabryki sesji", e);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

package com.wordpress.jarekprzygodzki;

import org.hibernate.Session;
import org.junit.Test;

public class AppTest {

    @Test
    public void testGetCurrentSesstion() throws Exception {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
    }

    @Test
    public void testTransaction() throws Exception {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        session.getTransaction().commit();
    }
}

maven test

mvn exec:java -Dexec.mainClass="org.apache.derby.tools.ij" -Dij.protocol=jdbc:derby: -Dij.database=db/derby.db

Kompletny kod jest dostępny do pobrania tutaj.

jruby -S gem install ruby-debug
jruby -S gem install ruby-debug-ide

setx JAVA_HOME "\path\to\jdk"

setx JRUBY_HOME "\path\to\jruby"

setx DERBY_HOME "\path\to\derby"

Restartujemy wiersz poleceń i dodajemy katalogi %JAVA_HOME%\bin,%DERBY_HOME%\bin i %JRUBY_HOME%\bin do zmiennej PATH

setx PATH "%PATH%;%JAVA_HOME%\bin;%DERBY_HOME%\bin;%JRUBY_HOME%\bin"

Instalujemy Rails

jruby -S gem install rails

Instalujemy gem ActiveRecord-JDBC dla Derby

jruby -S gem install activerecord-jdbcderby-adapter

I w zasadzie możemy już rozpocząć pracę z JRuby On Rails 3 .
Po wygenerowaniu aplikacji, wystarczy tylko zmodyfikować plik database.xml

development:
  adapter: derby
  database: db/development.db

test:
  adapter: derby
  database: db/test.db

production:
  adapter: derby
  database: db/production.db

i zamienić adapter JDBC z

'activerecord-jdbc-adapter'

'activerecord-jdbcderby-adapter'

Co oznacza, ze plik Gemfile powinien wyglądać następująco

source 'http://rubygems.org'

gem 'rails', '3.0.9'

# Bundle edge Rails instead:
# gem 'rails', :git => 'git://github.com/rails/rails.git'

platforms :ruby do
  gem 'sqlite3'
end

platforms :jruby do
  gem 'activerecord-jdbcderby-adapter'
end

Gotowe! Pora na test

cd myapp
jruby -S script/rails server

package jp.util;

import java.awt.Component;
import java.awt.Graphics;

import javax.swing.Icon;

/**
 * <p>
 * Fabryka pustych ikon
 * </p>
 * 
 * @author Jarek Przygódzki
 * 
 */
public class EmptyIconFactory {
	/**
	 * Tworzy pustą ikonę o podanych wymiarach
	 * 
	 * @param width
	 *            szerokość
	 * @param height
	 *            wysokość
	 * @return pusta ikona o podanych wymiarach
	 */
	public static Icon createEmptyIcon(final int width, final int height) {
		return new Icon() {

			@Override
			public void paintIcon(Component c, Graphics g, int x, int y) {
			}

			@Override
			public int getIconWidth() {
				return width;
			}

			@Override
			public int getIconHeight() {
				return height;
			}
			
		};
	}
}

package jp.util;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * <p>
 * Metody narzędziowe dla strumieni
 * </p>
 * 
 * @author Jarek Przygódzki
 * 
 */
public class Stream {
	/**
	 * Odczytuje wszystkie dane ze strumienia
	 * 
	 * @param stream
	 *            strumień do odczytu
	 * @param bufSize
	 *            rozmiar bufora odczytu
	 * @return tablica odczytanych bajtów
	 * @throws IOException
	 *             jeśli wyrzuci go strumień <code>stream</code>
	 */
	public static byte[] ReadAll(InputStream stream, int bufSize)
			throws IOException {
		ByteArrayOutputStream bs = new ByteArrayOutputStream(bufSize);
		byte[] buf = new byte[bufSize];
		int len;
		while ((len = stream.read(buf)) > 0) {
			bs.write(buf, 0, len);
		}
		/*
		 * W pełni świadomie nie opróżnieniamy bufora strumienia i nie zamykamy
		 * go. W przypadku ByteArrayOutputStream jest to zbędne.
		 */
		return bs.toByteArray();
	}
}

import java.io.ByteArrayOutputStream;

/**
 * <p>
 * Klasa rozszerza {@link java.io.BufferedOutputStream} umożliwiając dostęp do
 * wewnętrznego bufora
 * </p>
 * 
 * @author Jarek Przygódzki
 * 
 */
public class AccessibleByteArrayOutputStream extends ByteArrayOutputStream {

	public AccessibleByteArrayOutputStream(int size) {
		super(size);
	}

	public AccessibleByteArrayOutputStream() {
		super();
	}

	/**
	 * <p>
	 * Zwraca wewnętrzny bufor strumienia. Ważne - tylko pierwsze
	 * {@link AccessibleByteArrayOutputStream#size()} bajtów zawiera poprawne
	 * dane!
	 * </p>
	 */
	public byte[] getDataBuffer() {
		return buf;
	}
}

Dzięki temu możemy np. utworzyć strumień wejściowy bez zbędnego kopiowania

InputStream inputStream = new ByteArrayInputStream(
	outputStream.getDataBuffer(), 0 , outputStream.size());

import java.lang.reflect.Field;

/**
 * @author Jarek Przygódzki
 */
public class FieldUtils {

	@SuppressWarnings("unchecked")
	public static <T> T getFieldValue(Class<?> cls, String fieldName, T defaultValue) {
		T retValue = defaultValue;
		try {
			Field field = cls.getField(fieldName);
			field.setAccessible(true);
			retValue = (T) field.get(null);
		} catch (SecurityException ignore) {
		} catch (NoSuchFieldException ignore) {
		} catch (IllegalArgumentException ignore) {
		} catch (IllegalAccessException ignore) {
		}
		return retValue;
	}

	@SuppressWarnings("unchecked")
	public static <T> T getFieldValue(Object obj, String fieldName, T defaultValue) {
		T retValue = defaultValue;
		Class<?> cls = obj.getClass();
		try {
			Field field = cls.getField(fieldName);
			field.setAccessible(true);
			retValue = (T) field.get(obj);
		} catch (SecurityException ignore) {
		} catch (NoSuchFieldException ignore) {
		} catch (IllegalArgumentException ignore) {
		} catch (IllegalAccessException ignore) {
		}
		return retValue;
	}
}

import java.util.Enumeration;
import java.util.Iterator;

/**
 * @author Jarek Przygódzki
 */
public class En {
	public static <T> Enumeration<T> wrap(final Iterator<T> it) {
		return new Enumeration<T>() {

			@Override
			public boolean hasMoreElements() {
				return it.hasNext();
			}

			@Override
			public T nextElement() {
				return it.next();
			}

		};
	}
}