Frühling, Ruhezustand und eine JNDI-Datenquelle

1. Übersicht

In diesem Artikel erstellen wir eine Spring-Anwendung mit Hibernate / JPA und einer JNDI-Datenquelle.

Wenn Sie die Grundlagen von Spring und Hibernate neu entdecken möchten, lesen Sie diesen Artikel.

2. Deklarieren der Datenquelle

2.1. System

Da wir eine JNDI-Datenquelle verwenden, definieren wir sie nicht in unserer Anwendung, sondern in unserem Anwendungscontainer.

In diesem Beispiel verwenden wir die Version 8.5.x von Tomcat und die Version 9.5.x der PostgreSQL-Datenbank.

Sie sollten in der Lage sein, dieselben Schritte mit jedem anderen Java-Anwendungscontainer und einer Datenbank Ihrer Wahl zu replizieren (sofern Sie über geeignete JDBC-Jars verfügen!).

2.2. Deklarieren der Datenquelle im Anwendungscontainer

Wir deklarieren unsere Datenquelle in der Datei / conf / server.xml in der Element.

Unter der Annahme , dass der Datenbankserver auf der gleichen Maschine wie der Applikationsbehälter ausgeführt wird , und dass die vorgesehene Datenbank namens Postgres , und dass der Benutzername ist baeldung mit Passwort pass1234 würde eine Ressource wie folgt aussehen:

Beachten Sie, dass wir unsere Ressource jdbc / BaeldungDatabase benannt haben . Dies ist der Name, der verwendet wird, wenn auf diese Datenquelle verwiesen wird.

Wir mussten auch den Typ und den Klassennamen des Datenbanktreibers angeben. Damit dies funktioniert, müssen Sie auch das entsprechende JAR in / lib / platzieren (in diesem Fall das JDBC-JAR von PostgreSQL).

Verbleibende Konfigurationsparameter sind:

  • auth = ”Container” - bedeutet, dass sich der Container im Namen der Anwendung beim Ressourcenmanager anmeldet
  • maxTotal, maxIdle und maxWaitMillis - sind die Konfigurationsparameter der Poolverbindung

Wir müssen auch einen ResourceLink innerhalb der definierenElement in / conf / context .xml, das wie folgt aussehen würde:

Beachten Sie, dass wir den Namen verwenden, den wir in unserer Ressource in server.xml definiert haben .

3. Verwenden der Ressource

3.1. Einstellen der Anwendung

Wir werden jetzt eine einfache Spring + JPA + Hibernate-Anwendung mit reiner Java-Konfiguration definieren.

Zunächst definieren wir die Konfiguration des Spring-Kontexts (denken Sie daran, dass wir uns hier auf JNDI konzentrieren und davon ausgehen, dass Sie die Grundlagen der Spring-Konfiguration bereits kennen):

@Configuration @EnableTransactionManagement @PropertySource("classpath:persistence-jndi.properties") @ComponentScan("com.baeldung.hibernate.cache") @EnableJpaRepositories(basePackages = "com.baeldung.hibernate.cache.dao") public class PersistenceJNDIConfig { @Autowired private Environment env; @Bean public LocalContainerEntityManagerFactoryBean entityManagerFactory() throws NamingException { LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean(); em.setDataSource(dataSource()); // rest of entity manager configuration return em; } @Bean public DataSource dataSource() throws NamingException { return (DataSource) new JndiTemplate().lookup(env.getProperty("jdbc.url")); } @Bean public PlatformTransactionManager transactionManager(EntityManagerFactory emf) { JpaTransactionManager transactionManager = new JpaTransactionManager(); transactionManager.setEntityManagerFactory(emf); return transactionManager; } // rest of persistence configuration }

Beachten Sie, dass wir im Artikel zu Spring 4 und JPA mit Ruhezustand ein vollständiges Beispiel für die Konfiguration haben.

Um unsere dataSource- Bean zu erstellen , müssen wir nach der JNDI-Ressource suchen, die wir in unserem Anwendungscontainer definiert haben. Wir speichern dies im Schlüssel persistence-jndi.properties (unter anderem):

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

Beachten Sie, dass wir in der Eigenschaft jdbc.url einen Stammnamen definieren , nach dem gesucht werden soll : java: comp / env / (dies sind Standardeinstellungen und entsprechen der Komponente und der Umgebung) und dann denselben Namen, den wir in server.xml verwendet haben : jdbc / BaeldungDatenbank .

3.2. JPA-Konfiguration - Modell, DAO und Service

Wir werden ein einfaches Modell mit der Annotation @Entity mit einer generierten ID und einem Namen verwenden :

@Entity public class Foo { @Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = "ID") private Long id; @Column(name = "NAME") private String name; // default getters and setters }

Definieren wir ein einfaches Repository:

@Repository public class FooDao { @PersistenceContext private EntityManager entityManager; public List findAll() { return entityManager .createQuery("from " + Foo.class.getName()).getResultList(); } }

Und zum Schluss erstellen wir einen einfachen Service:

@Service @Transactional public class FooService { @Autowired private FooDao dao; public List findAll() { return dao.findAll(); } }

Damit haben Sie alles, was Sie brauchen, um Ihre JNDI-Datenquelle in Ihrer Spring-Anwendung zu verwenden.

4. Fazit

In diesem Artikel haben wir eine Spring-Beispielanwendung mit einem JPA + Hibernate-Setup erstellt, das mit einer JNDI-Datenquelle arbeitet.

Beachten Sie, dass die wichtigsten Teile die Definition der Ressource im Anwendungscontainer und die Suche nach der JNDI-Ressource in der Konfiguration sind.

Und wie immer finden Sie das vollständige Projekt auf GitHub.