JOOQ 和 Spring

Question

有沒有人嘗試過將 JOOQ 與 Spring 框架一起使用，或者我是否正在開辟新天地？

http://www.jooq.org

Answer 1

很多人都在使用 jOOQ 和 Spring 或 Spring Boot

• https://www.baeldung.com/jooq-with-spring
• https://www.baeldung.com/spring-boot-support-for-jooq

Petri Kainulainen 也有一個非常好的教程，解釋了設置項目的每一步，這里：

• 將 jOOQ 與 Spring 一起使用：配置
• 在 Spring 中使用 jOOQ：代碼生成
• 將 jOOQ 與 Spring 一起使用：CRUD
• 在 Spring 中使用 jOOQ：排序和分頁

這是一篇關於如何在 Spring Boot 中使用 jOOQ 的博客文章，當您需要 jOOQ 的商業發行版時特別有用：

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

Answer 2

我希望將 jOOQ 用作構建器庫，以提供對 Spring 的 JdbcTemplate 和相關類的查詢。 不幸的是，jOOQ 似乎將兩個概念結合到同一組類中：SQL 生成和查詢執行。 就我而言，我想要前者，但想讓 Spring 處理后者。 不過，它確實有效。 例如，您可以執行以下操作（使用 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

使用 jOOQ 運行 spring 事務要簡單得多（除非我忘記了什么）：

只需將您的數據源包裝到

org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy

可選：延遲打開 jdbc 連接，直到第一個實際的 sql 語句發生使用

org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy

所以作為一個示例，這樣做是為了創建一個應用了“事務”和“懶惰”的 jOOQ 工廠

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 4

為了使 jOOQ 與 spring 一起工作，您需要做/知道的所有事情：

1. 獲取事務管理器綁定到線程的java.sql.Connection 。
2. 通過異常翻譯正確處理事務
3. 了解 jOOQ Factory對象（盡管有名稱）不是線程安全的。 因此每次使用都需要實例化一個新對象（不要這樣做其他答案）。

因此，對於第一種和第二種情況，我提供了這個要點： https ://gist.github.com/3669307 符合Lukas 的建議。

對於第三種情況，您可以基本上創建工廠的工廠（其中包含DataSource ），也可以使用 spring 組件中的有線DataSource在每個方法中實例化一個新的Factory對象。

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

至於設置監聽器，您可以通過 JOOQ 的配置支持來避免編程創建。

我不會介紹如何在 Spring 中設置DataSource ，因為它在無數其他/更好的地方都有介紹。

Answer 5

假設你正在使用 Spring 構建一個 webapp，你可能想要做這樣的事情：

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
}

您可能希望通過 Spring 的依賴注入獲取 DataSource，因為您的 Web 容器 Tomcat 或其他任何東西都在提供 DataSource 並進行連接池。 在你的一個彈簧配置文件中，你會有類似的東西

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

上述代碼所在的對象（或為該代碼提供數據源的某個對象）可以在 spring 文件中配置以使用數據源實例化它，例如

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

字符串“jdbc/datasource”的部分將對應於 Web 容器中配置的資源名稱。 這會有所不同，但對於 Tomcat，它可能是 Tomcat 主頁下 conf/Catalina/localhost 中的上下文文件，例如，

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

希望這對某人有幫助....

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>

它將使用給定的連接自動填充公共工廠（是的，它可以是池連接，自動關閉等，請參閱 DriverManagerDataSource 類以獲得更詳細的配置）。 現在，publicFactory。 注意：不需要修改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);
    }
}

最后，只需致電工廠即可。

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

完畢！

Answer 7

對於 Java 配置（Spring Boot 的默認配置），您可以使用以下代碼：

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

最簡單的方法，（我發現）將 Spring Transactions 與 jOOQ 一起使用，在這里給出： http ://blog.liftoffllc.in/2014/06/jooq-and-transactions.html

看看這個答案以獲得更好的解釋： https ://stackoverflow.com/a/24380508/542108