JOOQ e primavera

Question

Qualcuno ha provato utilizzando JOOQ con il framework Spring o sto rompendo un nuovo terreno?

http://www.jooq.org

Answer 1

Sì, molte persone hanno (ormai). E il manuale jOOQ include un tutorial su come iniziare a utilizzare jOOQ , primavera, primavera-TX e BoneCP :

• http: // www. jooq.org/doc/latest/manual/getting-started/tutorials/jooq-with-spring/

C'è anche un ottimo tutorial da Petri Kainulainen, spiegando ogni passo per realizzare un progetto, qui:

• Utilizzando jOOQ con la Primavera: Configurazione
• Utilizzando jOOQ con la Primavera: Generazione codice
• Utilizzando jOOQ con la Primavera: CRUD
• Utilizzando jOOQ con la Primavera: Ordinamento e Impaginazione

Ecco un post sul blog su come utilizzare jOOQ con la Primavera di avvio, particolarmente utile quando è necessario le distribuzioni commerciali di jOOQ:

• https://blog.jooq.org/2019/06/26/how-to-use-jooqs-commercial-distributions-with-spring-boot/

Answer 2

che stavo cercando di usare jOOQ come una libreria costruttore per fornire le query al JdbcTemplate di primavera e classi correlate. Purtroppo, jOOQ sembra unire due concetti nello stesso insieme di classi: generazione SQL ed esecuzione di query. Nel mio caso, voglio che l'ex, ma voglio lasciare Primavera gestire quest'ultimo. E funziona, però. Ad esempio, è possibile fare qualcosa di simile (usando jOOQ 2.x API):

Factory create = new Factory(null, SQLDialect.ORACLE);
getJdbcTemplate().query(
    create.select(create.field(ID_COL),
                  create.field(VALUE_COL))
        .from(FOO_TABLE)
        .where(create.field(ID_COL).equals("ignored"))
        .getSQL(),
    myRowMapper,
    id);

Answer 3

Tutto quello che devi fare / sapere per rendere il lavoro jOOQ con molla:

1. Prendi il java.sql.Connection legato al filo da parte del gestore delle transazioni.
2. transazioni gestire correttamente attraverso la traduzione eccezione
3. capire che il jOOQ Fabbrica oggetti (nonostante il nome) non sono threadsafe. e quindi richiederà un'istanza di un nuovo oggetto per l'uso (non facciamo quest'altro risposta ).

Quindi, per il primo e secondo caso offro questo succo: https://gist.github.com/3669307 che fa quello Lukas consiglia .

Per il terzo caso è possibile creare praticamente una fabbrica di una fabbrica (che contiene il DataSource) o solo un'istanza di un nuovo oggetto Factory in ogni metodo che utilizza il DataSource cablata nel componente primavera.

@Service
public class MyDaoOrService {
    @Autowired
    private void DataSource dataSource;

    @Transactional
    public void doSomeJooq(){
        Settings s = new Settings();
        //You could instead put this jooq configuration xml
         s.getExecuteListeners().add("com.snaphop.jooq.SpringExceptionTranslationExecuteListener");
        MyGeneratedFactory f = new MyGeneratedFactory(dataSource, s);
        f.select(); //etc
    }
}

Per quanto riguarda le impostazioni ascoltatore è possibile supporto per la configurazione di JOOQ evitare la creazione programmatica.

Io non coprirà come si imposta un DataSource in primavera come che è coperto in miriade di altri luoghi / migliori.

Answer 4

Per le operazioni primaverili in esecuzione con jOOQ è molto più semplice (a meno che non ho dimenticato qualcosa):

Basta avvolgere l'origine dati in

org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy

opzionale : per ritardare l'apertura della connessione jdbc fino alla prima istruzione SQL effettiva accade uso

org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy

così come un campione di fare questo per creare una fabbrica jOOQ con 'operazioni' e 'pigrizia' applicato

DataSource rawDS = /* your actual data source */
// (optional) make access lazy
final DataSource lazyDS = new LazyConnectionDataSourceProxy(rawDataSource);
// make spring transactions available in plain jdbc context
final DataSource txDS = new TransactionAwareDataSourceProxy(lazyDS);
// create jOOQ factory
Factory jooq = new Factory(txDS, /* dialect */, /* settings */)
// voila!

Answer 5

Spero che questo sarà utile per qualcuno ....

configurazione contesto di applicazione di primavera.

 <bean id="propertyConfigurer" 
      class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="systemPropertiesModeName">
            <value>SYSTEM_PROPERTIES_MODE_OVERRIDE</value>
        </property>
        <property name="searchSystemEnvironment">
            <value type="boolean">true</value>
        </property>
    </bean>



    <bean id="dataSource" 
        class="org.springframework.jdbc.datasource.DriverManagerDataSource" >
        <property name="driverClassName" value="org.h2.Driver"/>
        <property name="url" 
        value="jdbc:h2://${user.home}
        ${file.separator}tracciabilitaCanarini${file.separator}db${file.separator}basedb"/>
        <property name="username" value="sa"/>
        <property name="password" value="sa"/>
    </bean>

    <bean id="datasourceConnection" 
     class="org.springframework.beans.factory.config.MethodInvokingFactoryBean" 
      lazy-init="true" depends-on="dataSource">
        <property name="targetObject">
            <ref bean="dataSource"/>
        </property>
        <property name="targetMethod">
            <value>getConnection</value>
        </property>
    </bean>

    <bean id="publicFactory" class="dbLayer.db.PublicFactory" lazy-init="true"
      depends-on="datasourceConnection" >
        <constructor-arg index="0" ref="datasourceConnection"  />
    </bean>

Sarà automaticamente riempire la fabbrica di pubblico con il dato di collegamento (e sì, può essere una connessione in pool, con l'auto vicino ecc, vedere Classe DriverManagerDataSource per la configurazione più dettagliata). E ora, la publicFactory. Nota:. Alcuna necessità di modificare la fabbrica pubblica originale generato da jOOQ

/**
 * This class is generated by jOOQ
 */
package dbLayer.db;

/**
 * This class is generated by jOOQ.
 */
@javax.annotation.Generated(value    = {"http://www.jooq.org", "2.0.5"},
                            comments = "This class is generated by jOOQ")
public class PublicFactory extends org.jooq.util.h2.H2Factory {

    private static final long serialVersionUID = -1930298411;

    /**
     * Create a factory with a connection
     *
     * @param connection The connection to use with objects created from this factory
     */
    public PublicFactory(java.sql.Connection connection) {
        super(connection);
    }

    /**
     * Create a factory with a connection and some settings
     *
     * @param connection The connection to use with objects created from this factory
     * @param settings The settings to apply to objects created from this factory
     */
    public PublicFactory(java.sql.Connection connection, org.jooq.conf.Settings settings) {
        super(connection, settings);
    }
}

Alla fine, è sufficiente chiamare la fabbrica.

 PublicFactory vs = (PublicFactory) SpringLoader.getBean("publicFactory");
    SimpleSelectQuery<VersionRecord> sq = vs.selectQuery(dbLayer.db.tables.Version.VERSION);
    VersionRecord v = null;
                try {
                    v = sq.fetchAny();
                } catch (Exception e) {
                    log.warn("Seems that version table does not exists!", e);
                }

Fatto!

Answer 6

Supponendo che si sta utilizzando primavera per costruire una webapp, probabilmente avrete bisogno di fare qualcosa di simile:

try {
  Connection conn = dataSource.getConnection();
  try {
    // Do something with JOOQ
    // No need to use a JdbcTemplate!
  }
  finally {
    if (conn != null) {
      conn.close();
    }
  }
} catch (SQLException e) {
  // your error handling
}

Probabilmente si vuole essere sempre un DataSource tramite iniezione di dipendenza di primavera, perché il vostro web container, Tomcat o whathaveyou, sta fornendo il DataSource e facendo il pool di connessioni. In uno dei vostri file di configurazione di primavera si dovrebbe avere qualcosa di simile

<jee:jndi-lookup id="dataSource" jndi-name="java:comp/env/jdbc/datasource"/>

L'oggetto che il codice di cui sopra è in (o qualche oggetto che fornisce questo codice con l'origine dati) potrebbe avere configurazione in un file primavera istanziare con l'origine dati, come

<bean id="fooService" class="com.fubar.FooServiceImpl">
  <constructor-arg ref="dataSource" type="javax.sql.DataSource" />
</bean>

La parte della stringa "jdbc / DataSource" corrisponderebbe ad un nome di risorsa configurata nel contenitore web. Questo varia, ma per Tomcat potrebbe essere un file di contesto in conf / Catalina / localhost sotto Tomcat casa, per esempio,

<?xml version="1.0" encoding="UTF-8"?>
<Context debug="10" reloadable="true" useNaming="true" antiJARLocking="true">
    <Resource name="jdbc/datasource" auth="Container" type="javax.sql.DataSource"
        maxActive="100" maxIdle="30" maxWait="10000" validationQuery="SELECT 1"
        username="foo" password="fubar" driverClassName="org.postgresql.Driver" 
        url="jdbc:postgresql://localhost/foobase"/>         
</Context>

Answer 7

Per la configurazione di Java (che è l'impostazione predefinita per la primavera di avvio) è possibile utilizzare il seguente codice:

/* JOOQ Configuration */
@Bean
public DataSourceConnectionProvider dataSourceConnectionProvider() {
    return new DataSourceConnectionProvider(dataSource());
}

@Bean
public DefaultConfiguration defaultConfiguration() {
    DefaultConfiguration defaultConfiguration = new DefaultConfiguration();
    defaultConfiguration.setConnectionProvider(dataSourceConnectionProvider());
    defaultConfiguration.setSQLDialect(SQLDialect.POSTGRES);
    return defaultConfiguration;
}

@Bean
public DSLContext dslContext() {
    return new DefaultDSLContext(defaultConfiguration());
}

Answer 8

Il modo più semplice, (ho trovato) per utilizzare le transazioni di primavera con jOOQ, qui è dato: http://blog.liftoffllc.in/2014/06/jooq-and-transactions.html

Date un'occhiata a questa risposta per una migliore spiegazione: https://stackoverflow.com/a/24380508/542108