JOOQ und Frühling

Question

Hat jemand versucht, mit jOOQ mit dem Spring-Framework oder bin ich Neuland?

http://www.jooq.org

Answer 1

Ja, viele Menschen haben (inzwischen). Und die jOOQ Handbuch enthält eine Anleitung dazu, wie, um loszulegen mit jOOQ , Frühling, Frühling-TX und BoneCP :

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

Es gibt auch ein sehr gutes Tutorial von Petri Kainulainen, jeden Schritt erklären, ein Projekt zu gründen, hier:

• Mit jOOQ mit Spring: Konfiguration
• Mit jOOQ mit Spring: Code Generation
• Mit jOOQ mit Spring: CRUD
• Mit jOOQ mit Spring: Sorting und Paginierung

Hier ist eine Blog-Post über wie jOOQ mit Frühlings-Stiefel verwenden, vor allem dann nützlich, wenn Sie die kommerziellen Distributionen von jOOQ müssen:

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

Answer 2

Ich war auf der Suche jOOQ als Builder-Bibliothek verwenden für Anfragen an Spring JdbcTemplate und verwandte Klassen bieten. Leider scheint jOOQ zwei Konzepte in den gleichen Satz von Klassen zu kombinieren: SQL-Generierung und Ausführung der Abfrage. In meinem Fall möchte ich die ehemalige wollen, aber Frühling behandeln diese lassen. Es funktioniert, though. Zum Beispiel können Sie so etwas wie diese (mit jOOQ 2.x API) tun:

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

Alles, was Sie tun müssen, um / weiß jOOQ Arbeit mit Frühling zu machen:

1. Holen Sie sich das java.sql.Connection auf den Faden durch den Transaktionsmanager gebunden.
2. Handle Transaktionen ordnungsgemäß durch Ausnahme Übersetzung
3. Verstehen Sie, dass die jOOQ Fabrik Objekte (trotz des Namens) sind nicht THREAD. und somit erfordert ein neues Objekt pro Anwendung instanziieren (dies nicht tun andere Antwort ).

Also für den ersten und zweiten Fall biete ich diesen Kern: https://gist.github.com/3669307 , die tut, was Lukas empfiehlt .

Für den dritten Fall können Sie entweder erstellen im Grunde eine Fabrik von einer Fabrik (die die DataSource enthält) oder instantiate gerade ein neues Factory Objekt in jedem Verfahren des verdrahteten DataSource im Frühjahr Komponente.

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

Wie bei den Einstellungen Hörer Sie können jOOQ Konfiguration Unterstützung die programmatische Erstellung zu vermeiden.

Ich werde nicht decken, wie Sie Setup einen DataSource im Frühjahr wie in unzähligen anderen / besseren Plätzen abgedeckt ist.

Answer 4

Frühling Transaktionen immer mit jOOQ läuft, ist viel einfacher (es sei denn, ich etwas vergessen):

nur wickeln Sie Ihre Datenquelle in

org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy

optional : verzögern eine JDBC-Verbindung, bis die ersten SQL-Anweisung Öffnen geschieht Verwendung

org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy

, um eine Probe dies tun, um eine jOOQ Fabrik mit ‚Transaktionen‘ zu schaffen und ‚lazyness‘ Angewandte

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

Hope dies für jemanden nützlich sein ....

Spring-Anwendungskontext Konfiguration.

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

Es wird automatisch füllen die öffentlichen Fabrik mit der angegebenen Verbindung (und ja, kann es sich um eine zusammengefasste Verbindung mit Auto sein nah usw., siehe DriverManagerDataSource Klasse für detailliertere Konfiguration). Und nun die publicFactory. . Hinweis: keine Notwendigkeit, die ursprüngliche öffentliche Fabrik erzeugt durch jOOQ ändern

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

Am Ende, einfach das Werk nennen.

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

Fertig!

Answer 6

Angenommen, Sie Frühling verwenden eine Webapp zu bauen, wollen Sie wahrscheinlich so etwas zu tun:

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
}

Sie wollen wahrscheinlich eine Datasource über Spring Dependency Injection zu bekommen, weil Ihre Web-Container, Tomcat oder whathaveyou wird die Datasource-Bereitstellung und Connection-Pooling zu tun. In einem Ihrer Feder Konfigurationsdateien würden Sie so etwas wie

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

Das Ziel, dass der obige Code ist in (oder ein Objekt, das diesen Code mit der Datenquelle zur Verfügung stellt) Konfiguration in einer Feder-Datei mit der Datenquelle zu instanziiert haben könnte, wie

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

Der Abschnitt der Zeichenfolge „jdbc / Datenquelle“ auf einen Ressourcennamen in dem Web-Container konfiguriert entsprechen würde. Dies ist unterschiedlich, aber für Tomcat, es könnte eine Kontext-Datei in conf / Catalina / localhost unter Tomcat zu Hause, zum Beispiel:

sein

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

Für Java-Konfiguration (die Standardeinstellung für den Frühling-Boot ist) können Sie den folgenden Code verwenden:

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

Der einfachste Weg, (die ich gefunden habe) Frühling Transaktionen mit jOOQ zu verwenden, da hier: http://blog.liftoffllc.in/2014/06/jooq-and-transactions.html

Haben Sie einen Blick auf diese Antwort für eine bessere Erklärung: https://stackoverflow.com/a/24380508/542108