მიმოხილვა: Spring is one of the widely used frameworks in enterprise applications development. Spring აქვს სხვადასხვა კომპონენტები, როგორიცაა Spring ORM, საგაზაფხულო JDBC ა.შ. მხარდასაჭერად სხვადასხვა ფუნქციები. გაზაფხულის Apache Hadoop არის ფარგლებში, ხელი შეუწყოს განაცხადის შენობა Hadoop კომპონენტები, როგორიცაა HDFS, MapReduce და Hive ა.შ.. Spring უზრუნველყოფს APIs მუშაობა ყველა ეს კომპონენტი. საგაზაფხულო მხარს უჭერს Hadoop სხვა გაზაფხული ეკოსისტემის პროექტების რეალურ ცხოვრებაში განაცხადის განვითარების. ამ სტატიაში ჩვენ განვიხილავთ გამოყენება Spring ამისთვის Apache Hadoop ფარგლებში.
შესავალი:
Apache Hadoop არის ღია პროგრამული ფარგლებში, რომელიც გამოიყენება შესანახად და პროცესის მონაცემთა კომპლექტი დიდი მოცულობის. გაზაფხული ასევე ღია ჩარჩო, რომელიც ფართოდ გამოიყენება Java / J2EE პროგრამები. საგაზაფხულო დამოკიდებულების ინექცია (OF) და inversion კონტროლის (IO) მექანიზმი გახდა პოპულარული ალტერნატივა საწარმო Java ლობიო (ან EJB) model. საგაზაფხულო აქვს უპირატესობა, რომ მოქნილი საკმარისი უნდა იყოს ადვილად plugged ნებისმიერი სხვა განვითარების ჩარჩო. გამოყენება ამ უპირატესობა გაზაფხულზე, ჩვენ შეგვიძლია დანამატის იგი Apache Hadoop რომ დაგვეხმარება მიიღოს მაქსიმალური სარგებელი თითოეული ამ ორი ფარგლებში.
ვიწყებთ:
ამ სექციაში ჩვენ ვსაუბრობთ, თუ როგორ შექმნა Hadoop MapReduce სამსახური გამოყენება Spring. ეს მოიცავს შემდეგ საფეხურებს -
- Step 1 - მიიღოს საჭირო დამოკიდებულებები გამოყენებით Maven - როგორც ვიცით, maven არის დამოკიდებული pom.xml ფაილი, ჩვენ შემდეგი ჩანაწერების ჩვენი pom.xml ფაილი. ეს დამოკიდებულება მასალა არის Hadoop ძირითადი და საგაზაფხულო ფარგლებში.
Listing1: ნიმუში კონფიგურაციის მასალაა pom.xml ფაილი
[კოდი]
< !– საგაზაფხულო მონაცემთა Apache Hadoop — >
< დამოკიდებულება >
< groupId > org.springframework.data </ groupId >
< artifactId > გაზაფხულზე მონაცემთა Hadoop </ artifactId >
< version > 1.0.0.გავრცელებისთვის </ version >
< /დამოკიდებულება >
< !– Apache Hadoop Core -- >
< დამოკიდებულება >
< groupId > org.apache.hadoop </ groupId >
< artifactId > Hadoop-core </ artifactId >
< version > 1.0.3 </version >
</დამოკიდებულება>
[/ კოდი]
- Step 2 - შექმნა mapper კომპონენტი - როგორც ვიცით mapper კომპონენტი გამოიყენება შესვენება ფაქტობრივი პრობლემა შევიდა მცირე კომპონენტი. ეს პატარა კომპონენტები მაშინ უფრო ადვილი უნდა გადაწყვიტოს. შეგვიძლია ჩვენი საკუთარი ადრინდელს mapper კომპონენტი გავრცელებით Apache რუკა შეამციროს Mapper კლასის. ჩვენ უნდა გადაფაროს რუკა მეთოდი ამ კლასში. Mapper კლასის ელოდება შემდეგი პარამეტრებით -
შეყვანის: შემდეგი პარამეტრები შეყვანის გასაღები და მნიშვნელობა
- შემდეგ - ეს პარამეტრი აღწერს გასაღები ტიპის რომელიც არ არის გათვალისწინებული, როგორც შეყვანის mapper კომპონენტი.
- VALUEIN - ეს პარამეტრი აღწერს ტიპის ღირებულება, რომელიც არ არის გათვალისწინებული, როგორც შეყვანის mapper კომპონენტი.
გამომავალი: შემდეგი პარამეტრები გამომავალი გასაღები და მნიშვნელობა
- KEYOUT - ეს პარამეტრი აღწერს ტიპის გარეთ დააყენა გასაღები პარამეტრი საწყისი mapper კომპონენტი.
- VALUEOUT - ეს პარამეტრი აღწერს ტიპის გამომავალი ღირებულების mapper კომპონენტი.
თითოეული ამ პარამეტრების უნდა განახორციელონ ჩაწერადი interface. მოცემულ მაგალითად, ჩვენ გამოყენებული ჩვენი mapper წაკითხვის შინაარსი ფაილი ერთი ხაზის დროს და მოამზადოს გასაღები ღირებულება წყვილი ყველა ხაზი. ჩვენი განხორციელებას რუკაზე საშუალებას ასრულებს შემდეგ ამოცანებს -
- First, გაყოფილი თითოეული ხაზი სიტყვა
- მეორე, iterate მეშვეობით თითოეული სიტყვა და აიღოს არც ყველა Unicode სიმბოლოებს, რომლებიც არც წერილებს და არც გმირები.
- მესამე, მშენებლობა ძირითადი ღირებულების წყვილი გამოყენებით ჩაწერის მეთოდი კონტექსტი კლასის, რომელიც თავსებადია მოსალოდნელია გამომავალი ძირითადი ღირებულების წყვილი.
Listing2: Sample მორგებულია Mapper კლასის
[Code]
საჯარო კლასის MyWordMapper ვრცელდება Mapper<LongWritable, ტექსტი, ტექსტი, IntWritable> {
შეტყობინების ტექსტი myword = new ტექსტი();
@ Override
დაცული ბათილად რუკა(LongWritable გასაღები, ტექსტის მნიშვნელობა, კონტექსტში კონტექსტში) ისვრის IOException, InterruptedException {
სიმებიანი ხაზი = value.toString();
StringTokenizer lineTokenz = new StringTokenizer(line);
ხოლო (lineTokenz.hasMoreTokens()) {
სიმებიანი cleaned_data = removeNonLettersNonNumbers(lineTokenz.nextToken());
myword.set(cleaned_data);
context.write(myword, ახალი IntWritable(1));
}
}
/**
* შეცვლის ყველა Unicode სიმბოლოები, რომლებიც არც ნომრები და არც წერილები ცარიელი სტრიქონი.
* @param ორიგინალური, ეს არის ორიგინალური ტექსტი
* @return სიმებიანი ობიექტი, რომელიც შეიცავს მხოლოდ ასოები და ციფრები
*/
შეტყობინების String removeNonLettersNonNumbers (სიმებიანი ორიგინალური) {
დაბრუნდეს original.replaceAll(“[^ P{L}\\p{N}]”, “”);
}
}
[/Code]
Step 3 - შექმნა Reducer კომპონენტი - რედუქტორი არის კომპონენტი, რომელიც შლის არასასურველი შუალედური ღირებულებები და ფორვარდები მხოლოდ იმ გასაღები ღირებულება წყვილი, რომლებიც შესაბამისი. იმისათვის, რომ ჩვენი მორგებულია შეამცირა, ჩვენი კლასი უნდა გაგრძელდეს Reducer კლასი და მეტი ვისრიალოთ შემცირების მეთოდი. შეამცირა კლასის მოელის შემდეგ პარამეტრებით.
შეყვანის: შემდეგი პარამეტრები შეყვანის გასაღები და მნიშვნელობა
- შემდეგ - ეს პარამეტრი აღწერს გასაღები ტიპის რომელიც არ არის გათვალისწინებული, როგორც შეყვანის mapper კომპონენტი.
- VALUEIN - ეს პარამეტრი აღწერს ტიპის ღირებულება, რომელიც არ არის გათვალისწინებული, როგორც შეყვანის mapper კომპონენტი.
გამომავალი: შემდეგი პარამეტრები გამომავალი გასაღები და მნიშვნელობა
- KEYOUT - ეს პარამეტრი აღწერს ტიპის გარეთ დააყენა გასაღები პარამეტრი საწყისი mapper კომპონენტი
- VALUEOUT - ეს პარამეტრი აღწერს ტიპის გამომავალი ღირებულების mapper კომპონენტი.
განხორციელების დროს, ჩვენ უნდა დავრწმუნდეთ, რომ თემები, რომ "keyin" და "keyout" პარამეტრების იგივე. ასევე "valuein და valueout" პარამეტრების უნდა იყოს იგივე ტიპის. ჩვენი განხორციელების შემცირების საშუალებას ასრულებს შემდეგ ნაბიჯები -
- First, შეამოწმოს, რომ შეყვანის ძირითადი შეიცავს სასურველი სიტყვა.
- მეორე, თუ აღნიშნული ნაბიჯი მართალია, რომ რიგი შემთხვევები სიტყვა.
- მესამე, მშენებლობა ახალი ძირითადი ღირებულების წყვილი დარეკვით ჩაწერის მეთოდი შეამცირა კლასის.
Listing3: Sample მორგებულია Reducer კლასის
[Code]
იმპორტი org.apache.hadoop.io.IntWritable;
იმპორტი org.apache.hadoop.io.Text;
იმპორტი org.apache.hadoop.mapreduce.Reducer;
საჯარო კლასის MyWordReducer ვრცელდება Reducer<ტექსტი, IntWritable, ტექსტი, IntWritable> {
დაცული სტატიკური საბოლოო String MY_TARGET_TEXT = “Hadoop”;
@ Override
დაცული ბათილად შეამციროს(ტექსტი keyTxt, Iterable<IntWritable> ღირებულებები, კონტექსტში კონტექსტში) ისვრის IOException, InterruptedException {
თუ (containsTargetWord(keyTxt)) {
int wCount = 0;
ამისთვის (IntWritable მნიშვნელობა: ღირებულებები) {
wCount = value.get();
}
context.write(key, ახალი IntWritable(wCount));
}
}
შეტყობინების ლოგიკური containsTargetWord(ტექსტი keyTxt) {
დაბრუნდეს keyTxt.toString().უდრის(MY_TARGET_TEXT);
}
}
[/Code]
- Step 4 - შექმნა განაცხადის კონტექსტში - შემდეგი ნაბიჯი არის, რათა შეიქმნას განაცხადის კონტექსტში გამოყენებით XML. ჩვენ შეგვიძლია კონფიგურაციის განაცხადის კონტექსტში ჩვენი პროგრამა შემდეგი ნაბიჯების გამოყენებით -
- შექმნა თვისებები ფაილი, რომელიც შეიცავს ღირებულება კონფიგურაციის თვისებები. ნიმუში განაცხადის თვისებები ფაილი არის ნაჩვენები ქვემოთ -
[Code]
fs.default.name = HDFS://Localhost:9000
mapred.job.tracker = localhost:9001
input.path = / path / to / input / ფაილი /
output.path = / path / to / output / ფაილი
[/Code]
- კონფიგურაცია ქონება ადგილის მფლობელი, რომელიც გამოიყენება მოიტანონ ღირებულებების კონფიგურაციის თვისებების ის თვისებები ფაილი. ეს შეიძლება გაკეთდეს დასძინა შემდეგ ჩვენი განცხადება კონტექსტში XML ფაილი -
[Code]
<კონტექსტში:ქონების ჩანაცვლების ადგილმდებარეობა =”classpath:application.properties” />
[/Code]
- კონფიგურაცია Apache Hadoop და თავის საქმეს - ჩვენ შეგვიძლია კონფიგურაციის ნაგულისხმები ფაილური სისტემა და მისი საქმეა tracker დასძინა შემდეგ ჩვენი განცხადება კონტექსტში ფაილი
[Code]
<HDP:კონფიგურაციის>
fs.default.name = ${fs.default.name}
mapred.job.tracker = ${mapred.job.tracker}
</HDP:კონფიგურაციის>
[/Code]
ჩვენ უნდა დაემატოს შემდეგ ჩვენი განცხადება კონტექსტში XML ფაილი განსაზღვროს სამუშაო tracker -
[Code]
<HDP:სამუშაო id =”wordCountJobId”
შეყვანის გზა =”${input.path}”
გამომავალი გზა =”${output.path}”
jar-by-class =”net.qs.spring.data.apachehadoop.Main”
Mapper =”net.qs.spring.data.apachehadoop.MyWordMapper”
რედუქტორი =”net.qs.spring.data.apachehadoop.MyWordReducer”/>
[/Code]
- კონფიგურაცია სამუშაოს runner რომელიც გადის ის Hadoop სამუშაო. სამსახური runner შეიძლება კონფიგურაცია დასძინა შემდეგ ჩვენი განცხადება კონტექსტში XML ფაილი
[Code]
<HDP:სამუშაო runner id =”wordCountJobRunner” სამუშაო ref =”wordCountJobId” აწარმოებს at-გაშვების =”ნამდვილი”/>
[/Code]
- Step 5 – იტვირთება განაცხადის კონტექსტში გაშვების - ახლა ჩვენ შეგვიძლია შეასრულოს ის Hadoop სამუშაო დატვირთვის განაცხადის კონტექსტში, როდესაც პროგრამა იწყება. ჩვენ შეგვიძლია ამის გაკეთება შექმნით ინსტანციის ClasspathXmlApplicationContext ობიექტი, რომელიც ადასტურებს, რომ სახელი ჩვენი პროგრამა კონტექსტში ფაილი, როგორც შეყვანის პარამეტრი მშენებელი. ეს შეიძლება გაკეთდეს როგორც ქვეშ -
Listing4: Sample ჩვენება loading გამოყენების კონტექსტში
[Code]
იმპორტი org.springframework.context.ApplicationContext;
იმპორტი org.springframework.context.support.ClassPathXmlApplicationContext;
საჯარო კლასის მთავარი {
საჯარო სტატიკური ბათილად მთავარი(სიმებიანი[] არგუმენტები) {
ApplicationContext CTX = new ClassPathXmlApplicationContext(“applicationContext.xml”);
}
}
[/Code]
- Step 6 - აწარმოებს Mapreduce სამუშაო - ჩვენ შეგვიძლია დავიწყოთ ჩვენი რუკა შეამციროს სამუშაო შემდეგი ნაბიჯების გამოყენებით -
- ატვირთე შეტანის ფაილი HDFS - ჩვენ შეგვიძლია ამის გაკეთება შესრულებაში შემდეგი ბრძანება command prompt -
[Code]
Hadoop dfs -put sample.txt /input/sample.txt
[/Code]
შემდეგ არის ნიმუში შეტანის ფაილი, რომელიც გამოიყენება ამ მაგალითად. სამიზნე გასაღები სიტყვა "Hadoop " მონიშნულია GREEN. სიტყვა 'Hadoop " არსებობს 4 ჯერ ნიმუში.
შეყვანის
Image1: ნიმუში შეტანის ფაილი
- შეამოწმეთ თუ ფაილი აიტვირთა წარმატებით გაშვებული შემდეგ ბრძანება. ეს გამოჩნდება შეყვანის ფაილი.
[კოდი]
Hadoop dfs -LS / input
[/კოდი]
- აწარმოებს Mapreduce სამუშაო. ეს შეიძლება გაკეთდეს შესრულებაში ძირითადი მეთოდი ჩვენი java ფაილი IDE. თუ ყველა ნაბიჯები იმუშაოს მაშინ შემდეგ იქნება გამომავალი.
გამოყვანის: Hadoop 4
Summary: შეგვიძლია დავასკვნათ, რაც ჩვენ განვიხილეთ ჯერჯერობით შემდეგ ტყვიები –
- ორივე Spring და Hadoop სასარგებლოა ფარგლებში from ღია საზოგადოების.
- კომბინაციით ეს ჩვენ შეგვიძლია მივიღოთ სასარგებლოდ ორივე ფარგლებში.
- შექმნა რუკა შეამციროს სამუშაო გამოყენებით გაზაფხულზე ექვსი ნაბიჯი პროცესი, როგორც ეს ზემოთ.
