Contexte du projet
Pratique de projet complet professionnel Big Data, l'ensemble de données adopte l'ensemble de données public d'Ali Tianchi, lien de téléchargement : liste d'enquête sur les transactions de produits de consommation
Cet ensemble de données est un ensemble d'échantillons, avec un total de plus de 5 000 enregistrements, chaque enregistrement représente un produit de consommation informations de recherche sur les transactions. Vous trouverez ci-dessous une description de chaque champ :
消费者姓名：消费者的姓名。
年龄：消费者的年龄。
性别：消费者的性别。
月薪：消费者的月薪状况。
消费偏好：消费者在购买商品时的偏好类型，如性价比、功能性、时尚潮流、环保可持续等。
消费领域：消费者购买的商品领域，如家居用品、汽车配件、珠宝首饰、美妆护肤等。
购物平台：消费者常用的购物平台，如天猫、苏宁易购、淘宝、拼多多等。
支付方式：消费者在购物时使用的支付方式，如微信支付、货到付款、支付宝、信用卡等。
单次购买商品数量：消费者每次购买商品的数量。
优惠券获取情况：消费者在购物过程中是否获取到优惠券，如折扣优惠、免费赠品等。
购物动机：消费者购物的动机，如品牌忠诚、日常使用、礼物赠送、商品推荐等。
Grâce à l'analyse et à la visualisation d'ensembles de données, il est possible de comprendre les préférences d'achat, les habitudes de consommation et les motivations d'achat des consommateurs, fournissant ainsi une référence aux entreprises pour formuler des stratégies de marketing et le positionnement des produits.
1. Description de l'environnement du projet
Linux Ubuntu 16.04
jdk-7u75-linux-x64
eclipse-java-juno-SR2-linux-gtk-x86_64
Flume 1.5.0 -cdh5.4.5
Sqoop 1.4.5-cdh5.4.5
Hive-common-1.1.0-cdh5.4.5
Spark 1.6.0 Scala 2.10.5 kafka 0.8.2
Mysql Ver 14.14 Distrib 5.7.24 for Linux(x86_64)
2. Mapreduce nettoyage des données
1. Téléchargez le jeu de données et déplacez-vous dans le répertoire
Ouvrez le terminal, créez un répertoire, créez un nouveau fichier
mkdir /data/shiyan1
gedit /data/shiyan1/shujuji
Supprimez la ligne de titre du contenu téléchargé et écrivez-la dans le fichier shujuji (ou faites cette étape dans le programme mapreduce plus tard, mais ici, il faut d'abord supprimer la première ligne)
2. Téléchargez l'ensemble de données dans le cluster hadoop
hadoop fs -mkdir /shiyan1/origindata/
hadoop fs -put /data/shiyan1/shujuji /shiyan1/origindata/*
3. Écrivez mapreduce pour faire un nettoyage simple des données (supprimez quelques colonnes non pertinentes)
Créez d'abord un répertoire où les fichiers sont conservés après le nettoyage
hadoop fs -mkdir /shiyan1/cleandata/
Créez un nouveau projet dans eclipse, créez un nouveau dossier de répertoire, nommez-le lib et importez le package jar requis par le projet. Opération spécifique : sélectionnez tous les packages jar (appuyez sur la touche de raccourci Maj et maintenez-la enfoncée), cliquez avec le bouton droit sur Ajouter au chemin de construction. (Le package jar du projet se trouve dans la ressource de la page d'accueil de mon blog, qui doit être récupérée par moi-même)
Créez une nouvelle classe nommée Clean et écrivez le code suivant
package my.clean;
import java.io.IOException;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
public class Clean {
public static class doMapper extends Mapper<Object, Text, Text, Text> {
@Override
protected void map(Object key, Text value, Context context)
throws IOException, InterruptedException {
String[] arr = value.toString().split(",");
StringBuilder one = new StringBuilder();
one.append(arr[1]);
one.append("\t");
one.append(arr[2]);
one.append("\t");
one.append(arr[3]);
one.append("\t");
one.append(arr[4]);
one.append("\t");
one.append(arr[5]);
one.append("\t");
one.append(arr[9]);
one.append("\t");
one.append(arr[10]);
context.write(new Text(one.toString()), new Text(""));
}
}
public static void main(String[] args) throws IOException,
ClassNotFoundException, InterruptedException {
Job job = Job.getInstance();
job.setJobName("Clean");
job.setJarByClass(Clean.class);
job.setMapperClass(doMapper.class);
// job.setReducerClass(doReducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
Path in = new Path("hdfs://localhost:9000//shiyan1/origindata");
Path out = new Path("hdfs://localhost:9000//shiyan1/cleandata");
FileInputFormat.addInputPath(job, in);
FileOutputFormat.setOutputPath(job, out);
System.exit(job.waitForCompletion(true) ? 0 : 1);
}
}
4. Exécutez le programme et vérifiez les résultats
Faites un clic droit sur le projet, cliquez sur exécuter sur hadoop (faites attention de démarrer hadoop en premier)
Ouvrez le terminal, entrez la commande, affichez le résultat et téléchargez les données nettoyées sur le local
hadoop fs -cat /shiyan1/cleandata/part-r-00000 >> /data/shiyan1/cleandata
3. Hive données d'analyse hors ligne
1. Exécutez hive, entrez la ligne de commande interactive et créez des bases de données et des tables (la table interne par défaut, le chemin par défaut est /user/hive/warehouse/)
create database behavior;
use behavior;
create table xiaofei (age int,sex string,salary int,consumelike string,consumearea string, coupon string,shoppeupose string) row format delimited fields terminated by '\t' ;
2. Recharger les données depuis le local
load data local inpath '/data/shiyan1/cleandata' into table xiaofei;
Dans la ruche, effectuez une opération de requête pour vérifier si les données sont importées avec succès. S'il n'y a pas de données, voir s'il manque une commande
select * from xiaofei limit 10;
3. Écrire la requête sql pour l'analyse des données
Exigence 1 :
Dans la liste d'enquête sur les achats de biens de consommation, le nombre et la proportion de personnes d'âge moyen et âgées (35 ans) et de jeunes acheteurs :
select age,count(*) as num from(
select case when age>=35 then 1 when age<35 then 0 end as age from xiaofei
) t
group by age
(Le ratio de découverte est d'environ 1:2)
Exigence 2 : Statistiques des préférences de consommation et des motivations de consommation de différents âges, en explorant les occurrences les plus fréquentes et en découvrant ce que les personnes d'âges différents recherchent pour la consommation
select age,consumelike,shoppurpose,nums from (
select * ,row_number()over(partition by age order by nums desc) as rank from (
select age,consumelike,shoppurpose,nums from (
select age,consumelike,shoppurpose ,count(*) as nums from xiaofei
group by age,consumelike,shoppurpose
) t
where nums>=2
) p
) m
where rank = 1
(Les résultats statistiques montrent que certains groupes d'âge ont des activités de consommation plus concentrées, tandis que certains groupes d'âge ont des activités de consommation plus étendues, et les activités de consommation sont également assez différentes
) prendre les trois premiers pour chaque bit)
select sex ,coupon from (
select *, row_number()over(partition by sex order by num desc) as rank from (
select sex,coupon,count(*) as num from xiaofei
group by sex,coupon
) as t
) as p
where rank <=3
(Résultats statistiques : Indépendamment des hommes ou des femmes, les cadeaux gratuits sont toujours très tentants pour eux. De plus, les femmes aiment utiliser des coupons lors de leurs achats, tandis que les hommes achètent quand ils ont envie d'acheter. L'utilisation des coupons n'est pas très forte. grand)
4. Réécrivez les résultats de la requête dans la nouvelle table de la ruche pour une exportation sqoop ultérieure
Trois nouvelles tables sont créées ici pour enregistrer les résultats de la requête ci-dessus
create table agecount(age int,num int) row format delimited fields terminated by '\t' ;
create table agelike(age int,consumelike string,consumearea string,num int) row format delimited fields terminated by '\t' ;
create table sexcoupon(sex string,counpon string) row format delimited fields terminated by '\t' ;
Ajoutez ensuite insert into table avant l'instruction de requête, en prenant la première exigence comme exemple, et ainsi de suite
insert into table agecount select age,count(*) as num from(
select case when age>=35 then 1 when age<35 then 0 end as age from xiaofei
) t
group by age
4. Sqoop exporte les données de la ruche vers mysql
1. Installez l'environnement mysql et assurez-vous que le service a été démarré, puis lancez la commande
sudo service mysql start
2. Entrez dans la base de données mysql et créez les bibliothèques et tables correspondantes
Entrez votre nom d'utilisateur et votre mot de passe ici
mysql -u root -p
Créer une bibliothèque et créer une table sous la bibliothèque
CREATE DATABASE IF NOT EXISTS behavior DEFAULT CHARSET utf8 COLLATE utf8_general_ci;
use behavior;
create table agecount (age int ,num int);
create table agecount (age int ,consumelike varchar(200),consumearea varchar(200),num int);
create table sexcoupon(sex varchar(20),shoppurpose varchar(200));
3. Sqoop importe des données
sqoop export --connect jdbc:mysql://localhost:3306/behavior?characterEncoding=UTF-8 --username root --password strongs --table agecount --export-dir /user/hive/warehouse/behavior.db/agecount/000000_0 --input-fields-terminated-by '\t'
sqoop export --connect jdbc:mysql://localhost:3306/behavior?characterEncoding=UTF-8 --username root --password strongs --table agelike --export-dir /user/hive/warehouse/behavior.db/agelike/000000_0 --input-fields-terminated-by '\t'
sqoop export --connect jdbc:mysql://localhost:3306/behavior?characterEncoding=UTF-8 --username root --password strongs --table sexcoupon --export-dir /user/hive/warehouse/behavior.db/sexcoupon/000000_0 --input-fields-terminated-by '\t'
4. Exécutez la commande pour vérifier s'il y a des données dans la table Mysql
select * from sexcoupon;
Cinq, analyse en temps réel SparkStreaming
Voici une petite explication : étant donné que le projet lui-même doit utiliser un programme d'exploration pour explorer les données en temps réel du site Web, puis analyser le temps, le contenu des commentaires, etc. Cependant, étant donné que l'ensemble de données est téléchargé directement, il n'est pas facile d'effectuer une exploration en temps réel. Il est difficile de trouver des données disponibles similaires, puis de les filtrer, ce qui n'est pas l'objectif du projet. Voici donc un script shell pour simuler et générer des données en temps réel.
1. Créer un fichier projet
mkdir /data/shiyan1/realtime/datasource
mkdir /data/shiyan1/realtime/datarandom
mkdir /data/shiyan1/realtime/shellrealtime
2. Ecrire un script shell
Entrez d'abord dans le mode d'édition, si vous constatez que la commande gedit n'est pas reconnue, vous pouvez essayer d'utiliser vim ou vi
gedit /data/shiyan1/realtime/shellrealtime/time.sh
écrire ce qui suit
#!/bin/bash
file_count=1
while true;do
for i in {1..5} ; do
if read -r line; then
echo "$line" >> /data/shiyan1/realtime/datarandom/file_${file_count}.txt
else
break 2
fi
done
((file_count++))
sleep 10
done < /data/shiyan1/realtime/datasource/source
3. Démarrez le service flume pour voir s'il peut détecter une nouvelle génération de fichiers
Configurez le fichier conf de flume ci-dessous pour tester si flume peut fonctionner normalement
gedit spooldir_mem_logger.conf
Ajoutez les informations de configuration Flume suivantes au fichier, puis enregistrez et quittez. Faites-lui réaliser la fonction de surveillance du répertoire /data/shiyan1/realtime/datarandom et envoyez les fichiers lus à l'interface de la console.
agent1.sources=src
agent1.channels=ch
agent1.sinks=des
agent1.sources.src.type = spooldir
agent1.sources.src.restart = true
agent1.sources.src.spoolDir =/data/shiyan1/realtime/datarandom
agent1.channels.ch.type=memory
agent1.sinks.des.type = logger
agent1.sources.src.channels=ch
agent1.sinks.des.channel=ch
Après avoir configuré le fichier spooldir_mem_logger.conf, passez au répertoire d'installation de Flume et démarrez Flume. (Note : ici /data/edu6/ est le répertoire où je configure le fichier conf de flume )
cd /apps/flume
flume-ng agent -c /data/edu6/ -f /data/edu6/spooldir_mem_logger.conf -n agent1
-Dflume.root.logger=DEBUG,console
Exécutez le programme de script time.sh écrit ci-dessus et recherchez les modifications suivantes dans les fichiers du répertoire.
Si la détection est réussie, vous pouvez constater que le suffixe .COMPLETED est ajouté à la fin du fichier.
Veuillez ensuite supprimer tous les fichiers du répertoire /data/shiyan1/realtime/datarandom pour éviter l'impact de la surveillance du contenu du canal.
4. Démarrez le service kafka et détectez la connectivité des producteurs et des consommateurs
Pré-étapes : démarrez le service hadoop, le service zookeeper, puis entrez dans le répertoire d'installation de kafka et démarrez Kafka-server.
cd /apps/kafka
bin/kafka-server-start.sh config/server.properties
1. Une fois le service Kafka démarré, la fenêtre passe à l'état de blocage et un autre émulateur de port doit être démarré pour fonctionner.
Créez un sujet nommé flumesendkafka.
bin/kafka-topics.sh \
--create \
--zookeeper localhost:2181 \
--replication-factor 1 \
--topic flumesendkafka \
--partitions 1
Vérifiez quels sujets sont dans le Kafka actuel
/apps/kafka/bin/kafka-topics.sh --list --zookeeper localhost:2181
2. Appelez kafka-console-producer.sh dans le répertoire /apps/kafka/bin pour produire des messages, et le producteur est le producteur
cd /apps/kafka
bin/kafka-console-producer.sh --broker-list localhost:9092 --topic flumesendkafka
Ici, localhost est l'adresse IP de Kafka et 9092 est le port du nœud de courtier. Les utilisateurs peuvent saisir des informations sur l'interface de la console, les remettre au producteur pour traitement et les envoyer au consommateur.
3. Ouvrez une autre fenêtre, appelez kafka-console-consumer.sh dans le répertoire bin, démarrez le consommateur et utilisez le consommateur en tant que consommateur pour consommer des données.
cd /apps/kafka
bin/kafka-console-consumer.sh --zookeeper localhost:2181 --topic flumesendkafka
--from-beginning
kafka-console-consumer.sh doit encore ajouter certains paramètres, tels que l'adresse IP et le port de ZooKeeper, le nom du sujet, l'emplacement des données de lecture, etc.
4. Testez
Dans l'interface d'exécution de la commande kafka-console-producer.sh, entrez quelques lignes de texte et appuyez sur Entrée. Vous pouvez voir que du côté du consommateur, le même contenu sera produit
5. Écrire le programme de streaming Spark
Créez un nouveau projet Scala (si vous avez besoin du package jar utilisé par le projet, veuillez vous rendre sur les ressources de mon blog pour le télécharger vous-même), comptez le nombre
de nouvelles données dans chaque période et effectuez une analyse en temps réel. calcul
package my.streaming
import kafka.serializer.StringDecoder
import org.apache.spark.SparkConf
import org.apache.spark.streaming.StreamingContext
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.Seconds
import org.apache.spark.streaming.dstream.InputDStream
import java.sql.DriverManager
import java.sql.ResultSet
import java.sql.Connection
import java.sql.PreparedStatement
import java.text.SimpleDateFormat
import java.util.Date
object JianKong {
def main(args: Array[String]) {
val sparkConf = new SparkConf().setAppName("jiankong").setMaster("local[2]")
val ssc = new StreamingContext(sparkConf, Seconds(4))
ssc.checkpoint("checkpoint")
val topics = Set("flumesendkafka")
val brokers = "localhost:9092"
val zkQuorum = "localhost:2181"
val kafkaParams = Map[String, String](
"metadata.broker.list" -> brokers,
"serializer.class" -> "kafka.serializer.StringEncoder")
val lines = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, kafkaParams, topics).map(_._2)
lines.foreach(line => {
var strs = line.collect()
println(strs.size)
var finalNum = 0
for (str: String <- strs) {
/**Use Fastjson to parse jsonString!*/
println("finalNum : " + finalNum + "#"+ str)
if (!str.equals("")) {
finalNum = finalNum + 5
}
}
println("finalNum: " + finalNum)
var now: Date = new Date()
val dateFormat: SimpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
var creationtime = dateFormat.format(now)
val db_host = "localhost"
val db_name = "realtimebase"
val db_user = "root"
val db_passwd = "strongs"
val db_connection_str = "jdbc:mysql://" + db_host + ":3306/" + db_name + "?user=" + db_user + "&password=" + db_passwd
var conn: Connection = null
var ps: PreparedStatement = null
val sql = "insert into jiankong (creationtime, num) values (?, ?)"
try {
conn = DriverManager.getConnection(db_connection_str)
ps = conn.prepareStatement(sql)
ps.setString(1, creationtime)
ps.setInt(2, finalNum)
ps.executeUpdate()
} catch {
case e: Exception => println("MySQL Exception")
} finally {
if (ps != null) {
ps.close()
}
if (conn != null) {
conn.close()
}
}
})
ssc.start()
ssc.awaitTermination()
ssc.stop()
}
}
6. Démarrez le service Mysql et créez une table
sudo service mysql start
mysql -u root -p
CREATE DATABASE IF NOT EXISTS realtimebase DEFAULT CHARSET utf8 \
COLLATE utf8_general_ci;
use realtimebase
create table jiankong (creationtime datetime,num int);
De cette façon, le programme traité par sparkstreaming écrira les résultats dans la base de données Mysql, et enfin vérifiera combien de commentaires sont enregistrés dans chaque période de temps
7. Démarrez le programme de traitement en temps réel afin
1. Démarrez le serveur kafka
cd /apps/kafka
bin/kafka-server-start.sh config/server.properties
2. Démarrez le programme JianKong.scala de diffusion d'étincelles
3. Ouvrez un autre émulateur de terminal et démarrez le canal
cd /apps/flume
flume-ng agent -c /data/edu6/ -f /data/edu6/spooldir_mem_logger.conf -n agent1
-Dflume.root.logger=DEBUG,console
4. Démarrez le programme de robot d'exploration simulé
/data/shiyan1/realtime/shellrealtime/time.sh
5. Vérifiez MySQL et trouvez qu'il existe des statistiques correspondantes
Il s'avère qu'il existe un contenu correspondant dans la table Mysql et le traitement en temps réel se termine.