image.png
之前使用的数据库连接池 是 ali 的Druid ，不过springboot 默认是使用Hikari 作为数据库连接池的，听说要比Druid 更优秀一些。
正常我们使用Druid 和spring 的jdbcTemplate 一起操作，不过 JDBCTemplate 好像不是纯面向对象的数据库操作，拼写sql ，总是感觉 弱弱的，也容易出错
还有就是 mybatis ，这个吧，要为每个sql template 都要配置一下，有点冗余啰嗦
这个时候，不得不提 jooq ，超级强大，拿来主义，dao 层不用手写，可以使用插件主动生成相关的orm 映射的代码，现在建议使用 jooq 3.11.5 版本，网上很多是3.9 或3.8，3.11.5版本的已经不兼容低版本了，生成的代码不匹配，
最后研究得出，springboot hikari 和jooq 作为数据库的操作框架是比较合适的
有一点 好像是hikari可以不需要怎么配置就可以直接在springboot中开启的，不过
你需要在application.properties 配置文件里 声明 hikari 的相关配置
首先 创建springboot 的项目 ， 其中MongoDB consul hystrix zipikin sleuth 大家不需要引用
pom 引入相关依赖
4.0.0
com.my
mymodeldb
0.1
jar
muller-modeldb
mysql as database for modeldb
org.springframework.boot
spring-boot-starter-parent
2.1.0.RELEASE
0.10.0
UTF-8
UTF-8
1.8
Greenwich.M1
3.11.5
3.8.2
2.0.1.RELEASE
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-test
test
org.springframework.boot
spring-boot-starter-jooq
org.springframework.boot
spring-boot-starter-data-mongodb
org.springframework.boot
spring-boot-starter-actuator
mysql
mysql-connector-java
5.1.46
org.apache.commons
commons-lang3
3.5
compile
com.typesafe
config
1.3.0
compile
commons-cli
commons-cli
1.3
compile
commons-math
commons-math
1.2
compile
org.apache.thrift
libthrift
${thrift_version}
org.jooq
jooq
${jooq.version}
org.jooq
jooq-meta
${jooq.version}
org.jooq
jooq-codegen
${jooq.version}
org.xerial
sqlite-jdbc
3.15.1
junit
junit
4.12
test
org.mongodb
mongodb-driver
${mongo.version}
org.mongodb
mongodb-driver-core
${mongo.version}
org.mongodb
bson
${mongo.version}
org.slf4j
slf4j-simple
1.7.24
joda-time
joda-time
2.10.1
org.springframework.cloud
spring-cloud-starter-consul-discovery
${spring.cloud.starter.version}
org.springframework.cloud
spring-cloud-starter-netflix-hystrix
${spring.cloud.starter.version}
org.springframework.cloud
spring-cloud-starter-netflix-hystrix-dashboard
${spring.cloud.starter.version}
org.springframework.cloud
spring-cloud-starter-sleuth
${spring.cloud.starter.version}
org.springframework.cloud
spring-cloud-starter-zipkin
${spring.cloud.starter.version}
org.springframework.cloud
spring-cloud-dependencies
${spring-cloud.version}
pom
import
org.springframework.boot
spring-boot-maven-plugin
spring-milestones
Spring Milestones
https://repo.spring.io/milestone
false
DBGen
org.jooq
jooq-codegen-maven
3.11.5
generate
mysql
mysql-connector-java
5.1.46
com.mysql.jdbc.Driver
jdbc:mysql://cdhcode:3306/modeldb_test
muller
7104
org.jooq.util.mysql.MySQLDatabase
.*
modeldb_test
jooq.mysql.gen
target/generated-sources/jooq
true
true
false
然后在 application.properties 中配置 hikari 和jooq
spring.jooq.sql-dialect=mysql
#hikari datasource pool
spring.datasource.hikari.jdbc-url=jdbc:mysql://${mysql_host}:3306/modeldb_test?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&useSSL=false&zeroDateTimeBehavior=convertToNull
spring.datasource.hikari.username=muller
spring.datasource.hikari.password=7104
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=60000
spring.datasource.hikari.max-lifetime=1765000
spring.datasource.hikari.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.hikari.allow-pool-suspension=true
spring.datasource.hikari.pool-name=modeldb_ds_pool
#mysql
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/modeldb_test?useUnicode=true&characterEncoding=UTF-8&useSSL=false
spring.datasource.username=muller
spring.datasource.password=7104
然后是 写一个Bean ，来初始化 Hikari 和jooq ，注意 要在springboot的启动配置类
加 扫描包的注解 ，不然可能启动不了，
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.jooq.DSLContext;
import org.jooq.SQLDialect;
import org.jooq.impl.DSL;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import java.sql.Connection;
import java.sql.DriverManager;
@Configuration
@Component
public class MySqlDBConfig {
protected static final Logger logger=LoggerFactory.getLogger(MySqlDBConfig.class);
private DSLContext ctx;
// @Autowired
private HikariDataSource hikariDataSource;
@Value("${spring.datasource.url}")
private String url;
@Value("${spring.datasource.username}")
private String userName;
@Value("${spring.datasource.password}")
private String password;
// @Autowired
// private HikariConfig hikariConfig;
//
// @Bean
// public HikariDataSource getHikariDataSource( ){
//
// this.hikariDataSource=new HikariDataSource(hikariConfig);
// return this.hikariDataSource;
// }
@Bean
@ConfigurationProperties(prefix = "spring.datasource.hikari")
public HikariConfig getConfig( ){
HikariConfig config =new HikariConfig( );
return config;
}
@Bean(name = "primaryDataSource")
@Qualifier("primaryDataSource")
public HikariDataSource dataSource() throws Exception{
// this.hikariDataSource=(HikariDataSource) DataSourceBuilder.create().type(HikariDataSource.class).build();
this.hikariDataSource=new HikariDataSource(getConfig());
logger.info("hikari datasource pool session create succesfully "+hikariDataSource.getConnection().toString());
return this.hikariDataSource;
}
@Bean
public DSLContext dslContext( ) throws Exception{
// this.hikariDataSource=(HikariDataSource) DataSourceBuilder.create().type(HikariDataSource.class).build();
// logger.info("hikari datasource pool session create succesfully ");
// return this.hikariDataSource;
// Connection conn = DriverManager.getConnection(url, userName, password);
Connection conn=this.hikariDataSource.getConnection();
logger.info("use hikari datasource pool "+conn.toString());
this.ctx=DSL.using(conn,SQLDialect.MYSQL);
logger.info("jooq username: "+userName+ " pwd :"+password+ " url : "+url );
logger.info(" jooq dsl create successfully ");
return this.ctx;
}
// @Bean(name = "primaryDataSource")
// @Qualifier("primaryDataSource")
// @Primary
// @ConfigurationProperties(prefix = "spring.datasource.primary")
// public DruidDataSource primaryDatasource() {
// logger.info("database primary connection config is parsed by druid！！！");
// return DruidDataSourceBuilder.create().build();
// }
}
//import edu.mit.csail.db.ml.main.Main;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
@SpringBootApplication
@ComponentScan(basePackages = {"edu.mit.*"})
public class MullerModeldbApplication {
public static void main(String[] args)throws Exception {
SpringApplication.run(MullerModeldbApplication.class, args);
// Main mainz=new Main();
// mainz.main(args);
}
}
至此 基本配置ok，注意写正确的配置,其中最关键的是 HikariConfig 的注入，只有这里把配置文件的Hikari的配置注入成功了，后面的Hikari 和jooq 才能配置成功，springboot 对Hikari的封装还是很不错的，
@Bean
@ConfigurationProperties(prefix = "spring.datasource.hikari")
public HikariConfig getConfig( ){
HikariConfig config =new HikariConfig( );
return config;
}
这种书写方式，可以正确注入
MongoDB
另外 MongoDB 在 springboot 有专门的 MongoDBTemplate ，
首先得配置项
#mongodb
spring.data.mongodb.host=${mongo_env_ip}
spring.data.mongodb.port=27017
spring.data.mongodb.password=
spring.data.mongodb.database=modeldb_metadata
spring.data.mongodb.grid-fs-database=
spring.data.mongodb.uri=mongodb://${mongo_env_ip}:27017/modeldb_metadata
写的Bean
import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.config.AbstractMongoConfiguration;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;
import org.springframework.stereotype.Component;
@Component
@Configuration
@EnableMongoRepositories
public class MongoDBConfig extends AbstractMongoConfiguration {
protected final Logger logger=LoggerFactory.getLogger(MongoDBConfig.class);
@Value("${spring.data.mongodb.host}")
private String mongoHost; // = "localhost";
@Value("${spring.data.mongodb.port}")
private int mongoPort ; //= 27017;
@Value("${spring.data.mongodb.database}")
private String dbName ;//= "modeldb_metadata";
private static final String MONGO_BASE_PACKAGE = "com.tz.config";
@Autowired
private ApplicationContext appContext;
@Override
protected String getDatabaseName() {
return dbName;
}
// @Override
// public Mongo mongo() {
// MongoClient mongoClient = new MongoClient(mongoHost, mongoPort);
// return mongoClient;
// }
@Bean
@Override
public MongoClient mongoClient() {
MongoClient mongoClient = new MongoClient(mongoHost, mongoPort);
logger.info("Mongodb client session create succesfully : ");
return mongoClient;
}
@Override
protected String getMappingBasePackage() {
return MONGO_BASE_PACKAGE;
}
@Override
@Bean(name = "mongoTemplate")
@Qualifier("mongoTemplate")
public MongoTemplate mongoTemplate() throws Exception {
MongoTemplate mongoTemplate= new MongoTemplate(mongoClient(), getDatabaseName());
MongoDatabase db= mongoTemplate.getDb();
logger.warn(db.toString());
return mongoTemplate;
}
}
另外 thrift 的配置也可以作为bean 来管理
@Bean
public TThreadPoolServer createThriftserver() throws Exception{
TServerTransport transport = new TServerSocket(thrift_post);
logger.info(" thrift config : username : "+userName+" pwd "+password+" metadbhost: "+metadataDbHost+" url "+url);
// We use the binary protocol.
metadataDb.open();
TProtocolFactory protocolFactory = new TBinaryProtocol.Factory();
TTransportFactory transportFactory = new TFramedTransport.Factory();
TThreadPoolServer.Args serverArgs = new TThreadPoolServer.Args(transport)
.processor(new ModelDBService.Processor(new ModelDbServer(
// userName,
// password,
// url,
// ModelDbConfig.DatabaseType.MYSQL,
// metadataDbHost,
// metadataDbPort,
// metadataDbName,
// ModelDbConfig.MetadataDbType.MONGODB
this.ctx,
this.metadataDb
)))
.protocolFactory(protocolFactory)
.transportFactory(transportFactory)
.minWorkerThreads(1)
.maxWorkerThreads(100);
logger.info("begin");
TThreadPoolServer server = new TThreadPoolServer(serverArgs);
// Launch the server.
System.out.printf("Starting the simple server on port %d...\n", thrift_post);
server.serve();
return server;
}