Как настроить EclipseLink для использования HikariCP в качестве пула подключений

Question

Я использую EclipseLink в качестве поставщика с постоянством для нашего приложения, используя платформу Play и Akka. С play framework 2.3.x приложение работает правильно. Сейчас я мигрируют в 2.4.x и впоследствии будут мигрировать в 2.5.x, но я получаю проблемы при запуске приложения из-за пределов затмения говоря:

„Нет поставщик сохранения для EntityManager с именем по умолчанию“.

С изменением библиотеки пула соединений Play Framework от BoneCP до HikariCP я подумал, что, вероятно, я должен использовать этот пул соединений и с EclipseLink.

Первый вопрос: Является ли пул соединений, предоставляемый Play, использоваться для меня или это не мое дело? На самом деле, я не вижу в этом никакой цели, если я сам его не использую.

Кроме того, я не смог найти какую-либо информацию в Интернете о том, как настроить HikariCP в качестве поставщика пула соединений для EclipseLink. Может ли это быть достигнуто или я должен остаться с собственным пулом соединений и как-то попытаться отключить HikariCP?

Я немного потерял здесь варианты. Любые комментарии по моей проблеме? Скажите мне, что я должен предоставить вам, чтобы помочь мне решить проблемы.

persistence.xml

<?xml version="1.0" encoding="UTF-8" ?> 
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence" 
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
      xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd" 
      version="2.1"> 

    <persistence-unit name="default" transaction-type="RESOURCE_LOCAL"> 
    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider> 
    <!-- If <non-jta-data-source> is specified, the DB settings are read from application.conf (db.*.jndiName and db.default.*) --> 
    <!-- Also, <non-jta-data-source> is working fine with 'activator run' but causing strange exceptions when unloading the WAR in Jetty 9.2.3. --> 
    <non-jta-data-source>DefaultDS</non-jta-data-source> 

    <!-- Eclipse link needs the classes to be properly declared here whereas hibernate (seemingly) does not. 
    Keep up to date by searching for @Entity and adding all the found classes properly and add the converters. --> 
    <class>acm.data.Authorization</class>  
    <class>acm.data.LocalUser</class> 
    <class>acm.data.ResourceAssignedRole</class> 
    <class>acm.data.UserAssignedRole</class> 
    <class>acm.data.UserRole</class> 

    <class>alloc.data.MacroAllocation</class> 
    <class>alloc.data.MicroAllocation</class> 

    <class>clf.data.ClientStore</class> 

    <class>fco.data.Costs</class> 
    <class>fco.data.CostsSet</class> 
    <class>fco.data.CostsType</class> 

    <class>platform.data.DurationConverter</class> 
    <class>platform.data.EnumType</class> 
    <class>platform.data.EnumValue</class> 
    <class>platform.data.Log</class> 
    <class>platform.data.LogSet</class> 
    <class>platform.data.Property</class> 
    <class>platform.data.PropertySet</class> 
    <class>platform.data.IntlStringConverter</class> 
    <class>platform.data.StringLocalDateTimeConverter</class> 
    <class>platform.data.LocalDateConverter</class> 
    <class>platform.data.StringLocalDateConverter</class> 
    <class>platform.data.LocalDateTimeConverter</class> 
    <class>platform.license.License</class> 

    <class>pm.data.Indicator</class> 
    <class>pm.data.IndicatorSet</class> 
    <class>pm.data.Phase</class> 
    <class>pm.data.PhaseDependency</class> 
    <class>pm.data.PhaseRequirement</class> 
    <class>pm.data.Project</class> 
    <class>pm.data.ProjectGuideline</class> 
    <class>pm.data.ProjectMember</class> 
    <class>pm.data.ProjectReport</class> 
    <class>pm.data.Request</class> 
    <class>pm.data.RequestSet</class> 
    <class>pm.data.Risk</class> 
    <class>pm.data.RiskSet</class> 
    <class>pm.data.Role</class> 
    <class>pm.data.Scenario</class> 
    <class>pm.data.StatusAndForecast</class> 
    <class>pm.data.StatusAndForecastSet</class> 

    <class>resource.data.Absence</class> 
    <class>resource.data.Availability</class> 
    <class>resource.data.Holiday</class> 
    <class>resource.data.HolidayLocale</class> 
    <class>resource.data.Resource</class> 
    <class>resource.data.ResourceGroup</class> 
    <class>resource.data.ResourceLink</class> 
    <class>resource.data.ResourceType</class> 
    <class>resource.data.ResourceTypeLink</class> 
    <class>platform.data.EclipseLinkSessionCustomizer</class> 
    <!-- <exclude-unlisted-classes>false</exclude-unlisted-classes>--> <!-- Include all classes --> 
    <properties> 
     <!-- MSSQL --> 
     <!-- 
     <property name="javax.persistence.jdbc.driver"   value="net.sourceforge.jtds.jdbc.Driver"/> 
     <property name="javax.persistence.jdbc.url"    value="jdbc:jtds:sqlserver://SVG6030-DBTE-01/projectx_dev;instance=MSSQL2008R2"/> 
     <property name="javax.persistence.jdbc.user"   value="projectx_dev"/> 
     <property name="javax.persistence.jdbc.password"  value="projectx_pass"/> 
     --> 
     <!-- Configuring Eclipse Link --> 
     <property name="eclipselink.logging.level" value="OFF"/> <!-- How much log should be shown | from: https://wiki.eclipse.org/EclipseLink/Examples/JPA/Logging#Log_Level_Configuration--> 
     <property name="eclipselink.logging.level.sql" value="OFF"/> <!-- How to show the sql queries --> 
     <property name="eclipselink.target-database" value="SQLServer"/> <!-- What sql database is used | from: http://www.eclipse.org/eclipselink/documentation/2.5/jpa/extensions/p_target_database.htm--> 
     <property name="eclipselink.ddl-generation" value="none"/> 
     <property name="eclipselink.session.customizer" value="platform.data.EclipseLinkSessionCustomizer"/> <!-- Defines a naming strategy --> 

     <!-- Connection pooling for productive systems --> <!-- http://www.eclipse.org/eclipselink/documentation/2.5/jpa/extensions/p_connection_pool.htm --> 
     <property name="eclipselink.connection-pool.default.initial" value="50" /> 
     <property name="eclipselink.connection-pool.node2.min" value="5"/> 
     <property name="eclipselink.connection-pool.node2.max" value="100"/> 
     <!-- TODO: Add c3p0 to eclipse link: 
     http://stackoverflow.com/questions/17828377/eclipselink-pooling-equivalent-to-c3po 
     http://www.eclipse.org/forums/index.php/t/172073/ --> 

    </properties> 
    </persistence-unit>  
</persistence> 

application.conf

# This is the main configuration file for the application. 
# https://www.playframework.com/documentation/latest/ConfigFile 
# ~~~~~ 
# Play uses HOCON as its configuration file format. HOCON has a number 
# of advantages over other config formats, but there are two things that 
# can be used when modifying settings. 
# 
# You can include other configuration files in this main application.conf file: 
#include "extra-config.conf" 
# 
# You can declare variables and substitute for them: 
#mykey = ${some.value} 
# 
# And if an environment variable exists when there is no other subsitution, then 
# HOCON will fall back to substituting environment variable: 
#mykey = ${JAVA_HOME} 


## Secret key 
# http://www.playframework.com/documentation/latest/ApplicationSecret 
# ~~~~~ 
# The secret key is used to sign Play's session cookie. 
# This must be changed for production, but we don't recommend you change it in this file. 
play.crypto.secret="xxx" 

## Modules 
# https://www.playframework.com/documentation/latest/Modules 
# ~~~~~ 
# Control which modules are loaded when Play starts. Note that modules are 
# the replacement for "GlobalSettings", which are deprecated in 2.5.x. 
# Please see https://www.playframework.com/documentation/latest/GlobalSettings 
# for more information. 
# 
# You can also extend Play functionality by using one of the publically available 
# Play modules: https://playframework.com/documentation/latest/ModuleDirectory 
play.modules { 
    # By default, Play will load any class called Module that is defined 
    # in the root package (the "app" directory), or you can define them 
    # explicitly below. 
    # If there are any built-in modules that you want to disable, you can list them here. 
    #enabled += my.application.Module 

    # If there are any built-in modules that you want to disable, you can list them here. 
    #disabled += "" 
} 

## IDE 
# https://www.playframework.com/documentation/latest/IDE 
# ~~~~~ 
# Depending on your IDE, you can add a hyperlink for errors that will jump you 
# directly to the code location in the IDE in dev mode. The following line makes 
# use of the IntelliJ IDEA REST interface: 
#play.editor="http://localhost:63342/api/file/?file=%s&line=%s" 

## Internationalisation 
# https://www.playframework.com/documentation/latest/JavaI18N 
# https://www.playframework.com/documentation/latest/ScalaI18N 
# ~~~~~ 
# Play comes with its own i18n settings, which allow the user's preferred language 
# to map through to internal messages, or allow the language to be stored in a cookie. 
play.i18n { 
    # The application languages 
    langs = [ "en" ] 

    # Whether the language cookie should be secure or not 
    #langCookieSecure = true 

    # Whether the HTTP only attribute of the cookie should be set to true 
    #langCookieHttpOnly = true 
} 

## Play HTTP settings 
# ~~~~~ 
play.http { 
    ## Router 
    # https://www.playframework.com/documentation/latest/JavaRouting 
    # https://www.playframework.com/documentation/latest/ScalaRouting 
    # ~~~~~ 
    # Define the Router object to use for this application. 
    # This router will be looked up first when the application is starting up, 
    # so make sure this is the entry point. 
    # Furthermore, it's assumed your route file is named properly. 
    # So for an application router like `my.application.Router`, 
    # you may need to define a router file `conf/my.application.routes`. 
    # Default to Routes in the root package (aka "apps" folder) (and conf/routes) 
    #router = my.application.Router 

    ## Action Creator 
    # https://www.playframework.com/documentation/latest/JavaActionCreator 
    # ~~~~~ 
    #actionCreator = null 

    ## ErrorHandler 
    # https://www.playframework.com/documentation/latest/JavaRouting 
    # https://www.playframework.com/documentation/latest/ScalaRouting 
    # ~~~~~ 
    # If null, will attempt to load a class called ErrorHandler in the root package, 
    #errorHandler = null 

    ## Filters 
    # https://www.playframework.com/documentation/latest/ScalaHttpFilters 
    # https://www.playframework.com/documentation/latest/JavaHttpFilters 
    # ~~~~~ 
    # Filters run code on every request. They can be used to perform 
    # common logic for all your actions, e.g. adding common headers. 
    # Defaults to "Filters" in the root package (aka "apps" folder) 
    # Alternatively you can explicitly register a class here. 
    #filters = my.application.Filters 

    ## Session & Flash 
    # https://www.playframework.com/documentation/latest/JavaSessionFlash 
    # https://www.playframework.com/documentation/latest/ScalaSessionFlash 
    # ~~~~~ 
    session { 
    # Sets the cookie to be sent only over HTTPS. 
    #secure = true 

    # Sets the cookie to be accessed only by the server. 
    #httpOnly = true 

    # Sets the max-age field of the cookie to 5 minutes. 
    # NOTE: this only sets when the browser will discard the cookie. Play will consider any 
    # cookie value with a valid signature to be a valid session forever. To implement a server side session timeout, 
    # you need to put a timestamp in the session and check it at regular intervals to possibly expire it. 
    #maxAge = 300 

    # Sets the domain on the session cookie. 
    #domain = "example.com" 
    } 

    flash { 
    # Sets the cookie to be sent only over HTTPS. 
    #secure = true 

    # Sets the cookie to be accessed only by the server. 
    #httpOnly = true 
    } 

    parser { 
    maxMemoryBuffer = 1048576 
    } 

    requestHandler = "play.http.DefaultHttpRequestHandler" 
} 

## Netty Provider 
# https://www.playframework.com/documentation/latest/SettingsNetty 
# ~~~~~ 
play.server.netty { 
    # Whether the Netty wire should be logged 
    #log.wire = true 

    # If you run Play on Linux, you can use Netty's native socket transport 
    # for higher performance with less garbage. 
    #transport = "native" 
} 

## WS (HTTP Client) 
# https://www.playframework.com/documentation/latest/ScalaWS#Configuring-WS 
# ~~~~~ 
# The HTTP client primarily used for REST APIs. The default client can be 
# configured directly, but you can also create different client instances 
# with customized settings. You must enable this by adding to build.sbt: 
# 
# libraryDependencies += ws // or javaWs if using java 
# 
play.ws { 
    # Sets HTTP requests not to follow 302 requests 
    #followRedirects = false 

    # Sets the maximum number of open HTTP connections for the client. 
    #ahc.maxConnectionsTotal = 50 

    ## WS SSL 
    # https://www.playframework.com/documentation/latest/WsSSL 
    # ~~~~~ 
    ssl { 
    # Configuring HTTPS with Play WS does not require programming. You can 
    # set up both trustManager and keyManager for mutual authentication, and 
    # turn on JSSE debugging in development with a reload. 
    #debug.handshake = true 
    #trustManager = { 
    # stores = [ 
    # { type = "JKS", path = "exampletrust.jks" } 
    # ] 
    #} 
    } 
} 

## Cache 
# https://www.playframework.com/documentation/latest/JavaCache 
# https://www.playframework.com/documentation/latest/ScalaCache 
# ~~~~~ 
# Play comes with an integrated cache API that can reduce the operational 
# overhead of repeated requests. You must enable this by adding to build.sbt: 
# 
# libraryDependencies += cache 
# 
play.cache { 
    # If you want to bind several caches, you can bind the individually 
    #bindCaches = ["db-cache", "user-cache", "session-cache"] 
} 

## Filters 
# https://www.playframework.com/documentation/latest/Filters 
# ~~~~~ 
# There are a number of built-in filters that can be enabled and configured 
# to give Play greater security. You must enable this by adding to build.sbt: 
# 
# libraryDependencies += filters 
# 
play.filters { 
    ## CORS filter configuration 
    # https://www.playframework.com/documentation/latest/CorsFilter 
    # ~~~~~ 
    # CORS is a protocol that allows web applications to make requests from the browser 
    # across different domains. 
    # NOTE: You MUST apply the CORS configuration before the CSRF filter, as CSRF has 
    # dependencies on CORS settings. 
    cors { 
    # Filter paths by a whitelist of path prefixes 
    #pathPrefixes = ["/some/path", ...] 

    # The allowed origins. If null, all origins are allowed. 
    #allowedOrigins = ["http://www.example.com"] 

    # The allowed HTTP methods. If null, all methods are allowed 
    #allowedHttpMethods = ["GET", "POST"] 
    } 

    ## CSRF Filter 
    # https://www.playframework.com/documentation/latest/ScalaCsrf#Applying-a-global-CSRF-filter 
    # https://www.playframework.com/documentation/latest/JavaCsrf#Applying-a-global-CSRF-filter 
    # ~~~~~ 
    # Play supports multiple methods for verifying that a request is not a CSRF request. 
    # The primary mechanism is a CSRF token. This token gets placed either in the query string 
    # or body of every form submitted, and also gets placed in the users session. 
    # Play then verifies that both tokens are present and match. 
    csrf { 
    # Sets the cookie to be sent only over HTTPS 
    #cookie.secure = true 

    # Defaults to CSRFErrorHandler in the root package. 
    #errorHandler = MyCSRFErrorHandler 
    } 

    ## Security headers filter configuration 
    # https://www.playframework.com/documentation/latest/SecurityHeaders 
    # ~~~~~ 
    # Defines security headers that prevent XSS attacks. 
    # If enabled, then all options are set to the below configuration by default: 
    headers { 
    # The X-Frame-Options header. If null, the header is not set. 
    #frameOptions = "DENY" 

    # The X-XSS-Protection header. If null, the header is not set. 
    #xssProtection = "1; mode=block" 

    # The X-Content-Type-Options header. If null, the header is not set. 
    #contentTypeOptions = "nosniff" 

    # The X-Permitted-Cross-Domain-Policies header. If null, the header is not set. 
    #permittedCrossDomainPolicies = "master-only" 

    # The Content-Security-Policy header. If null, the header is not set. 
    #contentSecurityPolicy = "default-src 'self'" 
    } 

    ## Allowed hosts filter configuration 
    # https://www.playframework.com/documentation/latest/AllowedHostsFilter 
    # ~~~~~ 
    # Play provides a filter that lets you configure which hosts can access your application. 
    # This is useful to prevent cache poisoning attacks. 
    hosts { 
    # Allow requests to example.com, its subdomains, and localhost:9000. 
    #allowed = [".example.com", "localhost:9000"] 
    } 
} 

## Evolutions 
# https://www.playframework.com/documentation/latest/Evolutions 
# ~~~~~ 
# Evolutions allows database scripts to be automatically run on startup in dev mode 
# for database migrations. You must enable this by adding to build.sbt: 
# 
# libraryDependencies += evolutions 
# 
play.evolutions { 
    # You can disable evolutions for a specific datasource if necessary 
    #db.default.enabled = false 
} 

## Database Connection Pool 
# https://www.playframework.com/documentation/latest/SettingsJDBC 
# ~~~~~ 
# Play doesn't require a JDBC database to run, but you can easily enable one. 
# 
#libraryDependencies += jdbc 
# 
play.db { 
    # The combination of these two settings results in "db.default" as the 
    # default JDBC pool: 
    config = "db" 
    default = "default" 

    # Play uses HikariCP as the default connection pool. You can override 
    # settings by changing the prototype: 
    prototype { 
    # hikaricp.dataSourceClassName = "default" 
    # specify a connectionTestQuery. Only do this if upgrading the JDBC-Driver does not help 
    hikaricp.connectionTestQuery = "SELECT 1" # a bug in the driver when used with hikaricp in Play 2.4, workaround from here: https://www.playframework.com/documentation/2.5.x/Migration24 
    hikaricp.minimumIdle = 5 
    hikaricp.maximumPoolSize = 100 
    } 
} 

## JDBC Datasource 
# https://www.playframework.com/documentation/latest/JavaDatabase 
# https://www.playframework.com/documentation/latest/ScalaDatabase 
# ~~~~~ 
# Once JDBC datasource is set up, you can work with several different 
# database options: 
# 
# Slick (Scala preferred option): https://www.playframework.com/documentation/latest/PlaySlick 
# JPA (Java preferred option): https://playframework.com/documentation/latest/JavaJPA 
# EBean: https://playframework.com/documentation/latest/JavaEbean 
# Anorm: https://www.playframework.com/documentation/latest/ScalaAnorm 
# 
db { 

    # You can declare as many datasources as you want. 
    # By convention, the default datasource is named `default` 

    # Microsoft SQL Server (using free/open jTDS driver) 
    # The following is working fine with 'activator run' but causing strange exceptions when unloading the WAR in Jetty 9.2.3. 

    default.jndiName=DefaultDS 

    # Microsoft SQL Server (using free/open jTDS driver) 
    # The following is working fine with 'activator run' but causing strange exceptions when unloading the WAR in Jetty 9.2.3. 

    # Huenenberg 
    default.driver=net.sourceforge.jtds.jdbc.Driver 
    default.url="jdbc:jtds:sqlserver://xxx/xxx_dev;instance=MSSQL2008R2" 
    default.username=xxx_dev 
    default.password=xxx_pass 


    # https://www.playframework.com/documentation/latest/Developing-with-the-H2-Database 
    #default.driver = org.h2.Driver 
    #default.url = "jdbc:h2:mem:play" 
    #default.username = sa 
    #default.password = "" 

    # You can turn on SQL logging for any datasource 
    # https://www.playframework.com/documentation/latest/Highlights25#Logging-SQL-statements 
    #default.logSql=true 
} 

# Akka configuration 
# ================== 

akka { 
    # Let Akka use the same logging as Play 
    loggers = ["akka.event.slf4j.Slf4jLogger"] 
    loglevel = "DEBUG" 
    # This will filter the log events using the backend configuration (e.g. logback.xml) before they are published to the event bus. 
    logging-filter = "akka.event.slf4j.Slf4jLoggingFilter" 

    actor { 
    # Timeout for ask(), the max. acceptable value seems to be 30sec anyway. 
    typed.timeout=3600000 

    # Verify that messages are serializable, only for running tests and to ensure remoting is possible. 
    # It is completely pointless to have it turned on in other scenarios. 
    # serialize-messages = on 

    # Increase timeouts for running tests, the max. timeout seems to be 30sec. 
    # test.timefactor=100 

    default-dispatcher { // Akka default config for Play 2.4 http://doc.akka.io/docs/akka/2.4.9/general/configuration.html#listing-of-the-reference-configuration 
     fork-join-executor { 
     parallelism-factor = 3.0 
     parallelism-max = 64 
     task-peeking-mode = FIFO 
     } 
    } 
    } 
} 

# Configuration for sending emails 
smtp { 
    host = "xxxx" 
    port = 25 
    debug = false 
    mock = false 
} 

# Information about this xxx instance 
pqforce { 
    url = "http://localhost:9000/" 
    email = "xxx" 
} 

# Inactive clustering configuration, see clustering.conf for an alternative active configuration. 
projectx { 
    remotes = [ ] 
    accesscontrol.provider  = "acm.business.LocalAccessControlServiceImpl", 
    accesscontrol.timeout  = 300000, 
    accesscontrol.cachesize  = 1000, 
    accesscontrol.sessionexpiry = 1200 
} 

Answer 1

Проблема довольно некорректных к решению. По-видимому, единственное, что имеет значение, это то, что папка conf, содержащая META-INF с persistence.xml, не была в пути к классам, поэтому мне пришлось добавлять ее при запуске приложения из внешнего eclipse.

В моем случае, это означало, что я запустить приложение с:

java -cp .;target/universal/stage/lib/*;target/universal/stage/conf/ 

тогда как последний путь является одним из ведущих в папку META-INF.

Answer 2

Ваш файл persistence.xml должен быть в

основные/ресурсы/META-INF/