如果可以说些啥解读

1、1.1. 理论与原理概括1.1.1. Mapreduce每个Mapreduce任务都会被JobConf初始化为一个JOB,每个JOB可以分为两个阶段，MAP阶段和REDUCE阶段。是谁初始化了他的任务？是JOBtracker和tasktracker.前面的分配任务，后者执行任务。步骤：1) 初始化Mapreduce.,禾1J用反射，把Mapreduce的类装饰成JobConf对象。2) 给对象命名便于在JobTracker和TaskTracker里面进行监测。3) 设置输出、输入、路径利用工具类FileInputFormat,FileoutputFormat4) 获取数据栈inputsplit

2、.他存储的是数据的分片长度和记录了数据的位置。Inputsplit是怎么获取到的？Inputformat调用getrecordReader生成RecordReader,RR在通过createKey()和createValue()创建出可以处理的Map集合。不同类型的输入都会转成Map来处理。5) Map类继承了Mapreducebase,实现了Mapper6) Reduce类继承了Mapreducebase,实现了Reducer7)发布编译运行程序：MkdirfirstjarJavac-classpath/hadoop/hadopp-2.0-core.jar-dfirstjar/编译，并存放至

3、UfirstjarWordcount.javaJar-cvfwordcount.jar-Cfirstjar/.打包生成jar8)上传文件：/hadoop/bin/hadoopdfs-mkdirinput/hadoop/bin/hadoopdfs-put/input/file0*input9)部署将生成的jar文件，放到HADOOP_HOME目录下面执行：/hadoop/bin/hadoopjarwordcount.jarwordcountinputoutput注意：Mapreduce不仅仅只有一个reducetask每个reduce会收集一个或者多个key,reduce的数量可以通过程序控制。

4、一个reduce产生一个输出文件。没有reduce的时候，程序会将Maptask的结果作为最终结果，有多少个Maptask,就有多少个输出文件。1.1.2.Hbase. 安装注意：Hbase的版本。在Hbase的lib下面有hadoop-core.jar。如果想要与其他版本的Hadoop,那么需要将Hadoop的core.jar和test.jar复制一份到Hbase的lib下面。. 修改Hbase配置文件Hbase先加载Hbasedefault.xml里面的配置信息，然后加载Hbaseset.xml.所以：两个文件里面有相同配置信息后面加载的会覆盖前面的。1.1.2

5、.3. HbaseShell1、进入数据库hbaseshell2、2.2. 设计模式2.2.1. 策略模式好处：动态的改变对象的行为原则：把一个类中，经常改变，或者将来要改变的部分提取出来作为一个接口，然后在类中包含这个对象的实例。（组合的方式形成以前的类），目的：类的实例在运行时，可以随意的实现这个接口的行为。实例：会员算积分，刘备锦娘妙计packagenie.design.model.strategy;publicclassStrategypublicstaticvoidmain(String口args)/大部分模式结构相似，不同在客户端的调用SetStrategylmplsstegyl=

6、StrategyImpl1();sstegy1.open();SetStrategylmplsstegy2=StrategyImpl2();sstegy2.open();SetStrategyImplsstegy3=StrategyImpl3();sstegy3.open();newSetStrategyImpl(newSetStrategyImpl(newSetStrategyImpl(newnewnewnew SetStrategyImpl(newSetStrategyImplsstegy4=StrategyImpl4();sstegy4.open();interfaceIStrategy

7、voidoperate。;classSetStrategyImplprivateIStrategystrategy;publicSetStrategyImpl(IStrategystrategy)this.strategy=strategy;voidopen()this.strategy.operate。；classStrategyImpl1implementsIStrategyOverridepublicvoidoperate。classStrategyImpl2implementsIStrategyOverridepublicvoidoperate()classStrategyImpl3i

8、mplementsIStrategyOverridepublicvoidoperate。classStrategyImpl4implementsIStrategyOverridepublicvoidoperate。实例2:packagenie.design.model.strategy;publicclassStrategy2publicstaticvoidmain(String口args)Priceprice=newPrice(newprimaryMember();price.quote();interfaceMemberStraretgyvoidcalcPrice();classprima

9、ryMemberimplementsMemberStraretgyOverridepublicvoidcalcPrice()classMediaMemberimplementsMemberStraretgyOverridepublicvoidcalcPrice()classAdvancedMemberimplementsMemberStraretgyOverridepublicvoidcalcPrice()classPriceprivateMemberStraretgystraretgy;publicPrice(MemberStraretgystraretgy)this.straretgy=s

10、traretgy;/*计算价格*/voidquote()this.straretgy.calcPrice();1.2.2.责任链模式好处：客户端不需要知道具体是谁处理了他的请求。解耦请求的发出者和发请求的接受着之间的关系。原则：符合自己的能力就处理客户端发的请求，不符合自己的能力范围，就向上传递请求。缺点：责任链分为两种: 个产品的生成，一种是生成类型责任链，和检查类型责任链。生成类型的责任链也就是每一个对象无论如何都会做出自己相应的贡献,然后再向上传递，检查责任链是检查是否是自己的处理范围，是处理，不是就向上传递。实例：领导审批，报销packagenie.design.model.workc

11、hain;publicclassWorkChain publicstaticvoid main(String口 args) Handler h1 =new Manager1();Handler h2 =new Manager2();Handler h3 =new Manager3();Handler h4 =new Manager4();h2.setHandler(h1);h3.setHandler(h2);h4.setHandler(h3);Stringresult=h4.handlerRequest("",200);System.out.println("谁处

12、理的结果"+result);abstractclassHandlerprotectedHandlerhandler=null;publicHandlergetHandler()returnhandler;publicvoidsetHandler(Handlerhandler)this.handler=handler;publicabstractStringhandlerRequest(Stringstr,intfee);classManager1extendsHandlerOverrideif(this.getHandler()!=null && fee>400

13、)returnthis.getHandler().handlerRequest(str,fee);return"Manager1success"classManager2extendsHandlerOverridepublicStringhandlerRequest(Stringstr,intfee)if(this.getHandler()!=null&&fee>300)returnthis.getHandler().handlerRequest(str,fee);return"Manager2success"classManage

14、r3extendsHandlerOverridepublic String handlerRequest(String str,int fee) if(this.getHandler()!=null&&fee>200)returnthis.getHandler().handlerRequest(str,fee);return"Manager3success"classManager4extendsHandlerOverridepublicStringhandlerRequest(Stringstr,intfee)if(this.getHandler()

15、!=null&&fee>100)returnthis.getHandler().handlerRequest(str,fee);return"Manager4success"1.2.3. 观察者模式好处：所有对象都跟主对象进行相同的行为。在一对多依赖的对象关系中，如果这个一对象状态发生了变化，那么它所有依赖他的多'对象都应被通知，然后做相应的行为，这就是观察者模式.原则：实例：缺点：性能降低，需要添加和遍历packagenie.design.model.Observer;importjava.util.ArrayList;importjava.

16、util.List;publicclassObserver2public static voidWatched watched =Watcher watcher1 =Watcher watcher2 =Watcher watcher3 =main(String口 args) new WatchedImpl1();new WatcherImpl1();new WatcherImpl2();new WatcherImpl3();watched.add(watcher1);watched.add(watcher2);watched.add(watcher3);watched.notifys(&quo

17、t;ok");interfaceWatchervoidupdate(Stringstr);interfaceWatchedvoidadd(Watcherw);voidremove(Watcherw);voidnotifys(Stringstr);classWatcherlmpllimplementsWatcherOverridepublicvoidupdate(Stringstr)System.out.println("WatcherImpl1"+str);classWatcherImpl2implementsWatcherOverridepublicvoidup

18、date(Stringstr)System.out.println("WatcherImp12"+str);classWatcherImpl3implementsWatcherOverridepublicvoidupdate(Stringstr)System.out.println("WatcherImp13"+str);classWatchedImpl1implementsWatchedprivateList<Watcher>list=newArrayList<Watcher>();Overridepublicvoidadd(W

19、atcherw)list.add(w);Overridepublicvoidremove(Watcherw)list.remove(w);Overridepublicvoidnotifys(Stringstr)for(Watcherwa:list)wa.update(str);1.2.4. 状态模式状态模式和策略模式很相似。但是不同在于：状态模式加入的对象是谁，就会执行这个对象的内容，策略模式好处：状态模式可以使对象在不同的状态有不同的行为，策略模式是封装了一组算法，客户端在使用时候可以不改变Context,运行时选择任意的算法。策略模式允许对象选择行为，状态模式的行为是固定死的，根据不同的状

20、态，执行不同的行为。packagenie.design.model.state;publicclassStatepublicstaticvoidmain(String口args)IStatesits=newStatesImpl1();Contextcon=newContext();con.setiStates(its);con.request("工作好。”);interfaceIStatesvoidhandle(Strings);classContextprivateIStatesiStates;publicIStatesgetiStates()returniStates;publi

21、cvoidsetiStates(IStatesiStates)this.iStates=iStates;voidrequest(Stringstr)iStates.handle(str);classStatesImpl1implementsIStatespublicvoidhandle(Strings)System.out.println("Stateslmpll"+s);classStatesImpl2implementsIStatesOverridepublicvoidhandle(Strings)System.out.println("StatesImpl2

22、"+s);classStatesImpl3implementsIStatesOverridepublicvoidhandle(Strings)System.out.println("StatesImpl3"+s);classStatesImpl4implementsIStatesOverridepublicvoidhandle(Strings)System.out.println("StatesImpl4"+s);实例2:投票packagenie.design.model.state;importjava.util.HashMap;import

23、java.util.Map;publicclassState2publicstaticvoidmain(String口args)VoteManagervm=newVoteManager();for(inti=0;i<9;i+)vm.vote("u1","A");interfaceVoteStatepublicvoidvote(Stringuser,StringvoteItem,VoteManagervoteManager);/具体状态类一一正常投票classNormalVoteStateimplementsVoteStateOverridepubl

24、icvoidvote(Stringuser,Stringvoteitem,VoteManagervoteManager)/正常投票，记录到投票记录中voteManager.getMapVote().put(user,voteitem);System.out.println("恭喜投票成功”)；/具体状态类一一重复投票classRepeatVoteStateimplementsVoteStateOverridepublicvoidvote(Stringuser,Stringvoteitem,VoteManagervoteManager)System.out.println("

25、请不要重复投票”)；/具体状态类一一恶意刷票classSpiteVoteStateimplementsVoteStateOverridepublicvoidvote(Stringuser,Stringvoteitem,VoteManagervoteManager)/恶意投票，取消用户的投票资格，并取消投票记录Stringstr=voteManager.getMapVote().get(user);if(str!=null)voteManager.getMapVote().remove(user);System.out.println("你有恶意刷屏行为，取消投票资格");/

26、具体状态类一一黑名单classBlackVoteStateimplementsVoteStateOverridepublicvoidvote(Stringuser,Stringvoteitem,VoteManagervoteManager)/记录黑名单中，禁止登录系统System.out.println("进入黑名单，将禁止登录和使用本系统")；/环境类classVoteManager/持有状体处理对象privateVoteStatestate=null;/记录用户投票的结果，Map<String,String>对应Map<ffl户名称，投票的选项>

27、privateMap<String,StringmapVote=newHashMap<String,String>();/记录用户投票次数，Map<String,Integer>对应Map<用户名称，投票的次数>privateMapvString,IntegermapVoteCount=newHashMapvString,Integer>();/*获取用户投票结果的Map*/publicMapvString,StringgetMapVote()returnmapVote;publicvoidvote(Stringuser,Stringvoteit

28、em)/1.为该用户增加投票次数/从记录中取出该用户已有的投票次数IntegeroldVoteCount=mapVoteCount.get(user);if(oldVoteCount=null)oldVoteCount=0;oldVoteCount+=1;mapVoteCount.put(user,oldVoteCount);/2.判断该用户的投票类型，就相当于判断对应的状态/到底是正常投票、重复投票、恶意投票还是上黑名单的状态if(oldVoteCount=1)state=newNormalVoteState();elseif(oldVoteCount>1&&oldVo

29、teCount<5)state=newRepeatVoteState();elseif(oldVoteCount>=5&&oldVoteCount<8)state=newSpiteVoteState();elseif(oldVoteCount>8)state=newBlackVoteState();/然后转调状态对象来进行相应的操作state.vote(user,voteItem,this);1.2.5. 创建者模式创建者模式和工厂模式作用相似。工厂模式是关注整个产品，创建者模式是关注的生成产品的各个组成部分。当生成产品仅一个方法，适合工厂模式，生成一个

30、产品需要很多方法，用创建者。好处：场景：将算法独立于他的组成部分及独立于他的组配方式时实例：工程师和民工一起盖房子。packagenie.design.model.builder;publicclassBuilderpublicstaticvoidmain(String口args)IBuildermingong=newMingong();Designerdesigner=newDesigner。;designer.order(mingong);mingong.getRoom();classRoomprivateStringsize;privateStringcolor;interfaceIBu

31、ilderpublicvoidmakeWindow();publicvoidmakeFloor();publicRoomgetRoom();classDesignerpublicvoidorder(IBuilderbuilder)builder.makeWindow();builder.makeFloor();classMingongimplementsIBuilderprivateStringwindow=""privateStringfloor=""publicvoidmakeWindow()window=newString("接地的落地窗

32、“);publicvoidmakeFloor()floor=newString("红色的匹配地板”)；publicRoomgetRoom()if(!window.equals("")&&(!floor.equals("")System.out.println("roomsuccess!");returnnewRoom();elsereturnnull;1.2.6. 桥接模式好处：桥接模式分离了抽象部分和实现部分，从而极大地提高了系统的灵活性。原则：通过引入接口，把实现的部分从系统中分离出去。抽象部分的接口对象

33、，在这个对象里面通常会维护实现部分对象的引用，在抽象对象里面的方法，需要调用实现部分的对象来完成。本质：接口隔离。把并不内聚的两种体系区别开。场景：实现了多层抽象。实例：抽象人，在抽象路上，开着抽象的车。对比：策略模式是对算法的层次的解耦，桥接是体系的解耦，桥接里面包含策略。packagenie.design.model.bridge;publicclassBridge2publicstaticvoidmain(String口args)AbstractRoadspeedWay=newSpeedWay();speedWay.aCar=newCar();Peopleman=newMan();man

34、.road=speedWay;man.runing();abstractclassAbstractRoadAbstractCaraCar;AbstractCarbCar;voidruned();abstractclassAbstractCarvoidrun();AbstractCarcreate()returnnullclassStreetextendsAbstractRoad继承方法和属性。AbstractCarcCar=bCar.create();Overridevoidruned()aCar.run();bCar.run();System.out.println("在市区街道行

35、驶”)；classSpeedWayextendsAbstractRoadOverridevoidruned()aCar.run();System.out.println("在高速公路行驶”)；classCarextendsAbstractCarOverridevoidrun()System.out.println("小汽车");classBusextendsAbstractCarOverridevoidrun()super.run();System.out.println("公交车");abstractclassPeopleAbstractRo

36、adroad;voidruning()classManextendsPeopleOverridevoidruning()System.out.println("男人开着");road.runed();classWomanextendsPeopleOverridevoidruning()System.out.println("女人开着”);road.runed();1.2.7. 工厂模式如果有许多地方都需要生成A的对象，那么你需要写很多Aa=newA()。如果需要修改的话，你要修改许多地方。但是如果用工厂模式，你只需要修改工厂代码。其他地方引用工厂，可以做到只修改一

37、个地方，其他代码都不动，就是解耦了。好处：工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化，不必事先知道那个类实例化了。packagenie.design.model.factory;publicclassFactorypublicstaticvoidmain(String口args)throwsExceptionCommfactoryfatory=newCommfactory();HammyHam;myHam=fatory.getHam("HamB");myHam.show();interfaceHamvoidshow();/*工厂模式的工

38、厂类是普通类，经过参数比较得到实现类的对象*/classCommfactorypublicHamgetHam(StringHamType)throwsExceptionif(HamType.equals("HamA")returnnewHamA();elseif(HamType.equals("HamB")returnnewHamB();elseif(HamType.equals("HamC")returnnewHamC();elsethrownewException。;classHamAimplementsHampublicvoid

39、show()System.out.println("YougotaHamA.");classHamBimplementsHampublicvoidshow()System.out.println("YougotaHamB.");publicvoidsss()System.out.println("sssss");classHamCimplementsHampublicvoidshow()System.out.println("YougotaHamC.");1.2.8. 抽象工厂客户端需要知道组合方案名，并需要new

40、方案的实例。作用：抽象工厂可以随意的安排组合的方案（随意的组合实现类），并代码改动少。缺点：若想要增加实体类，需要改动的地方太大。纵向上看，几乎没有可扩展性。实例：产品线上的，产品类型配对。比如：选择联想内核，要选联想的cpu,要选联想的主板。packagenie.design.model.abstarctfactory;publicclassAbstarctFactorypublicstaticvoidmain(String口args)I*abstractFactorycreatel=newCreater1();ProductproductlA=create1.createProductA(

41、);Productproduct1B=create1.createProductB();product1A.dosomething();product1B.dosomething();I*/abstractFactorycreate2=newCreater2();Productproduct2A=create2.createProductA();Productproduct2B=create2.createProductB();product2A.dosomething();product2B.dosomething();abstractclassProductpublicabstractvo

42、iddosomething();classProductAIextendsProductOverridepublicvoiddosomething()System.out.println("这是产品A1”);classProductA2extendsProductOverridepublicvoiddosomething()System.out.println("这是产品A2");classProductB1extendsProductOverridepublicvoiddosomething()System.out.println("这里是产品B1”)

43、;classProductB2extendsProductOverridepublicvoiddosomething()System.out.println("这里是产品B2");abstractclassabstractFactorypublicabstractProductcreateProductA();publicabstractProductcreateProductB();classCreater1extendsabstractFactoryOverridepublicProductcreateProductA()returnnewProductA1();Ove

44、rridepublicProductcreateProductB()returnnewProductB1();classCreater2extendsabstractFactoryOverridepublicProductcreateProductA()returnnewProductA2();OverridepublicProductcreateProductB()returnnewProductB2();1.2.9. 适配器模式好处：场景：1：系统需要使用现有的类，而这些类的接口不符合系统的现有接口。2:系统想要建立一个可以重用的类，用于与彼此之间没有太大关联的类。3:两个类所做的事情相同

45、或者相似，但是却有不同的接口。4:使用第三方组件，组件接口和自己的接口不一致，又不想用组件接口而修改自己的口。5：我们要调用的借口类型，无法满足我们新系统的接口需要。实例类的适配packagenie.design.model.adapter;publicclassAdaptersForClasspublicstaticvoidmain(Stringrags口)AdaptersForClasstestAdapter=newAdaptersForClass();testAdapter.test();publicvoidtest()/*Adaptee被改造成Adapter*/Target2targe

46、t=newAdapter。；intv1=target.get110v();/get110vo是我想要调用的intv2=target.get220v();System.out.println("v2="+v2);System.out.println("v1="+v1);/* 标准适配器模式* 作用：当已有得类的接口不能满足业务需要的时候，需要重新搞一个接口，并重新搞一个类。* 新产生的类和接口满足需要。* 源角色，被改造者，我想使用get110v()*/classAdapteepublicintget220voreturn220;/*目标角色*/inter

47、faceTargetintget110v();intget220v();/*适配器角色：扩展源角色，实现目标角色，* 从而使得目标角色改动时候，不用改动源角色，* 只要改动适配器，* 适配者继承被改造的类，实现目标接口*/classAdapterextendsAdaptee2implementsTarget2publicintget110voreturn110;/*这里的这个get220vo可以注释，因为Adaptee类里面的已经是具体的实现类了* 也就是说如果被改造的方法不需要变化，那么适配者就不用再覆盖这个方法*/publicintget220voreturn440;实例2:对象的适配pa

48、ckagenie.design.model.adapter;/* 标准适配器模式* 作用：当已有得类的接口不能满足业务需要的时候，需要重新搞一个接口，并重新搞一个类。* 新产生的类和接口满足需要。* 源角色，被改造者，我想使用get110v()*/classAdaptee2publicintget220voreturn220;/*目标角色*/interfaceTarget2intget110v();intget220v();/*适配器角色：扩展源角色，实现目标角色，* 从而使得目标角色改动时候，不用改动源角色，* 只要改动适配器，* 适配者继承被改造的类，实现目标接口*/classAdapte

49、r2implementsTargetprivateAdapteeadaptee;publicAdapter2()this.adaptee=newAdaptee();publicintget110voreturn110;/*这里的这个get220vo可以注释，因为Adaptee类里面的已经是具体的实现类了也就是说如果被改造的方法不需要变化，那么适配者就不用再覆盖这个方法*/publicintget220voreturn440;/*客户端*/publicclassAdaptersForObjectpublicstaticvoidmain(Stringrags口)AdaptersForObjectt

50、estAdapter=newAdaptersForObject();testAdapter.test();publicvoidtest()/*Adaptee被改造成Adapter*/Targettarget=newAdapter2();/Adapter被适配过后的,我们可以使用的。intv1=target.get110v();/get110vo是我想要调用的。intv2=target.get220v();System.out.println("v2="+v2);System.out.println("v1="+v1);1.2.10. 装饰模式装饰者是主角

51、。客户端首先创建主角。主角的行为不变（调用的方法不变）被装饰者的构造方法需要装入接口。接口，装饰者（主角），被装饰者。继承被装饰者的实现类，客户端。说主角的行为不变，但是可以做被装饰者的功能好处：packagenie.design.model.constuctor;publicclassConstructorpublicstaticvoidmain(String口args)SuperDogdog=newSuperDog();dog.Swmming();anllna=newDog1();Yuyu=newYu(lna);yu.swmming();yu.ho();class Dog privateS

52、tringcolorvoidho()classSuperDogextendsDogOverridevoidho()/TODCAuto-generatedmethodstubsuper.ho();voidSwmming()/*通过继承，达到新增类的方法，保持原类不变，下面使用装饰模式*/interfaceanlvoidho();classDog1implementsanlprivateStringcolor;Overridepublicvoidho()System.out.println("我会吼");classChangXingimplementsanlprivateanl

53、annimal;publicChangXing(anlannimal)this.annimal=annimal;Overridepublicvoidho()System.out.println("我会吼")；classYuextendsChangXingpublicYu(anlannimal)super(annimal);/TODCAuto-generatedconstructorstubvoidswmming()System.out.println("我会游泳")；1.2.11. 单例模式只创建一次实例。JDBC连接数据库使用缺点：浪费缓存实例：略1.2.12. 简单工厂原则：使用反射创建类对象至少2个实体类，一个接口，接口里面要有抽象方法。工厂类，是普通的类，通过反射得到具体的实现类对象，通过传参去控制是哪个实现类，返回值必须是接口对象。测试类或者叫客户端，传参给工厂类。packagen