Category: Spring Data JPA

FLYWAY Spring Boot Properties

Posted on by Saurabh Gupta in DB, Flyway, Liquibase, Spring Boot, Spring Data JPA

FLYWAY is a provider of Spring Boot Data for handling database schemas operations. FLYWAY is a schema version control application to evolve your Database schema easily and reliably across all your DB instances. FLYWAY is helpful to handling database migrations or also called as schema migrations.

See Also:

Use below FLYWAY dependencies to integrate with Spring Boot.

<dependency>
   <groupId>org.flywaydb</groupId>
   <artifactId>flyway-core</artifactId>
</dependency>

After adding FLYWAY dependencies in your application it will automatically download and add the required other dependencies in your application and initialize with default values. You can overwrite these values through application.properties / application.yaml .

FLYWAY CONFIGURATION PROPERTIES

Spring Boot load these properties in FlywayProperties class.

NameDefault
Value		Description
flyway.baseline-description  
flyway.baseline-version1version to start migration
flyway.baseline-on-migrate  
flyway.check-locationfalseCheck that migration scripts location exists.
flyway.clean-on-validation-error  
flyway.enabledtrueEnable flyway.
flyway.encoding  
flyway.ignore-failed-future-migration  
flyway.init-sqls SQL statements to execute immediate to initialize when a connection obtain.
flyway.locationsclasspath:db/migrationlocations of migrations scripts
flyway.out-of-order  
flyway.password JDBC password In case if you want Flyway create its own DataSource
flyway.placeholder-prefix  
flyway.placeholder-replacement  
flyway.placeholder-suffix  
flyway.placeholders.*  
flyway.schemas schemas to update
flyway.sql-migration-prefixV 
flyway.sql-migration-separator  
flyway.sql-migration-suffix.sql 
flyway.table  
flyway.url JDBC database url to migrate. Incase not set then use the primary configured data source.
flyway.user Login user of the database to migrate.
flyway.validate-on-migrate  



REFERENCES

https://docs.spring.io/spring-boot/docs/1.4.x/reference/html/common-application-properties.html

LIQUIBASE Spring Boot Properties

Posted on by Saurabh Gupta in DB, Flyway, Liquibase, Spring Boot, Spring Data JPA

LIQUIBASE is a provider of Spring Boot Data for handling database schemas operations. LIQUIBASE is an Open Source tool which keep track of database schema script revisions. It can handle variety of database types and accepts a variety of file formats for defining the database structures.

See Also:

<dependency>
			<groupId>org.liquibase</groupId>
			<artifactId>liquibase-core</artifactId>
</dependency>

After adding LIQUIBASE dependencies in your application it will automatically download and add the required other dependencies in your application and initialize with default values. You can overwrite these values through application.properties / application.yaml .

Liquibase Configuration Properties

Spring Boot load these properties in LiquibaseProperties class.

NameDefault ValueDescription
liquibase.change-logclasspath:/db/ changelog/db.
changelog-master.yaml		Change log configuration path.
liquibase.check-change-log-locationtrueCheck the change log location exists.
liquibase.contexts Comma-separated list of runtime contexts to use.
liquibase.default-schema Default database schema.
liquibase.drop-firstfalseDrop the database schema first.
liquibase.enabledtrueEnable liquibase support.
liquibase.labels Comma-separated list of runtime labels to use.
liquibase.parameters.* Change log parameters.
liquibase.password Login password of the database to migrate.
liquibase.rollback-file File to rollback SQL statements will be written when an update is performed.
liquibase.url JDBC url of the database to migrate. Incase not set then use the primary configured data source.
liquibase.user Login user of the database to migrate.

References

https://docs.spring.io/spring-boot/docs/1.4.x/reference/html/common-application-properties.html

Cassandra Spring Boot Properties

Posted on by Saurabh Gupta in Spring Boot, Spring Data JPA

Apache Cassandra is a provider of Spring Boot Data for handling NoSQL database operations. Apache Cassandra is a NoSQL distributed database for managing large amounts of data across many servers (clusters) while providing high availability at the cost of decreased consistency. Cassandra high availability is achieved by replicating data to multiple nodes over cluster and allow one or more nodes to go down so that transaction will continue till that point even one server is running.

To use Apache Cassandra in your Spring boot application you have to add this Cassandra starter in your pom.xml .

<dependency>
         <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-cassandra</artifactId>
        <version>2.0.0.M7</version>
</dependency>

After adding Cassandra Database starter in your application it will automatically download and add the required dependencies in your application and initialize with default values. You can overwrite these values through application.properties / application.yaml .

Cassandra Configuration Properties

Spring Boot load these properties in CassandraProperties class.

NameDefault ValueDescription
spring.data.cassandra.cluster-name Cassandra cluster Name.
spring.data.cassandra.compression Compression supported by the Cassandra binary protocol.
spring.data.cassandra.connect-timeout-millis Socket option: connection time out.
spring.data.cassandra.consistency-level Queries consistency level.
spring.data.cassandra.contact-pointslocalhostComma-separated cluster node addresses.
spring.data.cassandra.fetch-size Queries default fetch size.
spring.data.cassandra.keyspace-name Keyspace name to use.
spring.data.cassandra.load-balancing-policy Class name of the load balancing policy.
spring.data.cassandra.port Port of the Cassandra server.
spring.data.cassandra.password Login password of the server.
spring.data.cassandra.read-timeout-millis Socket option: read time out.
spring.data.cassandra.reconnection-policy Reconnection policy class.
spring.data.cassandra.repositories.enabled Enable Cassandra repositories.
spring.data.cassandra.retry-policy Class name of the retry policy.
spring.data.cassandra.serial-consistency-level Queries serial consistency level.
spring.data.cassandra.schema-actionnoneSchema action to take at startup.
spring.data.cassandra.sslfalseEnable SSL support.
spring.data.cassandra.username Login user of the server.

References

https://docs.spring.io/spring-boot/docs/1.4.x/reference/html/common-application-properties.html

Spring Boot JPA/Data Properties

Posted on by Saurabh Gupta in Spring Data JPA

Spring Boot JPA/Data properties that can be configured with any Spring Boot Application where need to access database. These properties are already configured in Spring Boot with the given default value.

Note: In your application, You don’t need to add all these values in your application.proprties / application.yaml file. You just need to add only those values which you want to change/override.

See Also:

You can follow specific Spring Boot Configuration properties link for based on your data source.

  • Database/Data Source Configuration Properties
  • JPA Configuration Properties
  • JTA Configuration Properties

DAO Configuration Properties

Spring Boot load these properties in PersistenceExceptionTranslationAutoConfiguration class.

NameDefault ValueDescription
spring.dao.exceptiontranslation.enabledtrueEnable the PersistenceExceptionTranslationPostProcessor.

DataSource Configuration Properties

Spring Boot load these properties in DataSourceAutoConfiguration & DataSourceProperties class.

NameDefault ValueDescription
spring.datasource.continue-on-errorfalseDo not stop if an error occurs while initializing the database.
spring.datasource.data Data (DML) script resource reference.
spring.datasource.data-username database usename to execute DML scripts (if different).
spring.datasource.data-password database password to execute DML scripts (if different).
spring.datasource.dbcp.* Commons DBCP specific settings
spring.datasource.dbcp2.* Commons DBCP2 specific settings
spring.datasource.driver-class-name Fully qualified JDBC driver name. if not set detect from URL by default.
spring.datasource.generate-unique-namefalseGenerate a random datasource name.
spring.datasource.hikari.* Hikari specific settings
spring.datasource.initializetrueallow to execute query using ‘data.sql’.
spring.datasource.jmx-enabledfalseEnable JMX support (if underlying pool provided).
spring.datasource.jndi-name JNDI location of the datasource other set fields( Class, url, username & password) are ignored when set.
spring.datasource.nametestdbdatasource name.
spring.datasource.password database login password.
spring.datasource.platformallPlatform to use in the schema resource (schema-${platform}.sql).
spring.datasource.schema Schema (DDL) script resource reference.
spring.datasource.schema-username database user to execute DDL scripts (if different).
spring.datasource.schema-password database password to execute DDL scripts (if different).
spring.datasource.separator;Statement separator in SQL initialization scripts.
spring.datasource.sql-script-encoding SQL scripts encoding.
spring.datasource.tomcat.* Tomcat datasource specific settings
spring.datasource.type connection pool fully qualified name implementation to use. if not set by default detected from the classpath.
spring.datasource.url JDBC database url.
spring.datasource.username database user.
spring.datasource.xa.data-source-class-name fully qualified name of XA data source.
spring.datasource.xa.properties Properties to pass to the XA data source.

JPA Configuration Properties

Spring Boot load these properties in JpaBaseConfiguration and HibernateJpaAutoConfiguration class.

NameDefault ValueDescription
spring.data.jpa.repositories.enabledtrueEnable JPA repositories.
spring.jpa.database Target database to operate on. It detected by default or alternatively set using the “databasePlatform” property.
spring.jpa.database-platform Name of the target database to operate on. It detected by default or alternatively set using the “Database” enum.
spring.jpa.generate-ddlfalseInitialize the schema on startup.
spring.jpa.hibernate.ddl-auto DDL mode for the “hibernate.hbm2ddl.auto” property. Default value is “create-drop” when using an embedded database otherwise “none”.
spring.jpa.hibernate.naming.implicit-strategy Hibernate 5 implicit fully qualified naming strategy name .
spring.jpa.hibernate.naming.physical-strategy Hibernate 5 physical fully qualified naming strategy name .
spring.jpa.hibernate.naming.strategy Hibernate 4 fully qualified naming strategy name. Not supported with Hibernate 5.
spring.jpa.hibernate.use-new-id-generator-mappings Use Hibernate’s IdentifierGenerator for AUTO, TABLE and SEQUENCE.
spring.jpa.open-in-viewtrueRegister OpenEntityManagerInViewInterceptor. Binds a JPA EntityManager to the thread for request entire processing.
spring.jpa.properties.* Additional native properties set on JPA provider.
spring.jpa.show-sqlfalseEnable SQL statements logging.

JTA Configuration Properties

Spring Boot load these properties in JtaAutoConfiguration class.

NameDefault ValueDescription
spring.jta.enabledtrueEnable JTA support.
spring.jta.log-dir Transaction logs directory.
spring.jta.transaction-manager-id Transaction manager unique identifier.

Data REST Configuration Properties

Spring Boot load these properties in RepositoryRestProperties class.

NameDefault ValueDescription
spring.data.rest.base-path Base path for Spring Data REST to repository resources.
spring.data.rest.default-page-size Default page size.
spring.data.rest.enable-enum-translation Enable enum value translation through Spring Data REST by default resource bundle.
spring.data.rest.limit-param-name URL query parameter name that decide how many results return at once.
spring.data.rest.max-page-size Maximum size of pages.
spring.data.rest.page-param-name URL query string parameter to indicates what page to return.
spring.data.rest.return-body-on-create Return a response body after creating an entity.
spring.data.rest.return-body-on-update Return a response body after updating an entity.
spring.data.rest.sort-param-name URL query string parameter to indicates what direction to sort results.

H2 Web Console Configuration Properties

Spring Boot load these properties in H2ConsoleProperties class.

NameDefault ValueDescription
spring.h2.console.enabledfalseEnable the console.
spring.h2.console.path/h2-consolePath at which the console will be available.
spring.h2.console.settings.tracefalseEnable trace output.
spring.h2.console.settings.web-allow-othersfalseEnable remote access.

Data Redis Configuration Properties

Spring Boot load these properties in SecurityProperties class.

NameDefault ValueDescription
spring.data.redis.repositories.enabledtrueEnable Redis repositories.

Redis Configuration Properties

Spring Boot load these properties in RedisProperties class.

NameDefault ValueDescription
spring.redis.cluster.max-redirects Maximum number of redirects to follow when executing commands across the cluster.
spring.redis.cluster.nodes Comma-separated list of “host:port” pairs to bootstrap from.
spring.redis.database0Database index used by the connection factory.
spring.redis.hostlocalhostRedis server host.
spring.redis.password Login password of the redis server.
spring.redis.pool.max-active8Max number of connections that can be allocated by the pool at a given time. Use a negative value for no limit.
spring.redis.pool.max-idle8Max number of “idle” connections in the pool. Use a negative value to indicate an unlimited number of idle connections.
spring.redis.pool.max-wait-1Maximum time a connection allocation to block before throwing an exception in case of pool is exhausted. Use -1 to block indefinitely.
spring.redis.pool.min-idle0Minimum number of idle connections in pool. This works only when set as positive.
spring.redis.port6379Redis server port.
spring.redis.sentinel.master Name of Redis server.
spring.redis.sentinel.nodes Comma-separated host:port pairs.
spring.redis.timeout0Connection timeout (milliseconds).

References

https://docs.spring.io/spring-boot/docs/1.4.x/reference/html/common-application-properties.html

Couchbase Spring Boot Properties

Posted on by Saurabh Gupta in Spring Boot, Spring Data JPA

Couchbase is a provider of Spring Boot for handling NoSQL database operations through JSON. Couchbase is NoSQL document oriented distributed database over the cloud or on- premises which perform transactions by JSON and provide unmatched versatility, performance and scalability. To use Couchbase in your Spring boot application you have to add this Couchbase starter in your pom.xml .

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-couchbase</artifactId>
    <version>2.6.3</version>
</dependency>

After adding Couchbase Database starter in your application it will automatically download and add the required dependencies in your application and initialize with default values. You can overwrite these values through application.properties / application.yaml .

Data Couchbase Configuration Properties

Spring Boot load these properties in CouchbaseDataProperties class.

NameDefault ValueDescription
spring.data.couchbase.auto-indexfalsecreate views and indexes automatically.
spring.data.couchbase.consistencyread-your-own-writesBy default Consistency to apply on generated queries.
spring.data.couchbase.repositories.enabledtrueEnable Couchbase repositories.
Data Couch Spring Boot properties

Couchbase Configuration Properties

Spring Boot load these properties in CouchbaseProperties class.

NameDefault ValueDescription
spring.couchbase.bootstrap-hosts Couchbase nodes host/IP address to bootstrap from.
spring.couchbase.bucket.namedefaultbucket name connect to.
spring.couchbase.bucket.password bucket password.
spring.couchbase.env.endpoints.key-value1Number of sockets per node for each Key/value service.
spring.couchbase.env.endpoints.query1Number of sockets per node for each Query (N1QL) service.
spring.couchbase.env.endpoints.view1Number of sockets per node for each view service.
spring.couchbase.env.ssl.enabled Enable SSL support. Enabled automatically if a “keyStore” is provided otherwise specified otherwise.
spring.couchbase.env.ssl.key-store Path to JVM key store which holds the certificates.
spring.couchbase.env.ssl.key-store-password Password used to access the key store.
spring.couchbase.env.timeouts.connect5000Bucket connections timeout. (in milliseconds)
spring.couchbase.env.timeouts.key-value2500Blocking operations performed on a key timeout.( in milliseconds)
spring.couchbase.env.timeouts.query7500N1QL query operations timeout.( in milliseconds)
spring.couchbase.env.timeouts.socket-connect1000Socket connect connections timeout.( in milliseconds).
spring.couchbase.env.timeouts.view7500Regular and geospatial view operations timeout. (in milliseconds).
Couchbase Spring Boot Properties

References

https://docs.spring.io/spring-boot/docs/1.4.x/reference/html/common-application-properties.html

SOLR Spring Boot properties

Posted on by Saurabh Gupta in Spring Boot, Spring Data JPA

Apache SOLR is a provider of Spring Boot for handling search and indexing of data operations on SOLR content for web. SOLR is a Full Text search engine for content management and also provide REST based SOLR APIs for operations. To use SOLR in your Spring boot application you have to add this SOLR starter in your pom.xml .

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-solr</artifactId>
    <version>2.4.12</version>
</dependency>

After adding SOLR starter in your application it will automatically download and add the required dependencies in your application and initialize with default values. You can overwrite these values through application.properties / application.yaml .

SOLR Configuration Properties

Spring Boot load these properties in SolrProperties class.

NameDefault ValueDescription
spring.data.solr.hosthttp://127.0.0.1:8983/solrSolr host. Ignored if “zk-host” is set.
spring.data.solr.repositories.enabledtrueEnable Solr repositories.
spring.data.solr.zk-host ZooKeeper host address i.e HOST:PORT.

References

https://docs.spring.io/spring-boot/docs/1.4.x/reference/html/common-application-properties.html

ElasticSearch Spring Boot Properties

Posted on by Saurabh Gupta in Spring Boot, Spring Data JPA

Elasticsearch is a provider of Spring Boot for handling search and CRUD operations in Elastic Search. Elasticsearch is a Full Text search engine and also provide REST based Elasticsearch APIs for operations. To use Elastic Search in your Spring boot application you have to add this Elasticsearch starter in your pom.xml .

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

After adding Elasticsearch starter in your application it will automatically download and add the required dependencies in your application and initialize with default values. You can overwrite these values through application.properties / application.yaml .

ElasticSearch Configuration Properties

Spring Boot load these properties in ElasticsearchProperties class.

NameDefault ValueDescription
spring.data.elasticsearch.cluster-nameelasticsearchcluster name.
spring.data.elasticsearch.cluster-nodes Comma-separated cluster node addresses. If not specified, starts a client node.
spring.data.elasticsearch.properties.* Additional properties used to configure the client.
spring.data.elasticsearch.repositories.enabledtrueEnable Elasticsearch repositories.
Elastic Search Spring Boot Properties

JEST (Elasticsearch HTTP client) Configuration Properties

Spring Boot load these properties in JestProperties class.

NameDefault ValueDescription
spring.elasticsearch.jest.connection-timeout3000Connection timeout in milliseconds.
spring.elasticsearch.jest.password Login password.
spring.elasticsearch.jest.proxy.host Proxy host the HTTP client to use.
spring.elasticsearch.jest.proxy.port Proxy port the HTTP client to use.
spring.elasticsearch.jest.read-timeout3000Read timeout. (in milliseconds)
spring.elasticsearch.jest.urishttp://localhost:9200Comma-separated Elasticsearch instances to use.
spring.elasticsearch.jest.username Login user.
JEST/Elastic Search Client Spring Boot Properties

References

https://docs.spring.io/spring-boot/docs/1.4.x/reference/html/common-application-properties.html

MongoDB Spring Boot Properties

Posted on by Saurabh Gupta in Spring Boot, Spring Data JPA

MongoDB is a provider of Spring Boot for handling NoSQL database operations. To use MongoDB  in your Spring boot application you have to add this MongoDB starter in your pom.xml .

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>

After adding MongoDB starter in your application it will automatically download and add the required dependencies in your application and initialize with default values. You can overwrite these values through application.properties / application.yaml .

Embedded MongoDB Configuration Properties

Spring Boot load these properties in EmbeddedMongoProperties class.

NameDefault ValueDescription
spring.mongodb.embedded.featuresSYNC_DELAYComma-separated features to enable.
spring.mongodb.embedded.storage.database-dir Directory used for data storage.
spring.mongodb.embedded.storage.oplog-size Maximum size of the oplog in megabytes.
spring.mongodb.embedded.storage.repl-set-name Name of the replica set.
spring.mongodb.embedded.version2.6.10Version of Mongo to use.
MongoDB Embedded Spring Boot Properties

MongoDB Configuration Properties

Spring Boot load these properties in MongoProperties class.

NameDefault ValueDescription
spring.data.mongodb.authentication-database Authentication database name.
spring.data.mongodb.databasetestDatabase name.
spring.data.mongodb.field-naming-strategy USe Fully qualified name of the FieldNamingStrategy.
spring.data.mongodb.grid-fs-database GridFS database name.
spring.data.mongodb.hostlocalhostMongo server host.
spring.data.mongodb.password Login password of the mongo server.
spring.data.mongodb.port27017Mongo server port.
spring.data.mongodb.repositories.enabledtrueEnable Mongo repositories.
spring.data.mongodb.urimongodb://localhost/testMongo database URI.host and port are ignored when setting it.
spring.data.mongodb.username Login user of the mongo server.
MongoDB Spring Boot Properties

References

https://docs.spring.io/spring-boot/docs/1.4.x/reference/html/common-application-properties.html

Neo4J Spring Boot Properties

Posted on by Saurabh Gupta in Spring Boot, Spring Data JPA

Neo4J is a provider of Spring Boot for handling Graphical database.  Neo4J is a graphical datbase where need to represent stored data in graphical relational forms. You can add Neo4J  in your Spring boot application by adding Neo4J starter in your pom.xml (Maven) or build.gradle (Gradle).

Maven

<dependency>
        <groupId>org.neo4j.driver</groupId>
        <artifactId>neo4j-java-driver-spring-boot-starter</artifactId>
        <version>4.3.6.0</version>
</dependency>

Gradle

dependencies {
    compile 'org.neo4j.driver:neo4j-java-driver-spring-boot-starter:4.3.6.0'
}

After adding Neo4J starter in your application it will automatically download and add the required dependencies in your application and initialize with default values. You can overwrite these values through application.properties / application.yaml .

Neo4j Configuration Properties

Spring Boot load these properties in Neo4jProperties class.

NameDefault ValueDescription
spring.data.neo4j.compiler Compiler to use.
spring.data.neo4j.embedded.enabledtrueEnable embedded mode when embedded driver is available.
spring.data.neo4j.password Login password of the server.
spring.data.neo4j.repositories.enabledtrueEnable Neo4j repositories.
spring.data.neo4j.session.scopesingletonScope (lifetime) of the session.
spring.data.neo4j.uri URI used by the driver detected by default.
spring.data.neo4j.username Login user of the server.
NEO4J Spring Boot Properties

References

https://docs.spring.io/spring-boot/docs/1.4.x/reference/html/common-application-properties.html

ATOMIKOS Spring Boot Properties

Posted on by Saurabh Gupta in Spring Boot, Spring Data JPA

ATOMIKOS is a provider of Spring Boot for handling transactions atomicity in global transactions involving heterogeneous components. To use ATOMIKOS transaction manager in your Spring boot application you have to add this ATOMIKOS starter in your pom.xml .

<dependency>
      <groupId>com.atomikos</groupId>
      <artifactId>transactions-spring-boot-starter</artifactId>
   </dependency>

After adding ATOMIKOS starter in your application it will automatically download and add the required dependencies in your application and initialize with default values. You can overwrite these values through application.properties / application.yaml .

Atomikos Configuration Properties

Spring Boot load these properties in AtomikosProperties class.

NameDefault ValueDescription
spring.jta.atomikos.connectionfactory.borrow-connection-timeout30Timeout for borrowing connections from the pool. (in seconds)
spring.jta.atomikos.connectionfactory.ignore-session-transacted-flagtrueSet to ignore the transacted flag when creating session.
spring.jta.atomikos.connectionfactory.local-transaction-modefalseSet local transactions are desired.
spring.jta.atomikos.connectionfactory.maintenance-interval60The time between runs of the pool’s maintenance thread. (in seconds).
spring.jta.atomikos.connectionfactory.max-idle-time60The time after which connections are cleaned up from the pool. (in seconds)
spring.jta.atomikos.connectionfactory.max-lifetime0The time that a connection can be pooled for before being destroyed. 0 denotes no limit.(in seconds)
spring.jta.atomikos.connectionfactory.max-pool-size1The maximum pool size.
spring.jta.atomikos.connectionfactory.min-pool-size1The minimum pool size.
spring.jta.atomikos.connectionfactory.reap-timeout0The reap timeout for borrowed connections. 0 denotes no limit.( in seconds)
spring.jta.atomikos.connectionfactory.unique-resource-namejmsConnectionFactoryThe unique name used to identify the resource during recovery.
spring.jta.atomikos.datasource.borrow-connection-timeout30Timeout for borrowing connections from the pool. (in seconds)
spring.jta.atomikos.datasource.default-isolation-level Default isolation level of connections provided by the pool.
spring.jta.atomikos.datasource.login-timeout Timeout for establishing a database connection.(in seconds)
spring.jta.atomikos.datasource.maintenance-interval60The time between runs of the pool’s maintenance thread.(in seconds)
spring.jta.atomikos.datasource.max-idle-time60The time after which connections are cleaned up from the pool.(in seconds)
spring.jta.atomikos.datasource.max-lifetime0The time that a connection can be pooled for before being destroyed. 0 denotes no limit.(in seconds)
spring.jta.atomikos.datasource.max-pool-size1The maximum pool size.
spring.jta.atomikos.datasource.min-pool-size1The minimum pool size.
spring.jta.atomikos.datasource.reap-timeout0The reap timeout for borrowed connections. 0 denotes no limit.(in seconds)
spring.jta.atomikos.datasource.test-query SQL query or statement used to validate a connection before returning it.
spring.jta.atomikos.datasource.unique-resource-namedataSourceThe unique name used to identify the resource during recovery.
spring.jta.atomikos.properties.checkpoint-interval500Interval between checkpoints.
spring.jta.atomikos.properties.default-jta-timeout10000Default timeout for JTA transactions.
spring.jta.atomikos.properties.enable-loggingtrueEnable disk logging.
spring.jta.atomikos.properties.force-shutdown-on-vm-exitfalseSpecify if a VM shutdown should trigger forced shutdown of the transaction core.
spring.jta.atomikos.properties.log-base-dir Directory in which the log files should be stored.
spring.jta.atomikos.properties.log-base-nametmlogTransactions log file base name.
spring.jta.atomikos.properties.max-actives50Maximum active transactions.
spring.jta.atomikos.properties.max-timeout300000Maximum timeout that can be allowed for transactions. (in milliseconds)
spring.jta.atomikos.properties.serial-jta-transactionstrueSpecify if sub-transactions should be joined when possible.
spring.jta.atomikos.properties.service Transaction manager implementation that should be started.
spring.jta.atomikos.properties.threaded-two-phase-committrueUse different (and concurrent) threads for two-phase commit on the resources.
spring.jta.atomikos.properties.transaction-manager-unique-name Transaction manager’s unique name.
ATOMIKOS Spring Boot Properties

References

https://docs.spring.io/spring-boot/docs/1.4.x/reference/html/common-application-properties.html