Prise en charge des bottes de printemps pour jOOQ
1. Vue d'ensemble
Ce tutoriel fait suite à l'article deIntroduction to jOOQ with Spring, couvrant les façons dont jOOQ peut être utilisé dans une application Spring Boot.
Si vous n'avez pas suivi ce didacticiel, jetez-y un coup d'œil et suivez les instructions de la section 2 sur les dépendances Maven et de la section 3 sur la génération de code. Cela générera du code source pour les classes Java représentant les tables de la base de données exemple, y comprisAuthor,Book etAuthorBook.
2. Configuration Maven
En plus des dépendances et des plugins comme dans le tutoriel précédent, plusieurs autres composants doivent être inclus dans le fichier Maven POM pour que jOOQ fonctionne avec Spring Boot.
2.1. Gestion de la dépendance
La manière la plus courante d'utiliser Spring Boot est d'hériter du projetspring-boot-starter-parent en le déclarant dans l'élémentparent. Cependant, cette méthode ne convient pas toujours, car elle impose une chaîne d'héritage à suivre, ce qui peut ne pas être ce que les utilisateurs veulent dans de nombreux cas.
Ce tutoriel utilise une autre approche: déléguer la gestion des dépendances à Spring Boot. Pour ce faire, il suffit d'ajouter l'élémentdependencyManagement suivant au fichier POM:
org.springframework.boot
spring-boot-dependencies
1.3.5.RELEASE
pom
import
2.3. Les dépendances
Pour que Spring Boot contrôle jOOQ, une dépendance sur l'artefactspring-boot-starter-jooq doit être déclarée:
org.springframework.boot
spring-boot-starter-jooq
1.3.5.RELEASE
Notez que cet article se concentre sur la distribution open-source de jOOQ. Si vous souhaitez travailler avec les distributions commerciales, consultez lesGuide to Using jOOQ’s Commercial Distributions with Spring Boot sur le blog officiel.
3. Configuration de démarrage de printemps
3.1. Configuration initiale de démarrage
Avant d'arriver au support jOOQ, nous allons commencer à préparer les choses avec Spring Boot.
Tout d'abord, nous allons profiter de la prise en charge de la persistance et des améliorations de Boot et de nos informations d'accès aux données dans le fichier standardapplication.properties. De cette façon, nous pouvons ignorer la définition des beans et les rendre configurables via un fichier de propriétés séparé.
Nous ajouterons ici l'URL et les informations d'identification pour définir notre base de données H2 intégrée:
spring.datasource.url=jdbc:h2:~/jooq
spring.datasource.username=sa
spring.datasource.password=Nous allons également définir une application de démarrage simple:
@SpringBootApplication
@EnableTransactionManagement
public class Application {
}Nous laissons celle-ci simple et vide et nous définirons toutes les autres déclarations de bean dans une autre classe de configuration -InitialConfiguration.
3.2. Configuration du bean
Définissons maintenant cette classeInitialConfiguration:
@Configuration
public class InitialConfiguration {
// Other declarations
}Spring Boot a automatiquement généré et configuré le beandataSource en fonction des propriétés définies dans le fichierapplication.properties, nous n'avons donc pas besoin de l'enregistrer manuellement. Le code suivant permet au beanDataSource auto-configuré d'être injecté dans un champ et montre comment ce bean est utilisé:
@Autowired
private DataSource dataSource;
@Bean
public DataSourceConnectionProvider connectionProvider() {
return new DataSourceConnectionProvider
(new TransactionAwareDataSourceProxy(dataSource));
}Puisqu'un bean nommétransactionManager a également été automatiquement créé et configuré par Spring Boot, nous n'avons pas besoin de déclarer un autre bean du typeDataSourceTransactionManager comme dans le didacticiel précédent pour profiter de la prise en charge des transactions Spring.
Un beanDSLContext est créé de la même manière que dans la classePersistenceContext du tutoriel précédent:
@Bean
public DefaultDSLContext dsl() {
return new DefaultDSLContext(configuration());
}Enfin, une implémentation deConfiguration doit être fournie àDSLContext. Spring Boot étant capable de reconnaître le dialecte SQL utilisé grâce à l'existence d'un artefact H2 sur le chemin d'accès aux classes, une configuration de dialecte n'est plus nécessaire:
public DefaultConfiguration configuration() {
DefaultConfiguration jooqConfiguration = new DefaultConfiguration();
jooqConfiguration.set(connectionProvider());
jooqConfiguration
.set(new DefaultExecuteListenerProvider(exceptionTransformer()));
return jooqConfiguration;
}4. Utiliser Spring Boot avec jOOQ
Pour faciliter la démonstration de la prise en charge de Spring Boot pour jOOQ, les cas de test de la suite de ce didacticiel sont réutilisés avec une légère modification de ses annotations de niveau classe:
@SpringApplicationConfiguration(Application.class)
@Transactional("transactionManager")
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringBootTest {
// Other declarations
}Il est clair qu'au lieu d'adopter l'annotation@ContextConfiguration, Spring Boot utilise@SpringApplicationConfiguration pour tirer parti du chargeur de contexteSpringApplicationContextLoader pour tester les applications.
Les méthodes de test pour l'insertion, la mise à jour et la suppression de données sont exactement les mêmes que dans le didacticiel précédent. Veuillez consulter la section 5 de cet article sur l’utilisation de jOOQ avec Spring pour plus d’informations. Tous les tests doivent être exécutés avec succès avec la nouvelle configuration, ce qui prouve que jOOQ est entièrement pris en charge par Spring Boot.
5. Conclusion
Ce tutoriel a approfondi l'utilisation de jOOQ avec Spring. Il présentait les moyens permettant à une application Spring Boot de tirer parti de jOOQ pour interagir avec une base de données de manière sûre.
L'implémentation de tous ces exemples et extraits de code se trouve dansa GitHub project.