Java developer's issues

Quartz + Spring

2011-12-15T03:08:00.000-08:00

В больших проекта часто бывает необходимо выполнять какой-то участок кода по расписанию. Для этого подойдет популярная библиотека Quarz.
Рассмотрим, как можно интегрировать Quartz (1.x) в Spring.

Для начала подхватим зависимость в maven:


    org.quartz-scheduler
    quartz
    1.8.5

Создадим бин, отвечающий за выполнение задачи:

@Component
public class SomeWorkBean implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() {
    }

    public void doWork() {
        System.out.println("doing some work");
    }

    @Override
    public void destroy() throws Exception {
    }
}

теперь можно конфигурировать Spring:

где workJob - обьявление JobDetailBean,
simpleTrigger - триггер, обьявляющий критерии выполнения кода в SomeWorkBean,
schedulerFactoryBean - фабрика для создания шедьюлера

Все, теперь метод SomeWorkBean.doWork() будет выполняться каждую минуту. Для более гибкого задание расписания, можно использовать другие триггеры, например CronTrigger

Алгоритмы сортировки

2011-12-01T02:05:00.000-08:00

Сортировки сравнением (Comparison sorts)

Сортировки сравнением имеют минимальную сложность O(n*lg n).

Сортировка вставками (Insert sort)

Сложность: O(n²)

На каждом шаге алгоритма выбираем очередной элемент входных данных и сдвигаем его влево до тех пор, пока слева от него не останутся элементы, меньшие чем он. Метод выбора очередного элемента из исходного массива произволен; может использоваться практически любой алгоритм выбора. Обычно (и с целью получения устойчивого алгоритма сортировки), элементы выбираются по порядку их появления во входном массиве.

Преимущества: практически не требует выделения памяти (всего O(1)); алгоритм эффективен при малом размере входного массива.

Недостатки: неэффективен на большом размере входного массива (более 100).

Алгоритм:

Вход: массив A, состоящий из элементов A[1], A[2], ..., A[n]

for i = 2, 3, ..., n:  
    key = A[i]
    j = i - 1
    while j > 0 and A[j] > key:
        A[j + 1] = A[j]
        j = j - 1
    A[j + 1] = key

Реализация на Java:

//insertion sort
public static void insertionSort(int[] arr) {
    int i, j, tmp;
    //двигаемся вперед по массиву
    for (i = 1; i < arr.length; i++) {
        j = i;
        //двигаем элемент назад, пока он больше предыдущих
        while (j > 0 && arr[j - 1] > arr[j]) {
            tmp = arr[j];
            arr[j] = arr[j - 1];
            arr[j - 1] = tmp;
            j--;
        }
    }
}

Сортировка слиянием (Merge sort)

Сложность: O(n*lg n)

Этот алгоритм использует парадигму "Разделяй и властвуй". Сортируемая последовательность, состоящая из n элементов, разбивается на две меньшие последовательности. Рекурсивно сортируем каждую из полученных последовательностей тем же способом. Когда две меньшие последовательности отсортированы, производится слияние, поочередно выбирая из них наименьший член.

Преимущества: алгоритм эффективен при большом размере входного массива (более 1000).

Недостатки: требует выделения O(n) памяти

Алгоритм:

function mergesort(m)
    var list left, right, result
    if length(m) ≤ 1
        return m
    else
        middle = length(m) / 2
        for each x in m up to middle
            add x to left
        for each x in m after middle
            add x to right
        left = mergesort(left)
        right = mergesort(right)
        result = merge(left, right)
        return result
    end if

function merge(left,right)
    var list result
    while length(left) > 0 and length(right) > 0
        if first(left) ≤ first(right)
            append first(left) to result
            left = rest(left)
        else
            append first(right) to result
            right = rest(right)
        end if
    if length(left) > 0 
        append left to result
    if length(right) > 0 
        append right to result
    return result

Реализация на Java:

//merge sort
public static int[] mergeSort(int[] arr) {
    if (arr.length <= 1)  return arr;

    int mid = arr.length / 2;
    int[] left = new int[mid];
    int[] right = new int[mid + arr.length%2];

    int j = 0;
    for (int i = 0; i < arr.length; i++) {
        if (i < arr.length / 2) {
            left[i] = arr[i];
        } else {
            right[j++] = arr[i];
        }
    }
    return Merge(mergeSort(left), mergeSort(right));
}

public static int[] Merge(int[] left, int[] right) {
    int a = 0, b = 0;
    int[] merged = new int[left.length + right.length];
    //забиваем отсортированный массив из левой и правой частей
    for (int i = 0; i < left.length + right.length; i++) {
        //поочередно берем меньший член из крайних левого и правого
        if (b < right.length && a < left.length)
            if (left[a] > right[b] && b < right.length)
                merged[i] = right[b++];
            else
                merged[i] = left[a++];
        else
            if (b < right.length)
                merged[i] = right[b++];
            else
                merged[i] = left[a++];
    }
    return merged;
}

Пирамидальная сортировка (Heap sort)

Сложность: O(n*lg n)

Сортировка пирамидой использует сортирующее дерево. Алгоритм заключается в выстраивании элементов массива в сортирующее дерево. Итерационно удаляем элементы из корня под одному за раз и перестраиваем дерево. То есть на первом шаге обмениваем Array[1] и Array[n], преобразовываем Array[1], Array[2], … , Array[n-1] в сортирующее дерево. Затем переставляем Array[1] и Array[n-1], преобразовываем Array[1], Array[2], … , Array[n-2] в сортирующее дерево. Процесс продолжается до тех пор, пока в сортирующем дереве не останется один элемент. Тогда Array[1], Array[2], … , Array[n] — упорядоченная последовательность.

Преимущества: практически не требует выделения памяти (всего O(1))

Недостатки: Из-за сложности алгоритма выигрыш получается только на больших n (более 1000)

Алгоритм:

function build_max_heap(A)
  for i = length(A) downto 2
    do Обменять A[1] на A[i]
      heap_size[A] = heap_size[A] - 1
      max_heapify(A,1)

function max_heapify(A,i)
  l = left(i)
  r = right(i)
  if l <= heap_size(A) and A[l] > A[i]
    then largest = l
    else largest = i
  if r <= heap_size(A) and A[r] > A[largest]
    then largest = r
  if largest != i
    then Обменять A[i] на A[largest]
      max_heapify(A, largest)

Реализация на Java:

public static void heapSort(int[] arr) {
    for(int i = arr.length; i > 1; i--){
        buildMaxHeap(arr, i - 1);
    }
}

public static void buildMaxHeap(int[] arr, int max_index){
    int i, o;
    int leftChild, rightChild, maxChild, root, temp;
    root = (max_index -1)/2;

    //обходим дерево в поисках максимального члена (ранее отсортированные максимальные игнорируем)
    for(i = root; i >= 0; i--){
        leftChild = (2*i) + 1;
        rightChild = (2*i) + 2;

        if((leftChild <= max_index) && (rightChild <= max_index)){
            if(arr[rightChild] >= arr[leftChild])
                maxChild = rightChild;
            else
                maxChild = leftChild;
        } else{
            if(rightChild > max_index)
                maxChild = leftChild;
            else
                maxChild = rightChild;
        }

        //передвигаем  максимальный член вверх по пирамиде (начало массива)
        if(arr[i] < arr[maxChild]){
            temp = arr[i];
            arr[i] = arr[maxChild];
            arr[maxChild] = temp;
        }
    }

    //убираем максимальный член в конец массива
    temp = arr[0];
    arr[0] = arr[max_index];
    arr[max_index] = temp;
}

Быстрая сортировка (Quick sort)

Сложность: средняя O(n*lg n), максимальная O(n²)

Еще одна сортировка, основанная на парадигме "Разделяй и властвуй". Массив A[p..r] разбивается (путем переупорядочивания его элементов) на два подмассива A[p..q-1] и A[q+1..r]. Каждый элемент первого подмассива не превышает каждый елемент второго. Индекс q вычисляется в ходе процедуры разбиения и называется опорным элементом. Подмассивы сортируются путем рекурсивного вызова процедуры быстрой сортировки. После этого весь массив оказывается отсортированным.

Преимущества: при качественной реализации один из самых быстродействующих алгоритмов на практике; требует лишь O(lg n) дополнительной памяти

Недостатки: при неудачном выборе опорного элемента время вычисления деградирует к O(n²).

Алгоритм:

для сортировки всего списка вызов выглядит quick_sort(A,1,length[A])

function quick_sort(A,p,r)
  if p < r 
    then q = partition(A,p,r)
      quick_sort(A,p,q-1)
      quick_sort(A,q+1,r)

function partition(A,p,r)
  x = A[r]
  i = p - 1
  for i = p to r - 1
    do if A[j] <= x
      then i = i + 1
        Обменять A[i] на A[j]
  Обменять A[i + 1] на A[r]
  return i + 1

Реализация на Java:

//quick sort
public static void quickSort(int[] arr, int low, int high) {
    int i = low;
    int j = high;
    //выбираем середину в качестве опорного элемента
    int mid = arr[(low + high)/2];
    //сдвигаем меньшие члены влево от опорного, а большие вправо
    do {
        while (arr[i] < mid)
            ++i;
        while (mid < arr[j])
            --j;
        if ( i <= j ) {
            if( i < j ) {
                int t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
            }
            ++i;
            --j;
        }
    } while (i <= j);

    //теперь также сортируем левую и правую часть
    if (low < j)
        quickSort(arr, low, j);
    if (i < high)
        quickSort(arr, i, high);
}

Сортировки за линейное время

Как видно из названия, сложность следующих сортировок O(n)

Сортировка подсчетом (Counting sort)

Идея алгоритма заключается в том, чтобы для каждого входного элемента определить количество элементов, которые меньше него. С помощью этой информации элемент можно разместить на соответствующей позиции выходного массива.

Достоинства: достаточно быстр

Недостатки: элементы входного массива должны быть в интервале от 0 до k, где k - натуральное число; требует выделения памяти

Алгоритм:

function counting_sort
    for i = 0 to k - 1
        C[i] = 0
    for i = 0 to n - 1
        C[A[i]] = C[A[i]] + 1
    b = 0
    for j = 0 to k - 1
        for i = 0 to C[j] - 1
            A[b] = j
            b = b + 1

Реализация на Java:

//counting sort
public static void countingSort(int[] arr, int max) {
int i, j, b = 0;
int[] c = new int[max];

//забьем вспомогательный массив нулями (его индексы соответствуют исходным значениям)
for (i = 0; i < max; i++)  c[i] = 0;

    //забьем вспомогательный массив значениями, равными количеству элементов, меньших данного значения индекса
    for (i = 0; i < arr.length; i++) {
       c[arr[i]] = c[arr[i]] + 1;
       b = 0;
    }

    //забьем на основе данных из вспомогательного массива выходной массив
    for (j = 0; j < max; j++) {
       for (i = 0; i < c[j]; i++) {
           arr[b] = j;
           b = b + 1;
       }
    }
}

Поразрядная сортировка (Radix sort)

Вариант сортировки с младших разрядов least significant digit (LSD). Сначала производится сортировка по младшему разряду, потом по следующему, и так далее, пока дело не дойдет до старшего разряда. Но существует и второй вариант - сортировка по старшему разряду (most significant digit (MSD)).

Недостатки: хотя для этой сортировки нужно меньшее количество итераций прохода по элементам, чем для сортировок сравнения, каждая итерация может длиться значительно дольше.

Алгоритм:

function radix_sort
  for i = 1 to d 
    do Устойчивая сортировка массива A по i-ой цифре

Реализация на Java:

//radix sort
public static void radixSort(int[] arr) {
int cnt[][] = new int[4][];
int b[];
int i, j;
int a_len = arr.length;

if (a_len < 2) {
        // массив длиной 1 элемент не нужно сортировать :)
        return;
    }

    // инициализируем счетчик [cnt]
    for (j = 0; j < 4; j++) {
        cnt[j] = new int[257];
        for (i = 0; i < 257; i++) cnt[j][i] = 0;
    }

    // выделяем память под копию сортируемого массива
    b = new int[a_len];

    // подсчитываем количество элементов для каждого значения j-го разряда
    for (i = 0; i < a_len; i++) {
        for (j = 0; j < 4; j++) {
            cnt[j][1 + ((arr[i] >>> (8 * j)) & 0xff)]++;
}
}

for (j = 0; j < 4; j++) {
        /*
            вычисляем позиции cnt[i], начиная с которых будут располаться элементы
            с соответствующим значением j-го разряда
        */
        for (i = 1; i < 256; i++) cnt[j][i] += cnt[j][i - 1];
        // расставляем элементы из массива a в массив b в указанном порядке
        for (i = 0; i < a_len; i++) {
            b[cnt[j][(arr[i] >>> (8 * j)) & 0xff]++] = arr[i];
}
// копируем массив b на место массива a
for (i = 0; i < a_len; i++) arr[i] = b[i];
    }
}

Блочная (карманная) сортировка (Bucket sort)

Идея, лежащая в основе алгоритма заключается в том, чтобы разбить интервал [0,1) на n одинаковых интервалов, а затем распределить по этим интервалам n входных величин. Поскольку входные элементы равномерно распределены, можно предположить, что в каждый интервал попадет не много элементов. Для получения выходной последовательности, надо провести сортировку в каждом интервале, а затем последовательно перечислить элементы в каждом из них.

Недостатки: ожидаемое время работы алгоритма линейно зависит от количества входных данных только при равномерном распределении входных элементов на отрезке.

Алгоритм:

function bucket-sort(A, n) is
  buckets ← новый массив из n пустых элементов
  for i = 0 to (length(A)-1) do
    вставить A[i] в конец массива buckets[nA[i]]
  for i = 0 to n - 1 do
    next-sort(buckets[i])
  return Конкатенация массивов buckets[0], ..., buckets[n-1]

Реализация на Java:

//bucket sort
public static void bucketSort(int[] arr) {

    //поиск максимального элемента массива
    int maxValue = arr[0];
 
    for (int k = 1; k < arr.length; k++) {
       if (arr[k] > maxValue)
           maxValue = arr[k];
    }

    int i, j;
    //создадим вспомогательный массив
    int[] bucket = new int[maxValue + 1];
    //распределим числа по карманам
    for(i = 0; i < arr.length; i++ ) {
        bucket[arr[i]]++;
    }

    //отсортируем числа в карманах используя сортировку подсчетом
    for(i = 0, j = 0; i < bucket.length; i++) {
        for(; bucket[i]>0; (bucket[i])--) {
            arr[j++] = i;
        }
    }
}

ну и напоследок выложу код для запуска всех вышеперечисленных сортировок, может кому-то он пригодится:

public class Sorting {

    public static void main(String[] args) {
        String[] types = {"insertion","merge","heap","quick", "counting", "radix", "bucket"};
        sort(types);
    }

    private static void sort(String[] types) {
        for (String type: types) {
            int[] arr = {8,4,7,2,7,0,32,17,45,43,32,4,38,4,89,3,6,7,86,3,545,6,7,2,54};
            int[] arr2 = {8,24,7,2,7,0,22,17,15,13,12,4,18,4,19,3,6,7,16,3,15,6,7,2,14};
            if (type.equals("insertion")) {
                insertionSort(arr);
            } else if (type.equals("merge")) {
                arr = mergeSort(arr);
            } else if (type.equals("heap")) {
                heapSort(arr);
            } else if (type.equals("quick")) {
                quickSort(arr, 0, arr.length -1);
            } else if (type.equals("counting")) {
                countingSort(arr, 1000);
            } else if (type.equals("radix")) {
                radixSort(arr);
            } else if (type.equals("bucket")) {
                bucketSort(arr2);
            }
    
            System.out.println("\n"+ type + "Sorted: ");
            if (!type.equals("bucket")) {
                for (int i: arr)  System.out.print(i + ",");
            } else {
                for (int i: arr2)  System.out.print(i + ",");
            }
        }
    }


   ... //here is the code of sorts
}

Установка Etherpad на Ubuntu со Scala 2.8.1

2011-11-12T12:04:00.000-08:00

Для работы Etherpad 1.x требуется Sun JDK, Scala 2.8.1

Сборку Etherpad под scala 2.8.1 можно скачать здесь

Установка Sun JDK

sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
sudo apt-get update   
sudo apt-get install sun-java6-jdk
sudo update-alternatives --config java

установка mysql

mysql -u root -p
create database etherpad;
grant all privileges on etherpad.* to 'etherpad'@'localhost' identified by 'passwd';
quit

установка scala

sudo apt-get install scala
wget http://www.scala-lang.org/downloads/distrib/files/scala-2.8.1.final.tgz
sudo tar -C /opt/ -xvzf scala-2.8.1.final.tgz
PATH="$PATH:/opt/scala-2.8.1.final/bin"

Скачанный Эзер кладем в /usr/local/etherpad

не забудем добавить переменные среды

export JAVA_HOME="/usr/lib/jvm/java-6-sun"
export SCALA_HOME="/opt/scala-2.8.1.final"
export SCALA_LIBRARY_JAR="/opt/scala-2.8.1.final/lib/scala-library.jar"
export MYSQL_CONNECTOR_JAR="/usr/share/java/mysql-connector-java-5.1.10.jar"
export JAVA="$JAVA_HOME/bin/java"
export SCALA="/opt/scala-2.8.1.final/bin/scala"
export PATH="$JAVA_HOME/bin:$PATH"

после всех приготовлений можно собирать Эзер

bin/rebuildjar.sh clearcache

перед запуском подправить etheprad/etherpad/etc/etherpad.localdev-default.properties
мои настройки:

alwaysHttps = false
ajstdlibHome = ../infrastructure/framework-src/modules
appjetHome = ./data/appjet
devMode = true
#etherpad.SSOScript = /usr/local/structures/bin/etherpad.validator
etherpad.adminPass = ethe4RiveriBUYTDEFbzriutb7BIoxboyd7U
etherpad.fakeProduction = false
etherpad.isProduction = false
etherpad.proAccounts = true
etherpad.SQL_JDBC_DRIVER = com.mysql.jdbc.Driver
etherpad.SQL_JDBC_URL = jdbc:mysql://localhost:3306/etherpad
etherpad.SQL_PASSWORD = passwd
etherpad.SQL_USERNAME = etherpad
hidePorts = true
listen = 9000
#listenSecure = 9001
#sslKeyPassword = KEYPASS_CHANGEME
#sslKeyStore = ./data/appjet/keystore
#sslStorePassword = KEYPASS_CHANGEME
logDir = ./data/logs
modulePath = ./src
motdPage = /ep/pad/view/ro.3PfHCD0ApLc/latest?fullScreen=1&slider=0&sidebar=0
topdomains = mydomain.ru, localhost
transportPrefix = /comet
transportUseWildcardSubdomains = true
useHttpsUrls = false
useVirtualFileRoot = ./src
theme = default
etherpad.soffice = /usr/bin/soffice
customBrandingName = etherpad
customEmailAddress = etherpad@etherpad.com
showLinkandLicense = false
smtpServer = 192.168.0.1:25

запуск

bin/run-local.sh&

в дальнейшем можно добавить скрипт в init.d для автоматического запуска Эзера и экспорта переменых среды

Чтение и запись Tab Separated Values файлов

2011-11-11T11:11:00.000-08:00

Что же представляют из себя файлы в формате TSV? Это текстовые файлы, представляющие собой набор строк. В каждой строке одинаковое количество "полей" определенного формата, разделенные символом табуляции ("\t"). Похоже на некое подобие таблицы.

Итак, приступим к написанию reader-а:

/**
 * @author vie
 *
 * TSVReader.java
 * Class for read tab separated values files
 */
public class TSVReader<T> {

    private final String filePath;

    public TSVReader(String filePath) {
        this.filePath = filePath;
    }

    /**
     * This method reads tab separated values file
     * into object of the arbitrary class
     *
     * @param clazz type of transmitted class
     * @return List
     * @throws com.site.tsv.exceptions.TSVException
     */
    public List<T> read(Class<T> clazz) throws TSVException {
        List<T> result = new LinkedList<T>();

        try {
            BufferedReader bReader = new BufferedReader(new FileReader(filePath));
            String line;

            //recieving all lines
            int i = 1;
            while ((line = bReader.readLine()) != null) {
                //recieving all line members
                String datavalue[] = line.split("\t");

                //create instance of line entity
                Constructor constructor = clazz.getConstructor(null);
                Object somethingInstance = constructor.newInstance(null);

                //parsing line entity members
                Field[] fields = clazz.getDeclaredFields();

                //recieve map of line entity member types
                Map<Integer, Class<?>> mapFields = defineFields(clazz);

                //for each line entity field
                if (fields != null && datavalue != null && fields.length == datavalue.length) {
                    for (int j = 0; j < fields.length; j++) {
                        //for each line entity field
                        String s = fields[j].getName();
                        s = s.substring(0, 1).toUpperCase() + s.substring(1, s.length());

                        //exec line entity setter methods
                        Method method = clazz.getMethod("set" + s, mapFields.get(j));
                        method.invoke(somethingInstance, getDeterminatedValue(datavalue[j], fields[j].getType()));
                    }
                } else if (fields != null && datavalue != null && fields.length != datavalue.length) {
                    throw new TSVInvalidFileException("Count of formatted file fields on line " + i + " not equal count of entity fields");
                }

                i++;
                result.add((T) somethingInstance);
            }
            bReader.close();
        } catch (FileNotFoundException e) {
            throw new TSVException(e);
        } catch (IOException e) {
            throw new TSVException(e);
        } catch (ParseException e) {
            throw new TSVInvalidFileException(e);
        } catch (NumberFormatException e) {
            throw new TSVInvalidFileException(e);
        } catch (NoSuchMethodException e) { //reflect
            throw new TSVException(e);
        } catch (InstantiationException e) {
            throw new TSVException(e);
        } catch (IllegalAccessException e) {
            throw new TSVException(e);
        } catch (InvocationTargetException e) {
            throw new TSVException(e);
        }
        return result;
    }

    /**
     * Returns field names and types
     *
     * @param clazz type of transmitted class
     * @return Map<string,integer>.
     * @throws com.site.tsv.exceptions.TSVIncorrectAnnotatedFieldsException
     */
    private Map<Integer, Class<?>> defineFields(Class<?> clazz) throws TSVIncorrectAnnotatedFieldsException {
        Map<Integer, Class<?>> map = new HashMap<Integer, Class<?>>();

        Field[] fields = clazz.getDeclaredFields();
        int i = 0;
        for (Field field : fields) {
            if (field.isAnnotationPresent(TSVInteger.class)) {
                map.put(i++, Integer.class);
            } else if (field.isAnnotationPresent(TSVDouble.class)) {
                map.put(i++, Double.class);
            } else if (field.isAnnotationPresent(TSVString.class)) {
                map.put(i++, String.class);
            } else if (field.isAnnotationPresent(TSVDate.class)) {
                map.put(i++, Date.class);
            }
        }

        if (fields.length == 0 || fields.length != map.size()) {
            throw new TSVIncorrectAnnotatedFieldsException("Some field not annotated or count of fields = 0!");
        }

        return map;
    }

    /**
     * Returns converted to the native type field
     *
     * @param original value of obtained field
     * @param needType type of transmitted class
     * @return Object
     * @throws java.text.ParseException
     */
    private Object getDeterminatedValue(String original, Class<?> needType) throws ParseException {
        if (needType.getName().equals("java.lang.Integer")) {
            return Integer.parseInt(original);
        } else if (needType.getName().equals("java.lang.Double")) {
            return Double.parseDouble(original);
        } else if (needType.getName().equals("java.lang.String")) {
            return original;
        } else if (needType.getName().equals("java.util.Date")) {
            SimpleDateFormat formatter = new SimpleDateFormat("dd.MM.yyyy");
            return formatter.parse(original);
        } else {
            return null;
        }
    }
}

В классе я использовал generics, чтобы проверять заданного типы entity на этапе компиляции. В преобразовании строк с различными типами данных в entity объект мне помог reflection. Для разбора с его помощью entity, написаны приведенные ниже аннотации. Также я создал несколько исключений, чтобы в при выпадении ошибок можно было быстро понять что свалилось, будь то reflection, IO или преобразование чисел и дат.

теперь Writer:

/**
 * @author vie
 *
 * TSVWriter.java
 * Class for write tab separated values files
 */
public class TSVWriter<T> {

    private final static String tab = "\t";

    private final String filePath;

    public TSVWriter(String filePath) {
        this.filePath = filePath;
    }

    /**
     * This method writes tab separated values file
     * from entity object
     *
     * @param list list of line entity objects
     * @param clazz type of transmitted class
     * @throws com.site.tsv.exceptions.TSVException
     */
    public void write(List<T> list, Class<T> clazz) throws TSVException {
        try {
            BufferedWriter bufferWriter = new BufferedWriter(new FileWriter(filePath));
            //getting all line object fields
            Field[] fields = clazz.getDeclaredFields();

            //for each line
            if (fields != null) {
                for (T lineObject: list) {
                    StringBuilder line = new StringBuilder();

                    //for each line entity field
                    for (Field field : fields) {
                        String s = field.getName();
                        s = s.substring(0, 1).toUpperCase() + s.substring(1, s.length());

                        //exec line entity setter methods
                        Method method = clazz.getMethod("get" + s);
                        String val = method.invoke(lineObject) + "";

                        line.append(val).append(tab);
                    }
                    bufferWriter.write(line.substring(0, line.length() - 1));
                    bufferWriter.newLine();
                }
            }
            bufferWriter.close();
        } catch (FileNotFoundException e) {
            throw new TSVException(e);
        } catch (IOException e) {
            throw new TSVException(e);
        } catch (NoSuchMethodException e) {
            throw new TSVException(e);
        } catch (IllegalAccessException e) {
            throw new TSVException(e);
        } catch (InvocationTargetException e) {
            throw new TSVException(e);
        }
    }
}

Аннотации:

/**
 * @author vie
 */
@Target(value = ElementType.FIELD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface TSVInteger {
}

/**
 * @author vie
 */
@Target(value = ElementType.FIELD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface TSVDouble {
}

/**
 * @author vie
 */
@Target(value = ElementType.FIELD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface TSVString {
}

/**
 * @author vie
 */
@Target(value = ElementType.FIELD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface TSVDate {
}

Исключения:

/**
 * @author vie
 */
public class TSVException extends Exception {

    public TSVException() {
       super();
    }

    public TSVException(String message) {
       super(message);
    }

    public TSVException(String message, Throwable cause) {
        super(message, cause);
    }

    public TSVException(Throwable cause) {
        super(cause);
    }
}

/**
 * @author vie
 */
public class TSVInvalidFileException extends TSVException {

    public TSVInvalidFileException() {
       super();
    }

    public TSVInvalidFileException(String message) {
       super(message);
    }

    public TSVInvalidFileException(String message, Throwable cause) {
        super(message, cause);
    }

    public TSVInvalidFileException(Throwable cause) {
        super(cause);
    }
}

/**
 * @author vie
 */
public class TSVIncorrectAnnotatedFieldsException extends TSVException {

    public TSVIncorrectAnnotatedFieldsException() {
       super();
    }

    public TSVIncorrectAnnotatedFieldsException(String message) {
       super(message);
    }

    public TSVIncorrectAnnotatedFieldsException(String message, Throwable cause) {
        super(message, cause);
    }

    public TSVIncorrectAnnotatedFieldsException(Throwable cause) {
        super(cause);
    }
}

Все, теперь можно попробовать загрузить и записать в другой файл. Для этого создадим entity, аналогичный структуре файла:

test1 55 01.01.2010 rw
test2 daswqrg 56 31.01.2011 comment1
test3 dds 57 30.11.2011 comment32

entity:

/**
 * @author vie
 */
public class TestLineEntity {

    @TSVString
    protected String value;

    @TSVInteger
    protected Integer id;

    @TSVDate
    protected Date date;

    @TSVString
    protected String comment;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
    /*other getters and setters*/
}

сам код считывания и записи данных:

TSVReader<TestLineEntity> tsvReader = new TSVReader<TestLineEntity>("test.tsv");
List<TestLineEntity> test = tsvReader.read(TestLineEntity.class);

TSVWriter<TestLineEntity> tsvWriter = new TSVWriter<TestLineEntity>("new_test.tsv");
tsvWriter.write(forum, TestLineEntity.class);

Разделение выполнения задачи на n потоков

2011-11-09T01:17:00.000-08:00

Бывает при решении некоторых задач, таких как загрузка данных с FTP приходится разделять ход выполнения задачи на несколько потоков.
Казалось бы, все просто. Создаем n-е количество потоков (каждый из которых делает часть общей работы) и запускаем их:

public class MainClass {
  public static void main(String[] args) {
    WorkClass work = new WorkClass();
    work.doSomeWork();
  }
}

public class WorkClass {

  public void doSomeWork() {             
    for (int i = 0; i < 5; i++) { 
      Worker worker = new Worker("directory" + i);
      Thread thread = new Thread(worker);
      thread.start();
    }
    
    //here we must wait for execution of all threads

    //doing work on    
  }

  public class Worker implements Runnable {

    private String dir;

    public Worker(String dir) {
      this.dir = dir;
    }
  
    @Override
    public void run() {
      doPieceOfWork();
    }

    private void doPieceOfWork() {
      //doing loading from FTP, depending on the name of directory ...
    }
  }
}

Здесь в качестве примера разделения выполняемой работы на 5 потоков приводится загрузка по FTP. Каждый поток грузит свою папку. Но может возникнуть проблема. Надо подождать, пока выполнятся все запущенные потоки, и только после этого продолжать работу основного потока. Для этого обернем вызов потоков в блок синхронизации.

public void doSomeWork() {
  synchronized (this) {             
    for (int i = 0; i < 5; i++) { 
      Worker worker = new Worker("directory" + i);
      Thread thread = new Thread(worker);
      thread.start();
    }
  }
}

Далее остановим главный поток после запуска второстепенных потоков до тех пор, пока не получим ответ о завершении работы каждого из них. Для этого сделаем цикл, в котором получаем уведомление от одного из потоков и, если количество завершенных второстепенных потоков меньше количества запущенных, продолжаем ожидать ответа от оставшихся:

public void doSomeWork() {
  synchronized (this) { 
    Vector events = new Vector();
            
    for (int i = 0; i < 5; i++) {       
      Worker worker = new Worker(this, "directory" + i, events);
      Thread thread = new Thread(worker);
      thread.start();
    }

    //if all threads are dead, go ahead
    while (true) {
      try {
        this.wait();
      } catch (InterruptedException e) {
        errorLogger.error(e.getMessage(), e);
      }
      if (events.size() == 5) {
        break;
      }
    }        
  }

  //doing work on
}

теперь надо добавить во второстепенные потоки уведомления, которые будет получать основной поток:

public class Worker implements Runnable {

  private String dir;

  private Vector events;

  public Worker(WorkClass monitor, String dir, Vector events) {
    this.dir = dir;
    this.events = events;
  }
  
  @Override
  public void run() {
    doPieceOfWork();
  }

  private void doPieceOfWork() {
    //doing loading from FTP, depending on the name of directory ...
    
    synchronized (monitor) {
      events.add(new Object());
      monitor.notify();      
    }
  }
}

Cледует обратить внимание, что блоки синхронизации во второстепенных потоках и в главном создаются по монитору work класса WorkClass. Также в класс Worker добавлена коллекция events, которая выполняет роль счетчика завершенных потоков. Класс Vector выбран не случайно, тк его методы синхронизированы. В качестве его альтернативы можно воспользоваться Collections.synchronizedList(new ArrayList()). Хотя в данном случае синхронизация методов коллекции и не будет играть никакой роли, тк работа с ней происходит в блоке синхронизации. Все, теперь метод doSomeWork() разделит загрузку по FTP на 5 потоков и продолжит свою работу после завершения всех запущенных потоков. Общий результат выглядит так:

public class MainClass {
  public static void main(String[] args) {
    WorkClass work = new WorkClass();
    work.doSomeWork();
  }
}

public class WorkClass {
  protected static final Logger errorLogger = LoggerFactory.getLogger("errorLogger");

  public void doSomeWork() {
    synchronized (this) {     
      Vector events = new Vector();
        
      for (int i = 0; i < 5; i++) { 
        Worker worker = new Worker(this, "directory" + i, events);
        Thread thread = new Thread(worker);
        thread.start();
      }
      
      //if all threads are dead, go ahead
      while (true) {
        try {
          this.wait();
        } catch (InterruptedException e) {
          errorLogger.error(e.getMessage(), e);
        }
        if (events.size() == 5) {
          break;
        }
      }
    }
    
    //doing work on 
  }

  public class Worker implements Runnable {

    private String dir;

    private Vector events;

    public Worker(WorkClass monitor, String dir, Vector events) {
      this.dir = dir;
      this.events = events;
    }
  
    @Override
    public void run() {
      doPieceOfWork();
    }

    private void doPieceOfWork() {
      //doing loading from FTP, depending on the name of directory ...
    
      synchronized (monitor) {
        events.add(new Object());
        monitor.notify();        
      }
    }
  }
}

Maven Shade Plugin

2011-10-31T01:17:00.000-07:00

Shade плагин как альтернатива Assembly.

На днях используя Assembly, столкнулся со следующей проблемой. Приложение со Spring собрал в jar. При запуске валилась ошибка:

Exception in thread "main" org.springframework.beans.factory.parsing.BeanDefinitionParsingException:
Configuration problem: Unable to locate Spring NamespaceHandler
for XML schema namespace [http://www.springframework.org/schema/context]
at org.springframework.beans.factory.parsing.FailFastProblemReporter.
error(FailFastProblemReporter.java:68)
at org.springframework.beans.factory.parsing.ReaderContext.error(ReaderContext.java:85)
...

Это означает что при копировании в META-INF спринговых файлов spring.schemas и spring.handlers, они перезатираются для каждой spring библиотеки.

Assebly плагин выглядел так:


    maven-assembly-plugin
    2.2.1
    
        false
        
            jar-with-dependencies
        
        
            
                com.mypackage.MainClass

Немного погуглив, нашел вариант с обьявлением своего assembly дескриптора, или со скачиванем all-in-one Spring библиотеки. Но на stackoverflow посоветовали использовать плагин Shade.

Обьявление Shade:


    org.apache.maven.plugins
    maven-shade-plugin
    
        
            package
            
                shade
            
            
                
                    
                        com.mypackage.MainClass
                    
                    
                        META-INF/spring.handlers
                    
                    
                        META-INF/spring.schemas
                    
                
                
                    
                        *:*
                        
                            META-INF/*.SF
                            META-INF/*.DSA
                            META-INF/*.RSA

Все. После этого спокойно собираем jar командой package и никаких проблем.

RESTful веб-сервис на Jersey + Spring 3

2011-09-28T07:50:00.000-07:00

Пишем простой REST веб-сервис.

Как известно, начиная с третьей версии у Spring появилась возможность легко создавать REST веб сервис с помощью Spring MVC (на аннотациях @RequestMapping). Но я хочу рассмотреть классический Jax-RS с помощью Jersey. Итак, начнем.

Для начала определим maven зависимости:




    com.sun.jersey
    jersey-server
    1.9.1




    com.sun.jersey.contribs
    jersey-spring
    1.9.1
    
        
            org.springframework
            spring
        
        
            org.springframework
            spring-core
        
        
    



    com.sun.xml.bind
    jaxb-impl
    2.1.9

exclusions в зависимости jersey+spring необходимы потому, что библиотека требует зависимости спринга версий 2 или 2.5. А мы ей их дать не можем, тк используем третью версию. В исключениях требуется указать все библиотеки Spring, которые у нас есть в проекте.

Теперь можно писать сам сервис. Будем доставать продукты по их id:

@Path("/product/{id}")
@Component
@Scope("prototype")
public class ProductRSController {

    @Autowired
    private ProductService srv;

    @GET
    @Produces(MediaType.APPLICATION_XML)
    public Product getDescription(@PathParam("id") String productId) {
        Product product = srv.getProduct(productId);
        return product;
    }
}

Пометив метод с помощью аннотаций @GET и @Produces(MediaType.APPLICATION_XML), мы указали, что url вида http://myserver.com/myapp/rs/product/123 (где myserver.com - наш сервер, myapp - имя развернутого приложения), будет возвращать в ответ сериализованный обьект Product в xml.

Класс ProductService представляет собой сервис бин, с методом Product getProduct(String productId) {...}

Не забудем настроить web.xml:


    contextConfigLocation/WEB-INF/spring-context.xml


    org.springframework.web.context.ContextLoaderListener



    Jersey Web Application
    com.sun.jersey.spi.spring.container.servlet.SpringServlet
    1



    Jersey Web Application
    /rs/*

и spring-context.xml:

Теперь можно разворачивать приложение и зайти по URL http://myserver.com/myapp/rs/product/123. В случае успеха мы увидим полученный XML, если конечно у нас есть Product с id = 123.

Теперь можно создавать клиент веб-сервиса. Для удобства работы, возьмем клиент от Jersey.

зависимости:


    com.sun.xml.bind
    jaxb-impl
    2.1.9



    com.sun.jersey
    jersey-client
    1.9.1

сам клиент будет выглядеть так:

public class RESTClient {

    public Product recieveObject() {
        Client c = Client.create();
        WebResource r = client.resource("http://myserver.com/myapp/rs/");
        Product product = response = r.path("product/123").
                accept(MediaType.APPLICATION_XML_TYPE).
                get(Product.class);

        return product;
    }
    
    public String recieveXML() {
        Client c = Client.create();
        WebResource r = client.resource("http://myserver.com/myapp/rs/");
        String product = response = r.path("product/123").
                accept(MediaType.APPLICATION_XML_TYPE).
                get(String.class);

        return product;
    }
}

метод recieveObject() возвращает десериализованный обьект Product, а метод recieveXML() возвращает XML.

С помощью Generics можно сделать клиент универсальным:

public class RESTClient {

    private static final Client client;

    private String resource = "http://myserver.com/myapp/rs/";

    static {
        client = Client.create();
    }

    public RESTClient() {
    }

    public RESTClient(String resource) {
        this.resource = resource;
    }

    public void recieve() {

        //object
        Product product = recieve(Product.class, "product/", "123");
        System.out.println("response.getProductId: " + product.getProductId());
        
        //string 
        String xml = recieve(String.class, "product/", "123");
        System.out.println("response: " + xml);
    }

    private <T> T recieve(Class<T> type, String URI, String id) {
        WebResource r = client.resource(resource);

        T response = r.path(URI + id).
                accept(MediaType.APPLICATION_XML_TYPE).
                get(type);

        return response;
    }
}

Для настройки вывода данных в формате JSON необходимо проделать следующее:

Добавить зависимость:


            com.sun.jersey
            jersey-json
            1.10

Создать класс JAXBContextResolver в том же package, где лежит контроллер

@Provider
public final class JAXBContextResolver implements ContextResolver<jaxbcontext> {

    private final JAXBContext context;

    private final Set<class> types;

    private final Class[] cTypes = {MyEntity1.class, MyEntity1.class};

    public JAXBContextResolver() throws Exception {
        this.types = new HashSet(Arrays.asList(cTypes));
        this.context = new JSONJAXBContext(JSONConfiguration.natural().build(), cTypes);
    }

    @Override
    public JAXBContext getContext(Class<?> objectType) {
        return (types.contains(objectType)) ? context : null;
    }
}

где MyEntity1, MyEntity2 - отображаемые в JSON обьекты

и в контроллере указывать формат данных @Produces("application/json; charset=utf-8")

Scala под windows 7. ошибка при запуске компилятора.

2011-09-07T14:31:00.000-07:00

После установки Scala 2.9.0 на win 7 столкнулся с проблемой. (С предыдущими версиям scala все нормально)

при запуске команды scalac -version неожиданно вываливается Эксепшн:

Exception in thread "main" java.lang.NoClassDefFoundError: scala/tools/nsc/MainGenericRunner
Caused by: java.lang.ClassNotFoundException: scala.tools.nsc.MainGenericRunner
        at java.net.URLClassLoader$1.run(URLClassLoader.java:202)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(URLClassLoader.java:190)
        at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
        at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
        at java.lang.ClassLoader.loadClass(ClassLoader.java:248)
Could not find the main class: scala.tools.nsc.MainGenericRunner.  Program will exit.

Начал разбираться в чем проблема. Оказалось, что при запуске scala.bat тоже самое.

Путем трейса файлов scalac.bat и scala.bat установил переменная _SCALA_HOME
в них неверная:

_SCALA_HOME c:\Program Files\Files\scala\bin\..

Хотя Переменная среды проставлена правильно:

c:\Program Files\scala\bin\..

В итоге пришлось в файлах scala.bat и scala.sh исправить строчки:

:set_home
  set _BIN_DIR=
  rem for %%i in (%~sf0) do set _BIN_DIR=%_BIN_DIR%%%~dpsi
  rem set _SCALA_HOME=%_BIN_DIR%..
  set _SCALA_HOME=%~dps0..
goto :eof

здесь заккоментировал:

for %%i in (%~sf0) do set _BIN_DIR=%_BIN_DIR%%%~dpsi
set _SCALA_HOME=%_BIN_DIR%..

и добавил

set _SCALA_HOME=%~dps0..

AspectJ + Maven + Spring + IDEA

2011-08-27T03:25:00.000-07:00

Как заставить работать AspectJ с Maven и Spring.

Подцепим зависимости maven:


    org.springframework
    spring-aop
    ${spring.version}
    
        
            org.aspectj
            aspectjweaver
        
    



    org.springframework
    spring-aspects
    ${spring.version}
    
        
            org.aspectj
            aspectjweaver
        
    





    org.aspectj
    aspectjrt
    ${aspectj.version}

Для выполнения aspectj компиляции добавим плагин в maven:


    org.codehaus.mojo
    aspectj-maven-plugin
    1.1
    
        1.6
        1.6
        true
        ignore
        
            
                org.springframework
                spring-aspects
            
        
        false
    
    
        
            
                compile
                test-compile

Все, проект можно собирать.
Для выполнения приложения прямо из IDEA надо поставить галку "Run Maven Goal" в Run -> Edit Configurations -> Before Launch и выбрать в ней плагин aspectj:compile

Singleton и Prototype scope в Spring

2011-07-09T05:25:00.000-07:00

Singleton scope означает что экземпляр бина создается один раз, при инициализации контекста. Не стоит сравнивать этот scope со stateless bean в EJB. EJB контейнер при каждом обращении выдает новый экземпляр бина. Поэтому в stateless бине состояние не сохраняется. Таким образом Singleton scope в Spring - тоже statefull. В случае со scope Prototype, можно создавать его новые экземпляры, когда это надо, с помощью фабрики. (statefull)

В обьявлении этих бинов нет ничего сложного:

Но проблема появляется, когда нужна зависимость SingletonBean от PrototypeBean. В этом случае можно поступить несколькими способами:
ApplicationContextAware или BeanNameAware method injection; Lookup method injection; Arbitrary method replacement.
Расскажу о самом простом (по крайней мере для меня) из них - аналоге BeanNameAware.

PrototypeBean может представлять из себя что угодно. В данном контексте нам это не важно, так что будем рассматривать его просто как POJO класс:

public class PrototypeBean {
...
}

а в SingletonBean используем фабрику org.springframework.beans.factory.ObjectFactory:

public class SingletonBean {

  private ObjectFactory factory;

  public void createPrototypeBean() {
     //здесь можем получить сколько угодно экземпляров PrototypeBean
     PrototypeBean bean = factory.getObject();
  }

  ...

  public void setFactory(ObjectFactory beanFactory) throws BeansException {
     this.factory = beanFactory;
  }
}

Чтобы явно указать ObjectFactory экземпляр какого бина создавать, в конфигурации пропишем ObjectFactory как property Singleton-бина:

Установка Tomcat под Ubuntu

2011-06-25T05:59:00.000-07:00

Для начала установливаем openjdk вместе с пакетом ubuntu-restricted-extras:

sudo apt-get install ubuntu-restricted-extras

установленная версия: 1.06_22

качаем томкат:

wget http://apache.cyberuse.com/tomcat/tomcat-7/v7.0.16/bin/apache-tomcat-7.0.16.tar.gz

распаковываем:

tar xvzf apache-tomcat-7.0.16.tar.gz

копируем в нужную папку:

sudo mv apache-tomcat-7.0.16 /usr/local/tomcat

также необходимо прописать переменные окружения JAVA_HOME и JDK_HOME. Для этого добавляем в файле /etc/environment:

JDK_HOME="/usr/lib/jvm/java-6-openjdk"
JAVA_HOME="/usr/lib/jvm/java-6-openjdk"

запускаем томкат:

sudo /usr/local/tomcat/bin/catalina.sh start

редактируем server.xml:

sudo nano /usr/local/tomcat/conf/server.xml

ищем следующий текст:

меняем порт на стандартный для http - 80, и указываем кодировку для URI:

создаем файл автозагрузки

sudo nano /etc/init.d/tomcat

и вставляем следующее:

# Tomcat auto-start
#
# description: Auto-starts tomcat
# processname: tomcat
# pidfile: /var/run/tomcat.pid

export JAVA_HOME=/usr/lib/jvm/java-6-openjdk

case $1 in
start)
       sh /usr/local/tomcat/bin/startup.sh
       ;;
stop)  
       sh /usr/local/tomcat/bin/shutdown.sh
       ;;
restart)
       sh /usr/local/tomcat/bin/shutdown.sh
       sh /usr/local/tomcat/bin/startup.sh
       ;;
esac   
exit 0

далее сделаем этот скрипт запускаемым:

sudo chmod 755 /etc/init.d/tomcat

для проверки работы запустим tomcat:

sudo /etc/init.d/tomcat start

сервер должен запуститься на 80 порту. Для остановки используем следующую команду:

sudo /etc/init.d/tomcat stop

создадим ссылки на скрипт для автоматического запуска и останова:

sudo update-rc.d tomcat defaults

перезагружаем сервер:

sudo shutdown -r now

в конце надо не забыть создать пользователя tomcat с ролями admin-gui и manager-gui в conf\tomcat-users.xml:

Double checked locking

2011-06-09T05:10:00.001-07:00

Шаблон проектирования "Блокировка с двойной проверкой" используется в многопоточном программировании. Это один из излюбленных вопросов на собеседованиях. Звучит он обычно как просьба написать синглетон, корректно работающий в многопоточном режиме.

Рассмотрим принцип паттерна на примере Синглетона.

// Не работает в Java 1.4 и более ранних версиях из-за семантики volatile
class Foo {
  private volatile Helper helper = null;  

  public Helper getHelper() {
    if (helper == null) {          //блок проверки, для ускорения производительности
      synchronized(this) {         //блок синхронизации
        if (helper == null)        //если обьект еще не создан, то создаем его
          helper = new Helper();
      }
    }
    return helper;
  }
}

Первый блок проверки нужен для того, чтобы при инициализированной переменной не блокировать участок кода, тем самым ускорить процесс выполнения программы. Внутренняя проверка служит для проверки, инициализирована ли переменная, чтобы в последуюущих случаях обращения к ней после инициализации выдавался уже созданный ее экземпляр. Блок синхронизации разделяет доступ потоков к коду, инициализирующему переменную.

Модификатор volatile появился начиная с версии Java 1.5. Он позволяет корректно обработать запись в переменную в многопоточном режиме.

Typesafe Enum pattern или как обойтись без Enum-ов.

2011-05-11T05:05:00.000-07:00

Часто нужда в использовании Enum возникает в случае, если необходимо передать в метод одно из значений, например "green", "red" или "blue". Первое что приходит в голову - это принимать String:

public void method(String param) {...}

Но в таком случае в качестве параметра может быть принята любая строка. В соответствии с принципом, что все потенциальные ошибки по возможности надо переносить на момент компиляции, такой вариант неприемлем. Тут и приходит на помощь Enum:

public enum TypesafeEnum {GREEN, RED, BLUE};

А можно ли обойтись без него? Конечно можно, ведь Enum появились только с java 1.5. Тут нам может помочь паттерн Typesafe Enum:

public class TypesafeEnum {

  private final String name;

  private TypesafeEnum(String name) {
    this.name = name;
  }

  public static final TypesafeEnum GREEN = new TypesafeEnum("green");
  public static final TypesafeEnum RED = new TypesafeEnum("red");
  public static final TypesafeEnum BLUE = new TypesafeEnum("blue");

  public String toString() {
    return name;
  }
}

Теперь можно обьявить наш метод таким образом:

public void method(TypesafeEnum param) {...}

соответственно его вызов:

someObject.method(TypesafeEnum.RED);

Подробнее о паттерне здесь

Паттерн Entity-Attribute-Value (EAV)

2011-04-15T06:21:00.000-07:00

Паттерн "Entity-Attribute-Value" может пригодиться при проектировании базы данных товаров. Рассмотрим пример на СУБД Oracle.

В простейшем случае структура базы данных будет выглядеть следующим образом:

-- Create table
create table entity
(
  entity_id number,
  name      varchar2(50)
);
-- Create/Recreate primary, unique and foreign key constraints 
alter table entity
  add constraint xpk_entity_id primary key (ENTITY_ID);

Таблица Entity хранит сами сущности - товары. В качестве полей указываем общие свойства сущностей, таких как Название товара

-- Create table
create table attribute
(
  attribute_id   number,
  attribute_name varchar2(50),
  attribute_type varchar2(10),
  decriptions    clob
);
-- Create/Recreate primary, unique and foreign key constraints 
alter table attribute
  add constraint xpk_attribute_id primary key (ATTRIBUTE_ID);

Таблица Attribute хранит различные свойства товаров - атрибуты. В качестве полей указываем название атрибута, тип.

-- Create table
create table value
(
  attribute_id   number,
  entity_id      number,
  string_value   varchar2(100),
  number_value   number
);

таблица value - для хранения значений атрибутов, а также для связи многие ко многим между товарами и их атрибутами.

Реализация разных типов данных может быть реализована различными способами. Например вместо одного поля value можно создать разные поля под разные типы данных: string_value, number_value и использовать нужное исходя из типа атрибута из таблицы attribute.

Более подробная информация по паттерну

Simple ORM

2011-04-09T08:13:00.000-07:00

Наверное многие начинающие java программисты задумывались над тем, как неудобно писать слой взаимодейстия с базой данных на чистом JDBC. Ctrl+c, Ctrl+v и изменение названия таблиц и параметров. Все это приводит к излишнему дублированию кода. Конечно можно сразу взять тот же Hibernate или любую другую реализацию JPA. Но для небольших и простых проектов, имхо это как "из пушки по воробьям". К тому же считаю что надо один раз написать ORM самому, чтобы понять основы его работы.

В этой статье рассмотрим создание своего простого ORM на примере работы с СУБД Oracle.

Создадим интерфейс Persistence и реализующий его класс PersistenceOraImpl - собственно сам персистенс Api для работы с БД.

Список методов в Persistence:

1. selectAll - выбирает все записи из таблицы;
2. select - выбирает записи по заданным параметрам;
3. selectRow - выбирает одну запись по заданным параметрам;
4. insert - вставляет запись;
5. update - обновляет запись;
6. delete - удаляет запись.

Сам интерфейс выглядит так:

public interface Persistence {

 public List selectAll(Class<?> clazz);

 public List select(Class<?> clazz, Map<String, Object> params);

 public Object selectRow(Class<?> clazz, Map<String, Object> params);

 public void insert(Object obj);

 public void update(Object obj);

 public void delete(Class<?> clazz, Map<String, Object> params);

 public Connection getConnection();

 public void setConnection(Connection conn);
}

Имплементим методы в классе PersistenceOraImpl.

selectAll:

@Override
@Override
public List selectAll(Class<?> clazz) {

 try {

  OraclePreparedStatement stmt = (OraclePreparedStatement) conn.prepareStatement(
    "select t.* from " + PersistenceHelper.defineTable(clazz) + " t");

  OracleResultSet orset = (OracleResultSet) stmt.executeQuery();
  List treeList = new ArrayList();

  while (orset.next()) {

   Constructor constructor = clazz.getConstructor(null);
   Object somethingInstance = constructor.newInstance(null);
   Field[] fields = clazz.getDeclaredFields();

   Map<Integer, Class<?>> mapFields = PersistenceHelper.defineFields(clazz);

   /*выполняем методы set...()*/
   for (Integer i = 1; i <= mapFields.size(); i++) {
    String s = fields[i - 1].getName();
    s = s.substring(0, 1).toUpperCase() + s.substring(1, s.length());

    Method method = clazz.getMethod("set" + s, mapFields.get(i));
    method.invoke(somethingInstance, PersistenceHelper.getSqlValue(orset, mapFields.get(i), i));
   }

   treeList.add(somethingInstance);
  }
  orset.close();
  stmt.close();

  return treeList;

 } catch (Exception ex) {
  ex.printStackTrace();
  return nullArray;
 }
}

select:

@Override
public List select(Class<?> clazz, Map<String, Object> params) {
 try {

  String sSql = "select t.* from " + PersistenceHelper.defineTable(clazz) + " t ";
  String sSql1 = "where ";

  Integer j = 1;
  for (String key : params.keySet()) {
   if (key.equals("period")) {
    sSql1 += " to_char(t.period,'MM.yyyy') = to_char(?,'MM.yyyy') ";
   } else if (key.substring(key.length() - 1).equals(">")) {
    sSql1 += key + "= ?";
   } else if (key.substring(key.length() - 1).equals("<")) {
    sSql1 += key + "= ?";
   } else {
    sSql1 += key + " = ?";
   }

   if (j++ < params.size()) {
    sSql1 += " and ";
   }
  }

  OraclePreparedStatement stmt = (OraclePreparedStatement) conn.prepareStatement(
    sSql + sSql1);

  System.out.println("select: " + sSql + sSql1);

  j = 1;
  for (String key : params.keySet()) {
   PersistenceHelper.setSqlValue(stmt, params.get(key).getClass(), j++, params.get(key));
  }

  OracleResultSet orset = (OracleResultSet) stmt.executeQuery();
  List treeList = new ArrayList();

  while (orset.next()) {

   Constructor constructor = clazz.getConstructor(null);
   Object somethingInstance = constructor.newInstance(null);
   Field[] fields = clazz.getDeclaredFields();

   Map<Integer, Class<?>> mapFields = PersistenceHelper.defineFields(clazz);

   /*выполняем методы set...()*/
   for (Integer i = 1; i <= mapFields.size(); i++) {
    String s = fields[i - 1].getName();
    s = s.substring(0, 1).toUpperCase() + s.substring(1, s.length());

    Method method = clazz.getMethod("set" + s, mapFields.get(i));
    method.invoke(somethingInstance, PersistenceHelper.getSqlValue(orset, mapFields.get(i), i));
   }

   treeList.add(somethingInstance);
  }
  orset.close();
  stmt.close();

  return treeList;

 } catch (Exception ex) {
  ex.printStackTrace();
  return nullArray;
 }
}

selectRow:

@Override
public Object selectRow(Class<?> clazz, Map<String, Object> params) {

 try {

  String sSql = "select t.* from " + PersistenceHelper.defineTable(clazz) + " t ";
  String sSql1 = " where ";

  Integer j = 1;
  for (String key : params.keySet()) {
   if (key.equals("period")) {
    sSql1 += " to_char(t.period,'MM') = to_char(?,'MM') ";
   } else {
    sSql1 += key + " = ? ";
   }

   if (j++ < params.size()) {
    sSql1 += " and ";
   }
  }

  OraclePreparedStatement stmt = (OraclePreparedStatement) conn.prepareStatement(
    sSql + sSql1);

  System.out.println("selectRow: " + sSql + sSql1);
  j = 1;
  for (String key : params.keySet()) {
   PersistenceHelper.setSqlValue(stmt, params.get(key).getClass(), j++, params.get(key));
  }

  OracleResultSet orset = (OracleResultSet) stmt.executeQuery();
  List treeList = new ArrayList();

  while (orset.next()) {
   Constructor constructor = clazz.getConstructor(null);
   Object somethingInstance = constructor.newInstance(null);
   Field[] fields = clazz.getDeclaredFields();

   Map<Integer, Class<?>> mapFields = PersistenceHelper.defineFields(clazz);

   /*выполняем методы set...()*/
   for (Integer i = 1; i <= mapFields.size(); i++) {
    String s = fields[i - 1].getName();
    s = s.substring(0, 1).toUpperCase() + s.substring(1, s.length());

    Method method = clazz.getMethod("set" + s, mapFields.get(i));
    method.invoke(somethingInstance, PersistenceHelper.getSqlValue(orset, mapFields.get(i), i));
   }

   treeList.add(somethingInstance);
  }

  orset.close();
  stmt.close();

  if (treeList.size() > 0) {
   return treeList.get(0);
  } else {
   Constructor constructor = clazz.getConstructor(null);
   return constructor.newInstance(null);
  }

 } catch (Exception ex) {
  ex.printStackTrace();
  return new Object();
 }
}

insert:

@Override
public void insert(Object obj) {

 try {

  Class<?> clazz = obj.getClass();

  Map<Integer, Class<?>> mapFields = PersistenceHelper.defineFields(clazz);
  Map<Integer, String> mapFieldNames = PersistenceHelper.defineFieldNames(clazz);
  Field[] fields = clazz.getDeclaredFields();

  String sSql = "insert into " + PersistenceHelper.defineTable(clazz) + " t ";
  String sSql1 = "(";
  String sSql2 = ") values (";

  for (int i = 1; i <= mapFieldNames.size(); i++) {
   if (i < mapFieldNames.size()) {
    sSql1 += mapFieldNames.get(i) + ",";
    sSql2 += "?,";
   } else {
    sSql1 += mapFieldNames.get(i);
    sSql2 += "?";
   }
  }

  OraclePreparedStatement stmt = (OraclePreparedStatement) conn.prepareStatement(
    sSql + sSql1 + sSql2 + ")");

  /*выполняем методы get...()*/
  for (Integer i = 1; i <= mapFields.size(); i++) {
   String s = fields[i - 1].getName();
   s = s.substring(0, 1).toUpperCase() + s.substring(1, s.length());

   Method method = clazz.getMethod("get" + s);
   Object o = method.invoke(obj);
   PersistenceHelper.setSqlValue(stmt, mapFields.get(i), i, o);
  }

  stmt.executeUpdate();

  stmt.close();

 } catch (Exception ex) {
  ex.printStackTrace();
 }

}

update:

@Override
public void update(Object obj) {

 try {

  Class<?> clazz = obj.getClass();

  Map<Integer, Class<?>> mapFields = PersistenceHelper.defineFields(clazz);
  Map<Integer, String> mapFieldNames = PersistenceHelper.defineFieldNames(clazz);
  Field[] fields = clazz.getDeclaredFields();

  String sSql = "update " + PersistenceHelper.defineTable(clazz) + " t set ";
  String sSql1 = "";

  for (int i = 1; i <= mapFieldNames.size(); i++) {
   if (i < mapFieldNames.size()) {
    sSql1 += mapFieldNames.get(i) + " = ? , ";
   } else {
    sSql1 += mapFieldNames.get(i) + " = ? ";
   }
  }

  /*привяжем условие по первому полю. обычно это id*/
  sSql1 += " where " + mapFieldNames.get(1) + " = ?";

  OraclePreparedStatement stmt = (OraclePreparedStatement) conn.prepareStatement(
    sSql + sSql1);

  /*выполняем методы get...()*/
  for (Integer i = 1; i <= mapFields.size(); i++) {
   String s = fields[i - 1].getName();
   s = s.substring(0, 1).toUpperCase() + s.substring(1, s.length());


   Method method = clazz.getMethod("get" + s);
   Object o = method.invoke(obj);

   PersistenceHelper.setSqlValue(stmt, mapFields.get(i), i, o);

   /*привяжем переменную where*/
   if (i == 1) {
    PersistenceHelper.setSqlValue(stmt, mapFields.get(i), mapFields.size() + 1, o);
   }
  }


  stmt.executeUpdate();
  stmt.close();

 } catch (Exception ex) {
  ex.printStackTrace();
 }
}

delete:

@Override
public void delete(Class<?> clazz, Map<String, Object> params) {
 try {

  String sSql = "delete from " + PersistenceHelper.defineTable(clazz) + " t ";
  String sSql1 = " where ";

  Integer j = 1;
  for (String key : params.keySet()) {
   if (key.equals("period")) {
    sSql1 += " to_char(t.period,'MM') = to_char(?,'MM') ";
   } else {
    sSql1 += key + " = ? ";
   }

   if (j++ < params.size()) {
    sSql1 += " and ";
   }
  }

  OraclePreparedStatement stmt = (OraclePreparedStatement) conn.prepareStatement(
    sSql + sSql1);

  j = 1;
  for (String key : params.keySet()) {
   PersistenceHelper.setSqlValue(stmt, params.get(key).getClass(), j++, params.get(key));
  }

  stmt.executeUpdate();
  stmt.close();

 } catch (Exception ex) {
  ex.printStackTrace();
 }
}

Остальная часть класса:

public class PersistenceOraImpl implements Persistence {

 private static final List nullArray = new ArrayList();

 private OracleConnection conn;

 public PersistenceOraImpl(OracleConnection conn) {
  setConnection(conn);
 }
 
 /* методы CRUD 
  ...
 */
 
 @Override
 public OracleConnection getConnection() {
  return conn;
 }

 @Override
 public void setConnection(Connection conn) {
  this.conn = (OracleConnection) conn;
 }

В методах используется вспомогательный класс PersistenceHelper:

public class PersistenceHelper {


 /**
  * Возвращает название таблицы из аннотации
  *
  * @param clazz тип передаваемого класса
  * @return oracle String.
  */
 public static String defineTable(Class clazz) {
  String table;

  if (clazz.isAnnotationPresent(OraDataTable.class)) {
   table = clazz.getAnnotation(OraDataTable.class).value();
  } else {
   throw new IllegalStateException(clazz.getName() + " must be @OraDataTable");
  }
  return table.toUpperCase();
 }

 /**
  * Возвращает названия и типы полей
  *
  * @param clazz тип передаваемого класса
  * @return oracle Map.
  */
 public static Map<Integer, Class<?>> defineFields(Class<?> clazz) {
  Map<Integer, Class<?>> map = new HashMap<Integer, Class<?>>();

  Field[] fields = clazz.getDeclaredFields();
  for (Field field : fields) {
   if (field.isAnnotationPresent(OraInteger.class)) {
    map.put(field.getAnnotation(OraInteger.class).value(), Integer.class);
   } else if (field.isAnnotationPresent(OraString.class)) {
    map.put(field.getAnnotation(OraString.class).value(), String.class);
   } else if (field.isAnnotationPresent(OraDate.class)) {
    map.put(field.getAnnotation(OraDate.class).value(), Date.class);
   } else if (field.isAnnotationPresent(OraTimestamp.class)) {
    map.put(field.getAnnotation(OraTimestamp.class).value(), Timestamp.class);
   } else if (field.isAnnotationPresent(OraBigDecimal.class)) {
    map.put(field.getAnnotation(OraBigDecimal.class).value(), BigDecimal.class);
   } else if (field.isAnnotationPresent(OraClob.class)) {
    map.put(field.getAnnotation(OraClob.class).value(), Clob.class);
   } else if (field.isAnnotationPresent(OraBlob.class)) {
    map.put(field.getAnnotation(OraBlob.class).value(), Blob.class);
   }
  }

  return map;
 }

 public static Map<Integer, String> defineFieldNames(Class<?> clazz) {
  Map<Integer, String> map = new HashMap<Integer, String>();

  Field[] fields = clazz.getDeclaredFields();
  for (Field field : fields) {
   if (field.isAnnotationPresent(OraInteger.class)) {
    map.put(field.getAnnotation(OraInteger.class).value(),
      field.getAnnotation(OraInteger.class).field());
   } else if (field.isAnnotationPresent(OraString.class)) {
    map.put(field.getAnnotation(OraString.class).value(),
      field.getAnnotation(OraString.class).field());
   } else if (field.isAnnotationPresent(OraDate.class)) {
    map.put(field.getAnnotation(OraDate.class).value(),
      field.getAnnotation(OraDate.class).field());
   } else if (field.isAnnotationPresent(OraTimestamp.class)) {
    map.put(field.getAnnotation(OraTimestamp.class).value(),
      field.getAnnotation(OraTimestamp.class).field());
   } else if (field.isAnnotationPresent(OraBigDecimal.class)) {
    map.put(field.getAnnotation(OraBigDecimal.class).value(),
      field.getAnnotation(OraBigDecimal.class).field());
   } else if (field.isAnnotationPresent(OraClob.class)) {
    map.put(field.getAnnotation(OraClob.class).value(),
      field.getAnnotation(OraClob.class).field());
   } else if (field.isAnnotationPresent(OraBlob.class)) {
    map.put(field.getAnnotation(OraBlob.class).value(),
      field.getAnnotation(OraBlob.class).field());
   }
  }

  return map;
 }

 public static Object getSqlValue(OracleResultSet orset, Class<?> oraType, Integer i) throws SQLException {
  if (oraType.getName().equals("java.lang.Integer")) {
   return orset.getInt(i);
  } else if (oraType.getName().equals("java.lang.String")) {
   return orset.getString(i);
  } else if (oraType.getName().equals("java.sql.Date")) {
   return orset.getDate(i);
  } else if (oraType.getName().equals("java.sql.Timestamp")) {
   return orset.getTimestamp(i);
  } else if (oraType.getName().equals("java.math.BigDecimal")) {
   return orset.getBigDecimal(i);
  } else if (oraType.getName().equals("java.sql.Clob")) {
   return orset.getClob(i);
  } else if (oraType.getName().equals("java.sql.Blob")) {
   return orset.getBlob(i);
  } else {
   return null;
  }
 }

 public static void setSqlValue(OraclePreparedStatement stmt, Class<?> oraType, Integer i, Object val) throws SQLException, Exception {
  if (oraType.getName().equals("java.lang.Integer")) {
   stmt.setInt(i, (Integer) (val == null ? 0 : val));
  } else if (oraType.getName().equals("java.lang.String")) {
   stmt.setString(i, (String) val);
  } else if (oraType.getName().equals("java.sql.Date")) {
   stmt.setDate(i, (Date) val);
  } else if (oraType.getName().equals("java.sql.Timestamp")) {
   stmt.setTimestamp(i, (Timestamp) val);
  } else if (oraType.getName().equals("java.math.BigDecimal")) {
   stmt.setBigDecimal(i, (BigDecimal) val);
  } else if (oraType.getName().equals("java.sql.Clob")) {
   stmt.setClob(i, (Clob) val);
  } else if (oraType.getName().equals("java.sql.Blob")) {
   stmt.setBlob(i, (Blob) val);
  } else {
   throw new Exception("error in setSqlValue. Unknown type: " + oraType.getName());
  }
 }

 public static void setStatementValue(OracleCallableStatement ocs, String key, Class<?> oraType, Integer i, Object val) throws SQLException, Exception {
  if (key.equals("out")) {
   if (oraType.getName().equals("java.lang.Integer")) {
    ocs.registerOutParameter(1, OracleTypes.INTEGER);
   } else if (oraType.getName().equals("java.lang.String")) {
    ocs.registerOutParameter(1, OracleTypes.VARCHAR);
   } else if (oraType.getName().equals("java.sql.Date")) {
    ocs.registerOutParameter(1, OracleTypes.DATE);
   } else if (oraType.getName().equals("java.sql.Timestamp")) {
    ocs.registerOutParameter(1, OracleTypes.TIMESTAMP);
   } else if (oraType.getName().equals("java.math.BigDecimal")) {
    ocs.registerOutParameter(1, OracleTypes.NUMBER);
   } else if (oraType.getName().equals("java.sql.Clob")) {
    ocs.registerOutParameter(1, OracleTypes.CLOB);
   } else if (oraType.getName().equals("java.sql.Blob")) {
    ocs.registerOutParameter(1, OracleTypes.BLOB);
   } else if (oraType.getName().equals("java.sql.Array")) {
    ocs.registerOutParameter(1, OracleTypes.ARRAY);
   } else {
    throw new Exception("error in setStatementValue. Unknown out type: " + oraType.getName());
   }
  } else {
   if (oraType.getName().equals("java.lang.Integer")) {
    ocs.setInt(i, (Integer) val);
   } else if (oraType.getName().equals("java.lang.String")) {
    ocs.setString(i, (String) val);
   } else if (oraType.getName().equals("java.sql.Date")) {
    ocs.setDate(i, (Date) val);
   } else if (oraType.getName().equals("java.sql.Timestamp")) {
    ocs.setTimestamp(i, (Timestamp) val);
   } else if (oraType.getName().equals("java.math.BigDecimal")) {
    ocs.setBigDecimal(i, (BigDecimal) val);
   } else if (oraType.getName().equals("java.sql.Clob")) {
    ocs.setClob(i, (Clob) val);
   } else if (oraType.getName().equals("java.sql.Blob")) {
    ocs.setBlob(i, (Blob) val);
   } else if (oraType.getName().equals("java.sql.Array")) {
    ocs.setArray(i, (Array) val);
   } else {
    throw new Exception("error in setStatementValue. Unknown type: " + oraType.getName());
   }
  }
 }

 public static Object getStatementValue(OracleCallableStatement ocs, Class<?> oraType, Integer i) throws SQLException, Exception {
  if (oraType.getName().equals("java.lang.Integer")) {
   return ocs.getInt(1);
  } else if (oraType.getName().equals("java.lang.String")) {
   return ocs.getString(i);
  } else if (oraType.getName().equals("java.util.Date")) {
   return ocs.getDate(1);
  } else if (oraType.getName().equals("java.sql.Timestamp")) {
   return ocs.getTimestamp(1);
  } else if (oraType.getName().equals("java.math.BigDecimal")) {
   return ocs.getBigDecimal(1);
  } else if (oraType.getName().equals("java.sql.Clob")) {
   return ocs.getClob(1);
  } else if (oraType.getName().equals("java.sql.Blob")) {
   return ocs.getBlob(1);
  } else if (oraType.getName().equals("java.sql.Array")) {
   return ocs.getArray(1);
  } else {
   throw new Exception("error in setStatementValue. Unknown out type: " + oraType.getName());
  }
 }
}

Аннотации для обработки entity с помощью reflection:

/**
 * Аннотация класса.
 */
@Target(value = ElementType.TYPE)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface OraDataTable {
 /**
  * @return oracle table.
  */
 String value();
}

/**
 * Аннотация аттрибута класса.
 * для конвертации oracle.sql.Int в объект Integer.
 */
@Target(value = ElementType.FIELD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface OraInteger {
 /**
  * @return oracle Integer.
  */
 int value();

 String field();

}

/**
 * Аннотация аттрибута класса.
 * для конвертации oracle.sql.String в объект String.
 */
@Target(value = ElementType.FIELD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface OraString {
 /**
  * @return oracle String.
  */
 int value();

 String field();

}

/**
 * Аннотация аттрибута класса.
 * для конвертации oracle.sql.Int в объект Integer.
 */
@Target(value = ElementType.FIELD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface OraBigDecimal {
 /**
  * @return oracle Integer.
  */
 int value();

 String field();
}

/**
 * Аннотация аттрибута класса.
 * для конвертации oracle.sql.Int в объект Integer.
 */
@Target(value = ElementType.FIELD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface OraDate {
 /**
  * @return oracle Integer.
  */
 int value();

 String field();
}

С другими типами аннотации аналогичны. Теперь с помощью созданных аннотаций можно создать обьект-сущность. Из определения ORM (Object-relational mapping) следует что это отображение Java-обьектов в реляционный вид.

/**
 *  Обьект-сущность
 */
@OraDataTable("my_table")
public class MyTable {

 @OraInteger(value = 1, field = "id")
 private Integer id;

 @OraString(value = 2, field = "name")
 private Integer periodType;
 
 /* и т.д. */
 
 public String getId() {
  return id;
 }

 public void setId(Integer id) {
  this.id = id;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }
 
 /* и т.д. */

}

после этого можно проводить операции с этой сущностью в базе данных:

/*достанем все записи из таблицы my_table*/
public List<MyTable> getAllRecords() {
 try {
  OracleConnection conn = (OracleConnection) dataSource.getConnection();  
  Persistence persistence = new PersistenceOraImpl((OracleConnection) conn);
  
  List<MyTable> resultList = persistence.selectAll(CalcPeriod.class);
  
  conn.close();
  return resultList;
 } catch (SQLException e) {
  e.printStackTrace();
  return nullArray;
 }
}

/*достанем несколько записей из таблицы my_table по условию*/
public List<MyTable> getListRecords(MyTable entity) {
 try {
  OracleConnection conn = (OracleConnection) dataSource.getConnection();
  Persistence persistence = new PersistenceOraImpl((OracleConnection) conn);
  
  Map<String, Object> params = new HashMap<String, Object>();
  if (entity.getId() != null) params.put("id", entity.getId());
  
  List<MyTable> resultList = persistence.select(entity.getClass(), params);
  
  conn.close();
  return resultList;
 } catch (SQLException e) {
  e.printStackTrace();
  return nullArray;
 }
}

/*достанем одну запись из таблицы my_table по условию*/
public MyTable getRecordById(Integer inId) {
 try {
  OracleConnection conn = (OracleConnection) dataSource.getConnection();
  Persistence persistence = new PersistenceOraImpl((OracleConnection) conn);
  
  Map<String, Object> params = new HashMap<String, Object>();
  if (inId != null) params.put("id", inId);
  
  MyTable result = (MyTable) persistence.selectRow(MyTable.class, params);
  
  conn.close();
  return result;
 } catch (SQLException e) {
  e.printStackTrace();
  return null;
 }
}

/*создадим запись в таблице my_table*/
public void insertRecord(MyTable entity) {
 try {
  OracleConnection conn = (OracleConnection) dataSource.getConnection();
  Persistence persistence = new PersistenceOraImpl((OracleConnection) conn);
     
  persistence.insert(entity);
  
  conn.close();
 } catch (SQLException e) {
  e.printStackTrace();
 }
}

/*обновим запись в таблице my_table*/
public void updateRecord(MyTable entity) {
 try {
  OracleConnection conn = (OracleConnection) dataSource.getConnection();
  Persistence persistence = new PersistenceOraImpl((OracleConnection) conn);
     
  persistence.update(entity);
  
  conn.close();
 } catch (SQLException e) {
  e.printStackTrace();
 }
}

/*удалим запись в таблице my_table*/
public void deleteRecord(MyTable entity) {
 try {
  OracleConnection conn = (OracleConnection) dataSource.getConnection();
  Persistence persistence = new PersistenceOraImpl((OracleConnection) conn);
     
  Map<String, Object> params = new HashMap<String, Object>();
  if (entity.getId() != null) params.put("id", entity.getId());

  persistence.delete(entity.getClass(), params);
  
  conn.close();
 } catch (SQLException e) {
  e.printStackTrace();
 }
}

Замечу что в данном примере я беру connection к БД из готового dataSource.

Конечно данный ORM покажется излишне простым, нельзя работать с join-ами, транзакции придется писать самому и еще нельзя много чего другого. Думаю в нашем случае это и не надо.
Ну и напоследок стоит упомянуть, что серьезные ORM, например Hibernate, написаны с использованием FastMethod из cglib, и тем самым работают на порядок быстрее, чем с использованием reflection.

Сериализация обьекта

2011-04-05T07:27:00.000-07:00

отправка обьекта:

Message message = new Message();
 ByteArrayOutputStream fos = new ByteArrayOutputStream();
 ObjectOutputStream oos = new ObjectOutputStream(fos);
 oos.writeObject(message);
 oos.flush();
 oos.close();

 byte[] messageBodyBytes = fos.toByteArray();

где Message - POJO обьект.

Далее обьект можно записать в файл или отправить в сообщении.

прием обьекта:

ByteArrayInputStream fis = new ByteArrayInputStream(messageBodyBytes);
 ObjectInputStream oin = new ObjectInputStream(fis);
 Message mess = (Message) oin.readObject();

Настраиваем поддержку русского языка в Linux Ubuntu

2011-03-30T05:09:00.000-07:00

Открываем шелл: ALT+F2.

Обновляем репозиторий:

sudo apt-get update

Качаем саппорт языка, заодно всякие медиа и эмулятор windows:

sudo apt-get install language-support-ru ubuntu-restricted-extras wine

При установке шрифтов windows выскакивает лицензионное соглашение. Соглашаемся с ним TAB+ENTER.

После установки, для настройки переключения раскладки на клавиатуре редактируем файл:

sudo nano /etc/default/console-setup

Для переключения по CTRL+SHIFT зменяем строки:

XKBLAYOUT="us,ru"
XKBVARIANT=",winkeys"
XKBOPTIONS="grp:ctrl_shift_toggle"

Для переключения по ALT+SHIFT, устанавливаем параметр

XKBOPTIONS="grp:alt_shift_toggle"

перезагружаемся.

Огромные шрифты в темах PrimeFaces 2.2.x

2011-03-18T02:13:00.000-07:00

Чтобы избавиться от огромных шрифтов в PrimeFaces 2.2 надо переопределить стиль ui-widget.

Для этого создаем css следующего вида:

.ui-widget {
   font-size: 12px !important;
}

и подтягиваем ее на странице:


   <link rel="stylesheet" type="text/css" href="mystyle.css"/>

Реализуем обмен сообщениями AMQP с помощью RabbitMQ

2011-02-10T01:07:00.000-08:00

Для начала установим и настроим RabbitMQ.

Тут все просто, скачиваем с основного сайта Erlang, проставляем ERLANG_HOME. Далее качаем и ставим сам RabbitMQ. Запускаем Rabbit через командную строку:

%RABBITMQ_SERVER%/sbin/rabbitmq-server.bat

Если появилось сообщение broking running то все ок, наш сервер работает.

Теперь надо настроить пользователя и виртуальный хост сервера. Запускаем с командной строки:

%RABBITMQ_SERVER%/sbin/rabbitmqctl.bat add_user admin admin

Пользователь admin с паролем admin создан. Теперь создадим виртуальный хост:

rabbitmqctl.bat add_vhost ru.vie2004.vhost

после чего надо дать права на пользование им нашим пользователем:

rabbitmqctl.bat set_permissions -p ru.vie2004.vhost admin .* .* .*

Все, сервер настроен на работу. Более тонкие настройки можно найти на RabbitMQ

Теперь напишем простенькие Sender и Consumer.

Sender:

ConnectionFactory factory = new ConnectionFactory();

factory.setUsername("admin");
factory.setPassword("admin");
factory.setVirtualHost("ru.vie2004.vhost");
factory.setHost("localhost");
factory.setPort(5672);

Connection conn = factory.newConnection();
Channel channel = conn.createChannel();
String exchangeName = "myNewExchange";
String routingKey = "myNewRoute";

byte[] messageBodyBytes = "Наше сообщение".getBytes();

channel.basicPublish(exchangeName, routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, messageBodyBytes);

Если надо передать не текст, а обьект, то необходимо сериализовать его в byte[].

Consumer:

ConnectionFactory factory = new ConnectionFactory(); 

factory.setUsername("admin");
factory.setPassword("admin");
factory.setVirtualHost("ru.vie2004.vhost");
factory.setHost("localhost");
factory.setPort(5672);
Connection conn = factory.newConnection();
Channel channel = conn.createChannel();
boolean durable = true;

channel.exchangeDeclare("myNewExchange", "direct", durable);
channel.queueDeclare("myNewQueue", durable, false, false, null);
channel.queueBind("myNewQueue", "myNewExchange", "myNewRoute");

boolean noAck = false;
QueueingConsumer consumer = new QueueingConsumer(channel);
channel.basicConsume(queueName, noAck, consumer);

while (true) {
  QueueingConsumer.Delivery delivery;
  try {
    delivery = consumer.nextDelivery();
  } catch (InterruptedException ie) {
    continue;
  }
  System.out.println("Получено сообщение: " + new String(delivery.getBody()));
}

Все, запускаем слушателя с отправителем и читаем сообщение.

ps. Не могу не упомянуть что для RabbitMQ есть аппендер log4j. Работать с ним можно, но придется немного подработать напильником для удобного пользования.

primefaces migrate from 2.2.RC2 to 2.2

2011-02-09T12:00:00.000-08:00

С выходом на днях новой версии primefaces 2.2 появилось два нововведения. К сожалению не все они мне понравились:

1. теперь user guide платная, стоит порядка 10 евро.
http://primefaces.org/documentation.html
2. темы теперь надо подключать через jar.
http://primefaces.org/themes.html

ps. Документация от 26.07.2010. Настройки тем действительны только до версии 2.2.RC2 включительно.