Hibernate
Hibernate Framework — это фреймворк для языка Java, предназначенный для работы с базами данных. Он реализует объектно-реляционную модель — технологию, которая «соединяет» программные сущности и соответствующие записи в базе. Иногда его называют библиотекой — оба названия в принципе справедливы.
Освойте профессию «Java-разработчик»
Объектно-реляционная модель, или ORM, позволяет создать программную «виртуальную» базу данных из объектов. Объекты описываются на языках программирования с применением принципов ООП. Java Hibernate — популярное воплощение этой модели.
Hibernate построен на спецификации JPA 2.1 — наборе правил, который описывает взаимодействие программных объектов с записями в базах данных. JPA поясняет, как управлять сохранением данных из кода на Java в базу. Но сама по себе спецификация — только теоретические правила, а в «чистой» Java ее реализации нет. Hibernate — одна из самых популярных реализаций JPA на рынке.
Фреймворк бесплатный, с открытым исходным кодом, который может просмотреть любой программист. По-русски название читается как «хибернейт».
Профессия / 14 месяцев
Java-разработчик
Освойте востребованный язык
Для чего применяется Hibernate
Hibernate пользуются Java-разработчики, которые работают с базами данных или с обработкой информации для последующего переноса в базу. Фреймворк используют при создании информационных систем: приложений, крупных программ и сетей, которые работают с информацией и базами данных. Существует аббревиатура CRUD, означающая Create, Read, Update, Delete: создавать, читать, обновлять и удалять. Это четыре действия, которые должна уметь выполнять информационная система, работающая с базой. Задача Hibernate при создании такого приложения — сократить количество низкоуровневого кода и облегчить работу программиста с БД.
- ускоряет и облегчает написание кода;
- позволяет создать удобную модель для отображения базы данных в коде;
- дает возможность быстро и в читаемом виде записывать информацию из кода в базу.
Особенности Hibernate Framework
Идея фреймворка — создать «виртуальную» базу данных из программных объектов и работать с ней как с реальной базой. Поэтому им часто пользуются для упрощения работы. Он берет на себя взаимодействие с реляционной БД, а разработчику остается работать с кодом.
В Hibernate есть возможность, которую называют «ленивой загрузкой». Объекты в фреймворке не подгружают всю информацию из базы изначально. Вместо этого они просто «знают», как ее получить, и при первом обращении к информации загружают ее в фоне. Это нужно для оптимизации производительности.
Внутри Hibernate — собственный язык запросов Hibernate Query Language, или HQL. Это SQL-подобный язык, но полностью объектно-ориентированный и более краткий — не приходится так много работать с шаблонным кодом, как в «чистом» SQL.
Преимущества использования Hibernate
Популярность. Hibernate — популярный фреймворк, который фактически считают золотым стандартом. Это влечет за собой сразу три преимущества:
- по нему много учебников, туториалов и обсуждений на специализированных сайтах;
- большинство технологий, работающих с Java, поддерживают Hibernate. Это базы данных, фреймворки, библиотеки. Существуют плагины и для других языков или платформ, например порт на платформу .NET;
- разработчик, умеющий работать с этим фреймворком, всегда найдет работу.
Устранение лишнего кода. Повторяющийся шаблонный код, который делает программу менее читаемой, называют «спагетти». Если программа взаимодействует с базой, то в ней по определению много «спагетти»-кода, в том числе низкоуровневого. Использование Hibernate позволяет сократить количество «спагетти», соответственно, сделать программу более лаконичной и хорошо читаемой.
Возможность сосредоточиться на логике. Разработчику не приходится писать множество запросов, он избавлен от написания большого количества «технического» низкоуровневого кода. Поэтому можно сосредоточиться на логике работы программы и не отвлекаться на шаблонные задачи, поручив их фреймворку. Это облегчает и ускоряет разработку.
Станьте Java-разработчиком
и создавайте сложные сервисы
на востребованном языке
Независимость от базы данных. Hibernate может работать с любой базой и не имеет жесткой привязки к какой-то конкретной базе или СУБД. Благодаря этому он гибкий, его можно использовать в связке с другими технологиями. Язык запросов у него тоже свой, независимый от СУБД, хотя Hibernate поддерживает и «чистый» SQL.
Объектно-ориентированный подход. Hibernate реализует парадигму объектно-ориентированного программирования, которая очень распространена и хорошо знакома разработчикам. Поэтому работать с ним относительно просто, если вы уже знаете основы: не приходится постоянно отвлекаться на совершенно другую логику работы с базами данных. Можно реализовать все управление на ООП — этому способствует и наличие собственного SQL-подобного объектно-ориентированного языка запросов.
Недостатки Hibernate Framework
Сложность в освоении. Эта проблема актуальна в основном для новичков. Для работы с фреймворком нужно понимать теорию реляционных БД. Понадобится знать, что такое транзакция, по каким принципам работают базы данных, как с ними взаимодействовать и многое другое. Естественно, надо знать Java: осваивать фреймворки советуют после изучения основных принципов «чистого» языка.
Проблемы с производительностью. Несмотря на возможности, которые дает «ленивая загрузка», спецификацию JPA и в частности Hibernate часто критикуют за низкую производительность. Есть мнение, которое частично подкрепляется на практике, что такой тип взаимодействия с базой замедляет и утяжеляет код.
Непредсказуемость кода. Это еще один частый пункт критики JPA и Hibernate как ее реализации. Спецификация построена на объектно-ориентированной модели программирования, но не полностью соблюдает ее принципы. Это приводит к тому, что в коде могут появиться побочные эффекты — так называется явление, когда во время выполнения программы какие-то значения неявно изменяются. Побочные эффекты могут влиять на правильность работы программы, так что их надо избегать. А при использовании JPA избежать их сложно, и к Hibernate это тоже относится.
Сложности с кэшированием. В целом информацию в Hibernate можно кэшировать, то есть сохранять в специальном участке памяти, очень быстром и компактном. Это один из плюсов фреймворка — кэширование важно для производительности. Оно нужно для быстрого доступа к важным данным.
На практике кэширование самих сущностей JPA работает своеобразно:
- изменяемые сущности кэшировать не получится — инструментарий не дает возможности синхронизировать изменения с кэшем;
- неизменяемые сущности кэшировать можно, но не полноценно. Сущность загружается из базы через транзакцию — последовательность запросов в БД. Когда транзакция закрывается, на кэшированную сущность становится нельзя сослаться — только получить из нее данные.
Как начать пользоваться фреймворком
Что нужно. Вам понадобится загруженный и установленный Hibernate стабильной или последней версии — скачать его можно с официального сайта. Также необходима СУБД — система управления базами данных: если приложение будет работать с БД, без системы управления не обойтись. Можете выбрать любую СУБД — туториалы рекомендуют использовать PostgreSQL или MySQL, так как это бесплатные проекты с открытым исходным кодом.
Как начать. Обычно для начала работы с Hibernate рекомендуют использовать Maven — фреймворк для автоматизации сборки приложений на Java. Он создает в структуре проекта файл под названием pom.xml, где описываются все зависимости программы, все технологии, которыми она пользуется. Понадобится добавить в этот файл записи для Hibernate и для СУБД.
На официальном сайте Hibernate есть ссылки на центральный репозиторий Maven — там находятся образцы записей, которые надо добавить в файл для подключения разных версий фреймворка.
После того как все технологии подключены, можно писать код.
Java-разработчик
Java уже 20 лет в мировом топе языков программирования. На нем создают сложные финансовые сервисы, стриминги и маркетплейсы. Освойте технологии, которые нужны для backend-разработки, за 14 месяцев.
Статьи по теме:
Руководство по Hibernate. Архитектура.
Hibernate – это ORM фреймворк для Java с открытым исходным кодом. Эта технология является крайне мощной и имеет высокие показатели производительности.
Hibernate создаёт связь между таблицами в базе данных (далее – БД) и Java-классами и наоборот. Это избавляет разработчиков от огромного количества лишней, рутинной работы, в которой крайне легко допустить ошибку и крайне трудно потом её найти.
Схематично это можно изобразить следующим образом:
Какие же преимущества даёт нам использование Hibernate?
- Обеспечивает простой API для записи и получения Java-объектов в/из БД.
- Минимизирует доступ к БД, используя стратегии fetching.
- Не требует сервера приложения.
- Позволяет нам не работать с типами данных языка SQL, а иметь дело с привычными нам типами данных Java.
- Заботится о создании связей между Java-классами и таблицами БД с помощью XML-файлов не внося изменения в программный код.
- Если нам необходимо изменить БД, то достаточно лишь внести изменения в XML-файлы.
Hibernate поддерживает все основные СУБД: MySQL, Oracle, PostgreSQL, Microsoft SQL Server Database, HSQL, DB2.
Hibernate также может работать в связке с такими технологиями, как Maven и J2EE.
Архитектура
Приложение, которе использует Hibernate (в крайне поверхностном представлении) имеет такую архитектуру:
Если мы рассмотрим строение самого Hibernate более подробно, что этот же рисунок будет выглядеть следующим образом:
Hibernate поддерживает такие API, как JDBC, JNDI, JTA.
JDBC обеспечивает простейший уровень абстракции функциональности для реляционных БД. JTA и JNDI, в свою очередь, позволяют Hibernate использовать серверы приложений J2EE.
Давайте рассмотрим отдельно каждый из элементов Hibernate, которые указаны в схеме:
Transaction
Этот объект представляет собой рабочую единицу работы с БД. В Hibernate транзакции обрабатываются менеджером транзакций.
SessionFactory
Самый важный и самый тяжёлый объект (обычно создаётся в единственном экземпляре, при запуске приложения). Нам необходима как минимум одна SessionFactory для каждой БД, каждый из которых конфигурируется отдельным конфигурационным файлом.
Session
Сессия используется для получения физического соединения с БД. Обычно, сессия создаётся при необходимости, а после этого закрывается. Это связано с тем, что эти объекты крайне легковесны. Чтобы понять, что это такое, модно сказать, что создание, чтение, изменение и удаление объектов происходит через объект Session.
Query
Этот объект использует HQL или SQL для чтения/записи данных из/в БД. Экземпляр запроса используется для связывания параметров запроса, ограничения количества результатов, которые будут возвращены и для выполнения запроса.
Configuration
Этот объект используется для создания объекта SessionFactory и конфигурирует сам Hibernate с помощью конфигурационного XML-файла, который объясняет, как обрабатывать объект Session.
Criteria
Используется для создания и выполнения объекто-ориентированного запроса для получения объектов.
Hibernate для начинающих
Я сталкивался (да и не только я) с проблемой развертывания Hibernate и решил попробовать осветить данную тему. Hibernate — это популярный framework, цель которого связать ООП и реляционную базу данных. Работа с Hibernate сократит время разработки проекта в сравнении с обычным jdbc.
Для новичка программирования настройка framework часто вызывает затруднения. Помощь комьюнити с освещением базовых проблем поможет начинающим осваивать языки программирования быстрее. Статья предназначена только для начинающих в Java, которые впервые развертывают hibernate. Я развертывал hibernate на базе лицензионной IDEA.
Maven framework для автоматизации сборки проекта на основе POM, позволяющая подключать из интернета зависимости, не скачивая библиотеки в проект. POM (project object model) -декларативное описание проекта. Копируем название библиотек в xml формате с сайта mvnrepository.com.
Для начала создаёте структуру проекта maven:
Потом в pom.xml вставляем. Нам понадобятся две зависимости: hibernate-core и mysql-connector, но если вы хотите больше функционала — вы должны подключить больше зависимостей.
Существуют стандартные рекомендации подключать зависимости по отдельности, но я так не делаю.
5.0.1.Final mysql mysql-connector-java 5.1.34 org.hibernate hibernate-core $ org.hibernate hibernate-entitymanager $ И щелкаем на Import Changes Enable Auto-Import, автоматически импортируя изменения.
Подключаемся к базе данных, которая развернута на локальном компьютере, выбираем поставщика баз данных MySQL.
Вводим имя базы данных, имя пользователя и пароль. Протестируйте соединение.
Выбираем проект и через framework support просим у хибернейта создать за нас Entity файлы и классы с Getter и Setter.
Выбираем Generate Persistence Mapping через кладку Persistence, выбираем jenerate Persistance Mapping, а в появившемся окне прописываем схему базы данных, выбираем prefix и
sufix к автоматически сгенерированным названиям. Будут сгенерированы названия xml файлов и классов с аннотациями:
Раскидайте файлы в таком порядке: .xml-файлы должны находится в папке с ресурсами, а сущности в папке java.
Дописываем в hibernate.cfg username и password (звёзды поставил я, а так пишите обычным шрифтом).
Вот и все! Дальше через класс main запускаем проект.
Это моя первая статья. Рассчитываю на здравую критику.
Основы Hibernate
Хочу начать со слов благодарности тому человеку, который мне вчера накинул кармы, позволив этим писать мне в персональный блог.
Долго думал, о чем же написать свой «первый» топик… Слово первый не зря взял в кавычки, так как первый топик на самом деле уже был, опыт был к сожалению неудачный — дело закончилось баном. Решил больше не копипастить. Уверенности тому, что надо написать что-то свое, придал вот этот топик. Решил твердо — пусть это будет и редко, но буду писать сам.
Совсем недавно, по роду свой деятельности, мне пришлось столкнуться с таким понятием как ORM — (англ. Object-relational mapping). В двух словах ORM — это отображение объектов какого-либо объектно-ориентированного языка в структуры реляционных баз данных. Именно объектов, таких, какие они есть, со всеми полями, значениями, отношениями м/у друг другом.
ORM-решением для языка Java, является технология Hibernate, которая не только заботится о связи Java классов с таблицами базы данных (и типов данных Java в типы данных SQL), но также предоставляет средства для автоматического построения запросов и извлечения данных и может значительно уменьшить время разработки, которое обычно тратится на ручное написание SQL и JDBC кода. Hibernate генерирует SQL вызовы и освобождает разработчика от ручной обработки результирующего набора данных и конвертации объектов, сохраняя приложение портируемым во все SQL базы данных.
Итак, перед нами стоит задача написать небольшое приложение, которое бы осуществляло простое взаимодействие с базой данных, посредством технологии Hibernate.
Немного подумав, решил написать так называемый «Виртуальный автопарк». Суть парка такова: есть автобусы, есть маршруты и есть водители. Автобусы и маршруты связаны отношением один ко многим, т.е. на одном маршруте может кататься сразу несколько автобусов. Водители и автобусы связаны отношением многие ко многим, т.е. один водитель может водить разные автобусы и один автобус могут водить разные водители. Вроде ничего сложного.
Вот схема базы данных.
За качество не ругайте — под рукой не оказалось нормального инструмента таблички рисовать…
Вот ссылка на дамп, снятый с базы, вдруг кто-то решит все это дело поднять 🙂
Приступаем к коду. Во первых нам необходимо описать классы наших сущностей, т.е. класс автобуса, водителя и маршрута.
Класс автобус.
import java.util.Set;
import java.util.HashSet;
public class Bus private Long id;
private String number;
private Set drivers = new HashSet();
private Long route_id;
public Bus() >
public void setId(Long id) this .id = id;
>
public void setNumber( String number) this .number = number;
>
public void setDrivers(Set drivers) this .drivers = drivers;
>
public void setRoute_id(Long route_id) this .route_id = route_id;
>
public Long getId() return id;
>
public String getNumber() return number;
>
public Set getDrivers() return drivers;
>
public Long getRoute_id() return route_id;
>
> * This source code was highlighted with Source Code Highlighter .
Класс водитель.
import java.util.Set;
import java.util.HashSet;
public class Driver private Long id;
private String name;
private String surname;
private int age;
private Set busses = new HashSet();
public Driver() >
public void setBusses(Set busses) this .busses = busses;
>
public Set getBusses() return busses;
>
public void setId(Long id) this .id = id;
>
public void setName( String name) this .name = name;
>
public void setSurname( String surname) this .surname = surname;
>
public void setAge( int age) this .age = age;
>
public Long getId() return id;
>
public String getName() return name;
>
public String getSurname() return surname;
>
public int getAge() return age;
>
> * This source code was highlighted with Source Code Highlighter .
И класс маршрут.
import java.util.Set;
import java.util.HashSet;
public class Route private Long id;
private String name;
private int number;
private Set busses = new HashSet();
public Route() >
public void setId(Long id) this .id = id;
>
public void setName( String name) this .name = name;
>
public void setNumber( int number) this .number = number;
>
public void setBusses(Set busses) this .busses = busses;
>
public Long getId() return id;
>
public String getName() return name;
>
public int getNumber() return number;
>
public Set getBusses() return busses;
>
> * This source code was highlighted with Source Code Highlighter .
Заметьте, что все классы сущностей должны соответствовать Java naming conventions, т.е. у них должны быть обязательно геттеры, сеттеры и конструктор по умолчанию. Ничего сложного 🙂
Теперь для наших классов необходимо описать маппинг в виде xml-файлов, эти файлы как раз и будут отвечать за взаимодействие наших объектов с Hibernate и с базой данных.
Bus.hbm.xml
Driver.hbm.xml
Route.hbm.xml
- Тег hibernate-mapping я думаю понятен, тут ничего говорить не стоит.
- Тег class имеет два параметра: параметр name — Имя класса (необходимо указывать полный путь с учетом структуры пакетов) и параметр table — имя таблицы в базе данных, на которую будет маппиться наш класс.
- Тег id описывает идентификатор. Параметр column указывает на какую колонку в таблице будет ссылаться поле id нашего объекта, так же указываем класс и указываем generator, который отвечает за генерацию id.
- Тег property описывает простое поле нашего объекта, в качестве параметров указываем имя поля, его класс и имя колонки в таблице.
- Тег set описывает поле в котором содержится некий набор(коллекция) объектов. Тег содержит параметр name — имя поля нашего объекта, параметр table — имя таблицы связи(в случае отношения многие ко многим) и параметр lazy. Lazy, если меня не подводит моя память, с английского — ленивый. Так называемые ленивые коллекци, сейчас постараюсь объяснить понятнее. Когда мы в параметре lazy указываем значечение false, то у нас при получении объекта Route из базы вместе с объектом достается и коллекция объектов Bus, так как busses это поле объекта Route. А если в качестве параметра мы указываем значение true, то коллекция объектов Bus не вытаскивается, для ее получения надо явно вызывать метод route.getBusses(). Вот предположим такой очень хороший пример. Есть объект город, в него входит массив районов, в каждый район — массив улиц, в каждую улицу — массив домов и так далее до людей, живущих в квартирах. Предположим мы хотим вытянуть из базы названия районов. Если укажем lazy = false, то помимо районом у нас вытянется еще огромный объем «ненужных» данных, если же lazy = true, то мы получим то что надо и ничего лигнего.
- Тег key имеет параметр column, который говорит, на какую колонку в таблице связи будет ссылаться поле нашего объекта.
- Тег many-to-many описывает связь типа многие ко многим, в качестве параметров тег использует column — имя колонки второй колонки в таблице связи и параметр class, указывающий какого класса будут объеты на той стороне.
Теперь создадим главный конфигурационный файл hibernate.cfg.xml, файл, откуда он будет дергать всю необходимую ему информацию.
Тут я не буду особо вдаваться в объяснение, думаю многим и так все понятно 🙂 Скажу, что надо только в конце не забыть добавить тег mapping и указать в качестве параметра resources файлы конфигурации ваших бинов.
Теперь создадим класс, который будет хавать наш конфиг-файл и возвращать нам объект типа SessionFactory, который отвечает за создание hibernate-сессии.
import org.hibernate.cfg.Configuration;
import org.hibernate.SessionFactory;
public class HibernateUtil private static final SessionFactory sessionFactory;
static try sessionFactory = new Configuration().configure().buildSessionFactory();
> catch (Throwable ex) System.err.println( «Initial SessionFactory creation failed.» + ex);
throw new ExceptionInInitializerError(ex);
>
>
public static SessionFactory getSessionFactory() return sessionFactory;
>
> * This source code was highlighted with Source Code Highlighter .
Теперь нам осталось разобраться со взаимодействием нашего приложения с базой данных. Для этого для каждого класса-сущности, определим интерфейс, содержащий набор необходимых методов (Я приведу только один интерфейс и одну его реализацию, интерфейсы и реализации для др. классов подобны этим.)
import logic.Bus;
import logic.Driver;
import logic.Route;
import java.util.Collection;
import java.sql.SQLException;
public interface BusDAO public void addBus(Bus bus) throws SQLException;
public void updateBus(Long bus_id, Bus bus) throws SQLException;
public Bus getBusById(Long bus_id) throws SQLException;
public Collection getAllBusses() throws SQLException;
public void deleteBus(Bus bus) throws SQLException;
public Collection getBussesByDriver(Driver driver) throws SQLException;
public Collection getBussesByRoute(Route route) throws SQLException;
Теперь определим реализацию этого интерфейса в классе BusDAOImpl
import DAO.BusDAO;
import logic.Bus;
import logic.Driver;
import logic.Route;
import java.sql.SQLException;
import java.util.Collection;
import java.util. ArrayList ;
import java.util. List ;
import util.HibernateUtil;
import javax.swing.*;
import org.hibernate.Session;
import org.hibernate.Query;
public class BusDAOImpl implements BusDAO
public void addBus(Bus bus) throws SQLException Session session = null ;
try session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
session.save(bus);
session.getTransaction().commit();
> catch (Exception e) JOptionPane.showMessageDialog( null , e.getMessage(), «Ошибка при вставке» , JOptionPane.OK_OPTION);
> finally if (session != null && session.isOpen())
public void updateBus(Long bus_id, Bus bus) throws SQLException Session session = null ;
try session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
session.update(bus);
session.getTransaction().commit();
> catch (Exception e) JOptionPane.showMessageDialog( null , e.getMessage(), «Ошибка при вставке» , JOptionPane.OK_OPTION);
> finally if (session != null && session.isOpen()) session.close();
>
>
>
public Bus getBusById(Long bus_id) throws SQLException Session session = null ;
Bus bus = null ;
try session = HibernateUtil.getSessionFactory().openSession();
bus = (Bus) session.load(Bus. class , bus_id);
> catch (Exception e) JOptionPane.showMessageDialog( null , e.getMessage(), «Ошибка ‘findById’» , JOptionPane.OK_OPTION);
> finally if (session != null && session.isOpen()) session.close();
>
>
return bus;
>
public Collection getAllBusses() throws SQLException Session session = null ;
List busses = new ArrayList ();
try session = HibernateUtil.getSessionFactory().openSession();
busses = session.createCriteria(Bus. class ).list();
> catch (Exception e) JOptionPane.showMessageDialog( null , e.getMessage(), «Ошибка ‘getAll’» , JOptionPane.OK_OPTION);
> finally if (session != null && session.isOpen()) session.close();
>
>
return busses;
>
public void deleteBus(Bus bus) throws SQLException Session session = null ;
try session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
session.delete(bus);
session.getTransaction().commit();
> catch (Exception e) JOptionPane.showMessageDialog( null , e.getMessage(), «Ошибка при удалении» , JOptionPane.OK_OPTION);
> finally if (session != null && session.isOpen()) session.close();
>
>
>
public Collection getBussesByDriver(Driver driver) throws SQLException Session session = null ;
List busses = new ArrayList ();
try session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Long driver_id = driver.getId();
Query query = session.createQuery(
» select b »
+ » from Bus b INNER JOIN b.drivers driver»
+ » where driver.id = :driverId »
)
.setLong( «driverId» , driver_id);
busses = ( List ) query.list();
session.getTransaction().commit();
public Collection getBussesByRoute(Route route) Session session = null ;
List busses = new ArrayList ();
try session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Long route_id = route.getId();
Query query = session.createQuery( «from Bus where route_id = :routeId „ ).setLong( “routeId» , route_id);
busses = ( List ) query.list();
session.getTransaction().commit();
Еще рас скажу, что реализации DriverDAOImpl и RouteDAOImpl будут аналогичны этой.
Наибольший интерес для нас представляют два последних метода, взгляните на них повнимательнее. Как происходит общение с базой? От объекта SessionFactory создается новая или получается текущая сессия, зачем начинается транзакция, выполняются необходимые действия, коммит транзакции и закрытие сессии. Вроде ничего сложного 🙂 Обратите внимание, на то, каким синтаксисом описан запрос к базе. Это так называемый HQL (Hibernate Query Language) HQL представляет собой объектно-ориентированный язык запросов, возможности его широки, но мной настолько широко еще не осилены 🙂 Помимо save, load, update, delete и HQL, можно пользоваться и обычным SQL. Например:
String query = «SELECT driver_id, name, surname, age FROM drivers»;
List drivers = new ArrayList();
drivers = (List) session.createSQLQuery(query).list();
Теперь создадим класс фабрики, к которой будем обращаться за нашими реализациями DAO, от которых и будем вызывать необходимые нам методы.
public class Factory
private static BusDAO busDAO = null ;
private static DriverDAO driverDAO = null ;
private static RouteDAO routeDAO = null ;
private static Factory instance = null ;
public static synchronized Factory getInstance() if (instance == null ) instance = new Factory();
>
return instance;
>
public BusDAO getBusDAO() if (busDAO == null ) busDAO = new BusDAOImpl();
>
return busDAO;
>
public DriverDAO getDriverDAO() if (driverDAO == null ) driverDAO = new DriverDAOImpl();
>
return driverDAO;
>
public RouteDAO getRouteDAO() if (routeDAO == null ) routeDAO = new RouteDAOImpl();
>
return routeDAO;
>
> * This source code was highlighted with Source Code Highlighter .
Теперь нам осталось создать какой-либо демонстрационный класс, для того, чтобы посмотреть и опробовать все то, что мы написали. Ну, не будем тянуть, вот этот класс, возможно не самый удачный, но все же 🙂
public class Main public static void main( String [] args) throws SQLException
Collection routes = Factory.getInstance().getRouteDAO().getAllRoutes();
Iterator iterator = routes.iterator();
System. out .println( «========Все маршруты======== #0000ff»>while (iterator.hasNext()) Route route = (Route) iterator.next();
System. out .println( «Маршрут : » + route.getName() + » Номер маршрута : » + route.getNumber());
Collection busses = Factory.getInstance().getBusDAO().getBussesByRoute(route);
Iterator iterator2 = busses.iterator();
while (iterator2.hasNext()) Bus bus = (Bus) iterator2.next();
System. out .println( «Автобус № » + bus.getNumber());
Collection busses = Factory.getInstance().getBusDAO().getAllBusses();
iterator = busses.iterator();
System. out .println( «========Все автобусы======== #0000ff»>while (iterator.hasNext()) Bus bus = (Bus) iterator.next();
Collection drivers = Factory.getInstance().getDriverDAO().getDriversByBus(bus);
Iterator iterator2 = drivers.iterator();
System. out .println( «Автобус № » + bus.getNumber());
while (iterator2.hasNext()) Driver driver = (Driver) iterator2.next();
System. out .println( «Имя : » + driver.getName() + » Фамилия: » + driver.getSurname());
>
> * This source code was highlighted with Source Code Highlighter .
Еще раз скажу, что может не самый удачный вариант использования всего нами написанного, но для этого уже лучше GUI писать или Web-интерфейс, а это уже другая песня 🙂
P.S.. Скажу, что на 100%-ую правильность я не претендую, это мое личное имхо, однако очень надеюсь, что это станет для кого-то полезным материалом.
P.S.S. Все библиотеки и файлы качать тут.