springBoot多数据源配置，如mysql、hive，使用druid连接池

最新推荐文章于 2024-02-03 13:59:14 发布
最新推荐文章于 2024-02-03 13:59:14 发布
阅读量1.7k 收藏 9
点赞数
分类专栏： 大数据Hadoop javaEE spring框架 文章标签： java hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mathlpz126/article/details/108731347
版权

总共需要以下几个类：

package com.config.datasource;

import com.alibaba.druid.pool.DruidDataSource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 * @date 2019/10/11 15:27
 * @description
 */
@Slf4j
@Configuration
public class DataSourceConfig {

    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;
    @Value("${spring.datasource.url}")
    private String url;
    @Value("${spring.datasource.username}")
    private String userName;
    @Value("${spring.datasource.password}")
    private String password;

    @Value("${spring.datasource.hive.driver-class-name}")
    private String hiveDriverClassName;
    @Value("${spring.datasource.hive.url}")
    private String hiveJdbcUrl;
    @Value("${spring.datasource.hive.username}")
    private String hiveUsername;
    @Value("${spring.datasource.hive.password}")
    private String hivePassword;

    @Bean(name = "datasourceMysql")
    public DataSource getDataSourceMysql() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(userName);
        dataSource.setPassword(password);
        log.info("------------datasourceMysql dataSource.getUrl(): {}", dataSource.getUrl());
        return dataSource;
    }

    @Bean(name = "datasourceHive")
    public DataSource getDataSourceHive() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(hiveDriverClassName);
        dataSource.setUrl(hiveJdbcUrl);
        dataSource.setUsername(hiveUsername);
        dataSource.setPassword(hivePassword);
        dataSource.setTestWhileIdle(true);
        log.info("------------------------datasourceHive dataSource.getUrl(): {}", dataSource.getUrl());
        return dataSource;
    }

    /**
     * 动态数据源: 通过AOP在不同数据源之间动态切换
     *
     * @return
     */
    @Primary
    @Bean(name = "dynamicDataSource")
    public DataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        // 默认数据源
        dynamicDataSource.setDefaultTargetDataSource(getDataSourceMysql());
        // 配置多数据源
        Map<Object, Object> dsMap = new HashMap();
        dsMap.put(DynamicDataSource.DS_MYSQL, getDataSourceMysql());
        dsMap.put(DynamicDataSource.DS_HIVE, getDataSourceHive());
        dynamicDataSource.setTargetDataSources(dsMap);
        return dynamicDataSource;
    }

}

2

package content.config.datasource;

import lombok.extern.slf4j.Slf4j;
import org.springframework.util.ObjectUtils;

/**
 * @date 2019/10/11 15:55
 * @description
 */
@Slf4j
public class DataSourceContextHolder {
    /**
     * 默认数据源
     */
    public static final String DEFAULT_DS = "mysql";

    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    // 设置数据源名
    public static void setDB(String dbType) {
        log.info("setDB -> dbType = [{}]", dbType);
        CONTEXT_HOLDER.set(dbType);
    }

    // 获取数据源名
    public static String getDB() {
        return ObjectUtils.isEmpty(CONTEXT_HOLDER.get()) ? DEFAULT_DS : CONTEXT_HOLDER.get();

    }

    /**
     * 清除数据源名
     */
    public static void clearDB() {
        CONTEXT_HOLDER.remove();
    }
}

3

package content.config.datasource;

import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * @date 2019/10/11 15:53
 * @description
 */
@Slf4j
public class DynamicDataSource extends AbstractRoutingDataSource {

    public static final String DS_MYSQL = "mysql";

    public static final String DS_HIVE = "hive";


    @Override
    protected Object determineCurrentLookupKey() {
        log.info("the dynamic DataSource is: {}", DataSourceContextHolder.getDB());
        return DataSourceContextHolder.getDB();
    }
}

4

package content.config.datasource;

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.SqlSessionFactory;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * @date 2019/10/11 15:59
 * @description
 */
@Slf4j
@Component
@Aspect
public class DynamicDataSourceAspect {

    @Resource
    private SqlSessionFactory sqlSessionFactory;

    /**
     * @param point
     */
    @Before("execution(* unified.content.dao.hive.*.*(..))")
    public void beforeSwitchDS(JoinPoint point) {
//        Object target = point.getTarget();
        DataSourceContextHolder.setDB(DynamicDataSource.DS_HIVE);
        sqlSessionFactory.getConfiguration().setUseColumnLabel(Boolean.FALSE);
    }

    /**
     * @param point
     */
    @After("execution(* unified.content.dao.*.*.*(..))")
    public void afterSwitchDS(JoinPoint point) {
        DataSourceContextHolder.clearDB();
        sqlSessionFactory.getConfiguration().setUseColumnLabel(Boolean.TRUE);
    }

}

注意，springboot启动入口要加上注解：

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})

否则会有循环依赖报错。

***************************
APPLICATION FAILED TO START
***************************

Description:

The dependencies of some of the beans in the application context form a cycle:

   dynamicDataSourceAspect
      ↓
   sqlSessionFactory defined in class path resource [org/mybatis/spring/boot/autoconfigure/MybatisAutoConfiguration.class]
┌─────┐
|  dynamicDataSource defined in class path resource [unified/content/config/datasource/DataSourceConfig.class]
↑     ↓
|  datasourceMysql defined in class path resource [unified/content/config/datasource/DataSourceConfig.class]
↑     ↓
|  org.springframework.boot.autoconfigure.jdbc.DataSourceInitializerInvoker

 

然后就可以了。

这是mysql和hive多数据源的配置，也可以是和impala等其它数据源一起配置。

 

druid配置（application-dev.properties）：


#druid连接池设置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.druid.initial-size=1
spring.datasource.druid.min-idle=3
spring.datasource.druid.max-active=20
spring.datasource.druid.max-wait=6000
spring.datasource.druid.time-between-eviction-runs-millis=60000
spring.datasource.druid.min-evictable-idle-time-millis=30000
spring.datasource.druid.validation-query=select 1
spring.datasource.druid.test-while-idle=true
spring.datasource.druid.test-on-borrow=false
spring.datasource.druid.test-on-return=false
spring.datasource.druid.pool-prepared-statements=true
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20
spring.datasource.druid.connection-error-retry-attempts=0
spring.datasource.druid.break-after-acquire-failure=true

# mysql
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://172.28.xx.xxx:3306/xxxx?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true
spring.datasource.username=xxx
spring.datasource.password=xxx


#hive配置
spring.datasource.hive.driver-class-name=org.apache.hive.jdbc.HiveDriver
spring.datasource.hive.url=jdbc:hive2://172.16.xx.xx:xxxx/default
spring.datasource.hive.username=hive
spring.datasource.hive.password=xxx

 

maven包相关依赖，见pom文件：

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid.version}</version>
        </dependency>

        <!-- 引入hive-jdbc -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-jdbc</artifactId>
            <version>2.3.3</version>
            <exclusions>
                <exclusion>
                    <groupId>javax.servlet</groupId>
                    <artifactId>servlet-api</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.apache.logging.log4j</groupId>
                    <artifactId>log4j-slf4j-impl</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- 引入hbase -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-hadoop</artifactId>
            <version>${spring.hadoop.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>javax.servlet</groupId>
                    <artifactId>servlet-api</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-hadoop-hbase</artifactId>
            <version>${spring.hadoop.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>javax.servlet</groupId>
                    <artifactId>servlet-api</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>1.3.0</version>
            <!--<version>1.3.6</version>-->
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- -->


        <!--mysql-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

 

附录：

单独连接hive的配置可如下：

package unified.content.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

/**
 *
 */
@Configuration
@ConfigurationProperties(prefix = "spring.datasource")
public class HiveDruidConfig {

    @Value("hive.url")
    private String url;
    @Value("hive.username")
    private String username;
    @Value("hive.password")
    private String password;
    @Value("hive.driver-class-name")
    private String driverClassName;


    @Bean(name = "hiveDataSource")
    @Qualifier("hiveDataSource")
    public DataSource hiveDataSource() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(url);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);
        return datasource;
    }

    @Bean(name = "hiveJdbcTemplate")
    public JdbcTemplate hiveJdbcTemplate(@Qualifier("hiveDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
    //省略getter、setter
}

CRUD示例：

package unified.content.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * 测试
 */
@Slf4j
@RestController
@RequestMapping("/hive")
public class HiveController {


    @Autowired
    @Qualifier("datasourceHive")
    private DataSource hiveDataSource;

    @Autowired
    @Qualifier("hiveJdbcTemplate")
    private JdbcTemplate hiveJdbcTemplate;

    @RequestMapping("/table/show")
    public List<String> showtables() {
        List<String> list = new ArrayList<String>();
        Statement statement = null;
        try {
            statement = hiveDataSource.getConnection().createStatement();
            String sql = "show tables";
            log.info("Running: " + sql);
            ResultSet res = statement.executeQuery(sql);

//            List<Map<String, Object>> maps = hiveJdbcTemplate.queryForList(sql);

            while (res.next()) {
                list.add(res.getString(1));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 查询Hive库中的某张数据表字段信息
     */
    @RequestMapping("/table/describe")
    public List<String> describeTable(String tableName) throws SQLException {
        List<String> list = new ArrayList<String>();
        // Statement statement = jdbcDataSource.getConnection().createStatement();
        Statement statement = hiveDataSource.getConnection().createStatement();
        String sql = "describe " + tableName;
        log.info("Running: " + sql);
        ResultSet res = statement.executeQuery(sql);
        while (res.next()) {
            list.add(res.getString(1));
        }
        return list;
    }

    /**
     * 查询指定tableName表中的数据
     */
    @RequestMapping("/table/select")
    public List<String> selectFromTable(String tableName) throws SQLException {
        // Statement statement = jdbcDataSource.getConnection().createStatement();
        Statement statement = hiveDataSource.getConnection().createStatement();
        String sql = "select * from " + tableName;
        log.info("Running: " + sql);
        ResultSet res = statement.executeQuery(sql);
        List<String> list = new ArrayList<String>();
        int count = res.getMetaData().getColumnCount();
        String str = null;
        while (res.next()) {
            str = "";
            for (int i = 1; i < count; i++) {
                str += res.getString(i) + " ";
            }
            str += res.getString(count);
            log.info(str);
            list.add(str);
        }
        return list;
    }


    /**
     * @return
     */
    @RequestMapping("/table/select2")
    public String select() {
        String sql = "select * from HIVE_TEST";
        List<Map<String, Object>> rows = hiveJdbcTemplate.queryForList(sql);
        Iterator<Map<String, Object>> it = rows.iterator();
        while (it.hasNext()) {
            Map<String, Object> row = it.next();
            System.out.println(String.format("%s\t%s", row.get("key"), row.get("value")));
        }
        return "Done";
    }


    /**
     * 示例：创建新表
     */
    @RequestMapping("/table/create")
    public String createTable() {
        StringBuffer sql = new StringBuffer("CREATE TABLE IF NOT EXISTS ");
        sql.append("user_sample");
        sql.append("(user_num BIGINT, user_name STRING, user_gender STRING, user_age INT)");
        sql.append("ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n' "); // 定义分隔符
        sql.append("STORED AS TEXTFILE"); // 作为文本存储

        log.info("Running: " + sql);
        String result = "Create table successfully...";
        try {
            // hiveJdbcTemplate.execute(sql.toString());
            hiveJdbcTemplate.execute(sql.toString());
        } catch (DataAccessException dae) {
            result = "Create table encounter an error: " + dae.getMessage();
            log.error(result);
        }
        return result;

    }

    /**
     * 示例：将Hive服务器本地文档中的数据加载到Hive表中
     */
    @RequestMapping("/table/load")
    public String loadIntoTable() {
        String filepath = "/home/hadoop/user_sample.txt";
        String sql = "load data local inpath '" + filepath + "' into table user_sample";
        String result = "Load data into table successfully...";
        try {
            // hiveJdbcTemplate.execute(sql);
            hiveJdbcTemplate.execute(sql);
        } catch (DataAccessException dae) {
            result = "Load data into table encounter an error: " + dae.getMessage();
            log.error(result);
        }
        return result;
    }

    /**
     * 示例：向Hive表中添加数据
     */
    @RequestMapping("/table/insert")
    public String insertIntoTable() {
        String sql = "INSERT INTO TABLE user_sample(user_num,user_name,user_gender,user_age) VALUES(888,'Plum','M',32)";
        String result = "Insert into table successfully...";
        try {
            // hiveJdbcTemplate.execute(sql);
            hiveJdbcTemplate.execute(sql);
        } catch (DataAccessException dae) {
            result = "Insert into table encounter an error: " + dae.getMessage();
            log.error(result);
        }
        return result;
    }

    /**
     * 示例：删除表
     */
    @RequestMapping("/table/delete")
    public String delete(String tableName) {
        String sql = "DROP TABLE IF EXISTS " + tableName;
        String result = "Drop table successfully...";
        log.info("Running: " + sql);
        try {
            // hiveJdbcTemplate.execute(sql);
            hiveJdbcTemplate.execute(sql);
        } catch (DataAccessException dae) {
            result = "Drop table encounter an error: " + dae.getMessage();
            log.error(result);
        }
        return result;
    }


    @RequestMapping("/table/delete2")
    public String delete() {
        StringBuffer sql = new StringBuffer("DROP TABLE IF EXISTS HIVE_TEST");
        log.info(sql.toString());
        hiveJdbcTemplate.execute(sql.toString());
        return "Done";
    }


}

 

mathlpz666
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springBoot 配置多数据源，以mysql为例
JThreeStone的博客
11-16 656
在springBoot 项目中，配置mysql数据源配置，做到可以对数据的操作。 1：application.properties中，添加多个mysql连接： 2：创建DataSourceConfig文件。 @Configuration public class DataSourceConfig { private static Log log = LogFacto...
spring boot如何配置druid数据库连接池
你好，我们在哪里见过啊！
01-30 1万+
Druid是什么？        Druid是Java语言中最好的数据库连接池。对于一个简单的数据库应用，由于对于数据库的访问不是很频繁。这时可以简单地在需要访问数据库时，就新创建一个连接，用完后就关闭它，这样做也不会带来什么明显的性能上的开销。但是对于一个复杂的数据库应用，情况就完全不同了。频繁的建立、关闭连接，会极大的减低系统的性能，因为对于连接的使用成了系统性能的瓶颈。这个时候，我们通过建
springboot多数据源配置mybatis采用druid连接池对mysql，hive双数据源整合
立志欲坚不欲锐，成功在久不在速度
09-25 2175
介绍：在项目开发的过程中我们很少出现单纯的只使用一个数据源，而一般情况我们在一个项目中会用都多个数据源，最近遇到的项目就需要从大数据的数据中拿部分数据，然后自己项目中的一些业务用mysql所以涉及到两个数据源 本例子就讲解如何利用springboot配置hive、mysql、mybatis这样就不需要使用jdbc去连接方便灵活了很多 第一步：首先我们需要下载依赖： maven依赖,包括mybatis，springboot，大数据连接，MySQL依赖，druid等 <pr...
springboot 连接数据库失败取消自动重试，DruidDataSource取消自动重试
it佳佳的博客
11-06 5524
默认是无限自动重试，导致程序卡死，那么如果我不想让它重试呢? 方案1： application.properties里面添加即可 spring.datasource.druid.break-after-acquire-failure=true 方案2：动态数据源解决方案 DruidDataSource druidDataSource=new DruidDataSource(); druidDataSource.setUrl(dbInfo.getUrl()); drui
spring-boot集成mybtis+druid实现hive/mysql多数据源切换
09-28
spring-boot集成mybatis+druid实现 hive/mysql多数据源切换，用mysql数据库作为用户验证库以及用户信息库，hive作为数据可视化源库。
springboot+nacos + mybatis+hive/mysql多数据源
qq_38230416的博客
08-25 458
默认切换到主数据源master，方法切换到hive后，执行完毕后再次自动切换到master。配置成功后在需要切换数据源的方法上添加@DS注解，写入数据源名称。hive是需要手动事务开启的，则seta代理不能开启。nacos中system.yml配置。nacos中datasource配置。项目启动时会初始化数据源。
（五）springboot 配置多数据源连接mysql和hive
最新发布
java_linux_dev的博客
02-03 1651
项目结构如下mysql 执行如下建表语句，并插入一条测试数据12345CREATETABLEDEFAULTPRIMARYKEY使用hive客户端执行如下建表语句，并插入一条测试数据1createtable。
springboot多数据源代码
04-28
本项目涉及的主题是“springboot多数据源代码”，这意味着我们将探讨如何在SpringBoot应用中配置和管理多个数据源，包括Hive和MySQL数据库。 Hive是一个基于Hadoop的数据仓库工具，可以将结构化的数据文件映射为...
springboot +hive+mysql 德鲁伊特 实现 多数据源切换
12-09
springboot +hive+mysql 多数据源切换 个人写了一个demo 并测试通过 下载地址
springboot+mybatisplus+druid+hive+mysql.zip
10-26
3. **Druid数据源的配置**：初始化参数设置、监控配置、连接池的健康检查、性能优化等。 4. **Hive的JDBC连接**：在Java代码中如何使用Hive JDBC驱动建立与Hadoop集群的连接，执行HQL语句。 5. **Hive与MySQL的交互*...
SpringBoot多数据源配置(hive/mysql)
alan_liuyue的博客
05-20 9227
简介 在项目实践中，同一个项目可能需要整合多种数据源，把分散到各个数据库、数据表的数据都查询统计出来； SpringBoot有默认的数据源配置，本篇博客将整合SpringBoot多数据源配置，包括mysql、hive等，通过jdbctemplate或mybatis进行使用； 版本配置(版本可自行选择，这里是博主的测试版本)：jdk1.8，springboot1.5.9，hive2.1.1，h...
springboot hive mysql 多数据源切换
热门推荐
桃李不言下自成蹊
04-28 6万+
springboot hive mysql 多数据源切换 本次实验重在多数据源切换 性能不在考虑其中 开发环境： hive 3.1.3 mysql 8.0.33 jdk 1.8 maven 3.9.1 idea 2023.1 springboot 2.7.11 HikariCP 连接池 实验效果：从 hive 中迁移数据到 MySQL pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://mave
springboot项目多数据源配置，集成hive和mysql
小栋哟
11-05 4031
最近做的这个项目，原本数据库是用的mysql，后来需求问题，经过讨论后打算把hive集成进来，就是有一批数据入hive。 经过昨晚的尝试加上上网查阅资料总算是集成好了。 集成好了后的效果就是mysql和hive互不影响可独立使用，而且也不会影响mybatis的 使用，既然集成应该都是要这种效果吧。 代码有点多，不要着急，咱们一步一步的来 第一步pom文件：以下jar如果你已经有了就无需在添...
Dynamic-DataSource多数据源配置mybatis/mybatis-plus
qq_23095607的博客
09-25 4630
Dynamic-DataSource 可以和绝大多是连接层插件搭配使用，比如：mybatis,mybatis-plus,hibernate等如果公司不允许使用Dynamic-DataSource，可以参考上述视频进行原生代码的编写本示例仅讲就基本的使用（多数据源及事务），如果还需要更多功能，可参考上述官方文档进行编码。
springboot 2.* 整合 hive 和 mysql 多数据源配置
转身那一瞬
07-12 1728
话不多说，直接开搞： 添加 POM 的hive 和 mysql 依赖（可能有一些没有用） <dependency> <groupId>org.apache.hive</groupId> <artifactId>hive-jdbc</artifactId> <version>1.1.0</ver...
springboot动态数据源添hive等其他数据源
againI的博客
02-28 1521
BeanPostProcessor实际使用场景、动态数据源添加自定义实现、springboot整合hive
mybatisplus3.5多数据源多数据库动态切换方言分页插件
qq_42390636的博客
04-18 2230
问题：mysql中支持limit?,而postgresql不支持limit?2、最佳方案： 使用空参PaginationInnerInterceptor插件类。DbType.POSTGRE_SQL 可以解决。因为mysql兼容。
mysql impala_Mysql实时同步Impala
weixin_39974557的博客
02-17 382
本文将使用StreamSets实时同步Mysql数据到Impala1.创建Mysql数据表CREATE TABLE IF NOT EXISTS `test.mysqltest`(`id` INT UNSIGNED AUTO_INCREMENT,`name` VARCHAR(100) NOT NULL,`age` INT NOT NULL,PRIMARY KEY ( `id` ))ENGINE=In...
springboot集成mybatis+mysql/impala实现双数据源
weixin_48363639的博客
04-27 4375
最近大数据服务端项目开发需要springboot框架通过impala查询工具直接查hadoop的HDFS数据源，同时也需要查大数据聚合mysql数据，需要实现双数据源 所以研究了下，在springboot框架下，通过java语言来连接impala查询工具，实现数据仓库数据查询。 整个过程分为两大部分，第一部分：springboot集成mybatis+impala。第二部分，实现mysql和impala双数据源 第一部分：springboot集成mybatis详细过程不重复，下面的操作都是认为已经配置好
springboot集成hive、mysql、druid、mybatis
06-08
Spring Boot可以通过整合Hive、MySQL、Druid和MyBatis来实现数据访问。以下是整合步骤： 1. 添加依赖 在pom.xml文件中添加需要的依赖。例如： ``` <groupId>org.springframework.boot <artifactId>spring-boot...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值