求学旅途
求学旅途

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！

目录

 

流处理API

​

一、Environment

1.1 getExecutionEnvironment

1.2 createLocalEnvironment

1.3  createRemoteEnvironment

二、Source 

2.1 从集合读取数据

 2.2 从文件读取数据

2.3 以 kafka 消息队列的数据作为来源 

2.4 自定义 Source

三、Transform

3.1 map

3.2 flatMap

3.3 Filter

3.4 KeyBy

3.5 滚动聚合算子(Rolling Aggregation)

3.6 Reduce

微小结：

3.7 Split 和 Select

3.8 Connect 和 CoMap

3.9 Union

总结：

四、支持的数据类型

4.1 基础数据类型

4.2 Java 和 Scala 元组(Tuples) 

4.3 Scala 样例类(case classes) 

4.4 Java 简单对象(POJOs)

4.5 其它(Arrays, Lists, Maps, Enums, 等等) 

五 实现 UDF 函数——更细粒度的控制流

5.1 函数类(Function Classes)

5.2 匿名函数(Lambda Functions)

5.3 富函数(Rich Functions)

六 Sink

6.1 Kafka

6.2 Redis

6.3 Elasticsearch

6.4 JDBC 自定义 sink

流处理API

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第1张图片

一、Environment

1.1 getExecutionEnvironment

创建一个执行环境，表示当前执行程序的上下文。 如果程序是独立调用的，则 此方法返回本地执行环境;如果从命令行客户端调用程序以提交到集群，则此方法 返回此集群的执行环境，也就是说，getExecutionEnvironment 会根据查询运行的方 式决定返回什么样的运行环境，是最常用的一种创建执行环境的方式。

ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

 如果没有设置并行度，会以 flink-conf.yaml 中的配置为准，默认是 1。

1.2 createLocalEnvironment

返回本地执行环境，需要在调用时指定默认的并行度。

LocalStreamEnvironment env = StreamExecutionEnvironment.createLocalEnvironment(1);

1.3  createRemoteEnvironment

返回集群执行环境，将 Jar 提交到远程服务器。需要在调用时指定 JobManager 的 IP 和端口号，并指定要在集群中运行的 Jar 包。

StreamExecutionEnvironment env =
StreamExecutionEnvironment.createRemoteEnvironment("jobmanage-hostname", 6123,"YOURPATH//WordCount.jar");

二、Source 

2.1 从集合读取数据

package com.dongda.source;

import com.dongda.beans.SensorReading;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.util.Arrays;

public class SourceTest1_Collection {
    public static void main(String[] args) throws Exception {
        //1.Source:从集合中读取数据
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream sensorDataStream = env.fromCollection(Arrays.asList(
                new SensorReading("sensor_1", 1547718199L, 35.8),
                new SensorReading("sensor_6", 1547718201L, 15.4),
                new SensorReading("sensor_7", 1547718202L, 6.7),
                new SensorReading("sensor_10", 1547718205L, 38.1)
        ));

        //2.打印
        sensorDataStream.print();

        //3.执行
        env.execute();
    }
}

 2.2 从文件读取数据

在resource下创建sensor.txt文件，以便读取

sensor_1, 1547718199, 35.8
sensor_6", 1547718201, 15.4
sensor_7", 1547718202, 6.7
sensor_10", 1547718205, 38.1
package com.dongda.source;

import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;


public class SourceTest2_File {
    public static void main(String[] args) throws Exception {
        //1.Source:从集合中读取数据
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //从文件读取数据
        DataStream sensorDataStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");

        //2.打印
        sensorDataStream.print();

        //3.执行
        env.execute();
    }
}

2.3 以 kafka 消息队列的数据作为来源 

需要引入 kafka 连接器的依赖:


    org.apache.flink
    flink-connector-kafka-0.11_2.12
    1.10.1

package com.dongda.source;

import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer011;

import java.util.Properties;

public class SourceTest3_Kafka {
    public static void main(String[] args) throws Exception {
        //1.Source:从集合中读取数据
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        // kafka 配置项
        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers", "localhost:9092");
        properties.setProperty("group.id", "consumer-group");
        properties.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("auto.offset.reset", "latest");


        //从kafka读取数据
        DataStream sensorDataStream = env.addSource(new FlinkKafkaConsumer011("sensor",new SimpleStringSchema(),properties));

        //2.打印
        sensorDataStream.print();

        //3.执行
        env.execute();
    }

}

2.4 自定义 Source

package com.dongda.source;

import com.dongda.beans.SensorReading;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.SourceFunction;

import java.util.HashMap;
import java.util.Random;

public class SourceTest4_UDF {
    public static void main(String[] args) throws Exception {
        //1.Source:从集合中读取数据
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //从文件读取数据
        DataStream sensorDataStream = env.addSource(new MySensorSource());

        //2.打印
        sensorDataStream.print();

        //3.执行
        env.execute();
    }

    private static class MySensorSource implements SourceFunction {
        //定义一个标识位，用来控制数据的产生
        private boolean running = true;

        public void run(SourceContext sourceContext) throws Exception {
            //定义一个随机数发生器
            Random random = new Random();

            //设置10个传感器的初始温度
            HashMap sensorTempMap = new HashMap();
            for (int i = 0; i < 10; i++) {
                sensorTempMap.put("sensor_" + (i + 1), 60 + random.nextGaussian() * 20);
            }

            while (running) {
                for (String sensorId : sensorTempMap.keySet()) {
                    //在当前的温度基础上随机波动
                    double newtemp = sensorTempMap.get(sensorId) + random.nextGaussian();
                    sensorTempMap.put(sensorId,newtemp);
                    sourceContext.collect(new SensorReading(sensorId,System.currentTimeMillis(),newtemp));

                }
                Thread.sleep(1000L);
            }

        }

        public void cancel() {

        }
    }
}

三、Transform

转换算子

3.1 map

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第2张图片

3.2 flatMap

3.3 Filter

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第3张图片

package com.dongda.transform;

import org.apache.flink.api.common.JobExecutionResult;
import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

public class TransformTest1_Base {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1

        //从文件里面读取数据
        DataStream inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");

        //1.map 把String 转换成长度输出
        DataStream mapStream = inputStream.map(new MapFunction() {
            public Integer map(String s) throws Exception {
                return s.length();
            }
        });

        //2.flatmap,按逗号分字段
        DataStream flatMapStream = inputStream.flatMap(new FlatMapFunction() {
            public void flatMap(String s, Collector collector) throws Exception {
                String[] fields = s.split(",");
                for (String field : fields) {
                    collector.collect(field);
                }
            }
        });

        //3.filter,筛选sensor_1开头的Id对应的数据
        DataStream filterStream = inputStream.filter(new FilterFunction() {
            public boolean filter(String s) throws Exception {
                return s.startsWith("sensor_1");

            }
        });

        //打印输出
        mapStream.print();
        flatMapStream.print();
        filterStream.print();

        //执行
        env.execute();

    }
}

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第4张图片

3.4 KeyBy

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第5张图片

DataStream → KeyedStream:逻辑地将一个流拆分成不相交的分区，每个分 区包含具有相同 key 的元素，在内部以 hash 的形式实现的。

3.5 滚动聚合算子(Rolling Aggregation)

这些算子可以针对 KeyedStream 的每一个支流做聚合。

sum()
min()
max()

minBy()

maxBy()

这里面，min和minBy(或者max和maxBy)的区别是：语言解释起来有点绕，直接上代码上图！

sensor.txt

sensor_1,1547718199, 35.8
sensor_6",1547718201, 15.4
sensor_7",1547718202, 6.7
sensor_10",1547718205, 38.1
sensor_1,1547718123, 36.8
sensor_6",1547718341, 20.4
sensor_1,1547718239, 12.8
sensor_1,1547718111, 38.8

1、max() 

package com.dongda.transform;

import com.dongda.beans.SensorReading;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class TransformTest2_RollingAggregation {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1

        //从文件里面读取数据
        DataStream inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");

//        DataStream dataStream = inputStream.map(new MapFunction() {
//            public SensorReading map(String s) throws Exception {
//                String[] fields = s.split(",");
//                return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
//            }
//        });
        //lamda表达式写法
        DataStream dataStream = inputStream.map(line ->{
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        //分组
        KeyedStream keyedStream = dataStream.keyBy("id");
        //分组写法2
//        KeyedStream keyedStream1 = dataStream.keyBy(SensorReading::getId);
        
        //滚动聚合，取当前最大的温度值
        SingleOutputStreamOperator resultStream = keyedStream.max("temperature");

        resultStream.print();

        env.execute();
    }
}

运行输出如下：对应着sensor.txt，由于是滚动聚合，以sensor_1为例，第一条数据来的时候，最大值是35.8，第二条来的时候是38.1，temperature改变为当前最大值38.1，但是！时间戳timestamp没有变！！！以此类推

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第6张图片

2、maxBy()

package com.dongda.transform;

import com.dongda.beans.SensorReading;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class TransformTest2_RollingAggregation {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1

        //从文件里面读取数据
        DataStream inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");

//        DataStream dataStream = inputStream.map(new MapFunction() {
//            public SensorReading map(String s) throws Exception {
//                String[] fields = s.split(",");
//                return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
//            }
//        });
        //lamda表达式写法
        DataStream dataStream = inputStream.map(line ->{
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        //分组
        KeyedStream keyedStream = dataStream.keyBy("id");
        //分组写法2
//        KeyedStream keyedStream1 = dataStream.keyBy(SensorReading::getId);

        //滚动聚合，取当前最大的温度值
        SingleOutputStreamOperator resultStream = keyedStream.maxBy("temperature");

        resultStream.print();

        env.execute();
    }
}

输出结果如下：得到的是温度最大值的那一条整体数据！

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第7张图片

3.6 Reduce

KeyedStream → DataStream:一个分组数据流的聚合操作，合并当前的元素 和上次聚合的结果，产生一个新的值，返回的流中包含每一次聚合的结果，而不是 只返回最后一次聚合的最终结果。

package com.dongda.transform;

import com.dongda.beans.SensorReading;
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class TransformTest3_Reduce {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1

        //从文件里面读取数据
        DataStream inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");

        //lamda表达式写法 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line ->{
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        //分组
        KeyedStream keyedStream = dataStream.keyBy("id");
        //分组写法2
//        KeyedStream keyedStream1 = dataStream.keyBy(SensorReading::getId);

        //reduce聚合，取最大的温度值以及当前最新的时间戳
        SingleOutputStreamOperator reduce = keyedStream.reduce(new ReduceFunction() {
            @Override
            public SensorReading reduce(SensorReading sensorReading, SensorReading t1) throws Exception {
                return new SensorReading(sensorReading.getId(), t1.getTimestamp(), Math.max(sensorReading.getTemperature(), t1.getTemperature()));
            }
        });

        reduce.print();

        env.execute();
    }
}

输出结果如下: reduce聚合，取最大的温度值以及当前最新的时间戳

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第8张图片

微小结：

以上我们介绍了基本的转换计算，也学完了稍微复杂一点的聚合计算，其实我们做大数据一般就是map、reduce这两组操作，要不就是你只跟当前状态有关，做一个简单转换，要不就是和之前的某些数据、和状态有关，做一个聚合、做一个统计，那还可以做什么操作呢？接下来介绍的又可以归为一大类，第7节到第9节，操作的是多条流，所以我们往往会把他们总结起来，叫做多流转换算子！现在开始！

3.7 Split 和 Select

Split

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第9张图片

DataStream → SplitStream:根据某些特征把一个 DataStream 拆分成两个或者多个 DataStream。Split名义上是把一条流拆成两个，但事实上SplitStream还是一条流，那Split操作到底干了一件什么事情呢？它是按照一定的特征，把数据做一个划分，然后给他相当于盖上一个戳（相当于一个拣选的标志），就我当前还是放在同一个流里面，但是我已经根据他不同的特点，盖了不同的戳，那接下来下一步就是根据那个戳做一个拣选，就可以得到不同的流。也就是说，你做完Split操作后一定要跟上一个Select操作，这才是一个完整的分流操作。

Select

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第10张图片

基于这个SplitStream调用一个Select方法，然后根据不同的戳去提取，然后就能得到不同的DataStream，这就是一个完整的流程。

SplitStream→DataStream:从一个 SplitStream 中获取一个或者多个DataStream。

多流转换-需求:传感器数据按照温度高低(以 30 度为界)，拆分成两个流，低温流和高温流。

 

package com.dongda.transform;

import com.dongda.beans.SensorReading;
import org.apache.flink.streaming.api.collector.selector.OutputSelector;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SplitStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.util.Collections;

public class TransformTest4_MultipleStreams {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1

        //从文件里面读取数据
        DataStream inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");

        //lamda表达式写法 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        SplitStream splitStream = dataStream.split(new OutputSelector() {
            @Override
            public Iterable select(SensorReading sensorReading) {
                return (sensorReading.getTemperature() > 30) ? Collections.singletonList("high") : Collections.singletonList("low");
            }
        });

        DataStream highTemStream = splitStream.select("high");
        DataStream lowTemStream = splitStream.select("low");
        DataStream allTemStream = splitStream.select("high", "low");

        highTemStream.print("high");
        lowTemStream.print("low");
        allTemStream.print("all");

        env.execute();
    }
}

输出如下：

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第11张图片

3.8 Connect 和 CoMap

Connect

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第12张图片

DataStream,DataStream → ConnectedStreams:连接两个保持他们类型的数据流，两个数据流被 Connect 之后，只是被放在了一个同一个流中，内部依然保持 各自的数据和形式不发生任何变化，两个流相互独立。

CoMap,CoFlatMap

大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第13张图片

ConnectedStreams → DataStream:作用于 ConnectedStreams 上，功能与 map和 flatMap 一样，对 ConnectedStreams 中的每一个 Stream 分别进行 map 和 flatMap 处理。

需求：合流 connect 将高温流转换成二元组类型，与低温流连接合并之后，输出状态信息

package com.dongda.transform;

import com.dongda.beans.SensorReading;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.collector.selector.OutputSelector;
import org.apache.flink.streaming.api.datastream.ConnectedStreams;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.datastream.SplitStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.CoMapFunction;

import java.util.Collections;

public class TransformTest4_MultipleStreams {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1

        //从文件里面读取数据
        DataStream inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");

        //lamda表达式写法 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        SplitStream splitStream = dataStream.split(new OutputSelector() {
            @Override
            public Iterable select(SensorReading sensorReading) {
                return (sensorReading.getTemperature() > 30) ? Collections.singletonList("high") : Collections.singletonList("low");
            }
        });

        DataStream highTemStream = splitStream.select("high");
        DataStream lowTemStream = splitStream.select("low");
        DataStream allTemStream = splitStream.select("high", "low");

//        highTemStream.print("high");
//        lowTemStream.print("low");
//        allTemStream.print("all");

        //2.合流 connect 将高温流转换成二元组类型，与低温流连接合并之后，输出状态信息
        SingleOutputStreamOperator> warningStream = highTemStream.map(new MapFunction>() {
            @Override
            public Tuple2 map(SensorReading sensorReading) throws Exception {
                return new Tuple2<>(sensorReading.getId(), sensorReading.getTemperature());
            }
        });

        ConnectedStreams, SensorReading> connectedStream = warningStream.connect(lowTemStream);
        SingleOutputStreamOperator resultStream = connectedStream.map(new CoMapFunction, SensorReading, Object>() {
            @Override
            public Object map1(Tuple2 value1) throws Exception {
                return new Tuple3<>(value1.f0, value1.f1, "high tem warning!");
            }

            @Override
            public Object map2(SensorReading value2) throws Exception {
                return new Tuple2<>(value2.getId(), "normal");
            }
        });

        resultStream.print();

        env.execute();
    }
}
 
  
输出如下：
 
  
大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第14张图片
 
  
3.9 Union
 
  
前面介绍了connect连接两条流合并的操作，大家会发现connect的操作是非常灵活的，因为两个流的数据类型可以不一样，可以非常灵活的将各种各样的数据整合到一起，然后统一做操作（有点像一国两制）。但是他也有局限，它只能连接两条流，我们可以发现，他做map的时候只是实现了map1、map2。那么假如说我要想多条流合在一起怎么做呢？Union!它也不需要像connect操作后还要map，但是它要求合并的流的数据类型要一致。
 
  
总结一下就是说：各有各的特点，union的特点是可以合并多条流，但是它们的数据类型必须一样；connect的特点是数据类型可以不一样，然后再做转换，它就非常的灵活。实际使用中connect还是多一些。
 
  
大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第15张图片
 
  
DataStream → DataStream:对两个或者两个以上的DataStream进行union操作，产生一个包含所有 DataStream 元素的新 DataStream。
 
  
package com.dongda.transform;

import com.dongda.beans.SensorReading;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.collector.selector.OutputSelector;
import org.apache.flink.streaming.api.datastream.ConnectedStreams;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.datastream.SplitStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.CoMapFunction;

import java.util.Collections;

public class TransformTest4_MultipleStreams {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1

        //从文件里面读取数据
        DataStream inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");

        //lamda表达式写法 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        SplitStream splitStream = dataStream.split(new OutputSelector() {
            @Override
            public Iterable select(SensorReading sensorReading) {
                return (sensorReading.getTemperature() > 30) ? Collections.singletonList("high") : Collections.singletonList("low");
            }
        });

        DataStream highTemStream = splitStream.select("high");
        DataStream lowTemStream = splitStream.select("low");
        DataStream allTemStream = splitStream.select("high", "low");

//        highTemStream.print("high");
//        lowTemStream.print("low");
//        allTemStream.print("all");

        //2.合流 connect 将高温流转换成二元组类型，与低温流连接合并之后，输出状态信息
        SingleOutputStreamOperator> warningStream = highTemStream.map(new MapFunction>() {
            @Override
            public Tuple2 map(SensorReading sensorReading) throws Exception {
                return new Tuple2<>(sensorReading.getId(), sensorReading.getTemperature());
            }
        });

        ConnectedStreams, SensorReading> connectedStream = warningStream.connect(lowTemStream);
        SingleOutputStreamOperator resultStream = connectedStream.map(new CoMapFunction, SensorReading, Object>() {
            @Override
            public Object map1(Tuple2 value1) throws Exception {
                return new Tuple3<>(value1.f0, value1.f1, "high tem warning!");
            }

            @Override
            public Object map2(SensorReading value2) throws Exception {
                return new Tuple2<>(value2.getId(), "normal");
            }
        });

//        resultStream.print();

        //3.union 联合多条流
        DataStream union = highTemStream.union(lowTemStream, allTemStream);
        union.print();

        env.execute();
    }
}
 
  
输出如下：
 
  
大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第16张图片
 
  
总结：
 
  
到目前为止我们可以稍微总结一下，为什么所有的转换算子，都叫DataStreamAPI呢？就是因为我们基础的数据结构就是DataStream,然后里面可能有范型定义了内部的数据结构，它在做转换的过程当中，数据类型有可能会发生改变。那这里面涉及到流本身的数据结构变化的有哪些呢？简单转换不改变。KeyBy之后就会由一个DataStream 转换成 KeyedStream，当然，KeyedStream本质我们说还是一个DataStream，但是大家会发现KeyedStream里面有很多DataStream本身调用不了的方法，比如说聚合操作。
 
  
具体的类型转换图如下，核心就是DataStream
 
  
 
  
四、支持的数据类型
 
  
        Flink 流应用程序处理的是以数据对象表示的事件流。所以在 Flink 内部，我们 需要能够处理这些对象。它们需要被序列化和反序列化，以便通过网络传送它们; 或者从状态后端、检查点和保存点读取它们。为了有效地做到这一点，Flink 需要明 确知道应用程序所处理的数据类型。Flink 使用类型信息的概念来表示数据类型，并 为每个数据类型生成特定的序列化器、反序列化器和比较器。
 
  
        Flink 还具有一个类型提取系统，该系统分析函数的输入和返回类型，以自动获 取类型信息，从而获得序列化器和反序列化器。但是，在某些情况下，例如 lambda 函数或泛型类型，需要显式地提供类型信息，才能使应用程序正常工作或提高其性 能。
 
  
        Flink 支持 Java 和 Scala 中所有常见数据类型。使用最广泛的类型有以下几种。
 
  
4.1 基础数据类型
 
  
Flink 支持所有的 Java 和 Scala 基础数据类型，Int, Double, Long, String, ...
 
  
 
    
    
 
      
DataStream numberStream = env.fromElements(1, 2, 3, 4);
 		 
    
 
    
 
      
numberStream.map(data -> data * 2);
 		 
    
 
    
  
 
  
4.2 Java 和 Scala 元组(Tuples) 
 
  
 
    
    
 
      
DataStream> personStream = env.fromElements(
 		 
    
 
    
 
      
new Tuple2("Adam", 17),
 		 
    
 
    
 
      
new Tuple2("Sarah", 23) );
 		 
    
 
    
 
      
personStream.filter(p -> p.f1 > 18);
 		 
    
 
    
  
 
  
4.3 Scala 样例类(case classes) 
 
  
 
   
case class Person(name: String, age: Int)
 val persons: DataStream[Person] = env.fromElements(
 
   
Person("Adam", 17), Person("Sarah", 23) )
 
   
persons.filter(p => p.age > 18)
 
  
 
  
4.4 Java 简单对象(POJOs)
 
  
 
   
public class Person { 
 public String name;
 public int age;
 public Person() {}
 public Person(String name, int age) { 
 
   
this.name = name;
 
   
this.age = age; }
 
   
}
 DataStream persons = env.fromElements(
 
   
new Person("Alex", 42), new Person("Wendy", 23));
 
  
 
  
4.5 其它(Arrays, Lists, Maps, Enums, 等等) 
 
  
Flink 对 Java 和 Scala 中的一些特殊目的的类型也都是支持的，比如 Java 的ArrayList，HashMap，Enum 等等。
 
  
五 实现 UDF 函数——更细粒度的控制流
 
  
5.1 函数类(Function Classes)
 
  
Flink 暴露了所有 udf 函数的接口(实现方式为接口或者抽象类)。例如 MapFunction, FilterFunction, ProcessFunction 等等。
 
  
下面例子实现了 FilterFunction 接口:
 
  
DataStream flinkTweets = tweets.filter(new FlinkFilter());

    public static class FlinkFilter implements FilterFunction {
        @Override
        public boolean filter(String value) throws Exception {
            return value.contains("flink");
        }
    }
 
  
还可以将函数实现成匿名类
 
  
DataStream flinkTweets = tweets.filter(new FilterFunction() {
        @Override
        public boolean filter(String value) throws Exception {
            return value.contains("flink");
        }
    });
 
  
我们 filter 的字符串"flink"还可以当作参数传进去。
 
  
 DataStream tweets = env.readTextFile("INPUT_FILE ");
    DataStream flinkTweets = tweets.filter(new KeyWordFilter("flink"));

    public static class KeyWordFilter implements FilterFunction {
        private String keyWord;

        KeyWordFilter(String keyWord) {
            this.keyWord = keyWord;
        }

        @Override
        public boolean filter(String value) throws Exception {
            return value.contains(this.keyWord);
        }
    }
 
  
5.2 匿名函数(Lambda Functions)
 
  
DataStream tweets = env.readTextFile("INPUT_FILE");
    DataStream flinkTweets = tweets.filter(tweet -> tweet.contains("flink"));
 
  
5.3 富函数(Rich Functions)
 
  
“富函数”是 DataStream API 提供的一个函数类的接口，所有 Flink 函数类都 有其 Rich 版本。它与常规函数的不同在于，可以获取运行环境的上下文，并拥有一 些生命周期方法，所以可以实现更复杂的功能。
 
  
RichMapFunction
 RichFlatMapFunction
 RichFilterFunction
 ...
 Rich Function 有一个生命周期的概念。典型的生命周期方法有:
  open()方法是 rich function 的初始化方法，当一个算子例如 map 或者 filter
 
  
被调用之前 open()会被调用。
 close()方法是生命周期中的最后一个调用的方法，做一些清理工作。
 getRuntimeContext()方法提供了函数的 RuntimeContext 的一些信息，例如函数执行的并行度，任务的名字，以及 state 状态
 
  
package com.dongda.transform;

import com.dongda.beans.SensorReading;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class TransformTest5_RichFunction {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(4);//为了方便观察打印出来的结果，将全局并行度设置为1

        //从文件里面读取数据
        DataStream inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");

        //lamda表达式写法
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        DataStream> resultStream = dataStream.map(new MyMapper());

        resultStream.print();
        env.execute();
    }

    private static class MyMapper extends RichMapFunction> {
        @Override
        public Tuple2 map(SensorReading sensorReading) throws Exception {
            return new Tuple2<>(sensorReading.getId(),getRuntimeContext().getIndexOfThisSubtask());
        }

        @Override
        public void open(Configuration parameters) throws Exception {
            //以下可以做一些初始化工作，例如建立一个和HDFS的连接
            System.out.println("open");
        }

        @Override
        public void close() throws Exception {
            //以下做一些清理工作，例如断开和HDFS的连接
            System.out.println("close");
        }
    }
}
 
  
输出结果如下：
 
  
大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第17张图片
 
  
六 Sink
 
  
Flink 没有类似于 spark 中 foreach 方法，让用户进行迭代的操作。虽有对外的 输出操作都要利用 Sink 完成。最后通过类似如下方式完成整个任务最终输出操作。
 
  
 
   
stream.addSink(new MySink(xxxx))
 
  
 
  
官方提供了一部分的框架的 sink。除此以外，需要用户自定义实现 sink。
 
  
大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第18张图片
 
  
6.1 Kafka
 
  
package com.dongda.sink;

import com.dongda.beans.SensorReading;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer011;

public class SinkTest1_Kafka {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1

        //从文件里面读取数据
        DataStream inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");

        //lamda表达式写法
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2])).toString();
        });
        
        //添加kafka sink
        dataStream.addSink(new FlinkKafkaProducer011("localhost:9091","sinkTest",new SimpleStringSchema()));

        env.execute();
    }
}

 
  
6.2 Redis
 
  
需求：传进来的传感器数据，实时插入到redis（只保留最新）
 
  
添加pom依赖
 
  
 
   

    org.apache.bahir
    flink-connector-redis_2.11
    1.0

 
  
 
  
package com.dongda.sink;

import com.dongda.beans.SensorReading;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.redis.RedisSink;
import org.apache.flink.streaming.connectors.redis.common.config.FlinkJedisPoolConfig;
import org.apache.flink.streaming.connectors.redis.common.mapper.RedisCommand;
import org.apache.flink.streaming.connectors.redis.common.mapper.RedisCommandDescription;
import org.apache.flink.streaming.connectors.redis.common.mapper.RedisMapper;

public class SinkTest2_Redis {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1

        //从文件里面读取数据
        DataStream inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");

        //lamda表达式写法
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        //定义jedis连接配置
        FlinkJedisPoolConfig config = new FlinkJedisPoolConfig.Builder()
                .setHost("localhost")
                .setPort(6379)
                .build();

        dataStream.addSink(new RedisSink(config,new MyRedisMapper()));

        env.execute();
    }
    //自定义RedisMapper
    private static class MyRedisMapper implements RedisMapper {

        //定义保存数据到redis命令，存成Hash表，hset 表名：sensor_temp id temperature
        @Override
        public RedisCommandDescription getCommandDescription() { //操作redis命令的描述，描述redis到底发一个什么指令过去
            return new RedisCommandDescription(RedisCommand.HSET,"sensor_temp");
        }

        @Override
        public String getKeyFromData(SensorReading sensorReading) {
            return sensorReading.getId();
        }

        @Override
        public String getValueFromData(SensorReading sensorReading) {
            return sensorReading.getTemperature().toString();
        }
    }
}

 
  
输出结果如下：
 
  
大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第19张图片
 
  
6.3 Elasticsearch
 
  
添加pom依赖
 
  
 
   

    org.apache.flink
    flink-connector-elasticsearch6_2.12
    1.10.1

 
  
 
  
package com.dongda.sink;

import com.dongda.beans.SensorReading;
import org.apache.flink.api.common.functions.RuntimeContext;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.elasticsearch.ElasticsearchSinkFunction;
import org.apache.flink.streaming.connectors.elasticsearch.RequestIndexer;
import org.apache.flink.streaming.connectors.elasticsearch6.ElasticsearchSink;
import org.apache.http.HttpHost;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.Requests;

import java.util.ArrayList;
import java.util.HashMap;

public class SinkTest3_ElasticSearch {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1

        //从文件里面读取数据
        DataStream inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");

        //lamda表达式写法 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        //定义es的连接配置
        ArrayList httpHosts = new ArrayList<>();
        httpHosts.add(new HttpHost("localhost",9200));


        dataStream.addSink(new ElasticsearchSink.Builder(httpHosts,new MyEsSinkFunction()).build());
        
        env.execute();
    }

    //实现自定义的Es写入操作的ElasticsearchSinkFunction
    private static class MyEsSinkFunction implements ElasticsearchSinkFunction {
        @Override
        public void process(SensorReading sensorReading, RuntimeContext runtimeContext, RequestIndexer requestIndexer) {
            //1.定义写入的数据source
            HashMap dataSource = new HashMap<>();
            dataSource.put("id",sensorReading.getId());
            dataSource.put("temp",sensorReading.getTemperature().toString());
            dataSource.put("ts",sensorReading.getTimestamp().toString());

            //2.创建请求，作为向es发起的写入命令
            IndexRequest indexRequest = Requests.indexRequest()
                    .index("sensor")
                    .type("readingdata")
                    .source(dataSource);

            //3.用index发送请求
            requestIndexer.add(indexRequest);

        }
    }
}

 
  
输出结果如下：
 
  
执行命令：
 
  
 
  
展示：
 
  
大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第20张图片
 
  
6.4 JDBC 自定义 sink
 
  
前面的场景是向Kafka、Redis、Es里面插入数据，那现在要直接把数据写入Mysql怎么办呢？在实际生产中还是有这种需求的,因为往往生产环境中的业务数据库就是Mysql。但是,在当前1.10版本里面并没有相关的依赖支持，Mysql没有连接器支持，我们没办法直接用（后面的版本已经有了），那么我们就可以自定义Sink。
 
  
添加mysql-connector pom依赖
 
  
 
   

    mysql
    mysql-connector-java
    5.1.44

 
  
 
  
package com.dongda.sink;

import com.dongda.beans.SensorReading;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction;
import org.apache.flink.streaming.api.functions.sink.SinkFunction;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class SinkTest4_Jdbc {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1

        //从文件里面读取数据
        DataStream inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");

        //lamda表达式写法 转换成SensorReading类型
        DataStream dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        dataStream.addSink(new MyJdbcSink());

        env.execute();
    }

    //实现自定义的SinkFunction
    private static class MyJdbcSink extends RichSinkFunction {
        //声明连接和预编译语句
        Connection connection=null;
        PreparedStatement insertStmt=null;
        PreparedStatement updateStmt=null;
        @Override
        public void open(Configuration parameters) throws Exception {
            connection= DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","123456");
            insertStmt=connection.prepareStatement("insert into sensor_temp(id,temp) values(?,?)");
            updateStmt=connection.prepareStatement("update sensor_temp set temp= ? where id = ?");
        }


        //每来一条数据，调用连接，执行SQL
        @Override
        public void invoke(SensorReading value, Context context) throws Exception {
            //直接执行更新语句，如果没有更新那么就插入
            updateStmt.setDouble(1,value.getTemperature());
            updateStmt.setString(2,value.getId());
            updateStmt.execute();
            if (updateStmt.getUpdateCount()==0){
                insertStmt.setString(1,value.getId());
                insertStmt.setDouble(2,value.getTemperature());
                insertStmt.execute();
            }
        }

        //最后有始有终，我们要进行关闭
        @Override
        public void close() throws Exception {
            insertStmt.close();
            updateStmt.close();
            connection.close();
        }
    }
}

 
  
输出显示：可以看到每条都是最新的数据
 
  
大话Flink之四-Flink流处理API 行行代码带你深刻理解Flink流处理API！_第21张图片
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(flink,java,流处理,大数据)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    
                    
    • 
                    
  • ES聚合分析原理与代码实例讲解
                        光剑书架上的书
大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
                        
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Kafka是如何保证数据的安全性、可靠性和分区的
                        喜欢猪猪
kafka分布式
                        
    Kafka作为一个高性能、可扩展的分布式流处理平台，通过多种机制来确保数据的安全性、可靠性和分区的有效管理。以下是关于Kafka如何保证数据安全性、可靠性和分区的详细解析：一、数据安全性SSL/TLS加密：Kafka支持SSL/TLS协议，通过配置SSL证书和密钥来加密数据传输，确保数据在传输过程中不会被窃取或篡改。这一机制有效防止了中间人攻击，保护了数据的安全性。SASL认证：Kafka支持多种
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                                
  • java观察者模式
                                    3213213333332132
java设计模式游戏观察者模式
                                    
    观察者模式——顾名思义，就是一个对象观察另一个对象，当被观察的对象发生变化时，观察者也会跟着变化。 
 
在日常中，我们配java环境变量时，设置一个JAVAHOME变量,这就是被观察者，使用了JAVAHOME变量的对象都是观察者，一旦JAVAHOME的路径改动，其他的也会跟着改动。 
 
这样的例子很多，我想用小时候玩的老鹰捉小鸡游戏来简单的描绘观察者模式。 
 
老鹰会变成观察者，母鸡和小鸡是
    
                                
    • 
                                
  • TFS RESTful API 模拟上传测试
                                    ronin47

                                    
           TFS RESTful API 模拟上传测试。 
　　 
细节参看这里：https://github.com/alibaba/nginx-tfs/blob/master/TFS_RESTful_API.markdown 
模拟POST上传一个图片： 
curl --data-binary @/opt/tfs.png http
    
                                
    • 
                                
  • PHP常用设计模式单例, 工厂, 观察者, 责任链, 装饰, 策略,适配,桥接模式
                                    dcj3sjt126com
设计模式PHP
                                    
    // 多态, 在JAVA中是这样用的, 其实在PHP当中可以自然消除, 因为参数是动态的, 你传什么过来都可以, 不限制类型, 直接调用类的方法
abstract class Tiger {
    public abstract function climb();
}

class XTiger extends Tiger {
    public function  climb()
    
                                
    • 
                                
  • hibernate
                                    171815164
Hibernate
                                    
    main,save 
 
Configuration conf =new Configuration().configure();
SessionFactory sf=conf.buildSessionFactory();
Session sess=sf.openSession();
Transaction tx=sess.beginTransaction();

News a=new 
    
                                
    • 
                                
  • Ant实例分析
                                    g21121
ant
                                    
            下面是一个Ant构建文件的实例，通过这个实例我们可以很清楚的理顺构建一个项目的顺序及依赖关系，从而编写出更加合理的构建文件。 
  
        下面是build.xml的代码： 
<?xml version="1
    
                                
    • 
                                
  • [简单]工作记录_接口返回405原因
                                    53873039oycg
工作
                                    
             最近调接口时候一直报错，错误信息是: 
      
responseCode:405
responseMsg:Method Not Allowed 
       接口请求方式Post. 
    
                                
    • 
                                
  • 关于java.lang.ClassNotFoundException 和 java.lang.NoClassDefFoundError 的区别
                                    程序员是怎么炼成的

                                    
      
 真正完成类的加载工作是通过调用 defineClass来实现的； 
 而启动类的加载过程是通过调用 loadClass来实现的； 
 就是类加载器分为加载和定义 
   
 protected Class<?> findClass(String name) throws ClassNotFoundExcept
    
                                
    • 
                                
  • JDBC学习笔记-JDBC详细的操作流程
                                    aijuans
jdbc
                                    
    所有的JDBC应用程序都具有下面的基本流程：　　1、加载数据库驱动并建立到数据库的连接。　　2、执行SQL语句。　　3、处理结果。　　4、从数据库断开连接释放资源。 
下面我们就来仔细看一看每一个步骤： 
其实按照上面所说每个阶段都可得单独拿出来写成一个独立的类方法文件。共别的应用来调用。 
1、加载数据库驱动并建立到数据库的连接： 
     Html代码    
 
 St
    
                                
    • 
                                
  • rome创建rss
                                    antonyup_2006
tomcatcmsxmlstrutsOpera
                                    
    引用   
1.RSS标准 
 
RSS标准比较混乱，主要有以下3个系列 
 
 RSS 0.9x / 2.0 : RSS技术诞生于1999年的网景公司(Netscape)，其发布了一个0.9版本的规范。2001年，RSS技术标准的发展工作被Userland Software公司的戴夫 温那(Dave Winer)所接手。陆续发布了0.9x的系列版本。当W3C小组发布RSS 1.0后，Dave W
    
                                
    • 
                                
  • html表格和表单基础
                                    百合不是茶
html表格表单meta锚点
                                    
    第一次用html来写东西,感觉压力山大,每次看见别人发的都是比较牛逼的 再看看自己什么都还不会, 
  
html是一种标记语言,其实很简单都是固定的格式 
  
_----------------------------------------表格和表单 
表格是html的重要组成部分,表格用在body里面的 
主要用法如下; 
<table>

     &
    
                                
    • 
                                
  • ibatis如何传入完整的sql语句
                                    bijian1013
javasqlibatis
                                    
            ibatis如何传入完整的sql语句？进一步说，String str ="select * from test_table"，我想把str传入ibatis中执行，是传递整条sql语句。 
        解决办法： 
<
    
                                
    • 
                                
  • 精通Oracle10编程SQL(14)开发动态SQL
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *开发动态SQL
 */
--使用EXECUTE IMMEDIATE处理DDL操作
CREATE OR REPLACE PROCEDURE drop_table(table_name varchar2)
is
   sql_statement varchar2(100);
begin
   sql_statement:='DROP TABLE '||table_name;

    
                                
    • 
                                
  • 【Linux命令】Linux工作中常用命令
                                    bit1129
linux命令
                                    
    不断的总结工作中常用的Linux命令 
  
1.查看端口被哪个进程占用 
  
通过这个命令可以得到占用8085端口的进程号，然后通过ps -ef|grep 进程号得到进程的详细信息 
  
netstat -anp | grep 8085 
  
察看进程ID对应的进程占用的端口号 
  
netstat -anp | grep 进程ID 
&
    
                                
    • 
                                
  • 优秀网站和文档收集
                                    白糖_
网站
                                    
    集成 Flex, Spring, Hibernate 构建应用程序 
  
性能测试工具-JMeter 
  
Hmtl5-IOCN网站 
  
Oracle精简版教程网站 
  
鸟哥的linux私房菜 
  
Jetty中文文档 
  
50个jquery必备代码片段 
  
swfobject.js检测flash版本号工具
    
                                
    • 
                                
  • angular.extend
                                    boyitech
AngularJSangular.extendAngularJS API
                                    
    angular.extend   复制src对象中的属性去dst对象中. 支持多个src对象. 如果你不想改变一个对象，你可以把dst设为空对象{}: var object = angular.extend({}, object1, object2). 注意: angular.extend不支持递归复制.    使用方法:   angular.extend(dst, src);    参数:   
    
                                
    • 
                                
  • java-谷歌面试题-设计方便提取中数的数据结构
                                    bylijinnan
java
                                    
    网上找了一下这道题的解答，但都是提供思路，没有提供具体实现。其中使用大小堆这个思路看似简单，但实现起来要考虑很多。 
以下分别用排序数组和大小堆来实现。 
使用大小堆： 
 

import java.util.Arrays;

public class MedianInHeap {
	/**
	 * 题目：设计方便提取中数的数据结构
	 * 设计一个数据结构，其中包含两个函数，1.插
    
                                
    • 
                                
  • ajaxFileUpload 针对 ie jquery 1.7+不能使用问题修复版本
                                    Chen.H
ajaxFileUploadie6ie7ie8ie9
                                    
    jQuery.extend({
	handleError: function( s, xhr, status, e ) 		{
		// If a local callback was specified, fire it
				if ( s.error ) {
					s.error.call( s.context || s, xhr, status, e );
				}


    
                                
    • 
                                
  • [机器人制造原则]机器人的电池和存储器必须可以替换
                                    comsci
制造
                                    
     
 
       机器人的身体随时随地可能被外来力量所破坏,但是如果机器人的存储器和电池可以更换,那么这个机器人的思维和记忆力就可以保存下来,即使身体受到伤害,在把存储器取下来安装到一个新的身体上之后,原有的性格和能力都可以继续维持..... 
 
       另外,如果一
    
                                
    • 
                                
  • Oracle Multitable INSERT 的用法
                                    daizj
oracle
                                    
    转载Oracle笔记-Multitable INSERT 的用法 
 
http://blog.chinaunix.net/uid-8504518-id-3310531.html 
 
一、Insert基础用法 
 
语法： 
 
    Insert Into 表名 (字段1,字段2,字段3...） 
 
    Values (值1,
    
                                
    • 
                                
  • 专访黑客历史学家George Dyson
                                    datamachine
on
                                    
    20世纪最具威力的两项发明——核弹和计算机出自同一时代、同一群年青人。可是，与大名鼎鼎的曼哈顿计划（第二次世界大战中美国原子弹研究计划）相 比，计算机的起源显得默默无闻。出身计算机世家的历史学家George Dyson在其新书《图灵大教堂》（Turing’s Cathedral）中讲述了阿兰·图灵、约翰·冯·诺依曼等一帮子天才小子创造计算机及预见计算机未来
    
                                
    • 
                                
  • 小学6年级英语单词背诵第一课
                                    dcj3sjt126com
englishword
                                    
    always 总是 
rice 水稻，米饭 
before 在...之前 
live 生活，居住 
  
usual 通常的 
early 早的 
begin 开始 
month 月份 
  
year 年 
last 最后的 
east 东方的 
high 高的 
  
far 远的 
window 窗户 
world 世界 
than 比...更 
  
    
                                
    • 
                                
  • 在线IT教育和在线IT高端教育
                                    dcj3sjt126com
教育
                                    
    codecademy 
http://www.codecademy.com   codeschool 
https://www.codeschool.com   teamtreehouse 
http://teamtreehouse.com   lynda 
http://www.lynda.com/   Coursera 
https://www.coursera.
    
                                
    • 
                                
  • Struts2 xml校验框架所定义的校验文件
                                    蕃薯耀
Struts2 xml校验Struts2 xml校验框架Struts2校验
                                    
      
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年7月11日 15:54:59 星期六 
http://fa
    
                                
    • 
                                
  • mac下安装rar和unrar命令
                                    hanqunfeng
mac
                                    
    1.下载：http://www.rarlab.com/download.htm  选择 
RAR 5.21 for Mac OS X   2.解压下载后的文件   tar -zxvf rarosx-5.2.1.tar   3.cd rar   sudo install -c -o $USER unrar /bin #输入当前用户登录密码   sudo install -c -o $USER rar
    
                                
    • 
                                
  • 三种将list转换为map的方法
                                    jackyrong
list
                                    
      在本文中，介绍三种将list转换为map的方法： 
 
1） 传统方法 
 
假设有某个类如下 
   

class Movie {
    
    private Integer rank;
    private String description;
    
    public Movie(Integer rank, String des
    
                                
    • 
                                
  • 年轻程序员需要学习的5大经验
                                    lampcy
工作PHP程序员
                                    
    在过去的7年半时间里，我带过的软件实习生超过一打，也看到过数以百计的学生和毕业生的档案。我发现很多事情他们都需要学习。或许你会说，我说的不就是某种特定的技术、算法、数学，或者其他特定形式的知识吗？没错，这的确是需要学习的，但却并不是最重要的事情。他们需要学习的最重要的东西是“自我规范”。这些规范就是：尽可能地写出最简洁的代码；如果代码后期会因为改动而变得凌乱不堪就得重构；尽量删除没用的代码，并添加
    
                                
    • 
                                
  • 评“女孩遭野蛮引产致终身不育 60万赔偿款1分未得”医腐深入骨髓
                                    nannan408

                                    
    先来看南方网的一则报道： 
 

再正常不过的结婚、生子，对于29岁的郑畅来说，却是一个永远也无法实现的梦想。从2010年到2015年，从24岁到29岁，一张张新旧不一的诊断书记录了她病情的同时，也清晰地记下了她人生的悲哀。

　　粗暴手术让人发寒

　　2010年7月，在酒店做服务员的郑畅发现自己怀孕了，可男朋友却联系不上。在没有和家人商量的情况下，她决定堕胎。

　　12月5日，
    
                                
    • 
                                
  • 使用jQuery为input输入框绑定回车键事件 VS 为a标签绑定click事件
                                    Everyday都不同
jspinput回车键绑定clickenter
                                    
    假设如题所示的事件为同一个，必须先把该js函数抽离出来，该函数定义了监听的处理： 
  
function search() {
	//监听函数略......	
} 
  
为input框绑定回车事件，当用户在文本框中输入搜索关键字时，按回车键，即可触发search(): 
  
//回车绑定
$(".search").keydown(fun
    
                                
    • 
                                
  • EXT学习记录
                                    tntxia
ext
                                    
      
1. 准备 
  
（1） 官网：http://www.sencha.com/ 
  
里面有源代码和API文档下载。 
  
EXT的域名已经从www.extjs.com改成了www.sencha.com ，但extjs这个域名会自动转到sencha上。 
  
（2）帮助文档： 
  
想要查看EXT的官方文档的话，可以去这里h
    
                                
    • 
                                
  • mybatis3的mapper文件报Referenced file contains errors
                                    xingguangsixian
mybatis
                                    
    最近使用mybatis.3.1.0时无意中碰到一个问题： 
The errors below were detected when validating the file "mybatis-3-mapper.dtd" via the file "account-mapper.xml".  In most cases these errors can be d
    
                                
    •