Углубленный анализ картирования ассоциации один к одному в рамках Hibernate Java

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

 открытый класс Tuser реализует Serializable {Private Static Long Long SerialVersionUID = 1L; частный INT ID; частный int возраст; Приватное название строки; Частный паспорт Tpassport; // Опустить метод get/set} public Class Tpassport реализует Serializable {Private Static Long Long SerialVersionUID = 1L; частный INT ID; частная строковая сериал; Частный истечение срока действия; частный пользователь Tuser; // Опустить метод get/set}

Давайте посмотрим на различия между отображением файлов:

 <hibernate mapping package = "org.hibernate.tutorial.domain4"> <class name = "tuser" table = "user4"> <id name = "id" column = "id"> <generator/> </id> <name = "name" type = "java.lang. COLMAN = "AGE"/> <One-To-One name = "passport" cascade = "all" outter-join = "true"/> </class> </hibernate mapping>

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

 <hibernate mapping package = "org.hibernate.tutorial.domain4"> <class name = "tpassport" table = "passport4"> <id name = "id" column = "id"> <generator> <param name = "свойство"> Пользователь </param> </Generator> </id> name = "serial" type = "java.lang. name = "Expiry" type = "java.lang.integer" column = "expiry"/> <one-one name = "user" dentifled = "true"/> </class> </hibernate-mapping>

Здесь мы сосредоточены на значении класса генератора. Это указывает на эталонный внешний ключ для иностранного, и какой ссылку указывается Param, который указывает идентификатор класса ссылочного пользователя. В теге один к одному есть дополнительное ограниченное свойство, которое сообщает Hibernate, что в текущем классе есть ограничение внешнего ключа, то есть идентификатор текущего класса генерируется на основе идентификатора Tuser.
Давайте прямо загрузим тестовый класс. На этот раз тестовый класс не использовал JUNIT, но напрямую поставлялся с основным методом:

 public static void main (string [] args) {configuration cfg = new configuration (). configure (); SessionFactory SessionFactory = cfg.BuildSessionFactory (); Session Session = sessionFactory.Opensession (); session.beginTransaction (); Tuser user = new Tuser (); user.setage (20); user.setname ("shuntest"); Tpassport passport = new tpassport (); Passport.SetExpiry (20); Passport.seterial ("123123123"); passport.setuser (пользователь); user.setpassport (паспорт); session.save (пользователь); session.getTransaction (). Commit (); }

Код очень прост, поэтому я не буду говорить об этом. Давайте посмотрим на это в основном здесь:

 session.save (пользователь);

Почему мы называем здесь только один сохранение? Причина в том, что каскадное свойство в нашем файле отображения Tuser устанавливается на все, что означает, что когда мы сохраняем, обновляем, удаляем и т. Д. На Tuser, Tpassport также будет выполнять соответствующие операции, поэтому нам не нужно писать Session.Save (Passport). Мы видим фон:

 Hibernate: вставьте в пользовательский 4 (имя, возраст) значения (?,?) Hibernate: вставьте в Passport4 (Serial, Expiry, ID) значения (?,?,?)

Hibernate: он распечатывает два утверждения, доказывая, что Hibernate сделал эту работу для нас.


Давайте возьмем другой тестовый класс и тестовый запрос:

 public static void main (string [] args) {configuration cfg = new configuration (). configure (); SessionFactory SessionFactory = cfg.BuildSessionFactory (); Session Session = sessionFactory.Opensession (); Tuser user = (tuser) session.load (tuser.class, new Integer (3)); System.out.println (user.getName ()+":"+user.getPassport (). GetSerial ()); }

Здесь мы запрашиваем класс Tuser и получаем объект Tpassport.
Мы видим, что SQL -заявление Hibernate:
Кода -копия выглядит следующим образом:
С Worderate:
Выберите tuser0_.id как id0_1_, tuser0_.name as name0_1_, tuser0_.age as age0_1_, tpassport1_.id as id1_0_, tpaspport1_.serial as serial1_0_, tpaspport1_.expiry as expiry1_0_ от пользователя4 tuser0_. tuser0_.id = tpassport1_.id, где tuser0_.id =?

Мы видим левое внешнее соединение в утверждении, потому что мы устанавливаем Over-join = "true" в один к одному. Мы стараемся изменить его на ложь. Заявление SQL выглядит следующим образом:
Кода -копия выглядит следующим образом:
С Worderate:
Выберите TUSER0_.id AS ID0_0_, TUSER0_.NAME AS AS name0_0_, TUSER0_.age AS AGE0_0_ из user4 tuser0_, где tuser0_.id =? Hibernate:
Выберите tpassport0_.id как id1_0_, tpassport0_.serial как serial1_0_, tpassport0_.expiry как истечение срока.

Теперь мы разделили его на два элемента, чтобы проверить его, а затем нашли его на основе идентификатора, найденного в первом элементе, а затем на второй элемент.

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

Ассоциация иностранного ключа
Теперь давайте посмотрим на ассоциации «один к одному», которые делают ассоциации через иностранные ключи.
Это все же, как пример: мы написали два класса сущности, TGROUP и TUSER

 Общедоступный класс TGROUP реализует Serializable {Private Static Long Long SerialVersionUID = 1L; частный INT ID; Приватное название строки; частный пользователь Tuser; // Опустить метод get/set} public Class Tuser реализует Serializable {Private Static Long Long SerialVersionUID = 1L; частный INT ID; частный int возраст; Приватное название строки; частная группа TGROUP; // Опустить метод get/set}

После того, как класс объектов завершен, давайте посмотрим на картирование:

 <hibernate mapping package = "org.hibernate.tutorial.domain5"> <class name = "tuser" table = "user5"> <id name = "id" column = "id"> <generator/> </id> <name = "name" type = "java.lang.String" column = "/> <property name =" age "type" java. COLMAN = "AGE"/> <Много-один name = "Group" COLMAN = "GROUP_ID" Уникальный = "true"/> </class> </hibernate-mapping>

Здесь мы видим, что вместо одного к одному используется тег для одного к одному. Почему?
Я не обращал на это особого внимания, когда использовал его раньше. В любом случае, мне просто нужно использовать его. Но после прочтения книги Ся Синь на этот раз я наконец понял, что на самом деле этот способ ассоциации через иностранные ключи-это просто особый способ многих к одному. Мы ограничиваем его через уникальный = "true", что он должен иметь только один, то есть корреляцию один к одному.
Далее, давайте посмотрим на отображение файла TGROUP:

 <hibernate-mapping package="org.hibernate.tutorial.domain5"> <class name="TGroup" table="group5"> <id name="id" column="id"> <generator /> </id> <property name="name" type="java.lang.String" column="name"/> <one-to-one name="user" property-ref="group" /> </class> </hibernate mapping>

Здесь обратите внимание, что мы снова используем один к одному, указывая на то, что текущая сущность и Tuser являются один на один. Здесь мы не используем много-то, но указываем, какой атрибут в сущности Tuser для связи текущего класса T-группы. Здесь мы указываем, что Tuser связан с Tuser с помощью групповых атрибутов. Property-Ref указывает, какое свойство ассоциируется.
Давайте посмотрим на тестовый класс ниже:

 открытый класс hibernatetest {public static void main (string [] args) {configuration cfg = new configuration (). configure (); SessionFactory SessionFactory = cfg.BuildSessionFactory (); Session Session = sessionFactory.Opensession (); session.beginTransaction (); Tgroup Group = new tgroup (); Group.SetName ("TestGroup"); Tuser user = new Tuser (); user.setage (23); user.setName ("test"); user.setGroup (группа); group.setuser (пользователь); Session.save (группа); session.save (пользователь); session.getTransaction (). Commit (); session.close (); }}

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

 Hibernate: вставьте в Group5 (Имя) Значения (?) Hibernate: вставьте в user5 (имя, возраст, group_id) значения (?,?,?)

Это означает, что мы правильно сохранили два значения объекта.

Мы пишем дополнительный тестовый класс для запроса:

 public static void main (string [] args) {configuration cfg = new configuration (). configure (); SessionFactory SessionFactory = cfg.BuildSessionFactory (); Session Session = sessionFactory.Opensession (); Tuser user = (tuser) session.load (tuser.class, new Integer (1)); System.out.println ("От пользователя Get Group:"+user.getGroup (). GetName ()); Tgroup Group = (tgroup) session.load (tgroup.class, новое целое число (1)); System.out.println ("От группы получить пользователь:" + group.getUser (). GetName ()); session.close (); }

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