Показаны сообщения с ярлыком java. Показать все сообщения
Показаны сообщения с ярлыком java. Показать все сообщения

вторник, 17 февраля 2009 г.

Как нужно использовать Hibernate?

Когда я стал внедрять Hibernate, понял, что существует определённый стандартный способ его использования. У меня есть подозрение, что его специально не выставляют на показ начинающим пользователям, дабы не отпугнуть их тем, что на архитектуру их приложения накладываются новые требования со стороны тех средств, использование которых хотелось бы видеть прозрачным.

Стандартный способ использования Hibernate — паттерн Session per View. Согласно этому паттерну использование Hibernate должно выглядеть следующим образом: открывается сессия, получаются все необходимые данные, производятся вычисления, строится представление, сессия закрывается. После закрытия сессии никакие данные, полученные с момента её открытия, более не используются.

Не обязательно должно строится представление. Вместо него может формироваться ответ сервера на запрос, или реакция на событие. Важно то, что все полученные данные не используются после выполнения работы и не предаются другим потокам.

До тех пор пока вы используете объекты, полученные из Hibernate, вы должны иметь открытой сессию, в которой были получены эти объекты (или к которой были привязаны), и иметь активную транзакцию! Использовать эти объекты можно только в однопоточной среде! Иначе со стороны Hibernate возможны ошибки.

Обычно, создаётся некоторый перехватчик, срабатывающий при получении запроса. Он открывает сессию и делает её доступной для всех классов, методы которых выполняются в данном потоке обработки (что-то типа ThreadLocal).

Может быть, такого способа работы часто бывает достаточно, но, на мой взгляд, такой костюмчик жмёт.

Т.е. объекты, полученные из Hibernate — не совсем обычные POJO. Хоть об этом и уверяют на официальном сайте проекта. В чём же их отличие мы узнаем далее.

Начиная с Hibernate 3, везде, где только можно, выполняется ленивая загрузка, если явно не указано обратное. При помощи ASM'а Hibernate на лету генерирует байт код прокси-объектов и экранирует ими связи запрашиваемых объектов. За счёт этих прокси части объекта подгружаются по мере необходимости.

Если же сессия была закрыта, а использование объекта продолжается, то, в случае обращения к такому прокси возникает рантаймовое LazyInitializationException. Если же два потока в один момент обратятся к одному прокси, то поведение вовсе не предсказуемо, т.к. прокси используют сессию, а сессия предназначена только для однопоточного использования.

От ограничений Session per View можно избавиться, если в определённый момент иметь гарантию того, что объект загружен полностью со всеми своими связями. Тогда он станет обычным POJO. Его можно будет использовать после закрытия сессии и использовать многопоточно, если сам объект на это рассчитан.

Получить такую гарантию можно, если отключить для всех связей этого объекта ленивую загрузку. Это довольно утомительно, т.к. нет способа отключить ленивую загрузку сразу для всего — придётся отключать её для каждого класса отдельно.

Второй способ — написать метод, который бы в необходимый момент мог вызвать полную инициализацию всего графа объекта. В Hibernate нет собственного такого метода, но он позволяет его реализовать:


public class LoadDragoon {

private SessionFactory sessionFactory;

private static Logger logger = Logger.getLogger(LoadDragoon.class.getName());

public LoadDragoon(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}

public void forceLoad(Object obj) throws HibernateException {
if (obj == null) {
return;
}

Class entityClass = Hibernate.getClass(obj);

if (!Hibernate.isInitialized(obj)) {
logger.finest("Force initialization of " + entityClass.getName());
}

Hibernate.initialize(obj);
ClassMetadata md = sessionFactory.getClassMetadata(entityClass);

if (md == null) {
return;
}

String[] propertyNames = md.getPropertyNames();

for (String propertyName : propertyNames) {
Type propertyType = md.getPropertyType(propertyName);

if (propertyType.isEntityType()) {
Object assoc = md.getPropertyValue(obj, propertyName,
EntityMode.POJO);
forceLoad(assoc);
} else if (propertyType.isCollectionType()) {
Object container = md.getPropertyValue(obj, propertyName,
EntityMode.POJO);
Hibernate.initialize(container);

if (container instanceof Map) {
Map map = (Map) container;

for (Map.Entry entry : map.entrySet()) {
forceLoad(entry.getKey());
forceLoad(entry.getValue());
}
} else {
Collection collection = (Collection) container;

for (Object element : collection) {
forceLoad(element);
}
}
}
}
}

}

Злые модули

Есть такая засада в C++, Java и, вероятно, в некоторых других языках. Функции, вычисляющие модуль целого числа (std::abs в С++ или Math.abs в Java), способны возвращать отрицательные значения!

Например, число типа long имеет максимальное значение 2147483647, а минимальное — -2147483648. Соответственно, модуль минимального числа типа long не может быть представлен типом long — функция просто молча вернёт переданное в неё отрицательное значение.


cout << "min = " << numeric_limits::min() << " ; max = " <<
numeric_limits::max() << endl;
cout << "abs(min) = " << abs(numeric_limits::min());

Вывод:

min = -2147483648 ; max = 2147483647
abs(min) = -2147483648

На это можно однажды крепко налететь...

В SmallTalk, к слову, такой проблемы нет. Т.к. ему вообще не свойственна проблема переполнения целых чисел. LargePositiveInteger, имеет неограниченый размер. А операции над ограниченным по размеру SmallInteger, при необходимости автоматически приведут к созданию LargePositiveInteger и использованию его в качестве результата.

Собака

Забавная картинка из книги Your brain on java издательства Oreilly.

Картинка расположена в контексте разговора о коллекциях, генериках и преобразовании типов:

суббота, 2 августа 2008 г.

+=

Обычно считают, что в Java x += y (и аналогично -=, *= и т.п.) является лишь сокращённой записью x = x + y. Но это не вся правда. Посмотрим на следующий пример:

short s = 1;
s = s + 1;

Этот код не компилируется, несмотря на то, что 1 + 1 = 2 представимо типом short! Причина не только в том, что литерал 1 имеет тип int. Не будет компилироваться и такой вариант:
short s1 = 1;
short s2 = 1;
s2 = s2 + s1;

То же самое можно было бы написать с типами byte и char. Причина в том, что результат арифметических операций с использованием типов short, byte, char имеет тип int. Мотивация этого такова: к примеру, сумма двух byte может легко быть больше того, что влезет в byte. Но код можно исправить следующим образом без явного преобразования типов:
short s = 1;
s += 1;

short s1 = 1;
short s2 = 1;
s2 += s1;

На самом деле x += y, вопреки распространённому мнению, эквивалентно
x = (тип x) (x + y);

Т.е. включает в себя преобразование результата к типу x. То же самое верно и для операторов -=, *= и т.п.

Литералы

Известно, что в java литералы целых чисел имеют по умолчанию тип int, а литералы чисел с плавающей точкой – double. Но, помимо различий в типе, есть ещё некоторое различие в поведении.

Не удивительно, что эта строчка при компиляции вызывает ошибку из-за несовместимости типов float и double:

float f = 25.2; // слева float, справа double

И, казалось бы, следующий пример тоже не должен был бы компилироваться, ведь int не преобразуется в byte неявно:
byte b = 127; // слева byte, справа int

Однако последний пример компилируется! В этом случае, если значение справа представимо типом byte (от -128 до 127), компилятор сам выполнит преобразование. Аналогично, без явного преобразования, целочисленные литералы можно присваивать типам short и char.