Onelong

DataBinding主要解决了两个问题：

• 需要多次使用findViewById，损害了应用性能且令人厌烦 
• 更新UI数据需切换至UI线程，将数据分解映射到各个view比较麻烦

DataBinding基本使用包括以下内容：

• 单纯的摆脱findviewbyid
• 绑定基本数据类型及String
• 绑定Model数据
• 绑定事件
• 通过静态方法转换数据类型
• 通过运算符操作数据
• 自定义Binding的类名
• 绑定相同Model的操作
• model变量改变自动更新数据
• 绑定List/Map等集合数据
• Observable自动更新
• Databinding与include标签的结合
• DataBinding与RecyclerView的结合

命名规则

• 布局通过DataBindingUtils.setContentView()加载到代码中，而且会生成对应一个Binding对象，对象名是布局文件文称加上Binding后缀
• 通过Binding对象.id名称，就相当于拿到了指定的布局中的id的控件了，使用起来和findviewbyid获取的控件是一样的
• 在布局中是通过@{}来绑定数据的，{}中是布局中该控件属性对应的数据类型数据，同时还可以支持运算符运算和静态方法调用和转换

binding设置数据有2中方式:
1.binding.setUser(user) 
2.binding.setVariable(BR.user,user)–采用BR指

1.android:onClick="@{event.click1}"
2.android:onClick="@{event::click2}"
3.android:onClick="@{()->event.cilck3(title4)}"
 [注]：()->event.cilck3(title4)是lambda表达式写法，
 也可以写成：(view)->event.cilck3(title4),前面(view)表示onClick方法的传递的参数，
 如果event.click3()方法中不需要用到view参数，可以将view省略。
 当然event.click1也可以写成(view)->event.click1(view)，将onClick(View view)的view参数传递给event.click1(view)方法。
大概就这意思，以下是伪代码
onclick(View view){
     event.click1(view)
}

<?xml version="1.0" encoding="utf-8"?><!--布局以layout作为根布局-->
<layout>

    <data>
        <!--绑定基本数据类型及String-->
        <!--name:   和java代码中的对象是类似的，名字自定义-->
        <!--type:   和java代码中的类型是一致的-->
        <variable
            name="content"
            type="String" />

        <variable
            name="enabled"
            type="boolean" />
            <!--绑定Model数据2中形式，一中是导入该类型的，一种指定类型的全称，和java一样-->
        <!--  方式一 -->
        <variable
            name="user"
            type="www.zhang.com.databinding.User" />
        <!--  方式二 -->
        <!--<import type="www.zhang.com.databinding.User" />-->
        <!--<variable-->
            <!--name="user"-->
            <!--type="User" />-->
    </data>
    <!--我们需要展示的布局-->
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">

        <!--绑定基本数据类型及String的使用是通过   @{数据类型的对象}  通过对应数据类型的控制显示-->
        <Button
            android:id="@+id/main_tv2"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:clickable="@{enabled}"
            android:text="@{content}" />
       <Button
            android:id="@+id/main_btn3"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@{user.text}" /><!--这里user.text相当于user.getText()-->
    </LinearLayout>
</layout>

<data>
     <variable
            name="user"
            type="www.zhang.com.databinding.User" />

        <!--调用静态方法，需要先导入需要的包    当然java中的lang包可以不用导包-->
        <import type="www.zhang.com.databinding.Utils" />

    </data>
    android:text="@{Utils.getName(user)}" /><!--就和java中写代码一样，只要符合数据类型就好-->
    
    public class Utils {
    public static String getName(Object o) {
        return o.getClass().getName();
    }
}

        android:paddingLeft="@{user2.state ? @dimen/largepadding : (int)@dimen/smallpadding}"
        android:text="@{user2.content ?? @string/app_name}" />
        <!-- android:text="@{user2.content ?? @string/app_name}"
         等价于
         android:text="@{user2.content!=null? user2.content : @string/app_name}"-->
         android:text="@{`Hello World`+ @string/app_name}" /><!--``字符包裹的表示字符串，可用作拼接字符串 -->

 <data class="www.zhang.com.databinding.activity.Item">
    ...
</data>
import www.zhang.com.databinding.activity.Item;
Item binding = DataBindingUtil.setContentView(FiveActivity.this, R.layout.activity_five);



<data class=".Item">
    ...
</data>
import www.zhang.com.databinding.Item;
Item binding = DataBindingUtil.setContentView(FiveActivity.this, R.layout.activity_five);


<data class="Item">
    ...
</data>
import www.zhang.com.databinding.databinding.Item;
Item binding =DataBindingUtil.setContentView(FiveActivity.this, R.layout.activity_five);

<!--因为type="User"都为User类，会导致不知道到那个包，所以可以通过alias属性重命名type的类型，但实际上alias被指定的那个类型(如：www.zhang.com.databinding.model.User)-->
        <import type="www.zhang.com.databinding.model.User" alias="Model"/>
        
 
Model类继承BaseObservable,BaseObservable实现Android.databinding.Observable接口，Observable接口可以允许附加一个监听器到model对象以便监听对象上的所有属性的变化。
Observable接口有一个机制来添加和删除监听器，但通知与否由开发人员管理。为了使开发更容易，BaseObservable实现了监听器注册机制。DataBinding实现类依然负责通知当属性改变时。这是通过指定一个Bindable注解给getter以及setter内通知来完成的。
notifyPropertyChanged(BR.参数名)通知更新这一个参数，需要与@Bindable注解配合使用。notifyChange()通知更新所有参数，可以不用和@Bindable注解配合使用

Observable是一个接口，它的子类有BaseObservable,ObservableField,ObservableBoolean, ObservableByte, ObservableChar, ObservableShort, ObservableInt, ObservableLong, ObservableFloat, ObservableDouble, and ObservableParcelable，ObservableArrayList,ObservableArrayMap

泛型的支持会在编译时期报红线，是可以直接运行的,但是需要通过转义字符才行，如：\<数据类型> 或者\<数据类型\>
android:text="@{list[1]}"
android:text="@{map[`name`]}" 
android:text="@{arrays[0]}"

<include
            android:id="@+id/toolbar"
            layout="@layout/toolbar"
            android:layout_height="56dp"
            android:layout_width="match_parent"
            bind:content="@{con}" />
 <!--通过命名空间将写有toolbar的xml文件中定义的content对象作为属性绑定con对象，这2个对象是同一个类-->

据运维的说已经有50w装机了，不到一年时间。

阅读全文>>

折腾了一个月，iOS和android版本，昨天提交审核了。这个改版主要是首页和增加分期支付功能，这期改变比较有意思的是h5拍照上传和选择图库上传。具体也没什么可说的。留几个截屏作为纪念。iOS图

阅读全文>>

import java.text.SimpleDateFormat;
import java.util.*;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.*;

import scala.Tuple2;

public class SparkDemo {
 
    static final String USER = "huanglong";
 
    public static void main(String[] args) throws Exception {
        
       
        SparkConf conf =new SparkConf().setAppName("Spark Log").setMaster("local[4]");
        JavaSparkContext sc = new JavaSparkContext(conf); //其底层就是scala的sparkcontext


        //JavaSparkContext sc = new JavaSparkContext("local[4]", "Spark Log", "/user/huanglong/spark", new String[0], envs);
 
       
        String file="file:///Users/huanglong/access_05_30.log";
        JavaRDD<String> data = sc.textFile(file, 4).cache();

        //日志格式
        //27.19.74.143 - - [30/May/2013:17:38:20 +0800] "GET /static/image/common/faq.gif HTTP/1.1" 200 1127;

        JavaRDD<String> filter =  data.filter(new org.apache.spark.api.java.function.Function<String, Boolean>() {
            @Override
            public Boolean call(String s) throws Exception {
                //过滤合法和非静态的资源的日志
                return (s.contains("POST")||s.contains("GET"))&& !s.contains("/static/");
            }
        });

        final  SimpleDateFormat tf = new SimpleDateFormat("dd/MMM/yyyy:HH:mm:ss Z",
                Locale.ENGLISH);
        //只有一天的记录，不需要年月日了,时间精度到分钟
        final SimpleDateFormat tf1 = new SimpleDateFormat("HH:mm");

        JavaRDD<Map<String,String>> lines = filter.flatMap(new FlatMapFunction<String,Map<String,String>>(){

            @Override
            public Iterator<Map<String,String>> call(String s) throws Exception {
                List<Map<String,String>> list = new ArrayList<Map<String,String>>(1);
                Map<String,String> map = new HashMap<String, String>();
                list.add(map);
                String ip = s.substring(0,s.indexOf(" - - "));
                map.put("ip",ip);

                String t = s.substring(s.indexOf("[")+1,s.indexOf("]"));
                Date date =  tf.parse(t);
                map.put("time",tf1.format(date));

                String http = s.substring(s.indexOf("\"")+1,s.indexOf("\" "));
                String[] h= http.split(" ");

                if(h.length>1){

                    if(h[1]!=null&&h[1].indexOf("?")!=-1)
                    {
                        map.put("url",h[1].substring(0,h[1].indexOf("?")));
                    }else {
                        map.put("url",h[1]);
                    }
                }

                if(h.length>2)
                {
                    map.put("version",h[2]);
                }

                if(map.get("version")!=null&&map.get("version").contains("1.1"))
                {
                    String state = s.substring(s.indexOf("1.1\" ")+5,s.length());
                    String[] strings = state.split(" ");
                    if(strings.length>0) {
                        map.put("state", strings[0]);
                    }
                }else if(map.get("version")!=null&&map.get("version").contains("1.0"))
                {
                    String state = s.substring(s.indexOf("1.0\" ")+5,s.length());
                    String[] strings = state.split(" ");
                    if(strings.length>0) {
                        map.put("state", strings[0]);
                    }
                }else {
                    //System.out.println(s);
                }

                return list.iterator();
            }
        });

        System.out.println("总记录数:"+lines.count());
        // 统计ip
            ipsHandle(lines);
        System.out.println("--------------------------------------------------");
        // 统计分时页面访问量
            timeHandle(lines);
        System.out.println("--------------------------------------------------");
        // 统计分时ip访问量
            timeHandle2(lines);
        System.out.println("--------------------------------------------------");
        // 统计状态 400，300 200 各有多少,计算失败率
            stateHandle(lines);
        System.out.println("--------------------------------------------------");
        // 统计http版本 1.1、1.0
            versionHandle(lines);
        // 页面热度
        System.out.println("--------------------------------------------------");
            pageHandle(lines);
 
       sc.close();

    }


    private static void pageHandle(JavaRDD<Map<String, String>> lines) {

        JavaRDD<Map<String, String>> filterData =  lines.filter(new Function<Map<String, String>, Boolean>() {
            @Override
            public Boolean call(Map<String, String> map) throws Exception {
                String url = map.get("url");
                return "200".equals(map.get("state"))&&url.endsWith(".php");
            }
        });


        JavaPairRDD<String,Integer> versionPairs = filterData.mapToPair(new PairFunction<Map<String,String>, String,Integer>() {
            @Override
            public Tuple2<String,Integer> call(Map<String, String> stringStringMap) throws Exception {
                return  new Tuple2<String, Integer>(stringStringMap.get("url"),1);
            }
        });

        JavaPairRDD<String,Integer> versionCount = versionPairs.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1+v2;
            }
        });


        versionCount.foreach(new VoidFunction<Tuple2<String,Integer>>() {
            @Override
            public void call(Tuple2<String, Integer> pairs) throws Exception {
                System.out.println("URL->PV："+pairs._1+" : " +pairs._2);
            }
        });
    }


    private static void versionHandle(JavaRDD<Map<String, String>> lines) {
        JavaPairRDD<String,Integer> versionPairs = lines.mapToPair(new PairFunction<Map<String,String>, String,Integer>() {
            @Override
            public Tuple2<String,Integer> call(Map<String, String> stringStringMap) throws Exception {
                return  new Tuple2<String, Integer>(stringStringMap.get("version"),1);
            }
        });

        JavaPairRDD<String,Integer> versionCount = versionPairs.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1+v2;
            }
        });


        versionCount.foreach(new VoidFunction<Tuple2<String,Integer>>() {
            @Override
            public void call(Tuple2<String, Integer> pairs) throws Exception {
                System.out.println("VERSION->PV："+pairs._1+" : " +pairs._2);
            }
        });
    }

    private static void stateHandle(JavaRDD<Map<String, String>> lines) {
        JavaPairRDD<String,Integer> statePairs = lines.mapToPair(new PairFunction<Map<String,String>, String,Integer>() {
            @Override
            public Tuple2<String,Integer> call(Map<String, String> stringStringMap) throws Exception {
                return  new Tuple2<String, Integer>(stringStringMap.get("state"),1);
            }
        });

        JavaPairRDD<String,Integer> stateCount = statePairs.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1+v2;
            }
        });

        stateCount.foreach(new VoidFunction<Tuple2<String,Integer>>() {
            @Override
            public void call(Tuple2<String, Integer> pairs) throws Exception {
                System.out.println("STATE->PV："+pairs._1+" : " +pairs._2);

            }
        });
    }

    private static void ipsHandle(JavaRDD<Map<String, String>> lines) {
        JavaPairRDD<String,Integer> ipPairs = lines.mapToPair(new PairFunction<Map<String,String>, String,Integer>() {
            @Override
            public Tuple2<String,Integer> call(Map<String, String> stringStringMap) throws Exception {
                return  new Tuple2<String, Integer>(stringStringMap.get("ip"),1);
            }
        });

        JavaPairRDD<String,Integer> ipCount = ipPairs.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1+v2;
            }
        });

        System.out.println("总ip数:"+ipCount.count());


        ipCount.foreach(new VoidFunction<Tuple2<String,Integer>>() {
            @Override
            public void call(Tuple2<String, Integer> pairs) throws Exception {
                System.out.println("IP->PV："+pairs._1+" : " +pairs._2);
            }
        });
    }

    private static void timeHandle2(JavaRDD<Map<String, String>> lines) {
        JavaPairRDD<String,Map<String,Boolean>> timePairs = lines.mapToPair(new PairFunction<Map<String,String>, String,Map<String,Boolean>>() {
            @Override
            public Tuple2<String,Map<String,Boolean>> call(Map<String, String> stringStringMap) throws Exception {
                Map<String,Boolean> m = new HashMap<String, Boolean>();
                m.put(stringStringMap.get("ip"),Boolean.TRUE);
                return new Tuple2<String, Map<String,Boolean>>(stringStringMap.get("time"),m);
            }
        });

        JavaPairRDD<String,Map<String,Boolean>> timeCount = timePairs.reduceByKey(new Function2<Map<String,Boolean>, Map<String,Boolean>,Map<String,Boolean>>() {
            @Override
            public Map<String,Boolean> call(Map<String,Boolean> v1, Map<String,Boolean> v2) throws Exception {
                HashMap<String, Boolean> m = new HashMap<String, Boolean>();
                m.putAll(v1);
                m.putAll(v2);
                return m;
            }
        });


        timeCount.foreach(new VoidFunction<Tuple2<String,Map<String,Boolean>>>() {
            @Override
            public void call(Tuple2<String, Map<String,Boolean>> pairs) throws Exception {

                System.out.println("TIME->IP："+pairs._1+" : " +pairs._2.size());

            }
        });

    }

    private static void timeHandle(JavaRDD<Map<String, String>> lines) {
        JavaPairRDD<String,Integer> timePairs = lines.mapToPair(new PairFunction<Map<String,String>, String,Integer>() {
            @Override
            public Tuple2<String,Integer> call(Map<String, String> stringStringMap) throws Exception {
                return  new Tuple2<String, Integer>(stringStringMap.get("time"),1);
            }
        });

        JavaPairRDD<String,Integer> timeCount = timePairs.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1+v2;
            }
        });

        timeCount.foreach(new VoidFunction<Tuple2<String,Integer>>() {
            @Override
            public void call(Tuple2<String, Integer> pairs) throws Exception {
                System.out.println("TIME->PV："+pairs._1+" : " +pairs._2);

            }
        });

    }

}

阅读全文>>

Hive是一个构建在Hadoop基础设施之上的数据仓库。通过Hive可以使用HQL语言查询存放在HDFS上的数据。HQL是一种类SQL语言，这种语言最终被转化为Map/Reduce. 虽然Hive提供了SQL查询功能，但是Hive不能够进行交互查询--因为它只能够在Haoop上批量的执行Hadoop。 Hive帮助熟悉SQL的人运行MapReduce任务，Hive目前不支持更新操作，Hive适合用来对一段时间内的数据进行分析查询，Hive必须提供预先定义好的schema将文件和目录映射到列。
HBase是一种Key/Value系统，它运行在HDFS之上， Hbase非常适合用来进行大数据的实时查询。Facebook用Hbase进行消息和实时的分析。它也可以用来统计Facebook的连接数。
Hive和Hbase是两种基于Hadoop的不同技术--Hive是一种类SQL的引擎，并且运行MapReduce任务，Hbase是一种在Hadoop之上的NoSQL 的Key/vale数据库。当然，这两种工具是可以同时使用的。就像用Google来搜索，用FaceBook进行社交一样，Hive可以用来进行统计查询，HBase可以用来进行实时查询，数据也可以从Hive写到Hbase，设置再从Hbase写回Hive。 

阅读全文>>

记得曾经看到这样一句话：“只有度过了一段连自己都被感动了的日子，才会变成那个最好的自己”，稻盛和夫还有一句话“当你感到不行了，事情才刚刚开始”。中国老话，置之死地而后生。很多时候人成长是孤单的，甚至是寂寞的，需要莫大的勇气才走过泥泞，面朝大海，春暖花开。今天在朋友圈又分享一篇文章，其中有段话是这样的：“真正的努力，不是比谁把自己虐得更惨，不是比谁花的时间更多，也不是比谁能进行更多的项目，而是找到合适的方法，抛下杂念，全身心地投入去做一件事情，多思考，多总结。”，或许鸡汤喝多了，容易长胖，然后什么都干不动了。之前，很多人和我说，我们不像你，那么喜欢技术，我们能过生活就好了。当危机发生的时候，不曾努力或许能生活都过不好。如逆水行舟，你不前进，别人在前进，你就是变相的后腿，人是逼出来的，没有人天生喜欢哪些伤脑筋的事情，只是没有更好的选择。然而在没有更好的选择是应该珍惜当下，不轻易浪费生命，每一个不求上进的时刻，都是对生命的辜负。成长就是强迫自己做自己害怕的事情，强迫自己做不曾想过的事情，过程肯定是痛苦难耐。所以人生中总要有那么几段连自己都被感动的日子，这样才不枉此生。
作为一个非计算机专业的人，全凭自己的毅力和坚持走到今天，过程是很辛苦的，当然也是快乐的，因为每天都忘记时间是流逝的，每个眼干的深夜却异常的兴奋，那一刻问题得到解决。从前端到移动端到服务端，一直记得师兄那句玩笑“有些东西你不懂，永远都不会懂的拉”，也是这样一股不服的心坚持到现在。IT，并不是我最喜欢的，在没上大学之前，我最喜欢物理电子，在初中的时候，我就很喜欢看职高的物理书了，后来因为希望留在工作室上网“叹 ”空调，强迫自己学好前端通过重重考验，成为页面部部长。而今天看来，大家都是觉得我喜欢技术才这样折腾这个，折腾那个，其实没有更好的选择了。无论是学历还是背景都没有亮点，只是通过自己努力坚强的走下去了，久而久之就觉得IT这个世界很刺激，每天都是新鲜感，也就喜欢了。说到喜欢，其实每个男人心中都是喜欢极限挑战，征服世界。在征服世界之前，需要走过每个关卡。男人最怕就是退休，因为退休了就意味着老了，不行了，夕阳西下了，再也无法征服世界了。
在技术领域里面，很多东西都是反复折腾的，就像最近了解的SQL一样 ，在学校看过几本书，出来工作了折腾过一点时间，还是没搞懂，糊里糊涂的过去了，因为不懂，所以一直很抗拒SQL，总想着很多很复杂的东西，但是当某一刻你突然明白了，其实并没有那没那么复杂，以前觉得几个表连起来查询好像要变天一样，而今天用起来确实自然而然了，量变到质变的过程，总是无声无息的。以前看师弟们做的网址，当时看他们写了很多关键词的过滤函数，主要是为了防止SQL注入，而今天我发现其实java也好，php也好其实框架都内置防注入的方案，很多事情突然间就没那么恐怖了，以前自己写函数过滤，得多了解各种坑呀，所以觉得很复杂。一直以来喜欢做服务开发，不喜欢web开发，服务开发一般在内网运行，基本不做安全措施，绝大部分的安全问题由防火墙来搞定。随着时间的推移，阅历的丰富，其实javaweb并没有想象中那么复杂，想起两年前在珠海移动的时候，死活都看不懂spring用来干嘛的，用eclipse折腾maven项目要死要死的，配个tomcat调试还弄了几次不行，最后叫人帮我弄，弄好了，换一下就不行了，最后放弃了。而今年弄idea，还爱上了maven，一切都用得很顺手，现在看到哪些不是maven的java项目，我就觉得烦。当开始了解spring的时候，就会发现它很神奇，依赖注入，反向调用。很神奇的地方就是你可以注入一个数据源对象和SQL的配置文件，就可以使用各种驱动去访问数据库了，甚至支持读写分类，分库分表。在java的生态里面，你会感叹什么才是真正的组件化开发，spring是何等伟大的东西。我给javaweb来了总结：javaWeb=UI+sql，然后好多人笑话我的肤浅，至少我深层理解过，web这个东西依赖关系型数据做逻辑太重了。
最近为什么要学SQL呢，其实就是因为Hive和spark sql，突然意识到SQL是一切数据技术的基础，过去忽视它是一种缺失。再说让我管理整个产品线，我至少应该会做web吧，大部分技术能折腾一下吧，于是就学了SQL。从SOA到微服务再到大数据，都hello world了一会，感性认识了一遍，发现前面路好像变宽了，之前看完dobbu的源代码，其实对服务治理有了一定的了解，对现有产品的技术框架也有了初步粗暴评价。 往后希望有合适场景让我hello world一下机器学习和深度学习。
也许这一切并没有什么卵用，不能当作实际的经验，但是至少了解了原理，路走起来会更顺。 以前面试吹水这些，心里会很不踏实，万一真的让我干岂不是完蛋了，现在完全不会脸红了。怕毛呀，干就干。。。。。

#import "ViewController.h"

#import <CommonCrypto/CommonDigest.h>

#import <CommonCrypto/CommonCryptor.h>

阅读全文>>

这两天了解了一下大数据处理框架，网上浏览了一番，看得眼花撩乱，Hadoop，HBase，Hive，Spark，JStrom等等，既然花了时间去了解，当然要做一下总结吧：
Hadoop的框架最核心的设计就是：HDFS和MapReduce。HDFS为海量的数据提供了存储，则MapReduce为海量的数据提供了计算。后面发展产生了很多子项目，HDFS（分布式文件系统），MapReduce（并行计算框架），HBase（分布式NoSQL列数据库），Hive（数据仓库工具），pig，zk等。对于Hadoop的MapReduce要自己写Map和Reduce，各个方便比较繁琐，门槛比较高。Hadoop通常用超大规模静态数据分析，中间结果写入HDFS，时延比较高，但不能说慢，快和慢就看堆多少硬件的。只适用Batch数据处理，对于交互式数据处理，实时数据处理的支持不够，对于迭代式数据处理性能比较差。
Spark是新出来的，用于替代MapReduce的并行计算框架，主要特点是提供了一个集群的分布式内存抽象，以支持需要工作集的应用，RDD就是一个不可变的带分区的记录集合，RDD也是Spark中的编程模型。Spark提供了RDD上的两类操作，转换和动作。转换是用来定义一个新的RDD，包括map, flatMap, filter, union, sample, join, groupByKey, cogroup, ReduceByKey, cros, sortByKey, mapValues等，动作是返回一个结果，包括collect, reduce, count, save, lookupKey，也即是说Spark更易用了。Spark为迭代式数据处理提供更好的支持。每次迭代的数据可以保存在内存中，而不是写入文件，Spark的性能相比Hadoop有很大提升。Spark框架为批处理（Spark Core），交互式（Spark SQL），流式（Spark Streaming），机器学习（MLlib），图计算（GraphX）提供一个统一的数据处理平台。

Batch Layer，HDFS+Spark Core，将实时的增量数据追加到HDFS中，使用Spark Core批量处理全量数据，生成全量数据的视图
Speed Layer，Spark Streaming来处理实时的增量数据，以较低的时延生成实时数据的视图
Serving Layer，HDFS+Spark SQL，存储Batch Layer和Speed Layer输出的视图，提供低时延的即席查询功能，将批量数据的视图与实时数据的视图合并。