Lente, winterslaap en een JNDI-gegevensbron

1. Overzicht

In dit artikel maken we een Spring-applicatie met behulp van Hibernate / JPA met een JNDI-gegevensbron.

Lees dit artikel als je de basisprincipes van lente en winterslaap opnieuw wilt ontdekken.

2. Declaratie van de gegevensbron

2.1. Systeem

Omdat we een JNDI-gegevensbron gebruiken, zullen we deze niet in onze applicatie definiëren, maar in onze applicatiecontainer.

In dit voorbeeld gebruiken we de 8.5.x-versie van Tomcat en de 9.5.x-versie van de PostgreSQL-database.

Je zou dezelfde stappen moeten kunnen repliceren met een andere Java-applicatiecontainer en een database naar keuze (zolang je er de juiste JDBC-jars voor hebt!).

2.2. De gegevensbron op de toepassingscontainer declareren

We declareren onze gegevensbron in / conf /server.xml bestand in het element.

Ervan uitgaande dat de databaseserver op dezelfde computer draait als de applicatiecontainer, en dat de bedoelde database een naam heeft postgres, en dat de gebruikersnaam is baeldung met wachtwoord pass1234, zou een bron er als volgt uitzien:

Houd er rekening mee dat we onze bron hebben genoemd jdbc / BaeldungDatabase. Dit is de naam die moet worden gebruikt bij het verwijzen naar deze gegevensbron.

We hebben ook het type en de klassenaam van het databasestuurprogramma moeten specificeren. Om het te laten werken, moet u ook de bijbehorende pot erin plaatsen / lib / (in dit geval de JDBC-jar van PostgreSQL).

Resterende configuratieparameters zijn:

  • auth = "Container" - betekent dat de container zich namens de applicatie aanmeldt bij de resource manager
  • maxTotaal, maxIdle, en maxWaitMillis - zijn de configuratieparameters van de poolverbinding

We moeten ook een ResourceLink binnen in de element in / conf / context.xml, die eruit zou zien:

Merk op dat we de naam gebruiken die we hebben gedefinieerd in onze Bron in server.xml.

3. Met behulp van de bron

3.1. De applicatie instellen

We gaan nu een eenvoudige Spring + JPA + Hibernate-applicatie definiëren met behulp van pure Java-configuratie.

We beginnen met het definiëren van de configuratie van de Spring-context (houd er rekening mee dat we ons hier op JNDI concentreren en ervan uitgaande dat u de basisprincipes van de configuratie van Spring al kent):

@Configuration @EnableTransactionManagement @PropertySource ("classpath: persistence-jndi.properties") @ComponentScan ("com.baeldung.hibernate.cache") @EnableJpaRepositories (basePackages = "com.baeldung.hibernate.cICache class Personistence. {@Autowired privéomgeving env; @Bean openbaar LocalContainerEntityManagerFactoryBean entityManagerFactory () gooit NamingException {LocalContainerEntityManagerFactoryBean em = nieuwe LocalContainerEntityManagerFactoryBean (); em.setDataSource (dataSource ()); // rest van de entiteitbeheerderconfiguratie retourneert em; } @Bean openbare DataSource dataSource () gooit NamingException {return (DataSource) nieuwe JndiTemplate (). Lookup (env.getProperty ("jdbc.url")); } @Bean openbaar PlatformTransactionManager transactionManager (EntityManagerFactory emf) {JpaTransactionManager transactionManager = nieuwe JpaTransactionManager (); transactionManager.setEntityManagerFactory (emf); return transactionManager; } // rest van persistentieconfiguratie}

Merk op dat we een volledig voorbeeld hebben van de configuratie in het artikel Spring 4 en JPA met Hibernate.

Om onze databron bean, moeten we zoeken naar de JNDI-resource die we hebben gedefinieerd in onze applicatiecontainer. We slaan dit op in persistence-jndi.properties key (onder andere eigenschappen):

jdbc.url = java: comp / env / jdbc / BaeldungDatabase

Merk op dat in het jdbc.url we definiëren een root-naam om naar te zoeken: java: comp / env / (dit zijn standaardinstellingen en komen overeen met component en omgeving) en vervolgens dezelfde naam die we hebben gebruikt in server.xml: jdbc / BaeldungDatabase.

3.2. JPA-configuratie - Model, DAO en service

We gaan een eenvoudig model gebruiken met de @Entiteit annotatie met een gegenereerd ID kaart en een naam:

@Entity openbare klasse Foo {@Id @GeneratedValue (strategie = GenerationType.AUTO) @Column (naam = "ID") privé Lange id; @Column (name = "NAME") private String naam; // standaard getters en setters}

Laten we een eenvoudige repository definiëren:

@Repository openbare klasse Foobao {@PersistenceContext private EntityManager entityManager; openbare lijst findAll () {return entityManager .createQuery ("from" + Foo.class.getName ()). getResultList (); }}

En tot slot, laten we een eenvoudige service maken:

@Service @Transactional openbare klasse FooService {@Autowired privé Foobao dao; openbare lijst findAll () {return dao.findAll (); }}

Hiermee heb je alles wat je nodig hebt om je JNDI-databron te gebruiken in je Spring-applicatie.

4. Conclusie

In dit artikel hebben we een voorbeeld van een Spring-applicatie gemaakt met een JPA + Hibernate-installatie die werkt met een JNDI-gegevensbron.

Merk op dat de belangrijkste onderdelen de definitie van de resource in de applicatiecontainer zijn en het zoeken naar de JNDI-resource in de configuratie.

En, zoals altijd, is het volledige project te vinden op GitHub.