精华内容
下载资源
问答
  • 我的原创地址:http://dongkelun.com/2018/03/25/sparkHive/​dongkelun.com1、在服务器(虚拟机)spark-shell连接hive1.1 将hive-site.xml拷贝到spark/conf里cp /opt/apache-hive-2.3.2-bin/conf/hive-site.xml /opt/...

    我的原创地址:http://dongkelun.com/2018/03/25/sparkHive/​dongkelun.com

    1、在服务器(虚拟机)spark-shell连接hive

    1.1 将hive-site.xml拷贝到spark/conf里

    cp /opt/apache-hive-2.3.2-bin/conf/hive-site.xml /opt/spark-2.2.1-bin-hadoop2.7/conf/

    1.2 将mysql驱动拷贝到spark/jar里

    cp /opt/apache-hive-2.3.2-bin/bin/mysql-connector-java-5.1.46-bin.jar /opt/spark-2.2.1-bin-hadoop2.7/jars/

    1.3 启动spark-shell,输入代码测试

    spark-shell

    import org.apache.spark.sql.hive.HiveContext

    val hiveContext = new HiveContext(sc)

    hiveContext.sql("select * from test").show()

    1.4 异常及解决

    在执行hiveContext.sql("select * from test").show() 报了一个异常:

    The root scratch dir: /tmp/hive on HDFS should be writable. Current permissions are: rwxr-xr-x;

    解决办法:

    1.4.1 更改HDFS目录/tmp/hive的权限:

    hadoop fs -chmod 777 /tmp/hive

    1.4.2 同时删HDFS与本地的目录/tmp/hive:

    hadoop fs -rm -r /tmp/hive

    rm -rf /tmp/hive

    这次错误采用的是第二种解决办法,有的情况下用第一种方法,比如一次在启动hive时候报这种错误~。 错误截图:

    2、win10+eclipse上连接hive

    2.1 将hive-site.xml拷贝到项目中的resources文件夹下

    2.2 在sbt里添加对应版本的mysql依赖

    "mysql" % "mysql-connector-java" % "5.1.46"

    2.3 代码

    2.3.1 旧版api(1.6以上)

    package com.dkl.leanring.spark.sql

    import org.apache.spark.SparkConf

    import org.apache.spark.sql.SQLContext

    import org.apache.spark.sql.hive.HiveContext

    import org.apache.spark.SparkContext

    /*** 旧版本spark-hive测试*/

    object OldSparkHiveDemo {

    def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setAppName("OldSparkHiveDemo").setMaster("local")

    val sc = new SparkContext(conf)

    val sqlContext = new SQLContext(sc)

    import sqlContext.implicits._

    val hiveCtx = new HiveContext(sc)

    hiveCtx.sql("select * from test").show()

    val data = Array((3, "name3"), (4, "name4"), (5, "name5"))

    val df = sc.parallelize(data).toDF("id", "name")

    df.createOrReplaceTempView("user")

    hiveCtx.sql("insert into test select id,name from user")

    hiveCtx.sql("select * from test").show()

    }

    }

    (注:其中df.createOrReplaceTempView("user")改为df.registerTempTable("user"),因为createOrReplaceTempView方法是2.0.0才有的,registerTempTable是旧版的方法,1.6.0就有了,嫌麻烦就不改代码重新贴图了)

    2.3.2 新版api

    package com.dkl.leanring.spark.sql

    import org.apache.spark.sql.SparkSession

    /*** 新版本spark-hive测试*/

    object NewSparkHiveDemo {

    def main(args: Array[String]): Unit = {

    val spark = SparkSession

    .builder()

    .appName("Spark Hive Example")

    .master("local")

    .config("spark.sql.warehouse.dir", "/user/hive/warehouse/")

    .enableHiveSupport()

    .getOrCreate()

    import spark.implicits._

    import spark.sql

    sql("CREATE TABLE IF NOT EXISTS src (key INT, value STRING)")

    val data = Array((1, "val1"), (2, "val2"), (3, "val3"))

    var df = spark.createDataFrame(data).toDF("key", "value")

    df.createOrReplaceTempView("temp_src")

    sql("insert into src select key,value from temp_src")

    sql("SELECT * FROM src").show()

    }

    }

    2.4 异常及解决方法

    在执行insert语句时会出现如下异常信息:

    org.apache.hadoop.security.AccessControlException: Permission denied: user=dongkelun, access=EXECUTE, inode="/user/hive/warehouse":root...

    原因是:启动 Spark 应用程序的win用户对spark.sql.warehouse.dir没有写权限 解决办法:

    hadoop fs -chmod 777 /user/hive/warehouse/

    附异常信息截图:

    3、更新:写hive方法

    直接用下面这句代码即可将df里的全部数据存到hive表里

    df.write.mode(SaveMode.Append).saveAsTable(tableName)

    展开全文
  • springboot项目连接hive服务器并进行crud操作 本篇文章是讲在springboot项目中怎么去连接hive数据仓库,并且进行简单的增删改查操作。 一、连接hive 1.加入相关依赖如下: <dependency> <groupId>org...

    springboot项目连接hive服务器并进行crud操作

    本篇文章是讲在springboot项目中怎么去连接hive数据仓库,并且进行简单的增删改查操作。

    一、连接hive

    1.加入相关依赖如下:

        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-jdbc</artifactId>
            <version>1.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.6.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>jdk.tools</groupId>
            <artifactId>jdk.tools</artifactId>
            <version>1.8</version>
            <scope>system</scope>
            <systemPath>${JAVA_HOME}/lib/tools.jar</systemPath>
    	</dependency>
    

    如果上述依赖在加入过程中出现错误,可能是与springboot的版本冲突导致,改为相应版本即可。其中jdk.tools改为你对应的jdk版本。从这里可以看到加入了hive-jdbc依赖,该依赖是用于对hive仓库进行crud操作的。

    2.配置yml文件

    	hive:
    	  url: jdbc:hive2://ip地址:端口/;auth=noSasl
    	  driver-class-name: org.apache.hive.jdbc.HiveDriver
    	  type: com.alibaba.druid.pool.DruidDataSource
    	  user: 用户名
    	  password: 密码
    	           # 下面为连接池的补充设置,应用到上面所有数据源中
    	           # 初始化大小,最小,最大
    	  initialSize: 1
    	  minIdle: 3
    	  maxActive: 20
    	           # 配置获取连接等待超时的时间
    	  maxWait: 60000
    	           # 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
    	  timeBetweenEvictionRunsMillis: 60000
    	           # 配置一个连接在池中最小生存的时间,单位是毫秒
    	  minEvictableIdleTimeMillis: 30000
    	  validationQuery: select 1
    	  testWhileIdle: true
    	  testOnBorrow: false
    	  testOnReturn: false
    	           # 打开PSCache,并且指定每个连接上PSCache的大小
    	  poolPreparedStatements: true
    	  maxPoolPreparedStatementPerConnectionSize: 20
    	  connectionErrorRetryAttempts: 0
    	  breakAfterAcquireFailure: true
    

    注意将上述中ip地址、端口、用户名、密码等字样替换为你hive仓库相应的数据。

    三、编写hive配置类

    import com.alibaba.druid.pool.DruidDataSource;
    import org.springframework.beans.factory.annotation.Qualifier;
    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;
    
    /**
     * hive的相关配置类
     * @author zyl
     * @date 2019年4月1日
     */
    
    @Configuration
    @ConfigurationProperties(prefix = "hive")
    public class HiveDruidConfig {
    
    private String url;
    private String user;
    private String password;
    private String driverClassName;
    private int initialSize;
    private int minIdle;
    private int maxActive;
    private int maxWait;
    private int timeBetweenEvictionRunsMillis;
    private int minEvictableIdleTimeMillis;
    private String validationQuery;
    private boolean testWhileIdle;
    private boolean testOnBorrow;
    private boolean testOnReturn;
    private boolean poolPreparedStatements;
    private int maxPoolPreparedStatementPerConnectionSize;
    private int connectionErrorRetryAttempts;
    private boolean breakAfterAcquireFailure;
    
    @Bean(name = "hiveDruidDataSource")
    @Qualifier("hiveDruidDataSource")
    public DataSource dataSource() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(url);
        datasource.setUsername(user);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setValidationQuery(validationQuery);
        datasource.setTestWhileIdle(testWhileIdle);
        datasource.setTestOnBorrow(testOnBorrow);
        datasource.setTestOnReturn(testOnReturn);
        datasource.setPoolPreparedStatements(poolPreparedStatements);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        datasource.setConnectionErrorRetryAttempts(connectionErrorRetryAttempts);
        datasource.setBreakAfterAcquireFailure(breakAfterAcquireFailure);
        return datasource;
    }
    
    @Bean(name = "hiveDruidTemplate")
    public JdbcTemplate hiveDruidTemplate(@Qualifier("hiveDruidDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
    
    public int getConnectionErrorRetryAttempts() {
        return connectionErrorRetryAttempts;
    }
    
    public void setConnectionErrorRetryAttempts(int connectionErrorRetryAttempts) {
        this.connectionErrorRetryAttempts = connectionErrorRetryAttempts;
    }
    
    public boolean isBreakAfterAcquireFailure() {
        return breakAfterAcquireFailure;
    }
    
    public void setBreakAfterAcquireFailure(boolean breakAfterAcquireFailure) {
        this.breakAfterAcquireFailure = breakAfterAcquireFailure;
    }
    
    public String getUrl() {
        return url;
    }
    
    public void setUrl(String url) {
        this.url = url;
    }
    
    public String getUser() {
        return user;
    }
    
    public void setUser(String user) {
        this.user = user;
    }
    
    public String getPassword() {
        return password;
    }
    
    public void setPassword(String password) {
        this.password = password;
    }
    
    public String getDriverClassName() {
        return driverClassName;
    }
    
    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }
    
    public int getInitialSize() {
        return initialSize;
    }
    
    public void setInitialSize(int initialSize) {
        this.initialSize = initialSize;
    }
    
    public int getMinIdle() {
        return minIdle;
    }
    
    public void setMinIdle(int minIdle) {
        this.minIdle = minIdle;
    }
    
    public int getMaxActive() {
        return maxActive;
    }
    
    public void setMaxActive(int maxActive) {
        this.maxActive = maxActive;
    }
    
    public int getMaxWait() {
        return maxWait;
    }
    
    public void setMaxWait(int maxWait) {
        this.maxWait = maxWait;
    }
    
    public int getTimeBetweenEvictionRunsMillis() {
        return timeBetweenEvictionRunsMillis;
    }
    
    public void setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis) {
        this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    }
    
    public int getMinEvictableIdleTimeMillis() {
        return minEvictableIdleTimeMillis;
    }
    
    public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis) {
        this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    }
    
    public String getValidationQuery() {
        return validationQuery;
    }
    
    public void setValidationQuery(String validationQuery) {
        this.validationQuery = validationQuery;
    }
    
    public boolean isTestWhileIdle() {
        return testWhileIdle;
    }
    
    public void setTestWhileIdle(boolean testWhileIdle) {
        this.testWhileIdle = testWhileIdle;
    }
    
    public boolean isTestOnBorrow() {
        return testOnBorrow;
    }
    
    public void setTestOnBorrow(boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }
    
    public boolean isTestOnReturn() {
        return testOnReturn;
    }
    
    public void setTestOnReturn(boolean testOnReturn) {
        this.testOnReturn = testOnReturn;
    }
    
    public boolean isPoolPreparedStatements() {
        return poolPreparedStatements;
    }
    
    public void setPoolPreparedStatements(boolean poolPreparedStatements) {
        this.poolPreparedStatements = poolPreparedStatements;
    }
    
    public int getMaxPoolPreparedStatementPerConnectionSize() {
        return maxPoolPreparedStatementPerConnectionSize;
    }
    
    public void setMaxPoolPreparedStatementPerConnectionSize(int maxPoolPreparedStatementPerConnectionSize) {
        this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
    }
    

    }

    该配置类实际是配置DruidDataSource和JdbcTemplate。注意@ConfigurationProperties(prefix = “hive”)这句是将你yml文件中hive节点下的值注入到同名属性中去。

    二、进行crud操作

    使用jdbc操作hive跟使用jdbc操作mysql等关系型数据库基本一样,下面给出一个样例说明。

    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import javax.sql.DataSource;
    import java.sql.*;
    
    public class Test {
        @Autowired
        @Qualifier("hiveDruidDataSource")
        private DataSource druidDataSource;
    
        public static String getData(DataSource druidDataSource,String sqlString,String resultName) {
            Connection conn = null;
            Statement statement = null;
            ResultSet rs = null;
            JSONObject result = null;
            try {
                conn = druidDataSource.getConnection();
                statement = conn.createStatement();
                result = new JSONObject();
                result.put("state", "0");
                JSONArray array = new JSONArray();
                rs = statement.executeQuery(sqlString.toString());
                ResultSetMetaData metaData = rs.getMetaData();
                int columnCount = metaData.getColumnCount();
                while (rs.next()) {
                    JSONObject jsonObj = new JSONObject();
                    // 遍历每一列
                    for (int i = 1; i <= columnCount; i++) {
                        String columnName = metaData.getColumnLabel(i);
                        String value = rs.getString(columnName);
                        jsonObj.put(columnName, value);
                    }
                    array.add(jsonObj);
                }
                result.put("analysisMACResult", array.toString());
            } catch (SQLException e) {
                e.printStackTrace();
                return "{\"state\":\"1\"}";
            } finally {
                try {
                    conn.close();
                    statement.close();
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    return "{\"state\":\"1\"}";
                }
            }
            return result.toString();
        }
    }
    

    仔细看一下这个操作类,其实跟jdbc操作mysql没区别。但要注意@Qualifier(“hiveDruidDataSource”)中的hiveDruidDataSource这个对象名,其实是你在配置类中定义的。上述给出的是查询操作,其他操作也类似,如果你使用过jdbc操作过关系型数据库,我想我不用多说了。介绍就到这了,如有误解欢迎指正。

    展开全文
  • 展开全部连接hive的方法62616964757a686964616fe4b893e5b19e31333361306435:进入hive所在的服务器,输入:hive --service hiveserver(目的:启动thrift)打开kettle配置连接界面,输入hive所在服务器的ip、所需要的...

    展开全部

    连接hive的方法62616964757a686964616fe4b893e5b19e31333361306435:

    进入hive所在的服务器,输入:hive --service hiveserver(目的:启动thrift)

    打开kettle配置连接界面,输入hive所在服务器的ip、所需要的hive库、端口号(thrift默认端口为:10000)

    测试连接,即可

    连接hive2的方法:

    [plain] view plain copy

    Error connecting to database [Hive] : org.pentaho.di.core.exception.KettleDatabaseException:

    Error occured while trying to connect to the database

    Error connecting to database: (using class org.apache.hadoop.hive.jdbc.HiveDriver)

    Unable to load Hive Server 2 JDBC driver for the currently active Hadoop configuration

    org.pentaho.di.core.exception.KettleDatabaseException:

    Error occured while trying to connect to the database

    Error connecting to database: (using class org.apache.hadoop.hive.jdbc.HiveDriver)

    Unable to load Hive Server 2 JDBC driver for the currently active Hadoop configuration

    at org.pentaho.di.core.database.Database.normalConnect(Database.java:428)

    at org.pentaho.di.core.database.Database.connect(Database.java:361)

    at org.pentaho.di.core.database.Database.connect(Database.java:314)

    at org.pentaho.di.core.database.Database.connect(Database.java:302)

    at org.pentaho.di.core.database.DatabaseFactory.getConnectionTestReport(DatabaseFactory.java:80)

    at org.pentaho.di.core.database.DatabaseMeta.testConnection(DatabaseMeta.java:2685)

    at org.pentaho.di.ui.core.database.dialog.DatabaseDialog.test(DatabaseDialog.java:109)

    at org.pentaho.di.ui.core.database.wizard.CreateDatabaseWizardPage2.test(CreateDatabaseWizardPage2.java:157)

    at org.pentaho.di.ui.core.database.wizard.CreateDatabaseWizardPage2$3.widgetSelected(CreateDatabaseWizardPage2.java:147)

    at org.eclipse.swt.widgets.TypedListener.handleEvent(Unknown Source)

    at org.eclipse.swt.widgets.EventTable.sendEvent(Unknown Source)

    at org.eclipse.swt.widgets.Widget.sendEvent(Unknown Source)

    at org.eclipse.swt.widgets.Display.runDeferredEvents(Unknown Source)

    at org.eclipse.swt.widgets.Display.readAndDispatch(Unknown Source)

    at org.eclipse.jface.window.Window.runEventLoop(Window.java:820)

    at org.eclipse.jface.window.Window.open(Window.java:796)

    at org.pentaho.di.ui.core.database.wizard.CreateDatabaseWizard.createAndRunDatabaseWizard(CreateDatabaseWizard.java:111)

    at org.pentaho.di.ui.spoon.Spoon.createDatabaseWizard(Spoon.java:7457)

    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)

    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)

    at java.lang.reflect.Method.invoke(Unknown Source)

    at org.pentaho.ui.xul.impl.AbstractXulDomContainer.invoke(AbstractXulDomContainer.java:313)

    at org.pentaho.ui.xul.impl.AbstractXulComponent.invoke(AbstractXulComponent.java:157)

    at org.pentaho.ui.xul.impl.AbstractXulComponent.invoke(AbstractXulComponent.java:141)

    at org.pentaho.ui.xul.jface.tags.JfaceMenuitem.access$100(JfaceMenuitem.java:43)

    at org.pentaho.ui.xul.jface.tags.JfaceMenuitem$1.run(JfaceMenuitem.java:106)

    at org.eclipse.jface.action.Action.runWithEvent(Action.java:498)

    at org.eclipse.jface.action.ActionContributionItem.handleWidgetSelection(ActionContributionItem.java:545)

    at org.eclipse.jface.action.ActionContributionItem.access$2(ActionContributionItem.java:490)

    at org.eclipse.jface.action.ActionContributionItem$5.handleEvent(ActionContributionItem.java:402)

    at org.eclipse.swt.widgets.EventTable.sendEvent(Unknown Source)

    at org.eclipse.swt.widgets.Widget.sendEvent(Unknown Source)

    at org.eclipse.swt.widgets.Display.runDeferredEvents(Unknown Source)

    at org.eclipse.swt.widgets.Display.readAndDispatch(Unknown Source)

    at org.pentaho.di.ui.spoon.Spoon.readAndDispatch(Spoon.java:1297)

    at org.pentaho.di.ui.spoon.Spoon.waitForDispose(Spoon.java:7801)

    at org.pentaho.di.ui.spoon.Spoon.start(Spoon.java:9130)

    at org.pentaho.di.ui.spoon.Spoon.main(Spoon.java:638)

    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)

    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)

    at java.lang.reflect.Method.invoke(Unknown Source)

    at org.pentaho.commons.launcher.Launcher.main(Launcher.java:151)

    Caused by: org.pentaho.di.core.exception.KettleDatabaseException:

    Error connecting to database: (using class org.apache.hadoop.hive.jdbc.HiveDriver)

    Unable to load Hive Server 2 JDBC driver for the currently active Hadoop configuration

    at org.pentaho.di.core.database.Database.connectUsingClass(Database.java:573)

    at org.pentaho.di.core.database.Database.normalConnect(Database.java:410)

    ... 43 more

    Caused by: java.sql.SQLException: Unable to load Hive Server 2 JDBC driver for the currently active Hadoop configuration

    at org.apache.hive.jdbc.HiveDriver.getActiveDriver(HiveDriver.java:107)

    at org.apache.hive.jdbc.HiveDriver.callWithActiveDriver(HiveDriver.java:121)

    at org.apache.hive.jdbc.HiveDriver.connect(HiveDriver.java:132)

    at java.sql.DriverManager.getConnection(Unknown Source)

    at java.sql.DriverManager.getConnection(Unknown Source)

    at org.pentaho.di.core.database.Database.connectUsingClass(Database.java:555)

    ... 44 more

    Caused by: java.lang.reflect.InvocationTargetException

    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)

    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)

    at java.lang.reflect.Method.invoke(Unknown Source)

    at org.apache.hive.jdbc.HiveDriver.getActiveDriver(HiveDriver.java:105)

    ... 49 more

    Caused by: java.lang.RuntimeException: Unable to load JDBC driver of type: hive2

    at org.pentaho.hadoop.shim.common.CommonHadoopShim.getJdbcDriver(CommonHadoopShim.java:108)

    ... 54 more

    Caused by: java.lang.Exception: JDBC driver of type 'hive2' not supported

    at org.pentaho.hadoop.shim.common.CommonHadoopShim.getJdbcDriver(CommonHadoopShim.java:104)

    ... 54 more

    上述报错的解决方法如下:

    1.找到%KETTLE_HOME%/plugins/pehtaho-big-data-plugin/plugin.properties文件

    2.修改plugin.properties文件中的值:active.hadoop.configuration=hdp13

    3.修改后重启kettle

    4.配置完成后,即可连接上对应的库

    如果要使用hadoop-20,则需要添加如下jar包:

    hadoop-core-1.2.1.jar

    hive-common-0.13.0.jar

    hive-jdbc-0.13.0.jar

    hive-service-0.13.0.jar

    libthrift-0.9.1.jar

    slf4j-api-1.7.5.jar

    httpclient-4.2.5.jar

    httpcore-4.2.5.jar

    本回答由网友推荐

    已赞过

    已踩过<

    你对这个回答的评价是?

    评论

    收起

    展开全文
  • 仅仅通过./hive启动hive1.2.2的话,hive本质上就相当于hdfs的一个客户端,本身并不是一个服务,如果想要通过java代码以jdbc的方式去连接hive,那么首先要解决的是把hive变成服务器上的一个服务。 以jdbc方式连接...

    仅仅通过./hive启动hive1.2.2的话,hive本质上就相当于hdfs的一个客户端,本身并不是一个服务,如果想要通过java代码以jdbc的方式去连接hive,那么首先要解决的是把hive变成服务器上的一个服务。

    以jdbc方式连接hive的步骤:

    一、以./hive --service hiveserver2的方式启动hive

    [root@node113 /usr/local/hive/apache-hive-1.2.2-bin/bin]#./hive --service hiveserver2

    hive会卡在这里,另开一个窗口,hive如果作为服务启动的话,默认占用10000端口:

    [root@node113 ~]#netstat -tunpl|grep 10000
    tcp        0      0 0.0.0.0:10000           0.0.0.0:*               LISTEN      31627/java

    在以前老的版本里面绑定的是127.0.0.1:10000,需要修改

     <property>
        <name>hive.server2.thrift.bind.host</name>
        <value>localhost</value>
        <description>Bind host on which to run the HiveServer2 Thrift service.</description>
      </property>

    里面的localhost为node113(hive所在机器的hostname),现在hive1.2.2不需要修改了这个配置了,现在hive1.2.2的这个配置默认是

     <property>
        <name>hive.server2.thrift.bind.host</name>
        <value/>
        <description>Bind host on which to run the HiveServer2 Thrift service.</description>
      </property>

    可以不用修改。

    二、beeline是hive用来让你连接hive服务的脚本,运行命令  ./beeline 进入交互式

    [root@node113 /usr/local/hive/apache-hive-1.2.2-bin/bin]#./beeline 
    Beeline version 1.2.2 by Apache Hive
    beeline>

    三、尝试使用命令  "!connect jdbc:hive2://node113:10000/lzzcmsdb"连接hive:

    beeline> !connect jdbc:hive2://node113:10000/lzzcmsdb
    Connecting to jdbc:hive2://node113:10000/lzzcmsdb
    Enter username for jdbc:hive2://node113:10000/lzzcmsdb: root
    Enter password for jdbc:hive2://node113:10000/lzzcmsdb: 
    Connected to: Apache Hive (version 1.2.2)
    Driver: Hive JDBC (version 1.2.2)
    Transaction isolation: TRANSACTION_REPEATABLE_READ
    0: jdbc:hive2://node113:10000/lzzcmsdb>

    上面让你输入hive服务的username和password,hive作为服务启动后,默认的username和password分别为"root"和""(空字符串),从上面可以看到我们通过beeline客户端已经可以连接hive服务了,可以放心的写java程序来连接了。

    image.png

    四、写jdbc代码:

    package hadoop.hive;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    
    import org.junit.Test;
    
    /*
     * 导入hadoop安装包里面的jar包+hive安装包里面的jar
     */
    public class TestHive {
    	@Test
    	public void testHive1() throws Exception{
    		Class.forName("org.apache.hive.jdbc.HiveDriver");
    		Connection conn=DriverManager.getConnection("jdbc:hive2://node113:10000/lzzcmsdb",
    				"root","");
    		String sql="select count(*) from t_searchword";
    		PreparedStatement ps=conn.prepareStatement(sql);
    		ResultSet rs = ps.executeQuery();
    		while(rs.next()){
    			System.out.println(rs.getInt(1));
    		}
    		rs.close();
    		ps.close();
    		conn.close();
    	}
    }

    注意:hive服务的端口是10000,用户名默认是root,密码默认为空,执行结果:

    image.png

    展开全文
  • 1、在服务器(虚拟机)spark-shell连接hive1.1 将hive-site.xml拷贝到spark/conf里cp /opt/apache-hive-2.3.2-bin/conf/hive-site.xml /opt/spark-2.2.1-bin-hadoop2.7/conf/1.2 将mysql驱动拷贝到spark/jar里cp /opt/...
  • 要想实现Powe BI连接Hive数据库,需要安装一个驱动进行配置,同时服务器开启hiveserver2在后台运行。1、下载ClouderaHiveODBC64...
  • 昨天总结了一下Hive通过网络连接数据库模式的搭建过程,今天我来总结一下另外一种模式-远程服务器模式Hive的搭建过程。首先,我们来看一下机器如何分配: 在集群中,我们准备四台虚拟机,node001:mysql服务器,node...
  • python 连接 hive

    2018-03-05 16:19:11
    我建了一个CentOS的虚拟机,为了验证python连接hive首先,在服务器端除了安装hive,还需要做以下配置:(1)配置当前用户的权限,到hadoop下面的/etc/hadoop/core-site.xml。(2)配置客户端的权限,增加从本地的...
  • 昨天总结了一下Hive通过网络连接数据库模式的搭建过程,今天我来总结一下另外一种模式-远程服务器模式Hive的搭建过程。首先,我们来看一下机器如何分配: 在集群中,我们准备四台虚拟机,node001:mysql服务器,node...
  • 如何使用Spark连接Hive

    2021-05-12 16:14:31
    使用Spark连接Hive获取数据 一、在连接前,先保证服务器端的运行环境正常 1、Linux窗口输入start-all.sh启动hadoop环境 2、再输入 hive --service metastore & 启动hive服务 3、在Linux窗口输入jps检查服务是否...
  • 使用jdbc连接Hive

    2020-07-20 09:14:44
    一、hive提供了jdbc的连接方式,就是在hive的某个计算节点开启hiveserver2启动方法如下 默认已启动hadoop 先启动hive元数据服务 hive --service metastore &...将这两个jar包从服务器上的hive li..
  • 参考Hive2创建了一个简单的java程序连接HIVE2服务器(非本地)在eclipse中的类路径中添加了上述链接中的所有提到的jar,但是当我运行代码时它会抛出一个错误:09:42:35,580 INFO Utils:285 - Supplied authorities: ...
  • 1.连接hive首先需要启动HiveServer2的服务,执行以下两个命令启动:  启动metastore bin/hive --service metastore  启动hiveServer2 bin/hive --service hiveserver2   启动完成后,可执行netstat -nl |...
  • 首先看一下我通过xshell5远程连接hive的配置这是登陆时候的界面,可以看到我选择的是10.100.34.110这个服务器第一种,使用SSH,在idea中Tools--StartSSH session--edithost --172.18.254.49 Port --2...
  • idea远程连接hive

    千次阅读 2018-02-09 14:12:30
    首先看一下我通过xshell5远程连接hive的配置这是登陆时候的界面,可以看到我选择的是10.100.34.110这个服务器 第一种,使用SSH,在idea中Tools--StartSSH session--edit host --172.18.254.49 Port -...
  • 远程连接hive server

    万次阅读 2017-11-16 12:18:43
    1、在hive服务器上启动hive server2,在你的hive主目录/bin/下找到并执行下面的命令,默认监听10000端口 #hiveserver2 2、使用cli在本机连接 #beeline beeline> !connect jdbc:hive2://localhost:10000 user pwd ...
  • 要想实现Powe BI连接Hive数据库,需要安装一个驱动进行配置,同时服务器开启hiveserver2在后台运行。1、下载ClouderaHiveODBC64...
  • 通过SecureCRT工具连上linux后,通过beeline连接hive后,在输错hive语句时,无论 Backspace还是delete 都删除不掉错误的语句,没有办法退格。 解决办法如下: 1.英文版 第一步:SecureCRT菜单选项栏中"options"---...
  • python连接hive配置

    千次阅读 2019-07-25 18:45:27
    注:Python端所在服务器为centos6.8 一,hive安装配置 参考博文:https://blog.csdn.net/u010916338/article/details/89764877 重要一点,hive是个客户端,不是集群,在hive所在节点必须执行如下命令: hive --...
  • 1、在服务器(虚拟机)spark-shell连接hive1.1 将hive-site.xml拷贝到spark/conf里cp /opt/apache-hive-2.3.2-bin/conf/hive-site.xml /opt/spark-2.2.1-bin-hadoop2.7/conf/1.2 将mysql驱动拷贝到spark/jar里cp /opt/...
  • Hive CLI和Beeline的区别-Hive vs Beeline  Beeline主要是开发来与新服务器进行交互。Hive CLI是基于 Apache Thrift的客户端,而Beeline是基于SQLLine CLI的JDBC客户端。在本文中,我们将详细阐述Hive CLI和...
  • 如何使用kettle连接hive和hive2

    万次阅读 2014-10-13 11:08:54
    进入hive所在的服务器,输入:hive --service hiveserver
  • DbVisualizer连接Hive数据仓库

    千次阅读 2018-12-30 20:01:00
    前言 &amp;amp;amp;amp;nbsp;&amp;amp;... 小编最近的项目涉及到与大数据平台的对接,少不了要去操作Hadoop 下的Hive 数据仓库,下面来记录下操作过程。...2、连接hive地址 hive 服务器地址: 端口
  • DbVisualizer配置连接hive

    千次阅读 2016-09-16 18:56:23
    最近在测试hive on Spark的功能,由于数据库Oracle习惯...测试了2个hadoop集群,机器都是4台普通的服务器2U服务器 测试环境1:hive on hadoop hive-1.0 hadoop-common-2.2 测试环境2:hive on spark cdh5.7 hiv
  • centos7 pyhive连接hive(基于kerberos)。由于基于kerberos校验的hive服务器通过python连接的过程很麻烦,故整理文档。
  • 用Dbvisualizer连接hive数据库

    千次阅读 2019-03-04 17:38:50
    打开Dbvisualizer工具 ... 新建hive驱动 在这之前在Dbvisualizer的安装目录 \jdbc 下新建一个hive文件夹,移入两个需要的jar包。...新建driver,先加载上述移入hive文件夹下的两个jar 包 ...//imapala服务器IP:...
  • Java JDBC方式连接HIVE2

    万次阅读 2015-09-09 13:33:06
    一般连接hive的方式有CLI(登录到服务器或者本地切换到hive环境),Client(SQUIREEL SQL客户端),Web UI(hive --service hwi )等 Java 操作JDBC同普通JDBC数据库一样,首先需要启动Hive 服务打开bin/hive --...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 366
精华内容 146
关键字:

服务器连接hive