Javarush sql hibernate когда: Основы Hibernate / Хабр

Содержание

Hibernate. Начало пути

Hibernate — пакет для DAO

Самая главная задача Hibernate — сделать так, чтобы разработчик думал в терминах объектов. Причем не просто на уровне таблиц — на уровне отношений между таблицами. Т.е. если тот же студент учится в группе, то связь должна быть на уровне объектов, а не на уровне поля groupID у студента. Иными словами — загруженный объект «Студент» должен иметь ссылку на объект «Группа». Мало того — для получения данных о группе объект «Студент» не надо делать явный запрос к базе данных. Эту функцию должен взять на себя Hibernate — в коде на Java мы просто должны вызывать метод student.getGroup()
В принципе все пакеты, подобные Hibernate, предназначены именно для такой цели — дать возможность разработчику думать в терминах объектов и отношений между ними. Причем эти отношения могут быть разными — один-к-одному, один-ко-многим, многие-к-одному, многие-ко-многим.
Что еще важно отметить — вы можете создавать иерархиии классов. Да-да, именно наследование, которое так вдохновляет поборников объекто-ориентированного программирования. Конечно, не все абсолютно шикарно и гладко, но в общем и целом достаточно прилично.
Но учтите — Hibernate не должен являться заменой DAO. Да в общем-то и не очень это получится. Он просто позволяет вам удобно общаться с базой данных. Но как мы уже рассматривали раньше, база данных не является единственным вариантом хранилища. Разработку с использованием шаблона DAO мы отложим на некоторое время. Но обязательно к нему вернемся, как только будет подходящий случай.

Для решения своих задач Hibernate должен получить от разработчика следующую информацию:

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

Поначалу все эти сложности покажутся излишними — ну в конце концов, что нам стоит написать несколько SQL-запросов на получение данных — добавление, запрос, исправление и удаление. Но если у вас таблиц не 3-4, а 500-600 ? И если вам потребуется добавить какое-то поле и связь между таблицами ? Такого рода исправления становятся не тривиальной задачей, которая требует много времени и последующего тестирования.
С другой стороны обольщаться не стоит — Hibernate не так уж и здорово решает абсолютно все задачи. Например, сложные запросы, которые часто требуются для создания головоломных отчетов, часто проще и эффективнее сделать на SQL. Hibernate позволяет это сделать — в нем можно создать обычный SQL-запрос. Также массовые изменения в нем делаются не очень эффективно. И еще я бы выделил не всегда удачную реализацию отношений — особенно это касается отношения многие-ко-многим — при редактировани такого списка Hibernate просто удаляет все старые отношения и заменяет их на новые. В общем смотрите, сравнивайте, оптимизируйте.
Но все-таки Hibernate существенно облегчает работу с базой данных и значительно упрощает код Вашего приложения.

Ну что же — приступим. Для начала вам необходимо скачать сам пакет. Зайдите на страницу Hibernate. Слева будет в меню, в котором мы выбираем пункт Download. В списке реализаций выбираем «Hibernate Core». Я буду использовать версию 3.3.1.GA. Само собой, что со временем она устареет, но будем надеятся, что совместимость поможет разобраться и с более новой версией.

Чтобы сразу снять все вопросы по поводу остальных средств разработки:

Версия JDK — 1.6. По поводу подверсий — думаю, что для нас это не будет существенно. Но на всякий случай укажу версию, под которой я работал — 1.6.0_03.
NetBean 6.5. В принципе можно использовать и версию 6.1. Не думаю, что это будет принципиально
Tomcat 6.0.16. Но в общем-то подойдет любая подверсия Tomcat 6
MySQL 5.0 — мы даже его устанавливали и настраивали. Кто не помнит, что и как — обращайтес к Часть 3 — База данных

По поводу остальных пакетов — каждый раз при изучении я буду писать версию, с которой я писал примеры. Все пакеты я обычно устанавливаю в отдельную папку — JAVA. Там и Tomcat, и NetBeans, и JDK, и Hibernate и т.д. Вы можете себе выбрать какое-то другое имя. Это просто привычка

Предварительная настройка окружения

Данный раздел предназначен для тех, кто никогда не работал с NetBeans. Т.к. часто можно видеть вопросы «Как подключить библиотеку ?», «Как запустить программы ?» — постараюсь снять некоторые из них.
Для начала вам придется поставить JDK. Это вы можете сделать запустив инсталлятор. Во время установки вам потребуется выбрать директорию, куда будет установлена JDK — потом вам надо будет создать переменную окружения JAVA_HOME. Это все можно посмотреть в Часть 7 — что такое Servlet. Там есть раздел «Запускаем WEB-сервер Tomcat». Вот и используйте эту информацию. Кстати Tomcat можно установить сразу же за JDK. Несмотря на то, что там описана установка более ранней версии — в общем-то ничего особо не поменялось.

Теперь приступим к установке и настройке NetBeans. В общем-то ничего сложного в установке нет — единственное, что может вызвать какие-то раздумья — это настройка JDK. Но обычно NetBeans находит его сам (очень подозреваю, что он используется переменную JAVA-HOME).
Также кое-какие вопросы настройки NetBeans можно посмотреть в Часть 11 — Application Server и Enterprise Java Beans
Единственное, что нам точно потребуется — настроить пакет библиотек. Чтобы не подключать каждый раз отдельно все JAR-файлы, мы создадим библиотеку, в которую будем класть все необходимые JAR по мере необходимости. Для создания нашей библиотеки запустите NetBeans. Потом выберите меню — Tools->Libraries. Появится форма для настройки библиотек.

Нажмите кнопку «New library…» и введите в форме название нашей библиотеки — StudentLibrary. После этого нажмите OK.

Теперь у нас есть библиотека, в которую мы можем добавлять наши JAR-файлы. Что очень удобно. Теперь в проекте нам будет достаточно установит ссылку на нашу библиотеку и проект получит доступ ко всем JAR-файлам, которые в ней есть. Думаю, что вы догадались, как пользоваться кнопками редактирования содержимого библиотеки. они находятся с правой стороны формы.
Замечание: Обязательно положите хоть какой-нибудь JAR в нашу библиотеку перед закрытием формы. Пустые библиотеки не сохраняются !!!

Заключительное действие — подключение библиотеки к проекту. В общем-то ничего сложного тут тоже нет. Щелкните правой кнопкой мыши на разделе Libraries с окне со структурой проекта и выберите в нем пункт «Add Library…». Дальше выбираете нашу замечательную библиотеку. В общем-то и все.

Что еще важно отметить — система автоматически отслеживает изменения в нашей библиотеке. Если мы добавим новый JAR-файл — тут же этот файл будет отображен на структуре используемых файлов.

Как видно на рисунке — теперь в библиотеке два файла. Я просто добавил новый JAR.

Необходимые библиотеки

Все библиотеки, необходимяе для проекта «Студенческий отдел кадров» находятся ЗДЕСЬ

Для текущего проекта нам будет достаточно этих библиотек. Можно прямо тут и качать
antlr-2.7.6.jar
commons-collections-3.1.jar
dom4j-1.6.1.jar
hibernate3.jar
javassist-3.4.GA.jar
jta-1.1.jar
log4j-1.2.15.jar
mysqlJDBC-3.1.13.jar
slf4j-api-1.5.3.jar
slf4j-log4j12-1.5.3.jar

Так что содержимое библиотеки StudentsLibrary должно выглядеть приблизительно вот так:

В дальнейшем я не буду столь подробно останавливаться на библиотеках — буду просто приводить их список и вы должны будете сами все устанавливать. Думаю, что справитесь.

Hibernate — первое приложение

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

Как я уже говорил, Hibernate включает в себя как минимум две важные вещи — параметры соединения с базой данных и описание (отображение) классов относительно таблиц.
Эти данные Hibernate хранит в конфигурационных файлах, которые мы рассмотрим на примере всего лишь одной таблицы — PROFESSION. Она у нас не сложная и для ее создания не требуется каких-либо еще таблиц. Она у нас справочная. Так что запускайте MySQL, запускайте SQL-скрипт. Кто не знает как это сделать — смотрите предыдущую часть — Часть 15 — Новая структура данных
Итак, давайте создадим новый проект. Меню File->New Project. В форме выберите проект Java -> Java Application. На следующем экране выберите директорию, в которой будет расположен наш проект. Обратите внимание на чекбоксы в нижней части — поставьте их в соответствии с рисунком.

Теперь я приведу структуру файлов, которые мы будем использовать в нашем маленьком проекте. Все они расположены в папке scr нашего проекта.

hibernate.cfg.xml — файл конфигурации Hibernate
Main.java — хоть он и носит такое гордое название, он нам нужен всего лишь для запуска нашего приложения
Profession.java — класс, который хранит в себе данные из таблицы. Точнее будет сказать — данные одной строки таблицы.
Profession.hbm.xml — файл, который содержит описание того, как класс Profession отображается на таблицу PROFESSION
HibernateUtil.java — вспомогательный класс для инициализации системы Hibernate. Его название уже настолько устоялось (оно приводилось в самых ранних версиях документации), что уже почти стандартно. Хотя может быт и другим. Но не будем в данном случае выделяться

Обратите внимание на файл hibernate.cfg.xml. Он расположен прямо в корне директории scr. Положение остальных вы можете разобрать самостоятельно.

А теперь мы постепенно разберем все файлы, которые у нас здесь представлены. Начнем с файла hibernate.cfg.xml.

hibernate.cfg.xml

<?xml version=’1.0′ encoding=’utf-8′?>
<!DOCTYPE hibernate-configuration PUBLIC
«-//Hibernate/Hibernate Configuration DTD//EN»
«http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd»>

<hibernate-configuration>

<session-factory>

<!— Database connection settings —>
<property name=»connection.driver_class»>com.mysql.jdbc.Driver</property>
<property name=»connection.url»>jdbc:mysql://127.0.0.1:3306/db_applicant</property>
<property name=»connection.username»>root</property>
<property name=»connection.password»>root</property>

<!— SQL dialect —>
<property name=»dialect»>org.hibernate.dialect.MySQLInnoDBDialect</property>

<!— JDBC connection pool (use the built-in) —>
<property name=»connection.pool_size»>1</property>

<!— Enable Hibernate’s automatic session context management —>
<property name=»current_session_context_class»>thread</property>

<!— Disable the second-level cache —>
<property name=»cache.provider_class»>org.hibernate.cache.NoCacheProvider</property>

<!— Echo all executed SQL to stdout —>
<property name=»show_sql»>true</property>

<!— Mapping files —>
<mapping resource=»students/entity/Profession.hbm.xml»/>

</session-factory>

</hibernate-configuration>

<?xml version=’1.0′ encoding=’utf-8′?>

<!DOCTYPE hibernate-configuration PUBLIC

«-//Hibernate/Hibernate Configuration DTD//EN»

«http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd»>

<hibernate-configuration>

<session-factory>

<!— Database connection settings —>

<property name=»connection.driver_class»>com.mysql.jdbc.Driver</property>

<property name=»connection.url»>jdbc:mysql://127.0.0.1:3306/db_applicant</property>

<!— SQL dialect —>

<property name=»dialect»>org.hibernate.dialect.MySQLInnoDBDialect</property>

<!— JDBC connection pool (use the built-in) —>

<!— Enable Hibernate’s automatic session context management —>

<property name=»current_session_context_class»>thread</property>

<!— Disable the second-level cache —>

<property name=»cache.provider_class»>org.hibernate.cache.NoCacheProvider</property>

<!— Echo all executed SQL to stdout —>

<!— Mapping files —>

</session-factory>

</hibernate-configuration>

В приципе здесь представлены достаточно очевидные вещи. При небольшом усилии вы сами сможете разобрать что и зачем. Но я все-таки пробегусь по именам.

connection.driver_class — достаточно понятное свойство. Оно показывает класс драйвера, который используется для соединения с базой данных. Это наш старый знакомый (конечно если вы читали предыдущие части) — драйвер для MySQL
connection.url — тоже очевидно. Это URL для коннекта к базе данных
connection.username — логин к базе данных
connection.password — пароль к базе данных

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

dialect — т.к. Hibernate может работать с разными базами данных, и каждая имеет какие-то особенности (генерация первичного ключа, страничный вывод, функции), нам надо указать, с какой базой мы работаем. В данном случае у нас MySQL, что мы и указываем
connection.pool_size — данное свойство показывает, сколько коннектов к базе данных будет одновременно открыто. Как вы наверно уже слышали, это достаточно распространенный прием — иметь несколько соединений. Таким образом увеличивается скорость работы
current_session_context_class — это свойство указывает, каким образом происходит управление. Думаю, что пока вам не надо сильно углубляться в данный вопрос
cache.provider_class — кэширование позволяет существенно ускорить работу. Часто запрашиваемые данные можно хранить в памяти и не считывать их каждый раз. Такой способ имеет свои достоинства — скорость, но и свои недостатки. Если кто-то изменит данные в обход Hibernate, то он об этом может и не узнать. В нашем случае мы не используем кэш.
show_sql — данное свойство указывает, будут ли выводится SQL-запросы, которые генерит Hibrante на консоль. В процессе отладки это бывает очень удобно

Ну и наконец последнее свойство, или точнее тэг — mapping. Он используется для перечисления всех классов, которые имеют связь с базой данных. Т.е. если вы хотите использовать какой-то класс для связи с какой-то таблицей, вы должны его здесь указать. В данном случае у нас он всего один. Зато мы все можем подробно разобрать, не отвлекаясь на сложные взаимосвязи.

Следующий интересный файл — это Profession.hbm.xml. Он описывает как наш класс Profession связан с таблицей PROFESSION. Давайте сначала приведем файл Profession.java

Profession.java

package students.entity;

public class Profession {

private Long professionId;
private String professionName;

public Long getProfessionId() {
return professionId;
}

public void setProfessionId(Long professionId) {
this.professionId = professionId;
}

public String getProfessionName() {
return professionName;
}

public void setProfessionName(String professionName) {
this.professionName = professionName;
}
}

Что такое hibernate | Java master

В этой статье я постараюсь максимально просто объяснить Вам что такое hibernate фреймворк:

что он из себя представляет;
как пользоваться hibernate;
CRUD операции на примере простой таблицы.

Все вышеперечисленное закрепим примером. А для начала постараемся вникнуть в теорию.

Hibernate — это библиотека, которая предназначена для задач объектно-реляционного отображения. Примерно такое описание будет в википедии. Если простыми словами — hibernate позволяет разработчику работать с базой данных не напрямую, как мы это делали с помощью библиотеки JDBC в статье Работа с базой данных, а с помощью представления таблиц баз данных в виде классов java.

Чтобы до конца понять дебри терминов давайте разберем что такое JPA — Java Persistance API.

JPA — спецификация, которая дает возможность сохранять в удобном виде Java-объекты в базе данных. Hibernate — это одна из самых популярных реализаций этой спецификации. Вот такая вот драма. Данные термины даны только в ознакомительных целях так как очень часто запутывают и пугают начинающих разработчиков.

Как это работать с базой данных через классы java? Если Вы открыли эту статью, то наверняка уже подключали базу данных к своему приложению и работали с ней. Если нет — то настоятельно советую прочитать цикл статей Java WEB, в которых подробно описано как создать веб приложение на чистой Java. Также, советую ознакомитья с SQL. А если я прав, и Вы уже знакомы с подключением базы данных, то наверняка работали с ней таким образом: создавали объект, который отображает таблицу базы данных. Например таблицу users с полями:

Потом писали метод подключения к базе, возможно даже пул соединений. Далее был DAO класс в котором делался запрос в базу, доставались или создавались данные, распарсивали их и подавали в виде списка или объекта примерно вот таким образом:

public Article getArticleById(int id) {
Article article = null;
Connection connection = ConnectionPool.getInstance().getConnection();
try {
PreparedStatement pr = connection.prepareStatement(«select id, title, body, «
+ «category_id, users_id from article where id=?»);
pr.setInt(1, id);//то, что нужно вставить вместо первого знака вопроса
//можно было бы написать «select id, title, body, » + «category_id, users_id from article whereli1″>
//но в целях безопасности советую подставлять значение через метод сет.
ResultSet rs = pr.executeQuery();
if (rs.next()){
article = new Article();
article.setId(rs.getInt(1));
article.setTitle(rs.getString(2));
article.setBody(rs.getString(3));
Category category = new Category();
category.setId(rs.getInt(4));
article.setCategory(category);
Users user = new Users();
user.setId(rs.getInt(5));
article.setUsers(user);
}
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
connection.close();
// TODO Auto-generated catch block
e.printStackTrace();
}
return article;
}

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

Это называется ORM — Object Relational Mapping. Вам всего лишь нужно создать классы, которые соответствуют таблицам в базе данных, и написать методы, которые Вы хотите сделать с данными (получить, удалить, создать, обновить). Hibernate сам генерирует SQL запрос и выполняет его. Причем, ему не важно какую базу данных Вы используете. Это дает возможность переключать базы данных и не заботиться о том, что код не будет работать.

С теорией закончили. Теперь давайте узнаем как подключить Hibernate, мапить классы и делать простые запросы.

Начнем с нуля. Создадим простое Maven приложение. Если Вы используете Eclipse: File->New->Maven project.

Не забудьте проставить галочку возле Create a simple project. Даем нашему проекту название:

Далее нужно подключить библиотеку hibernate, JPA и драйвера к базе данных к нашему проекту. В данном примере я использую Postgresql, но разницы не будет никакой если Вы будете использовать другую базу данных. Я укажу место, где нужно будет сделать поправки.

После подключения зависимостей мой файл pom.xml выглядит так:

<project xmlns=»http://maven.apache.org/POM/4.0.0″ xmlns:xsi=»http://www.w3.org/2001/XMLSchema-instance»
xsi:schemaLocation=»http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd»>
<modelVersion>4.0.0</modelVersion>
<groupId>com.javamaster</groupId>
<artifactId>hibernate-tutorial</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-api</artifactId>
<version>7.0</version>
</dependency>
<!— https://mvnrepository.com/artifact/org.hibernate/hibernate-core —>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.3.0.Final</version>
</dependency>
<!— https://mvnrepository.com/artifact/postgresql/postgresql —>
<dependency>
<groupId>postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>9.1-901-1.jdbc4</version>
</dependency>
</dependencies>
</project>

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

С этим, думаю, проблем не будет.

Теперь создадим класс Users в котором будут поля, геттеры, сеттеры, методы equals, hashCode, toString.

public class Users {
private String password;
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((email == null) ? 0 : email.hashCode());
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((password == null) ? 0 : password.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Users other = (Users) obj;
if (email == null) {
if (other.email != null)
return false;
} else if (!email.equals(other.email))
return false;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.

Пройти путь до должности Java Junior Developer

И так, Java я изучаю уже около 2-ух лет. Но из этих двух лет можно смело отбросить где-то год, так как были моменты, когда я, кратко говоря, забивал на изучение Java. Во общем, я неплохо знаю Java Core, но этого не достаточно. На свою бывшую работу, а это было месяц назад, я возвращаться категорически не хочу. Работал я мерчендайзером… и больше им работать не хочу.

И так, чтобы стать Java программистом — изучением одной Java не отделаешься. Можно найти любую вакансию на данную должность и посмотреть, что там требуют. Да, когда я смотрел вакансии, аж кровь стыла в жилах. Требуют много, да еще и разбираться в этом нужно неплохо. Но, я справлюсь.

Во обще, у большинства вакансий на Java Junior Developer требуют опыт от одного и более лет. Вот где его взять этот опыт. Без опыта не берут, а чтобы набраться такого опыта, нужно работать на какого-то дяденьку, где можно и получить данный опыт.

Также, я изучал Java с помощью ресурса под названием JavaRush. Скажу сразу — вещь крутая и проходить данный ресурс обязательно! И это не реклама. Там около 1000 задач во всех 40-ка уровнях, которые реально, если их решить, тебя прокачают. Там у меня 20 уровень, до которого я дошёл примерно за 1 месяц. Не заходил туда около месяца, а то и больше, так как работал, и работа эта немного мешала учёбе.

Ранее прочитал книгу по HTML (HeadFirst), и книгу по SQL. Разбирался с JDBC. Читал книгу по паттернам проектирования (Head First). Все эти книги я читал около года назад, так что буду повторять.

Что я планирую выучить, прочитать, продолжать учить в ближайшее время:

Java, SQL, JDBC, сервлеты, jsp, паттерны проектирования, HTML & CSS, Spring, Hibernate, XML, Maven, Ant, SVN, jUnit, логирование, GIT, TomCat, ну и английский язык(хотя бы до уровня чтения технической документации).

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

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, но если вы хотите больше функционала — вы должны подключить больше зависимостей.

Существуют стандартные рекомендации подключать зависимости по отдельности, но я так не делаю.

<properties>
        <hibernate-version>5.0.1.Final</hibernate-version>
    </properties>
    <dependencies>
        <!--driver for connection to MYSql database -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.34</version>
        </dependency>

        <!-- Hibernate -->
        <!-- to start need only this -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate-version}</version>
        </dependency>

        <!-- for JPA, use hibernate-entitymanager instead of hibernate-core -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate-version}</version>
        </dependency>
    </dependencies>

И щелкаем на 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 запускаем проект.

Это моя первая статья. Рассчитываю на здравую критику.

JPA и Hibernate в вопросах и ответах / Хабр

В JPA описаны три стратегии наследования мапинга (Inheritance Mapping Strategies), то есть как JPA будет работать с классами-наследниками Entity:
1) одна таблица на всю иерархию наследования (a single table per class hierarchy) — все enity, со всеми наследниками записываются в одну таблицу, для идентификации типа entity определяется специальная колонка “discriminator column”. Например, если есть entity Animals c классами-потомками Cats и Dogs, при такой стратегии все entity записываются в таблицу Animals, но при это имеют дополнительную колонку animalType в которую соответственно пишется значение «cat» или «dog». Минусом является то что в общей таблице, будут созданы все поля уникальные для каждого из классов-потомков, которые будет пусты для всех других классов-потомков. Например, в таблице animals окажется и скорость лазанья по дереву от cats и может ли пес приносить тапки от dogs, которые будут всегда иметь null для dog и cat соотвественно.

2) объединяющая стратегия (joined subclass strategy) — в этой стратегии каждый класс enity сохраняет данные в свою таблицу, но только уникальные колонки (не унаследованные от классов-предков) и первичный ключ, а все унаследованные колонки записываются в таблицы класса-предка, дополнительно устанавливается связь (relationships) между этими таблицами, например в случае классов Animals (см.выше), будут три таблицы animals, cats, dogs, причем в cats будет записана только ключ и скорость лазанья, в dogs — ключ и умеет ли пес приносить палку, а в animals все остальные данные cats и dogs c ссылкой на соответствующие таблицы. Минусом тут являются потери производительности от объединения таблиц (join) для любых операций.

3) одна таблица для каждого класса (table per concrete class strategy) — тут все просто каждый отдельный класс-наследник имеет свою таблицу, т.е. для cats и dogs (см.выше) все данные будут записываться просто в таблицы cats и dogs как если бы они вообще не имели общего суперкласса. Минусом является плохая поддержка полиморфизма (polymorphic relationships) и то что для выборки всех классов иерархии потребуются большое количество отдельных sql запросов или использование UNION запроса.

Для задания стратегии наследования используется аннотация Inheritance (или соответствующие блоки
Java Persistence 2.1. Chapter 2.12, J7EE javadoc

ПримерыПримеры на github: TABLE_PER_CLASS: 1 2 3, JOINED:1 2 3 ,SINGLE_TABLE: 1 2 3

@Entity
@Inheritance(strategy=JOINED)
public class Customer { ... }
@Entity
public class ValuedCustomer extends Customer { ... }

Оригинал

There are three basic strategies that are used when mapping a class or class hierarchy to a relational

database:

• a single table per class hierarchy

• a joined subclass strategy, in which fields that are specific to a subclass are mapped to a separate

table than the fields that are common to the parent class, and a join is performed to instantiate

the subclass.

• a table per concrete entity class

java — Подключение к MS sql через hibernate

Переполнение стека

Около
Продукты
Для команд

Переполнение стека
Общественные вопросы и ответы
Переполнение стека для команд
Где разработчики и технологи делятся частными знаниями с коллегами
Вакансии
Программирование и связанные с ним технические возможности карьерного роста
Талант
Нанимайте технических специалистов и создавайте свой бренд работодателя
Реклама
Обратитесь к разработчикам и технологам со всего мира
О компании

java — Как распечатать строку запроса со значениями параметров при использовании Hibernate