JOOQ et printemps

https://stackoverflow.com/questions/4474365

11-10-2019
|

Question

Quelqu'un at-il essayé d'utiliser JOOQ avec le framework Spring ou suis-je repousse les limites?

http://www.jooq.org

La solution

Oui, beaucoup de gens ont (maintenant). Et le manuel jOOQ comprend un tutoriel sur la façon de commencer à utiliser jOOQ , Printemps, printemps-TX et BoneCP :

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

Il y a aussi un très bon tutoriel par Petri Kainulainen, ce qui explique toutes les étapes à mettre en place un projet, ici:

Voici un blog sur la façon d'utiliser jOOQ avec Spring Boot, particulièrement utile lorsque vous avez besoin des distributions commerciales de jOOQ:

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

Autres conseils

Je cherchais à utiliser jOOQ comme une bibliothèque de constructeur pour fournir des requêtes à JdbcTemplate de printemps et les classes connexes. Malheureusement, jOOQ semble combiner deux concepts dans le même ensemble de classes: génération SQL et exécution de la requête. Dans mon cas, je veux l'ancien mais qui veulent laisser printemps gérer ce dernier. Il fonctionne, cependant. Par exemple, vous pouvez faire quelque chose comme ça (en utilisant jOOQ API 2.x):

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);

Tout ce que vous devez faire / savoir pour faire le travail jOOQ avec ressort:

Obtenez le java.sql.Connection lié au fil par le gestionnaire de transactions.
transactions Traiter de façon appropriée par la traduction d'exception
Il faut comprendre que la jOOQ L'usine objets (malgré le nom) ne sont pas threadsafe. et donc, il faudra instancier un nouvel objet par utilisation (Ne pas faire cette autre réponse ).

Pour la première et la deuxième cas, je vous offre ce point essentiel: https://gist.github.com/3669307 qui fait ce Lukas recommande .

Pour le troisième cas, vous pouvez soit créer essentiellement une usine d'une usine (qui contient le DataSource) ou tout simplement instancier un nouvel objet Factory dans chaque méthode utilisant le DataSource câblé dans votre composant ressort.

@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
    }
}

En ce qui concerne les paramètres d'écoute, vous pouvez le support de configuration de JOOQ pour éviter la création de programmes.

Je ne vais pas couvrir comment vous installer un DataSource au printemps comme cela est couvert dans myriade d'autres / meilleurs endroits.

obtenir des opérations printanières en cours d'exécution avec jOOQ est beaucoup plus simple (à moins que j'oublié quelque chose):

juste envelopper votre source de données dans

org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy

option : pour retarder l'ouverture d'une connexion jdbc jusqu'à la première instruction SQL réelle arrive utilisation

org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy

comme un échantillon faire pour créer une usine jOOQ avec les « opérations » et « lazyness » appliquée

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!

Je espère que cela sera utile pour quelqu'un ....

Configuration du contexte d'application Spring.

 <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>

Il sera automatiquement remplir l'usine publique avec la connexion donnée (et oui, il peut être une connexion mis en commun, avec auto à proximité, etc., voir la classe DriverManagerDataSource pour une configuration plus détaillée). Et maintenant, le publicFactory. Note:. Pas besoin de modifier l'usine d'origine publique générée par 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);
    }
}

A la fin, il suffit d'appeler l'usine.

 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);
                }

Fait!

En supposant que vous utilisez Spring pour construire une webapp, vous voulez sans doute faire quelque chose comme ceci:

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
}

Vous voulez probablement être obtenir une source de données via l'injection de dépendance de printemps, parce que votre conteneur Web, Tomcat ou whathaveyou, fournit le DataSource et faire la mise en commun de connexion. Dans l'un de vos fichiers de configuration de printemps, vous auriez quelque chose comme

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

Le but que le code ci-dessus est (ou un objet qui fournit le code avec la source de données) peut avoir la configuration dans un fichier de source qui lui instancier avec la source de données, comme

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

Le passage de la chaîne « jdbc / source de données » correspondrait à un nom de ressource configuré dans le conteneur Web. Cela varie, mais pour Tomcat, il pourrait être un fichier de contexte dans le fichier conf / Catalina / localhost sous la maison Tomcat, par exemple,

<?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>

Pour la configuration Java (qui est par défaut pour le printemps Boot) vous pouvez utiliser le code suivant:

/* 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());
}

manière la plus simple, (je l'ai trouvé) d'utiliser des transactions avec Spring jOOQ, est donnée ici: http://blog.liftoffllc.in/2014/06/jooq-and-transactions.html

Jetez un oeil à cette réponse pour une meilleure explication: https://stackoverflow.com/a/24380508/542108

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow