• 大数据-SparkStreaming

    SparkStreaming

    SparkStreaming是一种微批处理，准实时的流式框架。数据来源包括：Kafka， Flume，TCP sockets，Twitter，ZeroMQ等

    • SparkStreaming与storm的区别：

      • SparkStreaming微批处理数据，storm按条处理数据

      • SparkStreaming支持稍复杂的逻辑

      • SparkStreaming与storm都支持资源动态调整和事务机制

    SparkStreaming的处理架构：采用recevier task持续拉取数据，拉取时间间隔为batch Interval，每次来去的数据封装为batch，batch被封装到RDD中，RDD被封装进DStream中。SparkStreaming对DStream进程处理。

    数据处理与数据拉取同时进行，数据处理的速度需要与数据拉取量均衡，数据存储方式为memory_only，若数据处理速度慢于拉取速度会产生数据堆积，进而导致OOM。若数据存储方式包含disk，会加大延迟

    代码实现

    使用TCP sockets实现测试，liunx中命令：nc -lk 9999 实现模拟向9999端口发数据。

    • 数据拉取的间隔时长 + sparkconf/sparkcontext => JavaStreamingContext (stream上下文)

    • 数据源配置 + stream上下文 => JavaStreamingContext(首个DStream)

    SparkConf sparkConf = new SparkConf();
    //配置参数中需要至少2个线程，一条接收数据，一条执行job任务，否则无法打印数据，格式为：主机名[2]
    sparkConf.setMaster("local[2]").setAppName("s01");
    JavaSparkContext sparkContext = new JavaSparkContext(sparkConf);
    ​
    //通过sc上下文和指定间隔获取stream的上下文
    JavaStreamingContext jsc = new JavaStreamingContext(sparkContext, Durations.seconds(5));
    //通过conf 和指定间隔获取stream的上下文
    //JavaStreamingContext jsc2 = new JavaStreamingContext(sparkConf,Durations.seconds(5));
    ​
    //设置checkpoint路径
    //jsc.checkpoint("hdfs://node1:9000/spark/checkpoint");
    jsc.checkpoint("/checkpoint");
    ​
    //使用socket监听作为数据源，获取DStream
    JavaReceiverInputDStream<String> data = jsc.socketTextStream("node1", 9999);
    ​
    /* 此处写入 DStream 逻辑*/
    ​
    //使用 输出算子，触发DStream逻辑代码
    data.print();
    ​
    //通过JavaStreamingContext触发代码执行
    jsc.start();
    ​
    //阻塞线程，不断执行任务
    try {
        streamingContext.awaitTermination();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    ​
    //结束任务并关闭sparkContext
    //若不需要关闭sparkContext加参数false
    //stop之后无法再通过start启动任务
    jsc.stop();
    //jsc.stip(false);

    算子

    DStream能够使用RDD的算子，以下列举DStream的专属算子

    对于DStream可以转为RDD的执行的操作，RDD算子内的代码在exector进程执行，RDD外代码在driver进程执行

    转换算子

    transform

    将DStream在算子内部转为RDD运算，最后还是返回DStream。实现对DStream执行任意RDD操作

    JavaDStream<String> resultDStream = DStream.transform(new Function<JavaRDD<String>, JavaRDD<String>>() {
        @Override
        public JavaRDD<String> call(JavaRDD<String> value) throws Exception {
            //转换算子
            JavaRDD<String> map = value.map(x->{return x+"1";});
            //触发算子
            map.foreach(x-> System.out.println(x));
            return map;
        }
    });

    updateStateByKey（状态）

    • 实现修改DStream的key的状态值。

      • sparkstream中为每个key维护一个static值，static可以为任意类型

      • 每有一个新的batch数据计算，若数据中的key值对应的static执行更新

    • API

      • 指定checkpoint目录，实现static存储

      • 对于数据拉取间隔小于10s的操作，使用10秒一次的static更新，避免反复写磁盘

      • 数据由Optional对象封装

      //指定checkpoint路径，若加载了hdfs配置则为hdfs中的路径
      jsc.checkpoint("/checkpoint");
      JavaReceiverInputDStream<String> DStream = jsc.socketTextStream("node1", 9999);
      //数据转为KV结构
      JavaPairDStream<String, Integer> pair = data.mapToPair(new PairFunction<String, String, Integer>() {
          @Override
          public Tuple2<String, Integer> call(String s) throws Exception {
              return new Tuple2(s, 1);
          }
      });
      //执行updateStateByKey
      JavaPairDStream<String, Integer> result = pair.updateStateByKey(new Function2<List<Integer>, Optional<Integer>, Optional<Integer>>() {
          //内部call方法入参：本批次相同key的value集合，key对应static的值;
          //出参为新的static的值，为了数据安全使用Optional进行封装
          @Override
          public Optional<Integer> call(List<Integer> v1, Optional<Integer> v2) throws Exception {
              Integer value = 0;
              //对本次的key的value进行处理
              for (Integer i : v1) { value += i; }
              //对static非空判断，并逻辑处理
              if(v2.isPresent()){ value += v2.get(); }
      ​
              return Optional.of(value);
          }
      });
      result.print();

    reduceByKeyAndWindow(窗口)

    • 以若干时间间隔，一次性处理一段时间的数据

      • 滑动间隔：每隔多少时间处理一次数据（取值间隔时间的倍数）

      • 窗口：一次处理多少时间的数据（取值间隔时间的倍数）

    //DStream为KV格式的数据
    JavaPairDStream<String, Integer> result = DStream.reduceByKeyAndWindow(
        //对当前DStream中相同key的value进行reduce操作
        new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        },
        //指定窗口时间长度
        Durations.seconds(15),
        //指定滑动间隔的时间长度
        Durations.seconds(20));

    优化

    由于窗口函数需要对一段时间的数据进行计算，可能与前后一次的计算存在重复计算

    设置checkpoint存储已经计算好DStream数据，在窗口调用数据减去旧的数据，加上新的数据。

    //预先设置checkpoint路径
jsc.checkpoint("/checkpoint");
​
//DStream已经处理为kV结构
JavaPairDStream<String, Integer> result = DStream.reduceByKeyAndWindow(
    //以下逻辑用于对当前分区内，DStream内，窗口内，相同的key的value执行的操作
    对当前DStream中相同key的value进行reduce操作
    new Function2<Integer, Integer, Integer>() {
        @Override
        public Integer call(Integer v1, Integer v2) throws Exception {
        //v1为已累计的数据值，v2为新加入的数据值
            return v1 + v2;
        }
    },
    //对前一窗口中相同的key的value执行数据剔除的操作逻辑
    new Function2<Integer, Integer, Integer>() {
        @Override
        public Integer call(Integer v1, Integer v2) throws Exception {
            //v1为窗口中的数据值，v2为需要去除的数据值
            return v1 - v2;
        }
    },
    //指定窗口时间长度
    Durations.seconds(15),
    //指定滑动间隔的时间长度
    Durations.seconds(20));

     

    输出算子

    output operator：业务逻辑完成后需要至少一个output operator触发代码执行

    foreachRDD

    将DStream转为RDD进行算子运算，注意：内部RDD必须使用触发算子，否则代码不执行

    //RStream使用foreachRDD转换为RDD，通过RDD执行逻辑
    DStream.foreachRDD(new VoidFunction<JavaRDD<String>>() {
        @Override
        public void call(JavaRDD<String> stringJavaRDD) throws Exception {
            //RDD转换算子
            JavaRDD<String> result1 = stringJavaRDD.map(x->x);
            //RDD触发算子
            result1.foreach(x->{ System.out.println(x); });
        }
    });

    print

    DStream.print() 实现对内部的数据的打印

    Driver高可用

    由于Driver需要不间断获取数据，Driver宕机重启需要借助checkpoint恢复原先的是数据，

    • 启动层面，设置Driver宕机重启

      • standalone模式与Mesos 在启动任务时加入参数： --supervise

      • yarn模式具备自动重启能力

    • 代码层面，设置基于checkpoint恢复

      • 设置checkpoint路径

      • 设置启动方式，使用JavaStreamingContext的getOrCreate方法创建DStream上下文

    SparkConf conf = new SparkConf().setMaster("local[2]").setAppName("HA");
//指定逻辑恢复的路径
JavaStreamingContext jsc0 = JavaStreamingContext.getOrCreate(
    "/checkpoint",
    new Function0<JavaStreamingContext>() {
        @Override
        public JavaStreamingContext call() throws Exception {
            JavaStreamingContext ssc = new JavaStreamingContext(
                sparkConf, Durations.seconds(5));
            //设置checkpoint路径
            ssc.checkpoint("/checkpoint");
            return ssc;
        }
    });

    整合kafka

    Spark2.2+kafka0.8

    receiver模式

    1. executor进程中的receiver task线程定时从kafka上拉取数据

    2. receiver task将数据备份到各executor进程中，默认持久化级别MEMORY_AND_DISK_SER_2

    3. receiver task将偏移量写入zk，并将备份情况汇报给driver进程

    4. driver根据备份所在节点向executor进程分发task

      若driver宕机重启后从zk读取偏移量，重启receiver task进程。

      使用High Level Consumer API ，由zookeeper维护偏移量

      zk是投票机制更新数据消耗大，不利于大量数据吞吐

    并行度修改

    问题：对于数据量较大的场景，由于处理速度低于数据拉取速度，存在数据堆积的问题。

    方案：修改并行度，增加task的数量，但该措施需控制在机器性能允许的范围内。

    原理及实现：job的并行度由spark.streaming.blockInterval参数控制，该参数默认200ms对一批数据切分为若干数据块，每个数据块就是一个分区，分区数也就对应了并行度。该参数可修改的最小值为50ms

    数据丢失问题

    • 原因：dirver宕机，任务未执行完毕，但偏移量在zk中已经更新，dirver重启后丢失偏移量之前的任务数据

    • 解决：WAL机制(日志)：在偏移量提交zk前hdfs保存一份数据，driver先从hdfs上读取备份数据，再从zk中取偏移量。

      • 问题1：性能低，优化：可将持久化级别修改为MEMORY_AND_DISK_SER

      • 问题2：导致数据重复消费问题

    SparkConf conf = new SparkConf().setAppName("ccc").setMaster("local[2]");
//设置启动WAL机制
conf.set("spark.streaming.receiver.writeAheadLog.enable","true");
JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(5));
//设置checkpoint的路径
jsc.checkpoint("/rec");
​
//通过map设置读取的topic及线程数
HashMap<String, Integer> topics = new HashMap<>();
topics.put("topic1",1);
topics.put("topic2",1);
​
//通过KafkaUtils的createStream方法创建DStream
//参数：上下文，zk，所属消费者组，读取的topic，持久化级别
JavaPairReceiverInputDStream<String,String> lines = KafkaUtils.createStream(
        jsc,
        "node03:2181,node02:2181,node01:2181",
        "ConsumerGroup",
        topics,
        StorageLevel.MEMORY_AND_DISK());

    direct模式

    • task直接从kafka的分区上拉取数据，task并行度与kafka的分区数一致

    • 偏移量

      1. 默认使用内存维护偏移量（会有数据丢失），底层使用Simple Consumer API

      2. 可以添加checkpoint来维护偏移量，checkpoint也用于实现dirver宕机恢复

        • direct模式下的checkpoint中存储了代码逻辑+偏移量

        • 存在问题：在HA机制中，无法在运行过程中改变逻辑。若将新逻辑存入checkpoint，则会导致原有偏移量读取异常。同时存在driver宕机恢复时数据重复输出

      3. 可以自定义维护偏移量

        • 使用外部数据库存取更新偏移量，并实现手动提交偏移量，获取偏移量

        • 流程：构建DStream时手动获取并传入原有偏移量，从首个RDD中获取新的偏移量，在数据输出时将新的偏移量存入外部数据库。

        • 存在问题：只能保证转换1次，无法保证输出只有一次，需要通过输出幂等性或事务处理来解决

    默认/checkpoint方式自动维护偏移量

    //设置上下文
SparkConf conf = new SparkConf().setAppName("direct").setMaster("local[2]");
JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(10));

//设置checkpoint路径
jsc.checkpoint("./ck");

//设置kafka各节点路径
HashMap<String, String> parms = new HashMap<>();
parms.put("metadata.broker.list", "node01:9092,node02:9092,node03:9092");
//设置读取的topic
HashSet<String> topics = new HashSet<>();
topics.add("topic1");topics.add("topic2");

/*
通过KafkaUtils创建DStream.参数为：
    上下文，kafka中key类型，value类型，key解码方式,vlaue解码方式，kafka参数，topic
*/
JavaPairInputDStream<String, String> ds = KafkaUtils.createDirectStream(
        jsc,
        String.class,
        String.class,
        StringDecoder.class,
        StringDecoder.class,
        parms,
        topics
);

    自定义维护offsets的代码示例：

    //设置上下文与传统方式一致，不再设置checkpoint路径   jsc.checkpoint("./ck");
SparkConf conf = new SparkConf().setAppName("direct").setMaster("local[2]");
JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(10));
HashMap<String, String> parms = new HashMap<>();
parms.put("metadata.broker.list", "node01:9092,node02:9092,node03:9092");

//读取偏移量数据，本示例中直接指定了偏移量，生产环境中从数据度读取偏移量
//使用Map容器临时存储，key为TopicAndPartition对象，value为偏移量

Map<TopicAndPartition, Long> offsets = new HashMap<>();
TopicAndPartition tp1 = new TopicAndPartition("topic1", 0);
TopicAndPartition tp2 = new TopicAndPartition("topic1", 1);
offsets.put(tp1, 123L);
offsets.put(tp2, 456L);

//创建DStream，参数为：
//    上下文，kafka中key类型，value类型，key解码方式,vlaue解码方式，DStream的数据类型,kafka参数，存储偏移量的map容器，获取消息的value作为DStream的数据
JavaInputDStream<String> ds = KafkaUtils.createDirectStream(
        jsc,
        String.class,
        String.class,
        StringDecoder.class,
        StringDecoder.class,
        String.class,
        parms,
        offsets,
        new Function<MessageAndMetadata<String, String>, String>() {
            @Override
            public String call(MessageAndMetadata<String, String> v1) throws Exception {
                return v1.message();
            }
        }
);

//设置新的偏移量封装容器
AtomicReference<OffsetRange[]> offsetRanges = new AtomicReference();

//必须在第一个DStream中通过RDD，获取当前的偏移量
JavaDStream<String> ds1 = ds.transform(new Function<JavaRDD<String>, JavaRDD<String>>() {
    @Override
    public JavaRDD<String> call(JavaRDD<String> rdd) throws Exception {
        //通过RDD获取当前偏移量
        OffsetRange[] offsets = ((HasOffsetRanges) rdd.rdd()).offsetRanges();
        //将偏移量存入偏移量封装容器中，返回出去
        offsetRanges.set(offsets);
        return rdd;
    }
});

//通过output算子触发逻辑，在执行完成时，将偏移量提交到数据库
//这一过程中为了避免数据重复消费，输出操作应当是幂等输出，或者使用事务，目的都是保证偏移量提交与输出操作的一致性

ds1.foreachRDD(new VoidFunction<JavaRDD<String>>() {
    @Override
    public void call(JavaRDD<String> RDD) throws Exception {
        //以下触发算子的输出操作和偏移量向外存储，写在一个事务中（建议使用异常机制）
        
        //触发算子
        RDD.foreach(x -> System.out.println(x));

        //将偏移量封装容器转换为数组，每个元素就是一个OffsetRange对象。
        //OffsetRange对象存储了一个topic分区的偏移量信息，可以对OffsetRange解析后存入数据库
        OffsetRange[] offsets = offsetRanges.get();
        for (OffsetRange x : offsets) {
            //解析
            String topic = x.topic();
            int partition = x.partition();
            long offset = x.untilOffset();
        }
    }
});

    Spark2.3+kafka0.10+

    • 只有direct模式

    • 偏移量维护策略：

      1. 使用kafka维护，kafka中使用特殊的topic(_consumer_offsets)实现

      2. 若设置了checkpoint，则偏移量会存在checkpoint中维护。

      3. 使用自定义方式维护偏移量

    • 任务分配策略

      • LocationStrategies.PreferBrokers：如Executor在kafka 集群中的节点上，该executor 读取当前broker节点的数据（一般用这个）

      • LocationStrategies.PreferFixed：节点之间的分区有明显的分布不均，通过一个map 指定将topic分区分布在哪些节点中

    • 缓存策略

      • kafka的数据预先读取到Executor的缓存中再处理，该缓存默认64K，能够加快数据的处理速度

      • spark.streaming.kafka.consumer.cache.maxCapacity 控制缓存大小

      • spark.streaming.kafka.consumer.cache.enabled 控制缓存机制开关

    kafka维护偏移量

    • 提交时间

      • 自动提交默认5s提交一次偏移量，参数auto.commit.interval.ms控制

      • 手动提交偏移量，底层api也是异步的

    • 问题

      • 若一天不访问kafka偏移量数据，kafka会自动清空

      • 使用手动提交偏移量的方式，偏移量提交与结果输出是异步的，也重复输出的问题

    本示例中：使用手动向kafka提交偏移量

    //创建JavaStreamingContext
SparkConf conf = new SparkConf().setAppName("direct").setMaster("local[2]");
JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(10));

//创建kafka参数对象
HashMap<String, Object> kafkaParams = new HashMap<>();
//kafka节点
kafkaParams.put("bootstrap.servers", "node1:9092,node2:9092,node3:9092");
//第一次读取的偏移量位置
kafkaParams.put("auto.offset.reset", "earliest");
//消费者组
kafkaParams.put("group.id", "myGroup");
//key序列化方式
kafkaParams.put("key.deserializer", StringDeserializer.class);
//key序列化方式
kafkaParams.put("value.deserializer", StringDeserializer.class);
//设置偏移量手动提交
kafkaParams.put("enable.auto.commit", false);

//设置读取的topics
Collection<String> topics = Arrays.asList("sm3");

//构建初始DStream，其数据元素为一条kafka的消息具备value值与kafuka的相关属性
//传入 上下文，task分配策略 ，kafkfa参数（topic+参数map）
JavaInputDStream<ConsumerRecord<String, String>> stream =
        KafkaUtils.createDirectStream(
                jsc,
                LocationStrategies.PreferBrokers(),
                ConsumerStrategies.Subscribe(topics, kafkaParams)
        );

//偏移量封装类具备原子更新属性
AtomicReference<OffsetRange[]> newoffset = new AtomicReference();

JavaDStream<String> stream1 = stream.transform(new Function<JavaRDD<ConsumerRecord<String, String>>, JavaRDD<String>>() {
    @Override
    public JavaRDD<String> call(JavaRDD<ConsumerRecord<String, String>> RDD) throws Exception {
        //获取偏移量，新的偏移量必须从初始DStream的第一个RDD中获取,其他的RDD弃置该信息
        OffsetRange[] offsetRanges = ((HasOffsetRanges) RDD.rdd()).offsetRanges();
        //将偏移量设置在封装对象中
        newoffset.set(offsetRanges);

        //将初始DStream解析为普通的RDD，即取出value值
        return RDD.map(new Function<ConsumerRecord<String, String>, String>() {
            @Override
            public String call(ConsumerRecord<String, String> record) throws Exception {
                //可以从每条记录中取出消息值及其kafka相关信息
                record.key(); record.topic(); record.partition();
                return record.value();
            }
        });
    }
});


//在执行触发算子时提交偏移量
stream1.foreachRDD(new VoidFunction<JavaRDD<String>>() {
    @Override
    public void call(JavaRDD<String> RDD) throws Exception {
        
        /*为了避免数据重复输出，采用以下两种方式解决：
        1.实现输出代码的幂等性
        2.将输出代码与偏移量提交代码写在一个事务中
        */
        
        //触发算子
        RDD.foreach(s->System.out.println(s));

        //通过偏移量封装对象获取偏移量
        OffsetRange[] offsetRanges = newoffset.get();
        //通过初始DStream转换，使用自动提交偏移量
        ((CanCommitOffsets) stream.inputDStream()).commitAsync(offsetRanges);
    }
});

    自定义维护偏移量

    • 实现从外部数据库读取偏移量，将新的偏移量存入外部数据库

    • 这种方式也存在重复输出的问题，需要实现输出幂等或(输出+offset)事务

    //kafka参数
HashMap<String, Object> kafkaParams = new HashMap<>();
kafkaParams.put("bootstrap.servers", "node1:9092,node2:9092,node3:9092"); 
kafkaParams.put("auto.offset.reset", "earliest"); 
kafkaParams.put("group.id", "myGroup"); 
kafkaParams.put("key.deserializer", StringDeserializer.class); 
kafkaParams.put("value.deserializer", StringDeserializer.class); 
kafkaParams.put("enable.auto.commit", false);

//本例子中直接给定偏移量，生产环境中偏移量从外部外部数据库读入
//偏移量通过map封装
Map<TopicPartition, Long> offsetdata = new HashMap<>();
offsetdata.put(new TopicPartition("topic1", 0), 123L);
offsetdata.put(new TopicPartition("topic1", 1), 444L);

//构建初始DStream。参数：
// 上下文，task分配策略 ，kafkfa参数（topic+参数map+偏移量map）
JavaInputDStream<ConsumerRecord<String, String>> stream = KafkaUtils.createDirectStream(
        jsc,
        LocationStrategies.PreferBrokers(),
        ConsumerStrategies.Assign(offsetdata.keySet(), kafkaParams, offsetdata));

//获取偏移量方式与上述方式相同，区别在于提交偏移量的方式不同 
AtomicReference<OffsetRange[]> newoffset = new AtomicReference();
JavaDStream<String> stream1 = stream.transform(new Function<JavaRDD<ConsumerRecord<String, String>>, JavaRDD<String>>() {
    @Override
    public JavaRDD<String> call(JavaRDD<ConsumerRecord<String, String>> RDD) throws Exception {
        //获取偏移量
        newoffset.set(((HasOffsetRanges) RDD.rdd()).offsetRanges());
        return RDD.map(x->x.value());
    }
});


stream1.foreachRDD(new VoidFunction<JavaRDD<String>>() {
    @Override
    public void call(JavaRDD<String> RDD) throws Exception {
        /*为了避免数据重复输出，采用以下两种方式解决：
        1.实现输出代码的幂等性
        2.将输出代码与偏移量提交代码写在一个事务中
        */
        //触发算子
        RDD.foreach(s->System.out.println(s));

        //通过偏移量封装对象获取偏移量,遍历偏移量存入数据库
        OffsetRange[] offsetRanges = newoffset.get();
       for(OffsetRange x : offsetRanges ){
           System.out.println(x);
       }

/**
* 开启事务
*/
//1.提交偏移量到redis
//2.提交计算结果到mysql中
//3.做好事务原子性的维护   
    }
});
    

    checkpoint维护偏移量
    

      

    • 

      driver宕机恢复容易产生数据重复消费
      

      • 

    • 

      修改代码逻辑，会导致原checkpoint偏移量丢失
      

      • 

    

    代码实现kafka维护基本一致，只需要指定checkpoint的路径
    

    整合参数
    

      

    • 

      receiver模式的参数
      

        

      • 

        spark.streaming.receiver.writeAheadLog.enable 默认false 是否开启预写日志
        

        • 

      • 

        spark.streaming.blockInterval 默认200ms 对一批数据的切分间隔，用于控制receiver模式下的分区数
        

        • 

      • 

        spark.streaming.receiver.maxRate 无默认值 修改receiver task的最大拉取速率
        

        • 

      

      • 

    • 

      Direct模式
      

        

      • 

        spark.streaming.kafka.maxRatePerPartition 修改每个分区拉取数据的最大速率
        

        • 

      

      • 

    • 

      反压机制
      

        

      • 

        spark.streaming.backpressure.enabled 默认false 微调数据拉取速率，提高运行效率
        

        • 

      

      • 

    • 

      关停任务
      

        

      • 

        spark.streaming.stopGracefullyOnShutdown 设置 true
        

        • 

      • 

        kill -15/sigterm driverpid
        

        • 

      

      • 

    

    注：以上参数均可以在conf中设置
    

     
    

    遗留问题：HA的ck，对direct模式的影响
    

    
    
          
    • 

          
  • 

            相关阅读:
    
            
              怎样练习一万小时
                
    新闻的未来
                
    有些人无缘再见，却一生想念
                
    媒体该如何展示事实之美？
                
    传统媒体：广告都去哪儿了？
                
    一线从业者干货分享：不做“忧伤”的媒体人
                
    整理者与信息平台
                
    把媒体当手段还是当目的？
                
    媒体人转身，转身去哪里？
                
    腾讯新闻的海量服务
                
                    
          
    • 
          
  • 
            原文地址：https://www.cnblogs.com/javaxiaobu/p/11775076.html
          
    • 

        

      



      
      

        

        

      

    

  


  

  
Copyright © 2020-2023 
  润新知