12.18
实验1
熟悉常用的Linux操作和Hadoop操作
1.实验目的
Hadoop运行在Linux系统上，因此，需要学习实践一些常用的Linux命令。本实验旨在熟悉常用的Linux操作和Hadoop操作，为顺利开展后续其他实验奠定基础。
2.实验平台
（1）操作系统：Linux（建议Ubuntu16.04或Ubuntu18.04）；
（2）Hadoop版本：3.1.3。
3.实验步骤
1.熟悉常用的Linux操作
1）cd命令：切换目录
（1） 切换到目录“/usr/local”
（2） 切换到当前目录的上一级目录
（3） 切换到当前登录Linux系统的用户的自己的主文件夹
2）ls命令：查看文件与目录
查看目录“/usr”下的所有文件和目录
3）mkdir命令：新建目录
（1）进入“/tmp”目录，创建一个名为“a”的目录，并查看“/tmp”目录下已经存在哪些目录
（2）进入“/tmp”目录，创建目录“a1/a2/a3/a4”
4）rmdir命令：删除空的目录
（1）将上面创建的目录a（在“/tmp”目录下面）删除
（2）删除上面创建的目录“a1/a2/a3/a4” （在“/tmp”目录下面），然后查看“/tmp”目录下面存在哪些目录
5）cp命令：复制文件或目录
（1）将当前用户的主文件夹下的文件.bashrc复制到目录“/usr”下，并重命名为bashrc1
（2）在目录“/tmp”下新建目录test，再把这个目录复制到“/usr”目录下
6）mv命令：移动文件与目录，或更名
（1）将“/usr”目录下的文件bashrc1移动到“/usr/test”目录下
（2）将“/usr”目录下的test目录重命名为test2
7）rm命令：移除文件或目录
（1）将“/usr/test2”目录下的bashrc1文件删除
（2）将“/usr”目录下的test2目录删除
8）cat命令：查看文件内容
查看当前用户主文件夹下的.bashrc文件内容
9）tac命令：反向查看文件内容
反向查看当前用户主文件夹下的.bashrc文件的内容
10）more命令：一页一页翻动查看
翻页查看当前用户主文件夹下的.bashrc文件的内容
11）head命令：取出前面几行
（1）查看当前用户主文件夹下.bashrc文件内容前20行
（2）查看当前用户主文件夹下.bashrc文件内容，后面50行不显示，只显示前面几行
12）tail命令：取出后面几行
（1）查看当前用户主文件夹下.bashrc文件内容最后20行
（2）查看当前用户主文件夹下.bashrc文件内容，并且只列出50行以后的数据
13）touch命令：修改文件时间或创建新文件
（1）在“/tmp”目录下创建一个空文件hello，并查看文件时间
（2）修改hello文件，将文件时间整为5天前
14）chown命令：修改文件所有者权限
将hello文件所有者改为root帐号，并查看属性
15）find命令：文件查找
找出主文件夹下文件名为.bashrc的文件
16）tar命令：压缩命令
（1）在根目录“/”下新建文件夹test，然后在根目录“/”下打包成test.tar.gz
（2）把上面的test.tar.gz压缩包，解压缩到“/tmp”目录
17）grep命令：查找字符串
从“～/.bashrc”文件中查找字符串'examples'
18）配置环境变量
（1）请在“～/.bashrc”中设置，配置Java环境变量
（2）查看JAVA_HOME变量的值
2.熟悉常用的Hadoop操作
（1）使用hadoop用户登录Linux系统，启动Hadoop（Hadoop的安装目录为“/usr/local/hadoop”），为hadoop用户在HDFS中创建用户目录“/user/hadoop”
（2）接着在HDFS的目录“/user/hadoop”下，创建test文件夹，并查看文件列表
（3）将Linux系统本地的“～/.bashrc”文件上传到HDFS的test文件夹中，并查看test
（4）将HDFS文件夹test复制到Linux系统本地文件系统的“/usr/local/hadoop”目录下
4.实验报告
|
题目： |
熟悉常用的Linux操作和Hadoop操作 |
姓名 |
梁思远 |
日期 2024.11.11 |
|
实验环境：linux |
||||
|
实验内容与完成情况：完成 |
||||
|
出现的问题：无 |
||||
|
解决方案（列出遇到的问题和解决办法，列出没有解决的问题）：无 |
||||
实验2
熟悉常用的HDFS操作
1.实验目的
（1）理解HDFS在Hadoop体系结构中的角色；
（2）熟练使用HDFS操作常用的Shell命令；
（3）熟悉HDFS操作常用的Java API。
2. 实验平台
（1）操作系统：Linux（建议Ubuntu16.04或Ubuntu18.04）；
（2）Hadoop版本：3.1.3；
（3）JDK版本：1.8；
（4）Java IDE：Eclipse。
3. 实验步骤
（一）编程实现以下功能，并利用Hadoop提供的Shell命令完成相同任务：
向HDFS中上传任意文本文件，如果指定的文件在HDFS中已经存在，则由用户来指定是追加到原有文件末尾还是覆盖原有的文件；
从HDFS中下载指定文件，如果本地文件与要下载的文件名称相同，则自动对下载的文件重命名；
将HDFS中指定文件的内容输出到终端中；
显示HDFS中指定的文件的读写权限、大小、创建时间、路径等信息；
给定HDFS中某一个目录，输出该目录下的所有文件的读写权限、大小、创建时间、路径等信息，如果该文件是目录，则递归输出该目录下所有文件相关信息；
提供一个HDFS内的文件的路径，对该文件进行创建和删除操作。如果文件所在目录不存在，则自动创建目录；
提供一个HDFS的目录的路径，对该目录进行创建和删除操作。创建目录时，如果目录文件所在目录不存在，则自动创建相应目录；删除目录时，由用户指定当该目录不为空时是否还删除该目录；
向HDFS中指定的文件追加内容，由用户指定内容追加到原有文件的开头或结尾；
删除HDFS中指定的文件；
在HDFS中，将文件从源路径移动到目的路径。
（二）编程实现一个类“MyFSDataInputStream”，该类继承“org.apache.hadoop.fs.FSDataInputStream”，要求如下：实现按行读取HDFS中指定文件的方法“readLine()”，如果读到文件末尾，则返回空，否则返回文件一行的文本。
（三）查看Java帮助手册或其它资料，用“java.net.URL”和“org.apache.hadoop.fs.FsURLStreamHandlerFactory”编程完成输出HDFS中指定文件的文本到终端中。
4.实验报告
|
题目： |
|
姓名 |
梁思远 |
日期 |
|
实验环境： |
||||
|
实验内容与完成情况： |
||||
|
出现的问题： |
||||
|
解决方案（列出遇到的问题和解决办法，列出没有解决的问题）： |
||||
实验3
熟悉常用的HBase操作
1.实验目的
（1）理解HBase在Hadoop体系结构中的角色；
（2）熟练使用HBase操作常用的Shell命令；
（3）熟悉HBase操作常用的Java API。
2.实验平台
（1）操作系统：Linux（建议Ubuntu16.04或Ubuntu18.04）；
（2）Hadoop版本：3.1.3；
（3）HBase版本：2.2.2；
（4）JDK版本：1.8；
（5）Java IDE：Eclipse。
3. 实验步骤
（一）编程实现以下指定功能，并用Hadoop提供的HBase Shell命令完成相同任务：
列出HBase所有的表的相关信息，例如表名；
在终端打印出指定的表的所有记录数据；
向已经创建好的表添加和删除指定的列族或列；
清空指定的表的所有记录数据；
统计表的行数。
（二）HBase数据库操作
1. 现有以下关系型数据库中的表和数据（见表14-3到表14-5），要求将其转换为适合于HBase存储的表并插入数据：
表14-3 学生表（Student）
|
学号（S_No） |
姓名（S_Name） |
性别（S_Sex） |
年龄（S_Age） |
|
2015001 |
Zhangsan |
male |
23 |
|
2015002 |
Mary |
female |
22 |
|
2015003 |
Lisi |
male |
24 |
表14-4 课程表（Course）
|
课程号（C_No） |
课程名（C_Name） |
学分（C_Credit） |
|
123001 |
Math |
2.0 |
|
123002 |
Computer Science |
5.0 |
|
123003 |
English |
3.0 |
表14-5 选课表（SC）
|
学号（SC_Sno） |
课程号（SC_Cno） |
成绩（SC_Score） |
|
2015001 |
123001 |
86 |
|
2015001 |
123003 |
69 |
|
2015002 |
123002 |
77 |
|
2015002 |
123003 |
99 |
|
2015003 |
123001 |
98 |
|
2015003 |
123002 |
95 |
2. 请编程实现以下功能：
（1）createTable(String tableName, String[] fields)
创建表，参数tableName为表的名称，字符串数组fields为存储记录各个字段名称的数组。要求当HBase已经存在名为tableName的表的时候，先删除原有的表，然后再创建新的表。
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import java.io.IOException;
public class CreateTable {
public static Configuration configuration;
public static Connection connection;
public static Admin admin;
public static void createTable(String tableName, String[] fields) throws IOException {
init();
TableName tablename = TableName.valueOf(tableName);
if (admin.tableExists(tablename)) {
System.out.println("table is exists!");
admin.disableTable(tablename);
admin.deleteTable(tablename);
}
HTableDescriptor hTableDescriptor = new HTableDescriptor(tablename);
for (String str : fields) {
HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(str);
hTableDescriptor.addFamily(hColumnDescriptor);
}
admin.createTable(hTableDescriptor);
close();
}
public static void init() {
configuration = HBaseConfiguration.create();
configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
try {
connection = ConnectionFactory.createConnection(configuration);
admin = connection.getAdmin();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void close() {
try {
if (admin != null) {
admin.close();
}
if (null != connection) {
connection.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String[] fields = {"Score"};
try {
createTable("person", fields);
} catch (IOException e) {
e.printStackTrace();
}
}
}
（2）addRecord(String tableName, String row, String[] fields, String[] values)
向表tableName、行row（用S_Name表示）和字符串数组fields指定的单元格中添加对应的数据values。其中，fields中每个元素如果对应的列族下还有相应的列限定符的话，用“columnFamily:column”表示。例如，同时向“Math”、“Computer Science”、“English”三列添加成绩时，字符串数组fields为{“Score:Math”, ”Score:Computer Science”, ”Score:English”}，数组values存储这三门课的成绩。
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import java.io.IOException;
public class AddRecord {
public static Configuration configuration;
public static Connection connection;
public static Admin admin;
public static void addRecord(String tableName, String row, String[] fields, String[] values) throws IOException {
init();
Table table = connection.getTable(TableName.valueOf(tableName));
for (int i = 0; i != fields.length; i++) {
Put put = new Put(row.getBytes());
String[] cols = fields[i].split(":");
put.addColumn(cols[0].getBytes(), cols[1].getBytes(), values[i].getBytes());
table.put(put);
}
table.close();
close();
}
public static void init() {
configuration = HBaseConfiguration.create();
configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
try {
connection = ConnectionFactory.createConnection(configuration);
admin = connection.getAdmin();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void close() {
try {
if (admin != null) {
admin.close();
}
if (null != connection) {
connection.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String[] fields = {"Score:Math", "Score:Computer Science", "Score:English"};
String[] values = {"99", "80", "100"};
try {
addRecord("person", "Score", fields, values);
} catch (IOException e) {
e.printStackTrace();
}
}
}
（3）scanColumn(String tableName, String column)
浏览表tableName某一列的数据，如果某一行记录中该列数据不存在，则返回null。要求当参数column为某一列族名称时，如果底下有若干个列限定符，则要列出每个列限定符代表的列的数据；当参数column为某一列具体名称（例如“Score:Math”）时，只需要列出该列的数据。
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
public class ScanColumn {
public static Configuration configuration;
public static Connection connection;
public static Admin admin;
public static void scanColumn(String tableName, String column) throws IOException {
init();
Table table = connection.getTable(TableName.valueOf(tableName));
Scan scan = new Scan();
scan.addFamily(Bytes.toBytes(column));
ResultScanner scanner = table.getScanner(scan);
for (Result result = scanner.next(); result != null; result = scanner.next()) {
showCell(result);
}
table.close();
close();
}
public static void showCell(Result result) {
Cell[] cells = result.rawCells();
for (Cell cell : cells) {
System.out.println("RowName:" + new String(CellUtil.cloneRow(cell)) + " ");
System.out.println("Timetamp:" + cell.getTimestamp() + " ");
System.out.println("column Family:" + new String(CellUtil.cloneFamily(cell)) + " ");
System.out.println("row Name:" + new String(CellUtil.cloneQualifier(cell)) + " ");
System.out.println("value:" + new String(CellUtil.cloneValue(cell)) + " ");
}
}
public static void init() {
configuration = HBaseConfiguration.create();
configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
try {
connection = ConnectionFactory.createConnection(configuration);
admin = connection.getAdmin();
} catch (IOException e) {
e.printStackTrace();
}
}
// 关闭连接
public static void close() {
try {
if (admin != null) {
admin.close();
}
if (null != connection) {
connection.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
scanColumn("person", "Score");
} catch (IOException e) {
e.printStackTrace();
}
}
}
（4）modifyData(String tableName, String row, String column)
修改表tableName，行row（可以用学生姓名S_Name表示），列column指定的单元格的数据。
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import java.io.IOException;
public class ModifyData {
public static long ts;
public static Configuration configuration;
public static Connection connection;
public static Admin admin;
public static void modifyData(String tableName, String row, String column, String val) throws IOException {
init();
Table table = connection.getTable(TableName.valueOf(tableName));
Put put = new Put(row.getBytes());
Scan scan = new Scan();
ResultScanner resultScanner = table.getScanner(scan);
for (Result r : resultScanner) {
for (Cell cell : r.getColumnCells(row.getBytes(), column.getBytes())) {
ts = cell.getTimestamp();
}
}
put.addColumn(row.getBytes(), column.getBytes(), ts, val.getBytes());
table.put(put);
table.close();
close();
}
public static void init() {
configuration = HBaseConfiguration.create();
configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
try {
connection = ConnectionFactory.createConnection(configuration);
admin = connection.getAdmin();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void close() {
try {
if (admin != null) {
admin.close();
}
if (null != connection) {
connection.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
modifyData("person", "Score", "Math", "100");
} catch (IOException e) {
e.printStackTrace();
}
}
}
（5）deleteRow(String tableName, String row)
删除表tableName中row指定的行的记录。
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import java.io.IOException;
public class ModifyData {
public static long ts;
public static Configuration configuration;
public static Connection connection;
public static Admin admin;
public static void modifyData(String tableName, String row, String column, String val) throws IOException {
init();
Table table = connection.getTable(TableName.valueOf(tableName));
Put put = new Put(row.getBytes());
Scan scan = new Scan();
ResultScanner resultScanner = table.getScanner(scan);
for (Result r : resultScanner) {
for (Cell cell : r.getColumnCells(row.getBytes(), column.getBytes())) {
ts = cell.getTimestamp();
}
}
put.addColumn(row.getBytes(), column.getBytes(), ts, val.getBytes());
table.put(put);
table.close();
close();
}
public static void init() {
configuration = HBaseConfiguration.create();
configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
try {
connection = ConnectionFactory.createConnection(configuration);
admin = connection.getAdmin();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void close() {
try {
if (admin != null) {
admin.close();
}
if (null != connection) {
connection.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
modifyData("person", "Score", "Math", "100");
} catch (IOException e) {
e.printStackTrace();
}
}
}
4.实验报告
|
题目： |
|
姓名 |
|
日期 |
|
实验环境： |
||||
|
实验内容与完成情况： |
||||
|
出现的问题： |
||||
|
解决方案（列出遇到的问题和解决办法，列出没有解决的问题）： |
||||
实验4
NoSQL和关系数据库的操作比较
1.实验目的
（1）理解四种数据库(MySQL、HBase、Redis和MongoDB)的概念以及不同点；
（2）熟练使用四种数据库操作常用的Shell命令；
（3）熟悉四种数据库操作常用的Java API。
2.实验平台
（1）操作系统：Linux（建议Ubuntu16.04或Ubuntu18.04）；
（2）Hadoop版本：3.1.3；
（3）MySQL版本：5.6；
（4）HBase版本：2.2.2；
（5）Redis版本：5.0.5；
（6）MongoDB版本：4.0.16；
（7）JDK版本：1.8；
（8）Java IDE：Eclipse；
3.实验步骤
（一） MySQL数据库操作
学生表如14-7所示。
表14-7 学生表Student
|
Name |
English |
Math |
Computer |
|
zhangsan |
69 |
86 |
77 |
|
lisi |
55 |
100 |
88 |
- 根据上面给出的Student表，在MySQL数据库中完成如下操作：
（1）在MySQL中创建Student表，并录入数据；
（2）用SQL语句输出Student表中的所有记录；
（3）查询zhangsan的Computer成绩；
（4）修改lisi的Math成绩，改为95。
2.根据上面已经设计出的Student表，使用MySQL的JAVA客户端编程实现以下操作：
（1）向Student表中添加如下所示的一条记录：
|
scofield |
45 |
89 |
100 |
package Main;
import java.sql.*;
import com.mysql.jdbc.Driver;
public class main{
static final String DRIVER="com.mysql.jdbc.Driver";
static final String DB="jdbc:mysql://localhost/student?useSSL=false";
static final String USER="root";
static final String PASSWD="123456";
public static void main(String[] args) {
Connection conn=null;
Statement stmt=null;
try {
//加载驱动程序
Class.forName(DRIVER);
System.out.println("Connecting to a selected database...");
//打开一个连接
conn=DriverManager.getConnection(DB, USER, PASSWD);
//执行一个查询
stmt=conn.createStatement();
String sql="insert into student values('scofield',45,89,100)";
stmt.executeUpdate(sql);
System.out.println("Inserting records into the table successfully!");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}catch (SQLException e) {
e.printStackTrace();
}finally
{
if(stmt!=null)
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
if(conn!=null)
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
（2）获取scofield的English成绩信息
package Main;
import java.sql.*;
import com.mysql.jdbc.Driver;
public class main {
static final String DRIVER="com.mysql.jdbc.Driver";
static final String DB="jdbc:mysql://localhost/student?useSSL=false";
//Database auth
static final String USER="root";
static final String PASSWD="root";
public static void main(String[] args) {
Connection conn=null;
Statement stmt=null;
ResultSet rs=null;
try {
Class.forName(DRIVER);
System.out.println("Connecting to a selected database...");
conn=DriverManager.getConnection(DB, USER, PASSWD);
stmt=conn.createStatement();
String sql="select name,English from student where name='scofield' ";
rs=stmt.executeQuery(sql);
System.out.println("name"+"\t\t"+"English");
while(rs.next())
{
System.out.print(rs.getString(1)+"\t\t");
System.out.println(rs.getInt(2));
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}catch (SQLException e) {
e.printStackTrace();
}finally
{
if(rs!=null)
try {
rs.close();
} catch (SQLException e1) {
e1.printStackTrace();
}
if(stmt!=null)
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
if(conn!=null)
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
（二）HBase数据库操作
学生表Student如表14-8所示。
表14-8 学生表Student
|
name |
score |
|||
|
English |
Math |
Computer |
||
|
zhangsan |
69 |
86 |
77 |
|
|
lisi |
55 |
100 |
88 |
|
根据上面给出的学生表Student的信息，执行如下操作：
（1）用Hbase Shell命令创建学生表Student；
（2）用scan命令浏览Student表的相关信息；
（3）查询zhangsan的Computer成绩；
（4）修改lisi的Math成绩，改为95。
2.根据上面已经设计出的Student表，用HBase API编程实现以下操作：
（1）添加数据：English:45 Math:89 Computer:100
|
scofield |
45 |
89 |
100 |
package Main;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
public class main {
public static Configuration configuration;
public static Connection connection;
public static Admin admin;
public static void main(String[] args) {
// TODO Auto-generated method stub
configuration = HBaseConfiguration.create();
configuration.set("hbase.rootdir","hdfs://127.0.0.1:8020/hbase");
try{
connection = ConnectionFactory.createConnection(configuration);
admin = connection.getAdmin();
}catch (IOException e){
e.printStackTrace();
}
try {
insertRow("student","scofield","score","English","45");
insertRow("student","scofield","score","Math","89");
insertRow("student","scofield","score","Computer","100");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
close();
}
public static void insertRow(String tableName,String rowKey,String colFamily,
String col,String val) throws IOException {
Table table = connection.getTable(TableName.valueOf(tableName));
Put put = new Put(rowKey.getBytes());
put.addColumn(colFamily.getBytes(), col.getBytes(), val.getBytes());
table.put(put);
table.close();
}
public static void close(){
try{
if(admin != null){
admin.close();
}
if(null != connection){
connection.close();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
（2）获取scofield的English成绩信息。
package Main;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Table;
public class main {
public static Configuration configuration;
public static Connection connection;
public static Admin admin;
public static void main(String[] args) {
// TODO Auto-generated method stub
configuration = HBaseConfiguration.create();
configuration.set("hbase.rootdir", "hdfs://127.0.0.1:8020/hbase");
try {
connection = ConnectionFactory.createConnection(configuration);
admin = connection.getAdmin();
} catch (IOException e) {
e.printStackTrace();
}
try {
getData("student", "scofield", "score", "English");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
close();
}
public static void getData(String tableName, String rowKey, String colFamily,
String col) throws IOException {
Table table = connection.getTable(TableName.valueOf(tableName));
Get get = new Get(rowKey.getBytes());
get.addColumn(colFamily.getBytes(), col.getBytes());
Result result = table.get(get);
showCell(result);
table.close();
}
public static void showCell(Result result) {
Cell[] cells = result.rawCells();
for (Cell cell : cells) {
System.out.println("RowName:" + new String(CellUtil.cloneRow(cell)) + " ");
System.out.println("Timetamp:" + cell.getTimestamp() + " ");
System.out.println("column Family:" + new String(CellUtil.cloneFamily(cell)) + " ");
System.out.println("row Name:" + new String(CellUtil.cloneQualifier(cell)) + " ");
System.out.println("value:" + new String(CellUtil.cloneValue(cell)) + " ");
}
}
public static void close() {
try {
if (admin != null) {
admin.close();
}
if (null != connection) {
connection.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
（三）Redis数据库操作
Student键值对如下：
|
zhangsan:｛ English: 69 Math: 86 Computer: 77 ｝ lisi:｛ English: 55 Math: 100 Computer: 88 ｝ |
1. 根据上面给出的键值对，完成如下操作：
（1）用Redis的哈希结构设计出学生表Student（键值可以用student.zhangsan和student.lisi来表示两个键值属于同一个表）；
（2）用hgetall命令分别输出zhangsan和lisi的成绩信息；
（3）用hget命令查询zhangsan的Computer成绩；
（4）修改lisi的Math成绩，改为95。
2.根据上面已经设计出的学生表Student，用Redis的JAVA客户端编程(jedis)，实现如下操作：
（1）添加数据：English:45 Math:89 Computer:100
该数据对应的键值对形式如下：
|
scofield:｛ English: 45 Math: 89 Computer: 100 ｝ |
package Main;
import java.util.Map;
import redis.clients.jedis.Jedis;
public class main {
/**
* @param args
*/
public static void main(String[] args) {
Jedis jedis = new Jedis("127.0.0.1:6379");
jedis.hset("student.scofield", "English","45");
jedis.hset("student.scofield", "Math","89");
jedis.hset("student.scofield", "Computer","100");
Map<String,String> value = jedis.hgetAll("student.scofield");
for(Map.Entry<String, String> entry:value.entrySet())
{
System.out.println(entry.getKey()+":"+entry.getValue());
}
}
}
（2）获取 scofield 的 English 成绩信息
package Main;
import java.util.Map;
import redis.clients.jedis.Jedis;
public class main {
/**
* @param args
*/
public static void main(String[] args) {
Jedis jedis = new Jedis("localhost");
jedis.hset("student.scofield", "English","45");
jedis.hset("student.scofield", "Math","89");
jedis.hset("student.scofield", "Computer","100");
Map<String,String> value = jedis.hgetAll("student.scofield");
for(Map.Entry<String, String> entry:value.entrySet())
{
System.out.println(entry.getKey()+":"+entry.getValue());
}
}
}
（四）MongoDB数据库操作
Student文档如下:
|
{ “name”: “zhangsan”, “score”: { “English”: 69, “Math”: 86, “Computer”: 77 } } { “name”: “lisi”, “score”: { “English”: 55, “Math”: 100, “Computer”: 88 } } |
1.根据上面给出的文档，完成如下操作：
（1）用MongoDB Shell设计出student集合；
（2）用find()方法输出两个学生的信息；
（3）用find()方法查询zhangsan的所有成绩(只显示score列)；
（4）修改lisi的Math成绩，改为95。
2.根据上面已经设计出的Student集合，用MongoDB的Java客户端编程，实现如下操作：
（1）添加数据：English:45 Math:89 Computer:100
与上述数据对应的文档形式如下：
|
{ “name”: “scofield”, “score”: { “English”: 45, “Math”: 89, “Computer”: 100 } } |
package Main;
import java.util.ArrayList;
import java.util.List;
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
public class main {
public static void main(String[] args) {
MongoClient mongoClient = new MongoClient("localhost", 27017);
MongoDatabase mongoDatabase = mongoClient.getDatabase("student");
MongoCollection<Document> collection = mongoDatabase.getCollection("student");
Document document = new Document("name", "scofield").
append("score", new Document("English", 45).
append("Math", 89).
append("Computer", 100));
List<Document> documents = new ArrayList<Document>();
documents.add(document);
collection.insertMany(documents);
System.out.println("文档插入成功");
}
}
（2）获取scofield的所有成绩成绩信息(只显示score列)
package Main;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
public class main {
public static void main(String[] args) {
MongoClient mongoClient=new MongoClient("localhost",27017);
MongoDatabase mongoDatabase = mongoClient.getDatabase("student");
MongoCollection<Document> collection = mongoDatabase.getCollection("student");
MongoCursor<Document> cursor=collection.find( new Document("name","scofield")).
projection(new Document("score",1).append("_id", 0)).iterator();
while(cursor.hasNext())
System.out.println(cursor.next().toJson());
}
}
4.实验报告
|
题目： |
|
姓名 |
|
日期 |
|
实验环境： |
||||
|
实验内容与完成情况： |
||||
|
出现的问题： |
||||
|
解决方案（列出遇到的问题和解决办法，列出没有解决的问题）： |
||||
实验5
MapReduce初级编程实践
1.实验目的
（1）通过实验掌握基本的MapReduce编程方法；
（2）掌握用MapReduce解决一些常见的数据处理问题，包括数据去重、数据排序和数据挖掘等。
2.实验平台
（1）操作系统：Linux（建议Ubuntu16.04或Ubuntu18.04）
（2）Hadoop版本：3.1.3
3.实验步骤
（一）编程实现文件合并和去重操作
对于两个输入文件，即文件A和文件B，请编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C。下面是输入文件和输出文件的一个样例供参考。
输入文件A的样例如下：
|
20170101 x 20170102 y 20170103 x 20170104 y 20170105 z 20170106 x |
输入文件B的样例如下：
|
20170101 y 20170102 y 20170103 x 20170104 z 20170105 y |
根据输入文件A和B合并得到的输出文件C的样例如下：
|
20170101 x 20170101 y 20170102 y 20170103 x 20170104 y 20170104 z 20170105 y 20170105 z 20170106 x |
（二）编写程序实现对输入文件的排序
现在有多个输入文件，每个文件中的每行内容均为一个整数。要求读取所有文件中的整数，进行升序排序后，输出到一个新的文件中，输出的数据格式为每行两个整数，第一个数字为第二个整数的排序位次，第二个整数为原待排列的整数。下面是输入文件和输出文件的一个样例供参考。
输入文件1的样例如下：
|
33 37 12 40 |
输入文件2的样例如下：
|
4 16 39 5 |
输入文件3的样例如下：
|
1 45 25 |
根据输入文件1、2和3得到的输出文件如下：
|
1 1 2 4 3 5 4 12 5 16 6 25 7 33 8 37 9 39 10 40 11 45 |
（三）对给定的表格进行信息挖掘
下面给出一个child-parent的表格，要求挖掘其中的父子辈关系，给出祖孙辈关系的表格。
输入文件内容如下：
|
child parent Steven Lucy Steven Jack Jone Lucy Jone Jack Lucy Mary Lucy Frank Jack Alice Jack Jesse David Alice David Jesse Philip David Philip Alma Mark David Mark Alma |
输出文件内容如下：
|
grandchild grandparent Steven Alice Steven Jesse Jone Alice Jone Jesse Steven Mary Steven Frank Jone Mary Jone Frank Philip Alice Philip Jesse Mark Alice Mark Jesse |
4.实验报告
|
题目： |
|
姓名 |
|
日期 |
|
实验环境： |
||||
|
实验内容与完成情况： |
||||
|
出现的问题： |
||||
|
解决方案（列出遇到的问题和解决办法，列出没有解决的问题）： |
||||
实验6
熟悉Hive的基本操作
1.实验目的
（1）理解Hive作为数据仓库在Hadoop体系结构中的角色。
（2）熟练使用常用的HiveQL。
2.实验平台
操作系统：Ubuntu18.04（或Ubuntu16.04）。
Hadoop版本：3.1.3。
Hive版本：3.1.2。
JDK版本：1.8。
3.数据集
由《Hive编程指南》(O'Reilly系列，人民邮电出版社)提供，下载地址：
https://raw.githubusercontent.com/oreillymedia/programming_hive/master/prog-hive-1st-ed-data.zip
备用下载地址：
https://www.cocobolo.top/FileServer/prog-hive-1st-ed-data.zip
解压后可以得到本实验所需的stocks.csv和dividends.csv两个文件。
4.实验步骤
（1）创建一个内部表stocks，字段分隔符为英文逗号，表结构如表14-11所示。
表14-11 stocks表结构
|
col_name |
data_type |
|
exchange |
string |
|
symbol |
string |
|
ymd |
string |
|
price_open |
float |
|
price_high |
float |
|
price_low |
float |
|
price_close |
float |
|
volume |
int |
|
price_adj_close |
float |
（2）创建一个外部分区表dividends（分区字段为exchange和symbol），字段分隔符为英文逗号，表结构如表14-12所示。
表14-12 dividends表结构
|
col_name |
data_type |
|
ymd |
string |
|
dividend |
float |
|
exchange |
string |
|
symbol |
string |
（3）从stocks.csv文件向stocks表中导入数据。
（4） 创建一个未分区的外部表dividends_unpartitioned，并从dividends.csv向其中导入数据，表结构如表14-13所示。
表14-13 dividends_unpartitioned表结构
|
col_name |
data_type |
|
ymd |
string |
|
dividend |
float |
|
exchange |
string |
|
symbol |
string |
（5）通过对dividends_unpartitioned的查询语句，利用Hive自动分区特性向分区表dividends各个分区中插入对应数据。
（6）查询IBM公司(symbol=IBM)从2000年起所有支付股息的交易日(dividends表中有对应记录)的收盘价(price_close)。
（7）查询苹果公司(symbol=AAPL)2008年10月每个交易日的涨跌情况，涨显示rise，跌显示fall,不变显示unchange。
（8）查询stocks表中收盘价(price_close)比开盘价(price_open)高得最多的那条记录的交易所(exchange)、股票代码(symbol)、日期(ymd)、收盘价、开盘价及二者差价。
（9）从stocks表中查询苹果公司（symbol=AAPL）年平均调整后收盘价(price_adj_close) 大于50美元的年份及年平均调整后收盘价。
（10）查询每年年平均调整后收盘价(price_adj_close)前三名的公司的股票代码及年平均调整后收盘价。
5.实验报告
|
题目： |
|
姓名 |
|
日期： |
|
实验环境： |
||||
|
实验内容与完成情况： |
||||
|
出现的问题： |
||||
|
解决方案（列出遇到的问题和解决办法，列出没有解决的问题）： |
||||
实验7
Spark初级编程实践
1.实验目的
（1）掌握使用Spark访问本地文件和HDFS文件的方法
（2）掌握Spark应用程序的编写、编译和运行方法
2.实验平台
（1）操作系统：Ubuntu18.04（或Ubuntu16.04）；
（2）Spark版本：2.4.0；
（3）Hadoop版本：3.1.3。
3.实验步骤
（1）Spark读取文件系统的数据
（1）在spark-shell中读取Linux系统本地文件“/home/hadoop/test.txt”，然后统计出文件的行数；
（2）在spark-shell中读取HDFS系统文件“/user/hadoop/test.txt”（如果该文件不存在，请先创建），然后，统计出文件的行数；
（3）编写独立应用程序（推荐使用Scala语言），读取HDFS系统文件“/user/hadoop/test.txt”（如果该文件不存在，请先创建），然后，统计出文件的行数；通过sbt工具将整个应用程序编译打包成 JAR包，并将生成的JAR包通过 spark-submit 提交到 Spark 中运行命令。
/* SimpleApp.scala */
import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._
import org.apache.spark.SparkConf
object SimpleApp {
def main(args: Array[String]) {
val logFile = " hdfs://localhost:9000/user/hadoop/test.txt"
val conf = new SparkConf().setAppName("Simple Application")
val sc = new SparkContext(conf)
val logData = sc.textFile(logFile, 2)
val num = logData.count()
printf("The num of this file is %d rows", num)
}
}
name := "Simple Project"
version := "1.0"
scalaVersion := "2.11.12"
libraryDependencies += "org.apache.spark" %% "spark-core" % "2.4.0"
（2）编写独立应用程序实现数据去重
对于两个输入文件A和B，编写Spark独立应用程序（推荐使用Scala语言），对两个文件进行合并，并剔除其中重复的内容，得到一个新文件C。下面是输入文件和输出文件的一个样例，供参考。
输入文件A的样例如下：
20170101 x
20170102 y
20170103 x
20170104 y
20170105 z
20170106 z
输入文件B的样例如下：
20170101 y
20170102 y
20170103 x
20170104 z
20170105 y
根据输入的文件A和B合并得到的输出文件C的样例如下：
20170101 x
20170101 y
20170102 y
20170103 x
20170104 y
20170104 z
20170105 y
20170105 z
20170106 z
import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._
import org.apache.spark.SparkConf
import org.apache.spark.HashPartitioner
object RemDup {
def main(args: Array[String]) {
val conf = new SparkConf().setAppName("RemDup")
val sc = new SparkContext(conf)
val dataFile = "file:///home/charles/data"
val data = sc.textFile(dataFile,2)
val res = data.filter(_.trim().length>0).map(line=>(line.trim,"")).partitionBy(new HashPartitioner(1)).groupByKey().sortByKey().keys
res.saveAsTextFile("result")
}
}
（3）编写独立应用程序实现求平均值问题
每个输入文件表示班级学生某个学科的成绩，每行内容由两个字段组成，第一个是学生名字，第二个是学生的成绩；编写Spark独立应用程序求出所有学生的平均成绩，并输出到一个新文件中。下面是输入文件和输出文件的一个样例，供参考。
Algorithm成绩：
小明 92
小红 87
小新 82
小丽 90
Database成绩：
小明 95
小红 81
小新 89
小丽 85
Python成绩：
小明 82
小红 83
小新 94
小丽 91
平均成绩如下：
(小红,83.67)
(小新,88.33)
(小明,89.67)
(小丽,88.67)
import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._
import org.apache.spark.SparkConf
import org.apache.spark.HashPartitioner
object AvgScore {
def main(args: Array[String]) {
val conf = new SparkConf().setAppName("AvgScore")
val sc = new SparkContext(conf)
val dataFile = "file:///home/hadoop/data"
val data = sc.textFile(dataFile,3)
val res = data.filter(_.trim().length>0).map(line=>(line.split(" ")(0).trim(),line.split(" ")(1).trim().toInt)).partitionBy(new HashPartitioner(1)).groupByKey().map(x => {
var n = 0
var sum = 0.0
for(i <- x._2){
sum = sum + i
n = n +1
}
val avg = sum/n
val format = f"$avg%1.2f".toDouble
(x._1,format)
})
res.saveAsTextFile("resultAvgscore")
}
}
4.实验报告
|
题目： |
|
姓名 |
|
日期 |
|
实验环境： |
||||
|
实验内容与完成情况： |
||||
|
出现的问题： |
||||
|
解决方案（列出遇到的问题和解决办法，列出没有解决的问题）： |
||||
浙公网安备 33010602011771号