MapReduce
Superrigardo: Granda datumo estas nova paradigm kaj ĝia pretigo estas la plej grava areo koncentri. Granda datumo plu-gvidas al la granda volumo de datumo kiu venas de malsamaj fontoj kiel socia amaskomunikilaro, Sentila datumo, Movebla datumo, Interreta datumo kaj multaj pli. En ĉi tiu artikolo ni koncentros sur la pretiga parto uzanta Hadoop kadro kaj Mapo-Redukti programaron. Mapo-Redukti povas esti difinita kiel speciala tipo de programara kadro uzita pretigi grandegan kvanton de datumo en distribuita kadron vokis komercaĵan ladaĵejon. Do la artikolo priskribos la Mapon-Redukti konceptojn kaj ĝia praktika efektivigo uzanta Java kodo.
Enkonduko: Hadoop MapReduce povas esti difinita kiel softvara programaro kadro uzita pretigi grandan volumon de datumo (En terabyte nivelo) En paralela medio de clustered nodoj. La grapolo konsistas de miloj de nodoj de komercaĵa ladaĵejo. La pretigo estas distribuita, Fidinda kaj misfaro tolerant. Tipa MapReduce laborposteno estas elfarita laŭ la sekvantaj paŝoj
1) Fendi la datumon en sendependaj blokoj bazita sur kerna-valora paro. Tio ĉi estas farita de Mapa tasko en paralela maniero.
2) La ekstere metita de la Mapa laborposteno estas ordigis bazita sur la kernaj valoroj.
3) La ordigita produktadon estas la enigo al la Redukti laborpostenon. Kaj tiam ĝi produktas la finan produktadon al la pretigo kaj revenas la rezulton al la kliento.
Noto: Komercaĵa ladaĵejo estas resume malalte kostita komputilajn sistemojn
MapReduce kadro: Apache Hadoop MapReduce kadro estas skribita en Java. La kadro konsistas de mastra-sklava konfiguracio. La mastro estas konata kiel JobTracker kaj la sklavoj estas konata kiel TaskTrackers.La mastro kontrolas la taskon pretigita sur la sklavoj (Kiu estas nenio sed la nodoj en grapolo). La komputado estas farita sur la sklavoj. Do la komputi kaj tenadaj nodoj estas la samaj en clustered medio. La koncepto estas ‘ Movi la komputadon al la nodoj kie la datumo estas entenita’, Kaj ĝi faras la pretigantan pli rapida.
MapReduce Pretigo: La MapReduce kadra modelo estas tre luma pezo. Do la kosto de ladaĵejo estas malalte komparita al aliaj kadroj. Sed samtempe ni devus kompreni ke la modelaj laboroj efike nur en distribuita medion kiel la pretigo estas farita sur nodoj kie la datumo loĝas. La aliaj ĉefaĵoj kiel scalability, fidindeco kaj misfara toleremo ankaŭ laboras bone sur distribuita medion.
MapReduce efektivigo: Nun ni diskutos pri la efektivigo de MapReduce modelo uzanta Java programara platformo. Sekvanta estas la malsamaj eroj de la tuta fino fini efektivigon.
- La Klienta programo Kiu estas la ŝofora klaso kaj iniciatas la procezon
- La Mapa funkcio Kiu elfaras la fendon uzanta la kernan-valora paro.
- La Redukti funkcion Kiu entuta la pretigita datumon kaj sendi la produktadon reen al la kliento.
Ŝofora klaso: Sekvanta estas ŝofora klaso kiu ligas la Mapon kaj Redukti funkcion kaj komencas la pretigon. Tio ĉi estas la klienta programo kiu iniciatas la procezon.
Listing1: La klienta programo (Ŝofora klaso) Iniciatanta la procezon
[Kodo]
Prezenti com.Mapreduce.Techalpine;
Importi org.Apache.Commons.Arbohakanta.Ŝtipo;
Importi org.Apache.Commons.Arbohakanta.LogFactory;
Importi org.Apache.Hadoop.Conf.Konfiguracio;
Importi org.Apache.Hadoop.Fs.Vojo;
Importi org.Apache.Hadoop.Io.Teksto;
Importi org.Apache.Hadoop.Mapreduce.Job;
Importi org.Apache.Hadoop.Mapreduce.Lib.Enigo.FileInputFormat;
Importi org.Apache.Hadoop.Mapreduce.Lib.Enigo.TextInputFormat;
Importi org.Apache.Hadoop.Mapreduce.Lib.Produktado.FileOutputFormat;
Importi org.Apache.Hadoop.Mapreduce.Lib.Produktado.TextOutputFormat;
/**
* @Aŭtoro kaushik amiko
*
* Tio ĉi estas la ĉefa ŝofora klaso iniciati la mapon-redukti
* Procezo. Ĝi fiksas la malantaŭan teron por la tuta procezo kaj
* Tiam komencas ĝin.
*/
Publika klaso DevXDriver {
Publika senmova malplena ĉefa(Ŝnuro[] Args) Ĵetas Escepton {
// Inicita konfiguracio
Konfiguracio configx = nova Konfiguracio();
// Aldoni rimedajn dosierojn
Configx.AddResource(Nova Vojo(“/Uzanto/hadoop/kerna-ejo.Xml”));
Configx.AddResource(Nova Vojo(“/Uzanto/hadoop/hdfs-ejo.Xml”));
// Krei MapReduce laborposteno
Job devxmapjob = nova Laborposteno(Configx,”DevXDriver.Klaso”);
Devxmapjob.SetJarByClass(DevXDriver.Klaso);
Devxmapjob.SetJobName(“DevX MapReduce Job”);
// Fiksita produktadon kay kaj valora klaso
Devxmapjob.SetOutputKeyClass(Teksto.Klaso);
Devxmapjob.SetOutputValueClass(Teksto.Klaso);
// Fiksita Mapan klason
Devxmapjob.SetMapperClass(DevXMap.Klaso);
// Fiksita Combiner klaso
Devxmapjob.SetCombinerClass(DevXReducer.Klaso);
// Fiksita Reducer klaso
Devxmapjob.SetReducerClass(DevXReducer.Klaso);
// Fiksita Mapan produktadon ŝlosilo kaj valoraj klasoj
Devxmapjob.SetMapOutputKeyClass(Teksto.Klaso);
Devxmapjob.SetMapOutputValueClass(Teksto.Klaso);
// Fiksita nombron de reducer taskoj
Devxmapjob.SetNumReduceTasks(10);
// Fiksita enigon kaj produktadan formaton klasoj
Devxmapjob.SetInputFormatClass(TextInputFormat.Klaso);
Devxmapjob.SetOutputFormatClass(TextOutputFormat.Klaso);
// Fiksita enigon kaj produktadan vojon
FileInputFormat.AddInputPath(Devxmapjob, Nova Vojo(“/Uzanta/mapo_reduktas/enigon/”));
FileOutputFormat.SetOutputPath(Devxmapjob,Nova Vojo(“/Uzanta/mapo_reduktas/eligita”));
// Komenci MapReduce laborposteno
Devxmapjob.WaitForCompletion(Vera);
}
}
[/Kodo]
Mapa funkcio: Tio ĉi estas priresponda por fendanta la datumon bazita sur la kerna-valora paro. Tio ĉi estas konata kiel mapanta de datumo.
Listing2: Tio ĉi estas Mapa funkcio fendanta la datumon en blokoj
[Kodo]
Prezenti com.Mapreduce.Techalpine;
Importi java.Io.BufferedReader;
Importi java.Io.InputStreamReader;
Importi java.Reto.URI;
Importi java.Util.StringTokenizer;
Importi org.Apache.Commons.Arbohakanta.Ŝtipo;
Importi org.Apache.Commons.Arbohakanta.LogFactory;
Importi org.Apache.Hadoop.Conf.Konfiguracio;
Importi org.Apache.Hadoop.Fs.FileSystem;
Importi org.Apache.Hadoop.Fs.Vojo;
Importi org.Apache.Hadoop.Io.LongWritable;
Importi org.Apache.Hadoop.Io.Teksto;
Importi org.Apache.Hadoop.Mapreduce.Mapper;
/**
* @Aŭtoro kaushik amiko
*
* Tio ĉi estas la mapa procezo. Ĝi faras la mapadon por ŝlosilvorto-valora paro.
*/
Publika klaso DevXMap etendas Mapper<LongWritable, Teksto, Teksto,Teksto> {
// Krei Vojon, BufferedReader kaj Teksto variables
Voja dosiero_vojo;
BufferedReader bufra_leganto;
Teksto tweet_valoras = novan Tekston();
/**
* @Param ŝlosilo
* @Param valoro
* @Param kunteksto
*/
Publika malplena mapo(LongWritable ŝlosilo, Teksta valoro, Kunteksta kunteksto) {
Provo{
// Krei konfiguracion por Mapo
Konfiguracio mapas_config = nova Konfiguracio();
// Ŝarĝi Hadoop kernaj dosieroj en konfiguracio
Mapi_config.AddResource(Nova Vojo(“/Uzanto/hadoop/kerna-ejo.Xml”));
Mapi_config.AddResource(Nova Vojo(“/Uzanto/hadoop/hdfs-ejo.Xml”));
// Krei variables
Laĉi searchkeyword = “”;
// Malferma dosiero de la dosiera vojo
Dosiera_vojo=nova Vojo(“Dosiera/deponejo/ŝlosiloj.Txt”);
FileSystem dosiera_sistemo = FileSystem.Akiras(URI.Kreas(“Dosiera/deponejo/ŝlosiloj.Txt”),Nova Konfiguracio());
// Ŝarĝa bufro leganto
Bufra_leganto=nova BufferedReader(Nova InputStreamReader(Dosiera_sistemo.Turniro(Dosiera_vojo)));
Dum(Bufra_leganto.Preta())
{
Searchkeyword=bufra_leganto.ReadLine().Bonorda();
}
// Akiri kernan valoron
Fina Teksto kerna_valoro = nova Teksto(Searchkeyword);
// Kontrola valoro kaj preni decidon
Se(Valori == null)
{
Reveno;
}
Alia{
StringTokenizer laĉas_tokens = nova StringTokenizer(Valoro.ToString(),”,”);
Int kalkulo = 0;
Dum(Laĉi_tokens.HasMoreTokens()) {
Kalkulo ++;
Se(Kalkulo <=1)
Daŭri;
Laĉi novan_tweet_valora = ŝnuro_tokens.NextToken().ToLowerCase().Bonorda().ReplaceAll(“\\*”,””);
Se(Nova_tweet_valoro.Enhavas(Searchkeyword.ToLowerCase().Bonorda())) {
Tweet_valoroj.Aro(Nova_tweet_valoro);
Kunteksto.Skribas(Kerna_valoro,Tweet_valoroj);
}
}
}
}
Kaptaĵo(Escepto e){
E.PrintStackTrace();
}
}
}
[/Kodo]
Redukti funkcion: Tio ĉi estas priresponda por aggregating la datumo. La agrego estas farita bazitan sur la kernaj valoroj. Sekve post kiam pretiganta kaj ordiganta la agregon kompletigita kaj sendas la rezulton reen al la klienta programo.
Listing3: La Redukti funkciajn agregaĵojn la pretigita datumon
[Kodo]
Prezenti com.Mapreduce.Techalpine;
Importi java.Io.BufferedReader;
Importi java.Io.IOException;
Importi java.Io.InputStreamReader;
Importi java.Reto.URI;
Importi java.Util.RandomAccess;
Importi java.Util.Regex.Matcher;
Importi java.Util.Regex.Skemo;
Importi org.Apache.Commons.Arbohakanta.Ŝtipo;
Importi org.Apache.Commons.Arbohakanta.LogFactory;
Importi org.Apache.Hadoop.Conf.Konfiguracio;
Importi org.Apache.Hadoop.Fs.FSDataOutputStream;
Importi org.Apache.Hadoop.Fs.FileSystem;
Importi org.Apache.Hadoop.Fs.Vojo;
Importi org.Apache.Hadoop.Io.Teksto;
Importi org.Apache.Hadoop.Mapreduce.Reducer;
/**
* @Aŭtoro kaushik amiko
*
* Tio ĉi estas la reducer funkcio. Ĝi agregaĵoj la produktado bazita sur la
* Ordiganta de kerna-valoraj paroj.
*/
Publika klaso DevXReducer etendas Reducer<Teksto ,Teksto,Teksto,Teksto>
{
// Krei variables por dosiera vojo
Vojo pozitiva_dosiera_vojo;
Vojo negativa_dosiera_vojo;
Voja produktado_dosiera_vojo;
Voja ŝlosilvorto_dosiera_vojo;
// Krei variables por bufro
BufferedReader pozitivaĵo_poluras_leganton;
BufferedReader negativa_poluri_leganton;
BufferedReader ŝlosilvorto_poluras_leganton;
// Krei variables por kalkulo
Senmova Duobla totala_rekordo_kalkulas=novan Duoblon(“0”);
Senmova Duoblo kalkulas_neg=nova Duoblo(“0”);
Senmova Duoblo kalkulas_pos=nova Duoblo(“0”);
Senmova Duoblo kalkulas_neu=nova Duoblo(“0”);
Senmova Duoblo procente_neg=nova Duoblo(“0”);
Senmova Duoblo procente_pos=nova Duoblo(“0”);
Senmova Duoblo procente_neu=nova Duoblo(“0”);
Skemo pattrn_matcher;
Matcher matcher_txt;
Senmova int nova_disputo=0;
FSDataOutputStream ekstere_1a,Ekstere_2a;
/**
* @Param ŝlosilo
* @Param valoroj
* @Param kunteksto
* @Ĵetas IOException
* @Ĵetas InterruptedException
*/
Publika malpleno reduktas(Teksta ŝlosilo, Iterable<Teksto> Valoroj,Kunteksta kunteksto) Ĵetas IOException, InterruptedException
{
// Krei konfiguracion por reducer
Konfiguracio reduktas_config = nova Konfiguracio();
// Ŝarĝi hadoop config dosieroj
Redukti_config.AddResource(Nova Vojo(“/Uzanto/hadoop/kerna-ejo.Xml”));
Redukti_config.AddResource(Nova Vojo(“/Uzanto/hadoop/hdfs-ejo.Xml”));
// Krei variables
Laĉi kernan_vorton = “”;
Ŝnura kontrolo_ŝlosilvorto=kerna_vorto;
Ŝlosilvorta_dosiero_vojo=nova Vojo(“Dosiera/deponejo/ŝlosiloj.Txt”);
FileSystem dosiera_sistemo_legis = FileSystem.Akiras(URI.Kreas(“Dosiera/deponejo/ŝlosiloj.Txt”),Nova Konfiguracio());
Ŝlosilvorto_poluras_leganton=nova BufferedReader(Nova InputStreamReader(Dosiera_sistemo_legita.Turniro(Ŝlosilvorta_dosiero_vojo)));
FileSystem akiras_filesys = FileSystem.Akiras(Redukti_config);
FileSystem akiras_filesys_posneg = FileSystem.Akiras(Redukti_config);
Voja vojo_eligas = novan Vojon(“/Uzanta/sento_produktada_dosiero.Txt”);
Voja vojo_eligas_posneg = nova Vojo(“/Uzanto/posneg_produktada_dosiero.Txt”);
// Akiri ŝlosilvorton
Dum(Ŝlosilvorto_poluras_leganton.Preta())
{
Kerna_vorta=ŝlosilvorto_poluras_leganton.ReadLine().Bonorda();
}
// Kontrola dosiero sistemo
Se (!Akiri_filesys.Ekzistas(Voja_produktado)) {
Ekstere_1a = akiras_filesys.Kreas(Voja_produktado);
Ekstere_2a = akiras_filesys_posneg.Kreas(Voja_produktado_posneg);
}
// Kontrola ŝlosilvorto komparado uzanta pozitivajn kaj negativajn vortarojn
Se(Kontrola_ŝlosilvorto.Egaluloj(Kerna.ToString().ToLowerCase()))
{
Por(Teksto nova_tweets:Valoroj)
{
// Ŝarĝi pozitivan vortan vortaron
Pozitiva_dosiera_vojo=nova Vojo(“/Uzanta/mapo_reduktas/pos_vortoj.Txt”);
FileSystem filesystem_unu = FileSystem.Akiras(URI.Kreas(“Registras/pos_vortoj.Txt”),Nova Konfiguracio());
Pozitiva_poluri_leganton=nova BufferedReader(Nova InputStreamReader(Filesystem_unu.Turniro(Pozitiva_dosiera_vojo)));
// Ŝarĝi negativan vorton disctinary
Negativa_dosiera_vojo = nova Vojo(“/Uzanta/mapo_reduktas/neg_vortoj.Txt”);
FileSystem filesystem_du = FileSystem.Akiras(URI.Kreas(“Registras/neg_vortoj.Txt”),Nova Konfiguracio());
Negativa_poluri_leganton =nova BufferedReader(Nova InputStreamReader(Filesystem_du.Turniro(Negativa_dosiera_vojo)));
++Totala_rekorda_kalkulo;
Boolea unua_flago=falsa;
Boolea dua_flago=falsa;
Laĉi ĉiuj_tweets=nova_tweets.ToString();
Laĉi unuan_regex = “”;
Laĉi duan_regex = “”;
Dum(Pozitiva_poluri_leganton.Preta())
{
Unue_regex=pozitivaĵo_poluras_leganton.ReadLine().Bonorda();
Nova_disputo ;
Pattrn_matcher = Skemo.Kompilas(Unua_regex, Skemo.KAZO_MALSIMPATIA);
Matcher_txt = pattrn_matcher.Matcher(Ĉiuj_tweets);
Unua_flago=matcher_txt.Trovas();
?
Se(Unua_flago)
{
Ekstere_2a.WriteBytes(Ĉiuj_tweets);
Kunteksto.Skribas(Nova Teksto(Unua_regex),Nova Teksto(Ĉiuj_tweets));
Rompiĝo;
}
}
Dum(Negativa_poluri_leganton.Preta())
{
Nova_disputo ;
Dua_regex=negativa_poluri_leganton.ReadLine().Bonorda();
Pattrn_matcher = Skemo.Kompilas(Dua_regex, Skemo.KAZO_MALSIMPATIA);
Matcher_txt = pattrn_matcher.Matcher(Ĉiuj_tweets);
Dua_flago=matcher_txt.Trovas();
Se(Dua_flago)
{
Ekstere_2a.WriteBytes(Ĉiuj_tweets);
Kunteksto.Skribas(Nova Teksto(Dua_regex),Nova Teksto(Ĉiuj_tweets));
Rompiĝo;
}
}
Se(Unua_flago&Dua_flago)
{
++Kalkuli_neu;
}
Alia
{
Se(Unua_flago)
{
++Kalkuli_pos;
}
Se(Dua_flago)
{
++Kalkuli_neg;
}
Se(Unue_malvigliĝi==falsan&Due_malvigliĝi==falsan)
{
++Kalkuli_neu;
}
}
// Proksimaj bufroj
Negativa_poluri_leganton.Egale();
Pozitiva_poluri_leganton.Egale();
}
// Kalkuli procentajn valorojn
Procente_pos=kalkulo_pos/totala_rekorda_kalkulo100;
Procente_neg=kalkulo_neg/totala_rekorda_kalkulo100;
Procente_neu=kalkulo_neu/totala_rekorda_kalkulo100;
Provo{
// Skribi al la dosieroj
Ekstere_1a.WriteBytes(“\N”+Kerna_vorto);
Ekstere_1a.WriteBytes(“,”+Totala_rekorda_kalkulo);
Ekstere_1a.WriteBytes(“,”+Procente_neg);
Ekstere_1a.WriteBytes(“,”+Procente_pos);
Ekstere_1a.WriteBytes(“,”+Procente_neu);
// Proksimaj dosieraj sistemoj
Ekstere_1a.Egale();
Akiri_filesys.Egale();
}Kaptaĵo(Escepto e){
E.PrintStackTrace();
}
}
}
}
[/Kodo]
Konkludo: En ĉi tiu artikolo mi diskutis la MapReduce pretigo uzanta Java programara medio. La malsama ero kiel Mapo kaj Redukti funkcion elfaras la ĉefan taskon kaj revenas la produktadon al la kliento. La pretigo elfaras efike sur distribuita medion nur. Do ni devus instali la Apache Hadoop kadron sur distribuita medion akiri la plej bonan rezulton.
Hope vi ĝuis la artikolon kaj vi estos kapabla efektivigi ĝin en via praktika programaro. Teni legadon.
