Go geek!

Our Victory Is Imminent

JTable – zmiana kolejności kolumn

Skomentuj »

Przydatna metoda pozwalająca zmienić kolejność kolumn w tabeli w podstawie ich identyfikatorów

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
			}
		}
	}
}

Written by Jarek Przygódzki

Wrzesień 30, 2011 at 6:04 pm

Hibernate 3 + Derby – Artefakt dla Maven

Skomentuj »

Tytułowe 5 minut z poprzedniego wpisu stało się nieaktualne, jako że stworzony w jego ramach artefakt wyewoluował do archetypu i znalazł się na GitHubie. Wystarczy go pobrać i zainstalować w lokalnym repozytorium

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

Potem wystarczy już tylko wygenerować projekt
mvn archetype:generate -DarchetypeGroupId=com.wordpress.jarekprzygodzki  -DarchetypeArtifactId=archetype-hibernate3-derby -DgroupId=com.wordpress.jarekprzygodzki.test -DartifactId=hibernate-derby -DinteractiveMode=false

i można uruchamiać testy
cd hibernate-derby
mvn test

Written by Jarek Przygódzki

Wrzesień 19, 2011 at 9:01 pm

Hibernate 3 + Derby w 5 minut z Maven

Skomentuj »

Rozpoczęcie pracy z Hibernate naprawdę zajmuje nie więcej niż 5 minut – wystarczy JDK i Maven (moim zdaniem jeden z najbardziej przełomowych i najważniejszych wynalazków świata Javy). Nie wierzycie? Czas start!
Na początek musimy wygenerować nową aplikację. Tutaj z pomocą przychodzi mechanizm archetypów (a ściślej mówiąc Archetype Plugin). Poprzez wywołanie poniższego polecenia stworzymy kompletną strukturę prostego projektu wraz z podstawowym plikiem pom.xm

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

Następnie musimy dodać do pliku projektu wymagane zależności. Na szczęście zarządzanie zależnościami jest tym z czego Maven tak naprawdę słynie najbardziej. Wystarczy dodać do pliku pom.xml elementy dependency opisujące wymagane zależności. Maven podczas budowania automatycznie rozwiąże zależności (także te przechodnie) pobierając wymagane zasoby z repozytorium
<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>

Czas na Hibernate. Plik konfiguracyjny dla bazy danych Derby w trybie osadzonym wygląda następująco
<?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>

i najwygodniej będzie umieścić go w katalogu src\main\resources pod nazwą hibernate.cfg.xml.
Zaraz napiszemy kod testów aby sprawdzić, czy wszystko działa.
Najpierw typowa dla Hibernate-a klasa narzędziowa
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;
    }
}

i już możemy przystąpić do pisania testów. Maven wygenerował już nam klasę AppTest(niestety, dla JUnit 3.x). Wystarczy więc usunąć istniejący kod i zastąpić go naszym
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();
    }
}

i uruchomić testy (Maven automatycznie wykrywa i uruchamia testy JUnit 3.x, JUnit 4 i TestNG pod warunkiem że znajdują się w katalogu src/test i ich nazwy zaczynają się lub kończą od Test lub kończą na TestCase
maven test

Co jednak, gdy będziemy chcieli podłączyć się do naszej bazy danych i podejrzeć jej zawartość? W tym właśnie celu dodany został artefakt derbytools zawierający klienta umożliwiającego nawiązanie połączenia z bazą.
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.

Written by Jarek Przygódzki

Wrzesień 18, 2011 at 6:48 pm

[JRuby] Gemy ruby-debug i ruby-debug-ide w JRuby

Skomentuj »

Miło mi poinformować, że cała konfiguracja niezbędna do debugowania aplikacji w JRuby on Rails sprowadza się (nareszcie!) do instalacji dwóch gemów

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

Written by Jarek Przygódzki

Wrzesień 17, 2011 at 12:21 pm

Napisane w JRuby, Programming, Rails

JRuby on Rails 3 + Embedded Derby w Windows 7

Skomentuj »

Instalujemy JDK i ustawiamy zmienną środowiskową JAVA_HOME

setx JAVA_HOME "\path\to\jdk"

Pobieramy świeżą wersję JRuby, rozpakowujemy i ustawiamy zmienną środowiskową JRUBY_HOME
setx JRUBY_HOME "\path\to\jruby"

Pobieramy Derby, rozpakowujemy i ustawiamy zmienną DERBY_HOME
setx DERBY_HOME "\path\to\derby"

Technicznie rzecz biorąc, instalacja Derby nie jest konieczna, bo wymagane archiwum jar zostanie pobrane przy instalacji gem’a activerecord-jdbcderby-adapter – ale i tak warto to zrobić ze względu na przydatne narzędzia jakie dostajemy wraz z normalną instalacją 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

Zastosowanie opcji przy instalacji opcji --no-rdoc --no-ri znacząco ją przyśpieszy kosztem dokumentacji.

I w zasadzie możemy już rozpocząć pracę z JRuby On Rails 3 :D .
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'

na specyficzny dla Derby
'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

Written by Jarek Przygódzki

Listopad 9, 2010 at 9:10 pm

[Java] Fabryka pustych ikon

Skomentuj »

Jak w tytule – fabryka, która tworzy puste ikony o podanym rozmiarze. Bywa pomocna.

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;
			}
			
		};
	}
}

Written by Jarek Przygódzki

Październik 27, 2010 at 7:51 pm

[Java] Wczytywanie danych ze strumienia wejścia do tablicy

Skomentuj »

Odczyt danych ze strumienia wejścia i zapis do tablicy bajtów

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();
	}
}

Written by Jarek Przygódzki

Październik 26, 2010 at 8:26 pm

[Java] java.io.ByteArrayOutputStream – dostęp do wewnętrznego bufora

Skomentuj »

Klasa java.io.ByteArrayOutputStream jest bardzo użyteczna. Czasem jednak chcielibyśmy uzyskać bezpośredni dostęp do wewnętrznego bufora a nie tworzyć jego kopię za pomocą ByteArrayOutputStream#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());

Written by Jarek Przygódzki

Październik 20, 2010 at 10:10 pm

[Java] Pobieranie wartości pola na podstawie nazwy

Skomentuj »

Pobieranie wartości pola klasy lub obiektu (egzemplarza klasy) z wykorzystaniem mechanizmu refleksji

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;
	}
}

Written by Jarek Przygódzki

Październik 20, 2010 at 9:48 pm

[Java] Konwersja iteratora na wyliczenie

Skomentuj »

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();
			}

		};
	}
}

Written by Jarek Przygódzki

Październik 4, 2010 at 10:03 pm

Follow

Otrzymuj każdy nowy wpis na swoją skrzynkę e-mail.