[JAVA] Jusqu'à l'utilisation de Spring Data et JPA Part 2
La difficulté de réglage est assez élevée.
Pour le moment, j'ai utilisé Spring pour me connecter à la base de données. À partir de là, nous utiliserons un cadre d'opération DB à part entière appelé JPA.
Diviser les objectifs
-
- Ce dont vous avez juste besoin pour vous connecter avec SQL -Hibernate EntityManager bibliothèque ・ Bibliothèque JDBC Spring ・ Posture du pilote de base de données ou H2 · Dossier de propriété -Le fichier de configuration Bean (xml) JavaConfig n'est pas utilisé cette fois. Peut-être que ça va devenir déroutant ** ← Jusqu'à présent **
-
De plus, ce qui est requis pour JPA ** ← À partir d'ici ** ・ Bibliothèque JPA Spring Data ・ Classe d'entité · Fichier Persistence.xml (fonctionnalité Java EJB) -Fichier de configuration Bean (xml) -Classe d'exécution avec la méthode principale
Ajouter une bibliothèque
Ajoutez une bibliothèque comme d'habitude. Lorsque vous utilisez une nouvelle fonctionnalité dans Spring, vous modifiez généralement la bibliothèque.
pom.xml
<!-- Spring Data JPA -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
</dependency>
<!-- Spring ORM -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
Après avoir enregistré ** Maven → Mettre à jour le projet **
Classe d'entité
Cliquez ici pour savoir comment créer une classe d'entité à partir d'une table. emballer Faites un clic droit et convertissez de la configuration au projet JPA. Lorsqu'il devient un projet JPA, une entité sera automatiquement générée à partir de la table.
https://qiita.com/shibafu/items/39f3f5d6e63dda16bb12
C'est vraiment difficile à voir,
Une fois que vous avez une entité, ajoutez une annotation telle que @Id pour détecter l'erreur. Il peut être bon d'utiliser ** lombok ** et d'omettre le gettersetter dans @Data
Classe d'entité implémentée automatiquement
Création de persistence.xml
Créez un dossier META-INF dans src / main / resources et un fichier persistance.xml dedans. Cela semble être une fonction Java-EE appelée ** fichier de persistance ** (Si vous l'avez créé avec JPA, il est créé dans src / main / java, alors déplacez-le)
Esquisser src/main/resources/ | |---META-INF | | | |--persistance.xml |---bean.xml |---database.properties
persitance.xml
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1"
xmlns="http://xmlns.jcp.org/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
<persistence-unit name="persistance-unit">
<!--Définition de HibernatePersistance-->
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<class>model.Mypersonaldata</class>
<properties>
<property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQLDialect"/>
<property name="hibernate.hbm2ddl.auto" value="create" />
<!--Propriétés du pilote-->
<property name="javax.persistance.jdbc.driver"
value="${jdbc.driverClassname}" />
<property name="javax.persistance.jdbc.url"
value="${jdbc.url}" />
<property name="javax.persistance.jdbc.user"
value="${jdbc.username}" />
<property name="javax.persistance.jdbc.password"
value="${jdbc.password}" />
</properties>
</persistence-unit>
</persistence>
Créer un fichier de configuration de bean
Enfin, créez un fichier de configuration de bean. Espace de noms xmlns = http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/spring-jpa.xsd Ajouter Enregistrez le gestionnaire d'entités avec le conteneur DI.
bean.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/spring-jpa.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<!--Paramètres de la base de données intégrée>
<jdbc:embedded-database id="dataSource" type="H2">
<jdbc:script location="classpath:script.sql"/>
</jdbc:embedded-database-->
<!--Définition des propriétés de la base de données-->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location" value="database.properties" />
</bean>
<!--Paramètres EntityManager-->
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="generateDdl" value="true" />
</bean>
</property>
</bean>
<!--Paramètres de connexion à la base de données-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" >
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!--Créer un bean modèle JDBC-->
<bean class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg ref="dataSource" />
</bean>
<!--Paramètres du référentiel JPA-->
<jpa:repositories base-package="com.TsugaruInfo.repository" />
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
<property name="dataSource" ref="dataSource" />
</bean>
</beans>
Courons
Mettons le gestionnaire d'entités dans la classe principale et exécutons les fonctions de JPA!
App.java
public class App{
public static void main(String args[]) {
//Créer un modèle à l'aide d'annotations
//context = new AnnotationConfigApplicationContext(DataSourceConfig.class);
//JdbcTemplate jdbcTemplate = (JdbcTemplate)context.getBean(JdbcTemplate.class);
//Obtenez le contexte
// context = new ClassPathXmlApplicationContext("bean.xml");
// jdbcTemplate = context.getBean(JdbcTemplate.class);
context = new ClassPathXmlApplicationContext("bean.xml");
LocalContainerEntityManagerFactoryBean factory =
context.getBean(LocalContainerEntityManagerFactoryBean.class);
manager = factory.getNativeEntityManagerFactory().createEntityManager();
Mypersonaldata data = manager.find(Mypersonaldata.class, 1);
System.out.println(data);
}
}
Exécutez ceci à partir de l'application Java
En bas, vous pouvez voir les données lues à partir de postgresql.
Résumé.
Eh bien, avec Spring-Boot, cette procédure se fait automatiquement, Je ne pouvais pas garder les bases et cela a cessé de fonctionner, donc pour référence.
Recommended Posts