Hibernate One-to-One Mapping Beispiel mit Annotation
Wir betrachten ein Beispiel für Hibernate One-to-One Mapping mit Annotation und XML-Konfiguration.
One-to-One Mapping in Hibernate
Meistens sind Datenbanktabellen miteinander verbunden. Es gibt viele Formen von Verknüpfungen: One-to-One, One-to-Many und Many-to-Many. Diese können weiter in unidirektionale und bidirektionale Verknüpfungen unterteilt werden. Heute zeigen wir die Implementierung von Hibernate One-to-One Mapping mithilfe von XML- sowie Annotation-Konfigurationen.
Hibernate One-to-One Mapping Beispiel: Datenbanksetup
Zu Beginn müssen wir ein One-to-One Mapping in den Datenbanktabellen einrichten. Wir erstellen zwei Tabellen für unser Beispiel – Transaction und Customer. Beide Tabellen werden eine One-to-One-Verknüpfung haben. Transaction wird die Primärtabelle sein, und wir verwenden einen Fremdschlüssel in der Tabelle Customer für das One-to-One Mapping. Nachfolgend das MySQL-Skript, das in diesem Tutorial verwendet wird. Sollten Sie eine andere Datenbank nutzen, passen Sie das Skript entsprechend an.
-- Create Transaction Table
CREATE TABLE `Transaction` (
`txn_id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`txn_date` date NOT NULL,
`txn_total` decimal(10,0) NOT NULL,
PRIMARY KEY (`txn_id`)
) ENGINE=InnoDB AUTO_INCREMENT=16 DEFAULT CHARSET=utf8;
-- Create Customer table
CREATE TABLE `Customer` (
`txn_id` int(11) unsigned NOT NULL,
`cust_name` varchar(20) NOT NULL DEFAULT '',
`cust_email` varchar(20) DEFAULT NULL,
`cust_address` varchar(50) NOT NULL DEFAULT '',
PRIMARY KEY (`txn_id`),
CONSTRAINT `customer_ibfk_1` FOREIGN KEY (`txn_id`) REFERENCES `Transaction` (`txn_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
Das Entity-Relation-Diagramm (ERD) des oben beschriebenen One-to-One Mappings zwischen den Tabellen sieht wie folgt aus:
Hibernate One-to-One Mapping Beispiel: Projektstruktur
Erstellen Sie ein einfaches Maven-Projekt in Ihrer Java-IDE. Ich verwende Eclipse. Die endgültige Projektstruktur sieht wie folgt aus:
Zuerst betrachten wir ein XML-basiertes Hibernate One-to-One Mapping-Beispiel und anschließend dieselbe Implementierung mithilfe von Annotationen.
Hibernate Maven-Abhängigkeiten
Unsere abschließende pom.xml-Datei sieht wie folgt aus:
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.journaldev.hibernate</groupId>
<artifactId>HibernateOneToOneMapping</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>4.3.5.Final</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.0.5</version>
</dependency>
</dependencies>
</project>
Die Abhängigkeiten sind ausschließlich für Hibernate und den MySQL-Java-Treiber. Beachten Sie, dass ich die neueste Hibernate-Version (4.3.5.Final) und den MySQL-Treiber entsprechend meiner MySQL-Server-Version (5.0.5) verwende. Hibernate 4 verwendet JBoss Logging, das automatisch als transitive Abhängigkeit importiert wird.
Hibernate One-to-One Mapping Modelklassen
Modelklassen für das Hibernate One-to-One Mapping, die die Datenbanktabellen widerspiegeln, sehen wie folgt aus:
package com.journaldev.hibernate.model;
package com.journaldev.hibernate.model;
import java.util.Date;
public class Txn {
private long id;
private Date date;
private double total;
private Customer customer;
@Override
public String toString(){
return id+", "+total+", "+customer.getName()+", "+customer.getEmail()+", "+customer.getAddress();
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public double getTotal() {
return total;
}
public void setTotal(double total) {
this.total = total;
}
public Customer getCustomer() {
return customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
}
package com.journaldev.hibernate.model;
package com.journaldev.hibernate.model;
public class Customer {
private long id;
private String name;
private String email;
private String address;
private Txn txn;
public long getId() {
return id;
}
public void setId(long 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 getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public Txn getTxn() {
return txn;
}
public void setTxn(Txn txn) {
this.txn = txn;
}
}
Da wir eine XML-basierte Konfiguration für das Mapping verwenden
sind die oben gezeigten Modellklassen einfache POJO-Klassen oder Java Beans mit Getter- und Setter-Methoden. Ich verwende den Klassennamen Txn, um Verwechslungen zu vermeiden, da die Hibernate-API eine Klasse mit dem Namen Transaction hat.
Hibernate One-to-One Mapping Konfiguration
Erstellen wir die Hibernate One-to-One Mapping-Konfigurationsdateien für die Tabellen Txn und Customer.
txn.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"https://hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.journaldev.hibernate.model.Txn" table="TRANSACTION" >
<id name="id" type="long">
<column name="txn_id" />
<generator class="identity" />
</id>
<property name="date" type="date">
<column name="txn_date" />
</property>
<property name="total" type="double">
<column name="txn_total" />
</property>
<one-to-one name="customer" class="com.journaldev.hibernate.model.Customer"
cascade="save-update" />
</class>
</hibernate-mapping>
Der wichtige Punkt in der obigen Datei ist das Hibernate-Element one-to-one für die Eigenschaft customer.
customer.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"https://hibernate.org/dtd/hibernate-mapping-3.0.dtd" >
<hibernate-mapping>
<class name="com.journaldev.hibernate.model.Customer" table="CUSTOMER">
<id name="id" type="long">
<column name="txn_id" />
<generator class="foreign">
<param name="property">txn</param>
</generator>
</id>
<one-to-one name="txn" class="com.journaldev.hibernate.model.Txn"
constrained="true"></one-to-one>
<property name="name" type="string">
<column name="cust_name"></column>
</property>
<property name="email" type="string">
<column name="cust_email"></column>
</property>
<property name="address" type="string">
<column name="cust_address"></column>
</property>
</class>
</hibernate-mapping>
Das generator class="foreign" ist ein entscheidender Teil, der für die Implementierung von Fremdschlüsseln in Hibernate verwendet wird.
Hibernate Konfigurationsdatei
Hier ist die Hibernate-Konfigurationsdatei für die XML-basierte Mapping-Konfiguration.
hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"https://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.password">pankaj123</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost/TestDB</property>
<property name="hibernate.connection.username">pankaj</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.current_session_context_class">thread</property>
<property name="hibernate.show_sql">true</property>
<mapping resource="txn.hbm.xml"/>
<mapping resource="customer.hbm.xml"/>
</session-factory>
</hibernate-configuration>
Die Hibernate-Konfigurationsdatei ist einfach und enthält Datenbankverbindungsdetails sowie Mapping-Ressourcen.
Hibernate SessionFactory Utility
Hier ist die Utility-Klasse, um eine Hibernate-SessionFactory-Instanz zu erstellen.
package com.journaldev.hibernate.util;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
public class HibernateUtil {
private static SessionFactory sessionFactory;
private static SessionFactory buildSessionFactory() {
try {
// Create the SessionFactory from hibernate.cfg.xml
Configuration configuration = new Configuration();
configuration.configure("hibernate.cfg.xml");
System.out.println("Hibernate Configuration loaded");
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
System.out.println("Hibernate serviceRegistry created");
SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
}
catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + ex);
ex.printStackTrace();
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
if(sessionFactory == null) sessionFactory = buildSessionFactory();
return sessionFactory;
}
}
Das war’s. Schreiben wir nun ein Testprogramm, um die Hibernate One-to-One Mapping XML-basierte Konfiguration zu testen.
Hibernate One-to-One Mapping XML-Konfiguration Testprogramm
Im Hibernate One-to-One Mapping-Beispieltestprogramm erstellen wir zunächst ein Txn-Objekt und speichern es. Sobald es in der Datenbank gespeichert ist, verwenden wir die generierte ID, um das Txn-Objekt abzurufen und zu drucken.
package com.journaldev.hibernate.main;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import com.journaldev.hibernate.model.Customer;
import com.journaldev.hibernate.model.Txn;
import com.journaldev.hibernate.util.HibernateUtil;
public class HibernateOneToOneMain {
public static void main(String[] args) {
Txn txn = buildDemoTransaction();
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try{
//Get Session
sessionFactory = HibernateUtil.getSessionFactory();
session = sessionFactory.getCurrentSession();
System.out.println("Session created");
//start transaction
tx = session.beginTransaction();
//Save the Model object
session.save(txn);
//Commit transaction
tx.commit();
System.out.println("Transaction ID="+txn.getId());
//Get Saved Trasaction Data
printTransactionData(txn.getId(), sessionFactory);
}catch(Exception e){
System.out.println("Exception occured. "+e.getMessage());
e.printStackTrace();
}finally{
if(!sessionFactory.isClosed()){
System.out.println("Closing SessionFactory");
sessionFactory.close();
}
}
}
private static void printTransactionData(long id, SessionFactory sessionFactory) {
Session session = null;
Transaction tx = null;
try{
//Get Session
sessionFactory = HibernateUtil.getSessionFactory();
session = sessionFactory.getCurrentSession();
//start transaction
tx = session.beginTransaction();
//Save the Model object
Txn txn = (Txn) session.get(Txn.class, id);
//Commit transaction
tx.commit();
System.out.println("Transaction Details=\n"+txn);
}catch(Exception e){
System.out.println("Exception occured. "+e.getMessage());
e.printStackTrace();
}
}
private static Txn buildDemoTransaction() {
Txn txn = new Txn();
txn.setDate(new Date());
txn.setTotal(100);
Customer cust = new Customer();
cust.setAddress("Bangalore, India");
cust.setEmail("pankaj@gmail.com");
cust.setName("Pankaj Kumar");
txn.setCustomer(cust);
cust.setTxn(txn);
return txn;
}
}
Wenn wir das obige Testprogramm ausführen, erhalten wir folgende Ausgabe:
Hibernate Configuration loaded
Hibernate serviceRegistry created
Session created
Hibernate: insert into TRANSACTION (txn_date, txn_total) values (?, ?)
Hibernate: insert into CUSTOMER (cust_name, cust_email, cust_address, txn_id) values (?, ?, ?, ?)
Transaction ID=19
Hibernate: select txn0_.txn_id as txn_id1_1_0_, txn0_.txn_date as txn_date2_1_0_, txn0_.txn_total as txn_tota3_1_0_,
customer1_.txn_id as txn_id1_0_1_, customer1_.cust_name as cust_nam2_0_1_, customer1_.cust_email as cust_ema3_0_1_,
customer1_.cust_address as cust_add4_0_1_ from TRANSACTION txn0_ left outer join CUSTOMER customer1_ on
txn0_.txn_id=customer1_.txn_id where txn0_.txn_id=?
Transaction Details=
19, 100.0, Pankaj Kumar, pankaj@gmail.com, Bangalore, India
Closing SessionFactory
Wie Sie sehen, funktioniert es einwandfrei, und wir können Daten aus beiden Tabellen mithilfe der Transaktions-ID abrufen. Überprüfen Sie die SQL-Abfragen, die Hibernate intern verwendet. Es werden Joins verwendet, um Daten aus beiden Tabellen effizient abzurufen.
Hibernate One-to-One Mapping mit Annotation
Im vorherigen Abschnitt haben wir gesehen, wie man XML-basierte Konfiguration für Hibernate One-to-One Mapping verwendet. Nun schauen wir uns an, wie wir dasselbe mit JPA und Hibernate Annotationen umsetzen können.
Hibernate Konfigurationsdatei
Die Konfigurationsdatei für Hibernate-Mapping mit Annotationen sieht wie folgt aus:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"https://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.password">pankaj123</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost/TestDB</property>
<property name="hibernate.connection.username">pankaj</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.current_session_context_class">thread</property>
<property name="hibernate.show_sql">true</property>
<mapping class="com.journaldev.hibernate.model.Txn1"/>
<mapping class="com.journaldev.hibernate.model.Customer1"/>
</session-factory>
</hibernate-configuration>
Wie Sie sehen, habe ich zwei Modellklassen definiert, die wir mit Annotationen verwenden werden: Txn1 und Customer1.
Hibernate One-to-One Mapping Modellklassen mit Annotationen
Für Hibernate One-to-One Mapping mit Annotationen sind Modellklassen der wichtigste Bestandteil. Sehen wir uns an, wie unsere Modellklassen aussehen.
package com.journaldev.hibernate.model;
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import org.hibernate.annotations.Cascade;
@Entity
@Table(name="TRANSACTION")
public class Txn1 {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="txn_id")
private long id;
@Column(name="txn_date")
private Date date;
@Column(name="txn_total")
private double total;
@OneToOne(mappedBy="txn")
@Cascade(value=org.hibernate.annotations.CascadeType.SAVE_UPDATE)
private Customer1 customer;
@Override
public String toString(){
return id+", "+total+", "+customer.getName()+", "+customer.getEmail()+", "+customer.getAddress();
}
// Getter-Setter methods omitted for brevity
}
Beachten Sie, dass die meisten Annotationen aus der Java Persistence API (JPA) stammen, da Hibernate diese implementiert. Für das Cascading verwenden wir jedoch die Hibernate-spezifische Annotation org.hibernate.annotations.Cascade und den zugehörigen Enum org.hibernate.annotations.CascadeType.
package com.journaldev.hibernate.model;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;
@Entity
@Table(name="CUSTOMER")
public class Customer1 {
@Id
@Column(name="txn_id", unique=true, nullable=false)
@GeneratedValue(generator="gen")
@GenericGenerator(name="gen", strategy="foreign", parameters={@Parameter(name="property", value="txn")})
private long id;
@Column(name="cust_name")
private String name;
@Column(name="cust_email")
private String email;
@Column(name="cust_address")
private String address;
@OneToOne
@PrimaryKeyJoinColumn
private Txn1 txn;
// Getter-Setter methods
}
Beachten Sie, dass wir @GenericGenerator verwenden, damit die ID aus der Transaktion abgeleitet wird, anstatt eine neue ID zu generieren.
Hibernate SessionFactory Utility Klasse
Die Erstellung der SessionFactory ist unabhängig von der Methode, die wir für das Hibernate-Mapping verwenden. Unsere Utility-Klasse für die Erstellung der SessionFactory sieht wie folgt aus:
package com.journaldev.hibernate.util;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
public class HibernateAnnotationUtil {
private static SessionFactory sessionFactory;
private static SessionFactory buildSessionFactory() {
try {
Configuration configuration = new Configuration();
configuration.configure("hibernate-annotation.cfg.xml");
System.out.println("Hibernate Annotation Configuration loaded");
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
.applySettings(configuration.getProperties()).build();
System.out.println("Hibernate Annotation serviceRegistry created");
SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
} catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + ex);
ex.printStackTrace();
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
if(sessionFactory == null) sessionFactory = buildSessionFactory();
return sessionFactory;
}
}
Hibernate One-to-One Mapping Annotation Testprogramm
Hier ist ein einfaches Testprogramm für unser Hibernate One-to-One Mapping mit Annotationen:
package com.journaldev.hibernate.main;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import com.journaldev.hibernate.model.Customer1;
import com.journaldev.hibernate.model.Txn1;
import com.journaldev.hibernate.util.HibernateAnnotationUtil;
public class HibernateOneToOneAnnotationMain {
public static void main(String[] args) {
Txn1 txn = buildDemoTransaction();
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try {
// Get Session
sessionFactory = HibernateAnnotationUtil.getSessionFactory();
session = sessionFactory.getCurrentSession();
System.out.println("Session created using annotations configuration");
// Start transaction
tx = session.beginTransaction();
// Save the Model object
session.save(txn);
// Commit transaction
tx.commit();
System.out.println("Annotation Example. Transaction ID=" + txn.getId());
// Get Saved Transaction Data
printTransactionData(txn.getId(), sessionFactory);
} catch (Exception e) {
System.out.println("Exception occurred. " + e.getMessage());
e.printStackTrace();
} finally {
if (sessionFactory != null && !sessionFactory.isClosed()) {
System.out.println("Closing SessionFactory");
sessionFactory.close();
}
}
}
private static void printTransactionData(long id, SessionFactory sessionFactory) {
Session session = null;
Transaction tx = null;
try {
// Get Session
sessionFactory = HibernateAnnotationUtil.getSessionFactory();
session = sessionFactory.getCurrentSession();
// Start transaction
tx = session.beginTransaction();
// Save the Model object
Txn1 txn = (Txn1) session.get(Txn1.class, id);
// Commit transaction
tx.commit();
System.out.println("Annotation Example. Transaction Details=\n" + txn);
} catch (Exception e) {
System.out.println("Exception occurred. " + e.getMessage());
e.printStackTrace();
}
}
private static Txn1 buildDemoTransaction() {
Txn1 txn = new Txn1();
txn.setDate(new Date());
txn.setTotal(100);
Customer1 cust = new Customer1();
cust.setAddress("San Jose, USA");
cust.setEmail("pankaj@yahoo.com");
cust.setName("Pankaj Kr");
txn.setCustomer(cust);
cust.setTxn(txn);
return txn;
}
}
Wenn wir das obige Programm ausführen, erhalten wir folgende Ausgabe:
Hibernate Annotation Configuration loaded
Hibernate Annotation serviceRegistry created
Session created using annotations configuration
Hibernate: insert into TRANSACTION (txn_date, txn_total) values (?, ?)
Hibernate: insert into CUSTOMER (cust_address, cust_email, cust_name, txn_id) values (?, ?, ?, ?)
Annotation Example. Transaction ID=20
Hibernate: select txn1x0_.txn_id as txn_id1_1_0_, txn1x0_.txn_date as txn_date2_1_0_, txn1x0_.txn_total as txn_tota3_1_0_,
customer1x1_.txn_id as txn_id1_0_1_, customer1x1_.cust_address as cust_add2_0_1_, customer1x1_.cust_email as cust_ema3_0_1_,
customer1x1_.cust_name as cust_nam4_0_1_ from TRANSACTION txn1x0_ left outer join CUSTOMER customer1x1_ on
txn1x0_.txn_id=customer1x1_.txn_id where txn1x0_.txn_id=?
Annotation Example. Transaction Details=
20, 100.0, Pankaj Kr, pankaj@yahoo.com, San Jose, USA
Closing SessionFactory
Beachten Sie, dass die Ausgabe der des XML-basierten Hibernate One-to-One Mappings ähnelt. Hibernate verwendet SQL-Joins, um Daten effizient aus beiden Tabellen abzurufen.
Fazit
In diesem Tutorial haben wir das Hibernate One-to-One Mapping sowohl mit XML-Konfiguration als auch mit Annotationen untersucht. Wir haben eine MySQL-Datenbank eingerichtet, die erforderlichen Tabellen und Beziehungen erstellt und das Mapping mit beiden Methoden implementiert.
Wir haben Utility-Klassen, Modellklassen und Testprogramme erstellt, um zu demonstrieren, wie Daten effizient gespeichert und abgerufen werden können. Zusätzlich hat die von Hibernate generierte SQL-Ausgabe gezeigt, wie Joins genutzt werden, um Daten aus mehreren Tabellen effizient zu holen.
Beide Ansätze—XML-Konfiguration und Annotationen—haben ihre Anwendungsfälle. Die Wahl hängt von den Projektanforderungen und den Präferenzen des Teams ab. Während XML-Konfigurationen eine explizitere Kontrolle über das Mapping bieten, vereinfachen Annotationen die Entwicklung, indem sie Konfigurationen direkt in den Modellklassen einbetten.
Mit den in diesem Tutorial bereitgestellten Schritten und Beispielen sollten Sie nun in der Lage sein, ein One-to-One Mapping in Hibernate selbstbewusst zu implementieren und den besten Ansatz für Ihr Projekt auszuwählen.
