分布式-Hadoop课程-总结

于 2019-06-24 11:06:22 发布
阅读量1.9k 收藏 5
点赞数 6
分类专栏： 学习笔记 文章标签： 复习Hadoop 考查知识点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sujiangming/article/details/93470727
版权

下面内容分别课程内容、考查知识点大纲两个部分，请同学们认真复习总结

一、课程内容

    1、Linux

        常用命令cp mkdir cat tar

        shell脚本编程：

            （1）新建.sh 给执行权限（命令）

            （2）bash test.sh或./test.sh

            （3）$0 $1 $2

            注意：会在Linux下编写shell脚本，可以查看下实训所编写的脚本

 

    2、Hadoop

        （1）Google三篇的论文（思想来源）

             GFS:Google File System

             MapReduce：分布式计算框架

             BigTable: 大表

        （2）Hadoop的开源框架

             HDFS：Hadoop Distributed File System 分布式文件系统

             上传文件原理图

          

             下载文件原理图

           

  •   调用HDFS JAVA API操作HDFS
/**

  * 测试创建目录

  * @throws Exception

  */

@Test

public void test01() throws Exception {

       Configuration conf = new Configuration();

       conf.set("fs.defaultFS", "hdfs://niit110:9000");

       FileSystem fs = FileSystem.get(conf);

       fs.mkdirs(new Path("/dir01"));

       fs.close();

}

/**

  * 上传文件

  *

  * @throws Exception

  */

@Test

public void test03() throws Exception {    

       Configuration conf = new Configuration();

       conf.set("fs.defaultFS", "hdfs://niit110:9000");

       FileSystem fs = FileSystem.get(conf);

       FileInputStream in = new FileInputStream(new  File("F:\\mysql.zip"));

       FSDataOutputStream out = fs.create(new  Path("/dir01/mysql.zip"));

       IOUtils.copyBytes(in, out, conf);

}

/**

  * 下载文件

  *

  * @throws Exception

  */

@Test

public void test02() throws Exception {

       Configuration conf = new Configuration();

       conf.set("fs.defaultFS", "hdfs://niit110:9000");

       FileSystem fs = FileSystem.get(conf);

       FSDataInputStream in = fs.open(new  Path("/dir01/hadoop.zip"));

       FileOutputStream out = new FileOutputStream(new  File("F:\\hadoop.zip"));

       IOUtils.copyBytes(in, out, conf);

}

（3）三个流程：数据信息化、信息业务化、业务可视化

（4）体系结构：主从式结构

          NameNode：

          作用：1、接收客户端请求

                     2、维护了两个重要的日志文件

                            EditLog

                            FsImage            

                DataNode：

                    作用：存储数据

                注意：会画出HDFS的体系结构图及各个节点的作用

            （5）MapReduce

                思想：大任务拆分成小任务

                

                编程模型：请查看MapReduce相关笔记

                高级特性：key-value、combiner、排序、分区、序列化等

                Yarn容器的体系结构：主从式体系结构,ResourceManager,NodeManager及各自的作用

                注意：（1）编写MapReduce程序的一般思路与步骤

                                    （*）编写mapper，需要继承Hadoop的map类

                                    （*）编写Reducer，需要继承Hadoop的reduce类

                                    （*）编写Job,一般会有五个步骤

                      （2）会画图分析MapReduce程序处理数据的流程图

                         

（3）会手动编写Wordcount程序与求员工工资总额程序

   Wordcount程序  

//Map类

package com.sjm.wc;

import java.io.IOException;

import org.apache.hadoop.io.IntWritable;

import org.apache.hadoop.io.LongWritable;

import org.apache.hadoop.io.Text;

import org.apache.hadoop.mapreduce.Mapper;

                                    //key1       value1  key2  value2                    

public class MyMapper extends Mapper<LongWritable, Text, Text, IntWritable>{

    @Override

    protected void map(LongWritable key1, Text value1, Context context)

            throws IOException, InterruptedException {

        //map阶段 :读取文本进行分词

        //例如 value = i love Guiyang 一行文本

        //将Text数据类型转换成String类型

        String formatValue = value1.toString();

        //目的：将Text文本按空格进行分割

        String[] splitWord = formatValue.split(" ");

        //分词好之后将每个单词及其出现的次数输出给下一个阶段

        for (String word : splitWord) {

            context.write(new Text(word), new IntWritable(1));

        }

    }

}

//Reducer类

package com.sjm.wc;

import java.io.IOException;

import org.apache.hadoop.io.IntWritable;

import org.apache.hadoop.io.Text;

import org.apache.hadoop.mapreduce.Reducer;

                                    //key3   value3       key4  value4

public class MyReducer extends Reducer<Text, IntWritable, Text, IntWritable>{

    @Override                

    protected void reduce(Text key3, Iterable<IntWritable> value3,Context context) throws IOException, InterruptedException {

        int sum = 0;

        for (IntWritable intWritable : value3) {

            sum += intWritable.get();

        }

        context.write(new Text(key3), new IntWritable(sum));

    }

}

//Job类

package com.sjm.wc;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.fs.Path;

import org.apache.hadoop.io.IntWritable;

import org.apache.hadoop.io.Text;

import org.apache.hadoop.mapreduce.Job;

import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;

import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;



public class MyJob {

    public static void main(String[] args) throws Exception {

        // 1、创建程序入口及获取配置文件对象

        Configuration configuration = new Configuration();

        Job job = Job.getInstance(configuration);

        job.setJarByClass(MyJob.class);



        // 2、指定Job的map的输出及其输出的类型

        job.setMapperClass(MyMapper.class);

        job.setMapOutputKeyClass(Text.class);

        job.setMapOutputValueClass(IntWritable.class);



        // 3、指定job的reduce输出及其输出类型

        job.setReducerClass(MyReducer.class);

        job.setOutputKeyClass(Text.class);

        job.setOutputValueClass(IntWritable.class);



        // 4、指定job的输入文件及输出结果的路径

        FileInputFormat.setInputPaths(job, new Path(args[0]));

        FileOutputFormat.setOutputPath(job, new Path(args[1]));



        // 5、执行程序

        job.waitForCompletion(true);

    }

}

                              

 

求员工工资总额程序

//Map类

package com.sjm.sort.object;

import java.io.IOException;

import org.apache.hadoop.io.IntWritable;

import org.apache.hadoop.io.LongWritable;

import org.apache.hadoop.io.NullWritable;

import org.apache.hadoop.io.Text;

import org.apache.hadoop.mapreduce.Mapper;

public class SortMapper extends Mapper<LongWritable, Text, IntWritable, IntWritable> {

    @Override

    protected void map(LongWritable key1, Text value1, Context context) throws IOException, InterruptedException {

        // 7499,ALLEN,SALESMAN,7698,1981/2/20,1600,300,30

        String str = value1.toString();

        // 分词

        String[] words = str.split(",");

        // 将这个员工输出

        //context.write(e, NullWritable.get());

        context.write(new IntWritable(Integer.valueOf(words[7])),new IntWritable(Integer.valueOf(words[5])));

    }

}

//Reducer类

package com.sjm.sort.object;

import java.io.IOException;

import org.apache.hadoop.io.IntWritable;

import org.apache.hadoop.mapreduce.Reducer;

                                        //key3        value3    key4        value4

public class SortReducer extends Reducer<IntWritable, IntWritable,IntWritable, IntWritable> {

    @Override

    protected void reduce(IntWritable k3, Iterable<IntWritable> v3, Context context)

            throws IOException, InterruptedException {

        int sum = 0;

        for (IntWritable v : v3) {

            sum += v.get();

        }

        context.write(k3, new IntWritable(sum));

    }

}

//Job类

package com.sjm.sort.object;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.fs.Path;

import org.apache.hadoop.io.IntWritable;

import org.apache.hadoop.io.NullWritable;

import org.apache.hadoop.mapreduce.Job;

import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;

import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

 

import com.sjm.utils.MyUtils;

public class SortMain {

 

    public static void main(String[] args) throws Exception {

        // 指明程序的入口

        Job job = Job.getInstance(new Configuration());

        job.setJarByClass(SortMain.class);

        // 指明任务中的mapper及其输出类型

        job.setMapperClass(SortMapper.class);

        job.setMapOutputKeyClass(IntWritable.class);

        job.setMapOutputValueClass(IntWritable.class);

 

       // 指明任务中的reducer及其输出类型

        job.setReducerClass(SortReducer.class);

        job.setOutputKeyClass(IntWritable.class);

        job.setOutputValueClass(IntWritable.class);

 

        // 指明任务的输入路径和输出路径 ---> HDFS的路径

        FileInputFormat.setInputPaths(job, new Path(args[0]));

        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        

        // 启动任务

        job.waitForCompletion(true);

    }

}

 

                      （4）combiner的使用场景与不适用的场景（查看相关笔记）

                      （5）会画出Yarn容器的体系结构图及各个节点的作用（查看相关笔记） 

            （6）安装配置

                 本地模式（只进行MapReduce程序的测试，不需要启动hadoop）

                 伪分布模式（具备全分布式的环境的所有功能）

                 全分布模式（一般按照数据块的冗余度来进行主机集群的规划，主机数一般会大于数据块冗余度数）

                 高可用模式（HA）   

                 注意：（1）伪分布模式安装步骤

                       （2）五个配置文件及其作用

            （7）hadoop的性能优化

                 一般性能优化的的几个方面需要了解

                 配置文件、大文件存储、数据压缩、combiner减少IO、重用JVM等

            （8）hadoop HA(集群管理)

                单点故障问题的解决方式：借助zookeeper来实现高可用（HA）模式，解决单点故障问题    

            （9）HDFS底层原理：

                 RPC:远程过程调用，客户端与Hadoop通讯的方式是RPC

                 动态代理：客户端与NameNode节点通讯时会采用了代理模式的方式来返回代理对象给客户端

    3、Zookeeper

        概念：分布式协同资源服务器

        作用：

            （1）解决主从结构中产生的单点故障

            （2）作为HBase及Storm的结构体系中的一部分

            （3）分布式锁

            （4）数据同步

            （5）leader选择机制

        补充：

            架构中，一般选择其作为服务注册与发现中心

            通过Watch机制来实现服务的发现

        注意：有关使用Java api来操作zookeeper的代码，一定要看

        

package com.it18zhang.zktest;

import org.apache.zookeeper.ZooKeeper;

import org.junit.Test;

import java.util.List;

 

 

public class TestZK {

 

    //列出当前zk下所有的子节点

    @Test

    public void ls() throws  Exception{

        ZooKeeper zk = new ZooKeeper("s201:2181",5000,null);

        List<String> list = zk.getChildren("/",null);

        for(String s : list){

            System.out.println(s);

        }

    }

 

 

    @Test

    public void lsAll() throws  Exception{

        ls("/");

    }

 

 

    /**

     * 列出指定path下的孩子

     */

    public void ls(String path) throws  Exception{

        System.out.println(path);

        ZooKeeper zk = new ZooKeeper("s201:2181",5000,null);

        List<String> list = zk.getChildren(path,null);

        if(list == null || list.isEmpty()){

            return ;

        }

        for(String s : list){

            //先输出孩子

            if(path.equals("/")){

                ls(path + s);

            }

            else{

                ls(path + "/" + s);

            }

        }

    }

 

 

    /**

     * 设置数据

     */

    @Test

    public void setData() throws Exception{

        ZooKeeper zk = new ZooKeeper("s201:2181", 5000, null);

        zk.setData("/a","tomaslee".getBytes(),0);

    }

 

 

    /**

     * 创建临时节点

     */

    @Test

    public void reateEmphoral() throws Exception{

        ZooKeeper zk = new ZooKeeper("s201:2181", 5000, null);

        zk.create( "/c/c1" ,"tom".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);

        System.out.println("hello");

    }

 

 

    @Test

    public void testWatch() throws Exception{

        final ZooKeeper zk = new ZooKeeper("s201:2181", 5000, null);

        Stat st = new Stat();

        Watcher w = null ;

        w = new Watcher() {

            //回调

            public void process(WatchedEvent event) {

                try {

                    System.out.println("数据改了！！！");

                    zk.getData("/a", this, null);

                } catch (Exception e) {

                    e.printStackTrace();

                }

            }

        };

        byte[] data = zk.getData("/a", w , st);

        System.out.println(new String(data));

        while(true){

            Thread.sleep(1000);

        }

    }

  

}    

 

  

     4、HBase

        一款面向列的NOSQL数据库

        是Google的bigtable的开源实现

        结构：主从式的架构

        主节点：HMaster

        从节点：RegionServer

        基本数据模型：

        table、行、列、列族、行键

        对比的表结构：请查看HBase部分的笔记

        hbase的java api注意事项：

        （1）配置文件的时候需要配置的是zk的地址

        （2）使用Java api 写代码的时候，注意使用的是服务器的主机名

        注意：有关使用Java api来操作hbase的代码，一定要看   

注意：需要引入hbase安装目录下的所有的jar包，代码的中主机名需要在window下配置主机名与ip地址的映射关系        

package hbase.java;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HColumnDescriptor;

import org.apache.hadoop.hbase.HTableDescriptor;

import org.apache.hadoop.hbase.MasterNotRunningException;

import org.apache.hadoop.hbase.TableName;

import org.apache.hadoop.hbase.ZooKeeperConnectionException;

import org.apache.hadoop.hbase.client.Get;

import org.apache.hadoop.hbase.client.HBaseAdmin;

import org.apache.hadoop.hbase.client.HTable;

import org.apache.hadoop.hbase.client.Put;

import org.apache.hadoop.hbase.client.Result;

import org.apache.hadoop.hbase.client.ResultScanner;

import org.apache.hadoop.hbase.client.Scan;

import org.apache.hadoop.hbase.util.Bytes;

import org.junit.Test;

 

 

public class TestHBaseDemo {

 

 

    public static void main(String[] args) throws Exception {

         createTable();

        // insertOne();

         //get();

        // scan();

        // dropTable();

        insertMultRecord();

    }

 

    private static void createTable() throws Exception {

        // 指定ZooKeeper地址，从zk中获取HMaster的地址

        // 注意：ZK返回的是HMaster的主机名, 不是IP地址 ---> 配置Windows的hosts文件

        // C:\Windows\System32\drivers\etc\hosts

        Configuration conf = new Configuration();

        conf.set("hbase.zookeeper.quorum", "niit110");

        // 创建一个HBase的客户端

        HBaseAdmin client = new HBaseAdmin(conf);

        // 创建表: 通过表的描述符

        HTableDescriptor htd = new HTableDescriptor(TableName.valueOf("students"));

        // 列族的信息

        HColumnDescriptor h1 = new HColumnDescriptor("info");

        HColumnDescriptor h2 = new HColumnDescriptor("grade");

        // 将列族加入表

        htd.addFamily(h1);

        htd.addFamily(h2);

        // 创建表

        client.createTable(htd);

        client.close();

    }

 

    private static void insertOne() throws Exception {

        Configuration conf = new Configuration();

        conf.set("hbase.zookeeper.quorum", "niit110");

        // 指定表的客户端

        HTable table = new HTable(conf, "students");

        // 构造一条数据

        Put put = new Put(Bytes.toBytes("stu001"));

        put.addColumn(Bytes.toBytes("info"), // 列族的名字

                Bytes.toBytes("name"), // 列的名字

                Bytes.toBytes("Tom")); // 值

        // 插入

        table.put(put);

        table.close();

    }

 

 

    private static void dropTable() throws IOException {

        Configuration conf = new Configuration();

        conf.set("hbase.zookeeper.quorum", "niit110");

        // 创建一个HBase的客户端

        HBaseAdmin client = new HBaseAdmin(conf);

        client.disableTable("students");

        client.deleteTable("students");

        client.close();

    }

 

    private static void scan() throws Exception {

        Configuration conf = new Configuration();

        conf.set("hbase.zookeeper.quorum", "niit110");

        // 指定表的客户端

        HTable table = new HTable(conf, "students");

        // 创建一个扫描器 Scan

        Scan scanner = new Scan(); // ----> 相当于: select * from students;

        // scanner.setFilter(filter) ----> 过滤器

        // 执行查询

        ResultScanner rs = table.getScanner(scanner); // 返回ScannerResult --->

                                                        // Oracle中的游标

        for (Result r : rs) {

            String name = Bytes.toString(r.getValue(Bytes.toBytes("info"), Bytes.toBytes("name")));

            String age = Bytes.toString(r.getValue(Bytes.toBytes("info"), Bytes.toBytes("age")));

            System.out.println(name + "   " + age);

        }

        table.close();

    }

 

    private static void get() throws Exception {

        Configuration conf = new Configuration();

        conf.set("hbase.zookeeper.quorum", "niit110");

        // 指定表的客户端

        HTable table = new HTable(conf, "students");

        // 通过Get查询

        Get get = new Get(Bytes.toBytes("stu001"));

        // 执行查询

        Result record = table.get(get);

        // 输出

        String name = Bytes.toString(record.getValue(Bytes.toBytes("info"), Bytes.toBytes("name")));

        System.out.println(name);

        table.close();

    }

 

    private static void insertMultRecord() throws Exception {

        Configuration conf = new Configuration();

        conf.set("hbase.zookeeper.quorum", "niit110");

        // 指定表的客户端

        HTable table = new HTable(conf, "students");

        // 构造集合，代表要插入的数据

        List<Put> listData = new ArrayList<Put>();

        for (int i = 0; i < 20; i++) {

            Put put = new Put(Bytes.toBytes("stu00" + i));

            put.add(Bytes.toBytes("info"), Bytes.toBytes("name"), Bytes.toBytes("Tom-" + i));

            int age = 20 + i;

            put.add(Bytes.toBytes("info"), Bytes.toBytes("age"), Bytes.toBytes(String.valueOf(age)));

            listData.add(put);

        }

        table.put(listData);

        table.close();

    }

}

 

 

     5、Hive

       是一款开源的构建与Hadoop之上的数据仓库，支持SQL99标准

       核心是将HiveQL转换成MapReduce程序进行数据分析，本质上可以理解为MR程序的SQL表现方式

       数据模型有：内部表、外部表、分区表、桶表、视图等（注意掌握创建表的语句与意思）

       注意：（1）hive 依赖MySQL和Derby数据库用于存储hive的元信息，

                  因此在安装配置的时候，请注意引入MySQL的驱动包并进行初始化

             （2）启动hive时，需要先启动Hadoop

       操作方式：CLI（命令行方式）、Java api方式   

       具体的操作，请查看hive相关笔记

       如下为创建表的语句

一、内部表创建方式

create table emp1

(empno int,

ename string,

job string,

mgr int,

hiredate string,

sal int,

comm int,

deptno int)

row format delimited fields terminated by ',';

二、分区表创建方式

create table emp_part

(empno int,

ename string,

job string,

mgr int,

hiredate string,

sal int,

comm int)

partitioned by (deptno int)

row format delimited fields terminated by ',';

三、外部表

create external table t1

(sid int,sname string,age)

row format delimited fields terminated by ','

location '/students';

四、桶表

create table emp_bucket

(empno int,

ename string,

job string,

mgr int,

hiredate string,

sal int,

comm int,

deptno int)

clustered by (job) into 4 buckets

row format delimited fields terminated by ',';

 

     6、Spark

       （1）了解特点：基于内存、快、简单易用、兼容性好等

       （2）体系结构 ：主从式结构，Master、Worker

       （3）生态圈：Spark Core、Spark Streaming、Spark SQL、Spark MLlib、GraphX

    

     7、Flume

            一款支持实时采集日志的开源的日志采集工具

            一个Agent结构：Source、channel、sink

            一个sink只能与一个channel进行绑定

            安装部署与配置要掌握

 

     8、SQOOP

     一款用于关系型与非关系数据库之间进行数据转换的工具，可以作为ETL工具来使用

     了解其使用方式，export、import等关键字的使用等 

 

二、考查知识点大纲

一、HDFS

-------------

    0、Hadoop生态圈常用的工具

    1、安装步骤（配置文件名称）参考博客

    2、NameNode格式化命令及常用命令

    3、体系结构及主从节点的作用NameNode DataNode

    4、第二名称节点作用SecondaryNameNode

    5、上传下载代码操作

    6、不同版本的Hadoop数据块大小

    1.x 64M    2.x 128M

    

二、MapReduce

---------------

    （代码打包发云盘）

    1、Wordcount程序的处理流程分析及编码

    2、求员工工资总额的MapReduce程序的思路及编码

        (1)Map--->map()

        (2)Reduce---->reduce()

        (3)Job    

    3、Yarn的体系结构及其各个节点的作用

    4、Yarn容器的资源调度策略

    5、MapReduce的高级特性

    6、combiner的作用与使用场景（包括不适应的场景和适用的场景）

    

三、Hbase

--------------

    1、Hbase的体系结构

        主从结构：HMaster/RegionServer

        借助ZooKeeper

    2、支持的安装部署方式(4种)

    3、行键（rowkey）

    4、HBase的常用命令

        Hbase shell

    5、HBase删除表需要注意什么

    6、HBase的Java api操作

    

四、zookeeper

---------------

    1、zookeeper是什么

    2、zookeeper的运用场景

    3、zookeeper的安装部署

    4、zookeeper的启停命令

    5、zookeeper的Java api操作

    

五、Hive

---------------

    1、Hive的作用

    2、Hive的表的类型

    3、Hive表的创建（会写创建表的SQL语句）

六、Spark

---------------

    1、Spark的特点

    2、Spark的生态圈组件及各自含义

若兰幽竹
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

若兰幽竹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值