JOOQ初学-简单的增删改查demo

初步的数据库连接，在这里我用了bonecp连接池来管理

 

package com.jooq.Test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

import org.jooq.DSLContext;
import org.jooq.impl.DSL;

import com.jolbox.bonecp.BoneCP;
import com.jolbox.bonecp.BoneCPConfig;

public class BoneCpPool {
    
    private static BoneCP boneCP = null;
    private static BoneCPConfig boneCPConfig = null;
    
    static{
        try{
            Class.forName("org.postgresql.Driver");
            boneCPConfig = new BoneCPConfig();
            String jdbcUrl = "jdbc:postgresql://127.0.0.1:5432/spd";
            boneCPConfig.setJdbcUrl(jdbcUrl);
            boneCPConfig.setUsername("spd");
            boneCPConfig.setPassword("123456");
            boneCPConfig.setMinConnectionsPerPartition(5);  
            boneCPConfig.setMaxConnectionsPerPartition(10);  
            boneCPConfig.setPartitionCount(1);  
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    // 获取连接池  
    public static BoneCP getBoneCp(){
        try{
            boneCP = new BoneCP(boneCPConfig);  
        }catch(Exception e){
            e.printStackTrace();
        }
        return boneCP;
    }
    
    // 获取连接  
    public static Connection getConnection(BoneCP boneCP){
        if(boneCP!=null){
             try{
                return  boneCP.getConnection();
             }catch(Exception e){
                  return null;
             }
        }else{
            return null;
        }
    }
    
    // 关闭连接池  
    public static void closeBoneCP(BoneCP boneCP){
        boneCP.close();
    }
    
     // 关闭连接  
    public static void closeConnection(Connection con) throws SQLException {  
        con.close();  
    }  
    //获取数据库连接
    public static DSLContext getContext(Connection conDsl) {  
        return DSL.using(conDsl);  
    }  
}

 

 

2.

package com.jooq.Test;

import java.sql.Connection;

import org.jooq.Condition;
import org.jooq.DSLContext;
import org.jooq.Record;
import org.jooq.Result;
import org.jooq.SelectQuery;
import org.jooq.Table;
import org.jooq.UpdateQuery;
import org.jooq.impl.DSL;

import com.jolbox.bonecp.BoneCP;

public class JooqDao {

    private DSLContext dslContext = null;

    // 获取DSLContext对象
    private DSLContext getdslContext() {
        BoneCP boneCP = BoneCpPool.getBoneCp();
        Connection conn = BoneCpPool.getConnection(boneCP);
        dslContext = DSL.using(conn);
        return dslContext;
    }

    // 简单实体查询
    public void select(String add) {
        DSLContext dslContext = getdslContext();
        Table<Record> table = DSL.table("sys_role");
        // 获取查询对象
        SelectQuery<Record> selectQuery = dslContext.selectQuery(table);
        // 查询条件
        Condition eq = DSL.field("r_name").eq(add);
        // 添加查询条件
        selectQuery.addConditions(eq);
        Result<Record> fetch = selectQuery.fetch();
        for (Object aResult : fetch) {
            Record record = (Record) aResult;
            System.out.println(record);
            System.out.println(record.getValue("r_name"));
        }
    }

    // 实体更新
    public void update(String name) {
        DSLContext dslContext = getdslContext();
        Table<Record> table = DSL.table("sys_role");
        // 获取更新对象
        UpdateQuery<Record> updateQuery = dslContext.updateQuery(table);
        // 更新r_name字段的值为财务结算管理1
        updateQuery.addValue(DSL.field("r_name"), "财务结算管理");
        // 根据查询条件
        Condition condition = DSL.field("r_name").eq(name);
        updateQuery.addConditions(condition);
        int excute = updateQuery.execute();
        System.out.println(excute);
        select("财务结算管理");
    }

    // 原生态的sql查询
    public void getVal() {
        DSLContext dslContext = getdslContext();
        Table<Record> table = DSL.table("sys_role");
        Result<Record> fetch = dslContext.select().from(table)
                .where("domain_id=0").and("r_status='1'")
                .orderBy(DSL.field("b_createtime").asc()).fetch();

        for(Object aResult:fetch){
            Record record = (Record) aResult;
            System.out.println(record);
        }
        
         /*Map<String, Object> fetchAnyMap = orderBy.fetchAnyMap(); 
        Set<String> keySet = fetchAnyMap.keySet(); 
        for(String s:keySet) 
        { 
            System.out.println("key--"+s+"--val:"+fetchAnyMap.get(s)); 
        }*/  
    }
    
    //验证DSL.exists方法  
    public void exits(){
        DSLContext getdslContext = getdslContext(); 
         Condition condition = DSL.exists(DSL.select(DSL.field("r_name")));
          Table<Record> table = DSL.table("sys_role");  
         SelectQuery<Record> selectQuery = getdslContext.selectQuery(table);  
            selectQuery.addConditions(condition);  
            Result<Record> fetch = selectQuery.fetch();  
            for (Object aResult : fetch) {  
                Record record = (Record) aResult;  
                System.out.println(record);  
                System.out.println(record.getValue("r_name"));  
            }  
    }

    public static void main(String[] args) {

        JooqDao dao = new JooqDao();
        dao.exits();
    }
}