Featured Image with Sidebar

A Beginner’s Guide to JPA’s persistence.xml

By Thorben Janssen

Configuration, Mapping

In JPA, the persistence.xml file is the central piece of configuration. That makes it one of the most important files of your persistence layer. So, it shouldn’t surprise you that I’m recording a detailed lecture about it for my upcoming JPA for Beginners Online Training. And I thought it’s also something that I should share here on the blog.

The persistence.xml file defines one or more persistence units, and you can configure things like:

  • the name of each persistence unit,
  • which managed persistence classes are part of a persistence unit,
  • how these classes shall be mapped to database tables,
  • the persistence provider that shall be used at runtime,
  • the data source you want to use to connect to your database,
  • how to create and validate the database schema,
  • the mode of your 2nd level cache,
  • several provider-specific configuration parameters.

As you can see, you can configure a lot of things in this file. But don’t worry, it isn’t as complex or overwhelming as you might expect. Let’s take a look at the most basic configuration before we discuss all the other, optional elements and properties in greater detail.

The most basic persistence.xml configuration

You can use JPA with a very short, basic configuration. You only need a persistence element as the root element and a persistence-unit element with a name attribute. The attribute is used to identify the persistence unit, and you can use it during the bootstrapping process to instantiate a specific EntityManagerFactory.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
	</persistence-unit>
</persistence>

When you use this configuration, you configure a persistence unit with the name “my-persistence-unit” without defining a dependency to a specific JPA implementation. You also rely on a list of defaults defined by the specification:

  • Your persistence provider scans the root of your persistence unit and adds all annotated managed persistence classes to the persistence unit.
  • If your META-INF directory contains a file called orm.xml, it gets treated as a mapping file and all included mapping information get used.
  • The used transaction type depends on the environment in which you deploy your application. In a Jakarta EE environment, JPA expects that the container provides a JTA-compliant connection provider. In a Java SE environment, it uses a RESOURCE_LOCAL transaction instead.
  • You don’t configure any database connection. JPA, therefore, expects that you provide a datasource at runtime.
  • All JPA implementations support a set of proprietary configuration parameters. Examples for that are the logging configuration in EclipseLink JPA or Hibernate’s database dialect. As you don’t define any of them in this basic configuration, you also rely on all provider-specific defaults.

Optional configuration elements you should know

Having a basic configuration makes it easy to get started. But in most of your projects, you need more than that. You might need to reference a specific datasource, include managed classes from a different jar file, activate the 2nd level cache or include an external mapping configuration.

So, let’s take a look at JPA’s optional configuration elements and what they enable you to do.

Provide a description of your persistence unit

Sometimes, a meaningful name is not enough. Especially in bigger, more complex deployments that include multiple persistence-units, it’s a good practice to provide a short description that tells more about the usage and purpose of each persistence-unit. You can do that with the description element.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
		<description>This is a short text describing my persistence unit.</description>
	</persistence-unit>
</persistence>

Specify the managed classes included in your persistence unit

By default, your JPA persistence-unit includes all annotated managed classes found in its root. If you want to include any classes that are located somewhere else, you can either reference them explicitly or include all classes from a jar file.

Include one or more specific managed classes

By adding one or more class elements to your persistence-unit configuration, you can add classes to your persistence unit which are not in the root of the persistence unit. Each class element needs to contain the fully referenced name of a class. Please be aware that these classes need to be available on your classpath.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
		<class>org.thoughts.on.java.jpa.beginners.Professor</class>
	</persistence-unit>
</persistence>

Include managed classes from other jar files

Using multiple class elements to add a long list of managed classes to your persistence unit can be a cumbersome task. It’s oftentimes easier to use one or more jar-file elements to add all managed classes contained in these jar files.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
		<jar-file>my-entities.jar</jar-file>
	</persistence-unit>
</persistence>

Exclude unlisted classes

You can not only add classes to your persistence-unit which are not at its root, you can also exclude classes which would be added by default. To do that, you first need to use one or more class elements to explicitly specify which managed classes shall be part of the persistence-unit. In the next step, you can use the exclude-unlisted-classes element to exclude all classes from the persistence-unit which were not explicitly included.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
		<class>org.thoughts.on.java.jpa.beginners.Professor</class>
		<exclude-unlisted-classes>true</exclude-unlisted-classes>
	</persistence-unit>
</persistence>

Reference a mapping file

Annotations are the most common but not your only option to define the mapping between your entities and database tables. You can also use external, XML-based mapping files. By default, your persistence provider checks if the META-INF directory contains a file called orm.xml and includes its mapping information. As I explained in a previous post, the mapping definitions provided via annotations and in the mapping files are merged during the deployment, and the information in the mapping file prevail.

If you want to use multiple mapping files or if the name of your file doesn’t match the default naming pattern, you can use one or more mapping-file elements to reference the files that shall be used with your persistence-unit.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
		<mapping-file>file:\\\C:\dev\wrk\XmlMapping\XmlMappings\myMappings.xml</mapping-file>
	</persistence-unit>
</persistence>

Use a specific persistence provider

If you use any proprietary features of your persistence provider, you should specify a dependency to it. You can do that by defining the name of the class that implements the javax.persistence.spi.PersistenceProvider interface in the provider element.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
		<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
	</persistence-unit>
</persistence>

Reference a datasource

The jta-data-source and non-jta-data-source elements are mostly used in Jakarta EE environments. They enable you to reference the JNDI name of a datasource that is or is not compliant with the Java Transaction API. If you don’t use any of these two elements, you need to either configure a default JTA datasource for your container or provide the JNDI name of a datasource at deploy time.

And if you’re using JPA in a Java SE environment, you can either use one of these two elements to reference a datasource or use a set of properties to configure your database connection.

I use the jta-data-source parameter in the following example to reference a JTA datasource.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
		<jta-data-source>java:app/jdbc/MyDataSource</jta-data-source>
	</persistence-unit>
</persistence>

Activate the 2nd level cache

The 2nd level cache, which is defined by the JPA specification, is one of the bigger topics in my Hibernate Performance Tuning Online Training. You should use it to cache entities that you often read but only rarely change. It is deactivated by default. You can activate the cache and specify its mode with the shared-cache-mode element.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
		<shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
	</persistence-unit>
</persistence>

You can choose between 4 different options:

  1. ALL – To cache all entities
  2. NONE – To cache none of your entities (default)
  3. ENABLE_SELECTIVE – To cache only the entities annotated with @Cacheable or @Cacheable(true)
  4. DISABLE_SELECTIVE – To cache all entities not annotated with @Cacheable(false)

I always recommend using ENABLE_SELECTIVE because it requires you to annotate an entity before it gets cached. So, you shouldn’t slow down your application by accidentally caching an entity that shouldn’t be cached.

Deactivate automatic validation of your entities

As I explained in more details in my article How to automatically validate entities with Hibernate Validator, JPA integrates with the bean validation specification. This enables you to automatically validate the values of your entity attributes before they get persisted or updated. The 3 different values supported by the validation-mode element enable you to activate or deactivate the validation:

  1. AUTO – Perform the validation if a bean validation implementation is available (default)
  2. CALLBACK– Activate the validation and throw an exception if no bean validation implementation is available
  3. NONE – Do not perform any validation
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
		<validation-mode>CALLBACK</validation-mode>
	</persistence-unit>
</persistence>

Define additional properties

In addition to the previously described XML elements, you can use the properties element to configure additional standard and vendor-specific parameters and hints.

Configure timeouts

You can use the properties javax.persistence.lock.timeout and javax.persistence.query.timeout to define the pessimistic lock timeout and the query timeout in milliseconds. These are just hints and your persistence provider might or might not use them. That depends on the persistence provider you use in your project and the database to which it connects.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<persistence-unit name="my-persistence-unit">
		<properties>
			<property name="javax.persistence.lock.timeout" value="100"/>
			<property name="javax.persistence.query.timeout" value="100"/>
		</properties>
	</persistence-unit>
</persistence>

Specify Validation Groups

If you activate the automatic validation or rely on the default behavior, you can define custom groups which get validated before the persistence provider executes the persist, update or remove operations. You can configure one or more groups for each lifecycle state change by using the javax.persistence.validation.group.pre-persistjavax.persistence.validation.group.pre-update and javax.persistence.validation.group.pre-remove property.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<persistence-unit name="my-persistence-unit">
		<properties>
			<property name="javax.persistence.validation.group.pre-persist" value="javax.validation.groups.MyPersistValidation"/>
			<property name="javax.persistence.validation.group.pre-update" value="javax.validation.groups.MyUpdateValidation"/>
			<property name="javax.persistence.validation.group.pre-remove" value="javax.validation.groups.MyRemovetValidation"/>
		</properties>
	</persistence-unit>
</persistence>

Configure a database connection in Java SE

In a Java SE environment, you might not have a datasource that you can reference to define the database connection. In these situations, you can use the following set of properties to specify the JDBC driver class, the connection URL and the login information that your persistence provider shall use to connect to the database:

  • javax.persistence.jdbc.driver – The fully qualified class name of your JDBC driver
  • javax.persistence.jdbc.url – The connection URL of your database
  • javax.persistence.jdbc.user – The user name to login to your database
  • javax.persistence.jdbc.password – The password to login to your database
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<persistence-unit name="my-persistence-unit">
		<properties>
			<!-- database connection -->
			<property name="javax.persistence.jdbc.driver" value="org.postgresql.Driver" />
			<property name="javax.persistence.jdbc.url" value="jdbc:postgresql://localhost:5432/jpaForBeginners" />
			<property name="javax.persistence.jdbc.user" value="postgres" />
			<property name="javax.persistence.jdbc.password" value="postgres" />
		</properties>
	</persistence-unit>
</persistence>

Create and initialize the database

Since version 2.1, JPA can create a new database at startup and initialize it with a predefined dataset. But before you use this feature in your application, please be aware that it is not as powerful and flexible as a version-based database migration that I showed you in my tutorials about Flyway and Liquibase.

You can activate and configure this feature by adding the following properties to your configuration:

  • javax.persistence.schema-generation.database.action – The action that you want to performe to manage the database schema. Supported values are none (default), create, drop-and-create and drop. As you probably expect, the create option creates the database schema at startup, drop-and-create drops the existing database and creates a new one and drop just removes the existing database.
  • javax.persistence.schema-generation.create-script-source – The name or file URL to the script that creates the database.
  • javax.persistence.schema-generation.drop-script-source – The name or file URL to the script that drops the database.
  • javax.persistence.sql-load-script-source – The name or file URL to the script that initializes the database with a predefined dataset.
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<persistence-unit name="my-persistence-unit">
		<properties>
			<!-- DON'T USE THIS IN PRODUCTION -->
			<!-- automatically drop and create required database tables -->
			<property name="javax.persistence.schema-generation.database.action" value="drop-and-create" />
			<property name="javax.persistence.schema-generation.create-script-source" value="create-db.sql" />
			<property name="javax.persistence.schema-generation.drop-script-source" value="drop-db.sql" />
			<property name="javax.persistence.sql-load-script-source" value="data.sql" />
		</properties>
	</persistence-unit>
</persistence>

Generate your database scripts

And if you don’t have any SQL scripts to create or drop your database, you can create them based on your entity mappings. But please be aware that these scripts often need to be adapted and optimized before you can use them in production. But they are a good starting point and optimizing them is often times a lot faster than writing everything yourself.

You can tell your persistence provider to generate these scripts by configuring the following properties:

  • javax.persistence.schema-generation.scripts.action – The kind of scripts you want to generate. Supported values are none (default), create, drop-and-create and drop.
  • javax.persistence.schema-generation.create-source – The basis on which you want to create the database. You can choose between metadata, script, metadata-then-script and script-then-metadata.
  • javax.persistence.schema-generation.drop-source – The basis on which you want to drop the database. You can choose between metadata, script, metadata-then-script and script-then-metadata.
  • javax.persistence.schema-generation.scripts.create-target – The location where you want to store the generated create script.
  • javax.persistence.schema-generation.scripts.drop-target – The location where you want to store the generated drop script.
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
	<persistence-unit name="my-persistence-unit">
		<properties>
			<property name="javax.persistence.schema-generation.scripts.action" value="drop-and-create"/>
			<property name="javax.persistence.schema-generation.scripts.create-target" value="./create.sql"/>
			<property name="javax.persistence.schema-generation.scripts.drop-target" value="./drop.sql"/>
		</properties>
	</persistence-unit>
</persistence>

A few standard persistence.xml configurations

OK, you now know the different elements and properties that you can use in the persistence.xml file. Let’s combine them to a few standard configurations that are a good fit for projects using Hibernate or EclipseLink.

Configurations for Hibernate

Include all managed classes from external jar file, reference a datasource and specify the dialect

The following configuration for Hibernate adds all managed persistence classes from the root and the my-entities.jar file to the persistence unit. It uses the JTA datasource java:app/jdbc/MyDataSource and tells Hibernate to use the database-specific dialect for PostgreSQL9.5.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.1"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
		<description>JpaForBeginners</description>
		<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
		<jar-file>my-entities.jar</jar-file>
		<exclude-unlisted-classes>false</exclude-unlisted-classes>

		<jta-data-source>java:app/jdbc/MyDataSource</jta-data-source>

		<properties>		
			<property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQL95Dialect"/>
		</properties>
	</persistence-unit>
</persistence>

Include all managed classes, define a database connection and specify the dialect

This configuration for Hibernate adds all managed persistence classes from the root to the persistence unit and uses a set of properties to connect to a PostgreSQL database on localhost. It also tells Hibernate to use the database-specific dialect for PostgreSQL9.5.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.1"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
		<description>JpaForBeginners</description>
		<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
		<exclude-unlisted-classes>false</exclude-unlisted-classes>

		<properties>
			<!-- database connection -->
			<property name="javax.persistence.jdbc.driver" value="org.postgresql.Driver" />
			<property name="javax.persistence.jdbc.url" value="jdbc:postgresql://localhost:5432/jpaForBeginners" />
			<property name="javax.persistence.jdbc.user" value="postgres" />
			<property name="javax.persistence.jdbc.password" value="postgres" />
				
			<property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQL95Dialect"/>
		</properties>
	</persistence-unit>
</persistence>

Configurations for EclipseLink

Include all managed classes from external jar file, reference a datasource and activate logging

The following configuration for EclipseLink adds all managed persistence classes from the root and the my-entities.jar file to the persistence unit. It uses the JTA datasource java:app/jdbc/MyDataSource and logs all executed SQL statements with the bind parameter values.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.1"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
		<description>JpaForBeginners</description>
		<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
		<jar-file>my-entities.jar</jar-file>
		<exclude-unlisted-classes>false</exclude-unlisted-classes>

		<jta-data-source>java:app/jdbc/MyDataSource</jta-data-source>

		<properties>		
			<!-- configure logging -->
			<property name="eclipselink.logging.level" value="INFO"/>
			<property name="eclipselink.logging.level.sql" value="FINE"/>
			<property name="eclipselink.logging.parameters" value="true"/>
		</properties>
	</persistence-unit>
</persistence>

Include all managed classes, define a database connection and activate logging

This configuration for EclipseLink adds all managed persistence classes from the root to the persistence unit and uses a set of properties to connect to a PostgreSQL database on localhost. It also logs all executed SQL statements with the bind parameter values.

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.1"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
	<!-- Define persistence unit -->
	<persistence-unit name="my-persistence-unit">
		<description>JpaForBeginners</description>
		<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
		<exclude-unlisted-classes>false</exclude-unlisted-classes>

		<properties>
			<!-- database connection -->
			<property name="javax.persistence.jdbc.driver" value="org.postgresql.Driver" />
			<property name="javax.persistence.jdbc.url" value="jdbc:postgresql://localhost:5432/jpaForBeginners" />
			<property name="javax.persistence.jdbc.user" value="postgres" />
			<property name="javax.persistence.jdbc.password" value="postgres" />
				
			<!-- configure logging -->
			<property name="eclipselink.logging.level" value="INFO"/>
			<property name="eclipselink.logging.level.sql" value="FINE"/>
			<property name="eclipselink.logging.parameters" value="true"/>
		</properties>
	</persistence-unit>
</persistence>

Summary

As you have seen in this article, JPA’S persistence.xml enables you to configure the most important parts of your persistence layer. You can define which managed persistence classes you want to include, to which database your persistence provider shall connect, if and how the 2nd level cache shall be used and much more.

I know from my own experience that its hard to remember all the configuration details that I showed you in this article. I, therefore, recommend that you bookmark it or that you download the cheat sheet from the Thoughts on Java Library. If you’re not already a member, you can join it here for free.

About the author

Thorben is an independent consultant, international speaker, and trainer specialized in solving Java persistence problems with JPA and Hibernate.
He is also the author of Amazon’s bestselling book Hibernate Tips - More than 70 solutions to common Hibernate problems.

Books and Courses

Coaching and Consulting

Leave a Repl​​​​​y

Your email address will not be published. Required fields are marked

This site uses Akismet to reduce spam. Learn how your comment data is processed.

  1. Thanks for every other magnificent post. Where else could anyone get that
    type of info in such an ideal method of writing? I’ve a
    presentation next week, and I am at the search for such info.

    Reply

    1. No, not with plain JPA.
      If you’re using Spring or deploy your application in a Jakarta EE application server, you might have other frameworks in place which can handle that.

      Reply

{"email":"Email address invalid","url":"Website address invalid","required":"Required field missing"}