Flink中基于State的有状态计算开发方法

作者：王东阳

前言
状态在Flink中叫作State，用来保存中间计算结果或者缓存数据。根据是否需要保存中间结果，分为无状态计算和有状态计算。对于流计算而言，事件持续不断地产生，如果每次计算都是相互独立的，不依赖于上下游的事件，则是无状态计算。如果计算需要依赖于之前或者后续的事件，则是有状态计算。

在Flink中根据数据集是否根据Key进行分区，将状态分为Keyed State和Operator State（Non-keyed State）两种类型 ，本文主要介绍Keyed State，后续文章会介绍Operator State。

Keyed State 表示和key相关的一种State，只能用于KeydStream类型数据集对应的Functions和Operators之上。Keyed State是Operator State的特例，区别在于Keyed State事先按照key对数据集进行了分区，每个Key State仅对应一个Operator和Key的组合。Keyed State可以通过Key Groups进行管理，主要用于当算子并行度发生变化时，自动重新分布 Keyed State数据。在系统运行过程中，一个Keyed算子实例可能运行一个或者多个Key Groups的keys。

按照数据结构的不同，Flink中定义了多种Keyed State，具体如下:

ValueState 即类型为T的单值状态。这个状态与对应的Key绑定，是最简单的状态。
ListState即Key上的状态值为一个列表。
MapState 定义与Key对应键值对的状态，用于维护具有key-value结构类型的状态数据。
ReducingState这种State通过用户传入的ReduceFucntion，每次调用add(T)方法添加元素时，会调用ReduceFucntion，最后合并到一个单一的状态值。
AggregatingState 聚合State和ReducingState非常类似，不同的是，这里聚合的类型可以是不同的元素类型，使用add（IN）来加入元素，并使用AggregateFunction函数计算聚合结果。
State开发实战
本章节将通过实际的项目代码演示不同数据结构在不同计算场景下的开发方法。

本文中项目 pom文件
ValueState
ValueState 即类型为T的单值状态。这个状态与对应的Key绑定，是最简单的状态。可以通过update(T)方法更新状态值，通过T value()方法获取状态值。

由于ValueState 是与Key对应单个值的状态，应用场景可以是例如统计user_id对应的交易次数，每次用户交易都会在count状态值上进行更新。

接下来我们将通过一个具体的实例代码展示如何利用ValueState去统计各个用户的交易次数。

ValueStateCountUser实现
通过定义ValueState类型的countState存储用户已经访问的次数，并在每次收到新的元素时，对countState中的数据加1更新，同时把当前用户名和已经访问的总次数返回。在本样例代码中将会通过 RichMapFunction 来对流元素进行处理。

在其中的 open(Configuration parameters) 方法中对 countState进行初始化。Flink提供了RuntimeContext用于获取状态数据，同时RuntimeContext提供了常用的Managed Keyd State的获取方式，可以通过创建相应的StateDescriptor并调用RuntimeContext方法来获取状态数据。例如获取ValueState可以调用ValueState[T] getState(ValueStateDescriptor[T])方法。
在 Tuple2 map(Tuple2 s)中，通过 countState.value() 获取用户之前的访问次数，然后对countState中的数据加1更新，同时把当前用户名和已经访问的总次数返回。
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;

public class ValueStateCountUser extends RichMapFunction, Tuple2> {
private ValueState countState;

public ValueStateCountUser() {}

@Override
public void open(Configuration parameters) throws Exception {

// super.open(parameters);
countState = getRuntimeContext().getState(new ValueStateDescriptor("count", Integer.class));

}

@Override
public Tuple2 map(Tuple2 s) throws Exception {

Integer count = countState.value();
if (count == null) {
  countState.update(1);
  return Tuple2.of(s.f0, 1);
}

countState.update(count + 1);
return Tuple2.of(s.f0, count + 1);

}

@Override
public void close() throws Exception {

// super.close();
System.out.println(String.format("finally %d", countState.value()));

}
}
代码地址：ValueStateCountUser.java

验证代码
编写验证代码如下

private static void valueStateUserCount() throws Exception {

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(1);
DataStream> inputStream = env.fromElements(
    new Tuple2<>("zhangsan","aa"),
    new Tuple2<>("lisi","aa"),
    new Tuple2<>("zhangsan","aa"),
    new Tuple2<>("lisi","aa"),
    new Tuple2<>("wangwu","aa")
);

inputStream.keyBy(new KeySelector, String>() {
      @Override
      public String getKey(Tuple2 integerLongTuple2) throws Exception {
        return integerLongTuple2.f0;
      }
    })
    .map(new ValueStateCountUser())
    .print();

env.execute("StateCompute");

}
代码地址：valueStateUserCount

程序运行得到输出如下

(zhangsan,1)
(lisi,1)
(zhangsan,2)
(lisi,2)
(wangwu,1)
finally 1
可以看到对于流数据中的每一个元素，根据用户名进行统计，实时显示该用户已经访问了多少次。

ListState
ListState即Key上的状态值为一个列表。可以通过add(T)方法或者addAll(List[T])往列表中附加值；也可以通过Iterable get()方法返回一个Iterable来遍历状态值；使用update(List[T])来更新元素。

由于ListState保存的是与Key对应元素列表的状态，状态中存放元素的List列表，应用场景可以是例如定义ListState存储用户经常访问的IP地址。

接下来我们将通过一个具体的实例代码展示如何利用ListState去统计各个用户访问过的IP地址列表。为了更广泛的展示State的应用场景，本样例代码中将会基于KeyedProcessFunction来处理流元素。

ListStateUserIP 实现
声明ListState ipState 用于记录用户访问过的ip地址
在open(Configuration parameters)中利用 getRuntimeContext().getListState 对 ipState 进行初始化，getListState需要传入ListStateDescriptor类型的参数。
在 processElement中，将当前记录中的IP地址追究到 ipState中，然后从ipState 获取已经访问过的所有IP地址，和用户名一起放入到Collector
import com.google.common.collect.Lists;
import java.util.List;
import org.apache.flink.api.common.state.ListState;
import org.apache.flink.api.common.state.ListStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class ListStateUserIpKeyedProcessFunction
extends KeyedProcessFunction, Tuple2>>{
private ListState ipState;

@Override
public void open(Configuration parameters) throws Exception {

// super.open(parameters);
ipState = getRuntimeContext().getListState(new ListStateDescriptor("ipstate", String.class));

}

@Override
public void processElement(

  Tuple2 value,
  KeyedProcessFunction, Tuple2>>.Context context,
  Collector>> collector) throws Exception {

ipState.add(value.f1);
List ips = Lists.newArrayList(ipState.get());
collector.collect(Tuple2.of(value.f0, ips));

}
}
代码地址：ListStateUserIpKeyedProcessFunction.java

验证代码
编写验证程序如下

private static void listStateUserIP() throws Exception {

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(1);
DataStream> inputStream = env.fromElements(
    new Tuple2<>("zhangsan","192.168.0.1"),
    new Tuple2<>("lisi","192.168.0.1"),
    new Tuple2<>("zhangsan","192.168.0.2"),
    new Tuple2<>("lisi","192.168.0.3"),
    new Tuple2<>("wangwu","192.168.0.1")
);

inputStream.keyBy(new KeySelector, String>() {
      @Override
      public String getKey(Tuple2 integerLongTuple2) throws Exception {
        return integerLongTuple2.f0;
      }
    })
    .process(new ListStateUserIpKeyedProcessFunction())
    .print();

env.execute("listStateUserIP");

}
}
代码地址：listStateUserIP

执行结果打印如下

(zhangsan,[192.168.0.1])
(lisi,[192.168.0.1])
(zhangsan,[192.168.0.1, 192.168.0.2])
(lisi,[192.168.0.1, 192.168.0.3])
(wangwu,[192.168.0.1])
达到预期效果

MapState
MapState 定义与Key对应键值对的状态，用于维护具有key-value结构类型的状态数据。 MapState 使 用 Map 存 储 Key-Value 对 ， MapState的方法和Java的Map的方法极为相似，所以上手相对容易。常用的有如下：

get()方法获取值
put()，putAll()方法更新值
remove()删除某个key
contains()判断是否存在某个key
isEmpty() 判断是否为空
和HashMap接口相似，MapState也可以通过entries()、keys()、values()获取对应的keys或values的集合 。

接下来我们通过一个具体的实例介绍如何通过ReducingState 计算每个人的当前最高和最低体温。

实现KeyedProcessFunction
定义 MapState minMaxState 用于记录每个用户的最低低温和最高体温。
在 open方法中通过getRuntimeContext().getMapState初始化minMaxState，getMapState 需要传入MapStateDescriptor作为参数，构建MapStateDescriptor的第二个参数标识Map中Key的类型，第三个参数标识Map中Value的类型
在processElement方法中，将输入的流元素也就是用户当前的体温记录和minMaxState中的最低温和最高温进行对比，并更新到minMaxState中。
import org.apache.flink.api.common.state.MapState;
import org.apache.flink.api.common.state.MapStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class MapStateMinMaxTempKeyedProcessFunction

extends KeyedProcessFunction, Tuple3> {

private MapState minMaxState;

private final String minKey = "min";
private final String maxKey = "max";

@Override
public void open(Configuration parameters) throws Exception {

// super.open(parameters);
minMaxState = getRuntimeContext().getMapState(
    new MapStateDescriptor("minMaxState",
        String.class,
        Integer.class));

}

@Override
public void processElement(

  Tuple2 in,
  KeyedProcessFunction, Tuple3>.Context context,
  Collector> collector) throws Exception {

if (!minMaxState.contains(minKey)) {
  minMaxState.put(minKey, in.f1);
}

if (!minMaxState.contains(maxKey)) {
  minMaxState.put(maxKey, in.f1);
}

if (in.f1 > minMaxState.get(maxKey)) {
  minMaxState.put(maxKey, in.f1);
}

if (in.f1 < minMaxState.get(minKey)) {
  minMaxState.put(minKey, in.f1);
}

collector.collect(Tuple3.of(in.f0, minMaxState.get(minKey), minMaxState.get(maxKey)));

}
}
代码地址：MapStateMinMaxTempKeyedProcessFunction.java

验证代码
编写验证代码如下：

private static void mapStateMinMaxUserTemperature() throws Exception {

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(1);
DataStream> inputStream = env.fromElements(
    new Tuple2<>("zhangsan",36),
    new Tuple2<>("lisi",37),
    new Tuple2<>("zhangsan",35),
    new Tuple2<>("lisi",38),
    new Tuple2<>("wangwu",37)
);

inputStream.keyBy(new KeySelector, String>() {
      @Override
      public String getKey(Tuple2 integerLongTuple2) throws Exception {
        return integerLongTuple2.f0;
      }
    })
    .process(new MapStateMinMaxTempKeyedProcessFunction())
    .print();

env.execute("mapStateMinMaxUserTemperature");

}
代码地址：mapStateMinMaxUserTemperature

程序运行输出

(zhangsan,36,36)
(lisi,37,37)
(zhangsan,35,36)
(lisi,37,38)
(wangwu,37,37)
可以看到对于每一条用户记录，正确计算输出了当前的最低和最高低温，达到了预期的计算需求。

ReducingState
ReducingState这种State通过用户传入的ReduceFucntion，每次调用add(T)方法添加元素时，会调用ReduceFucntion，最后合并到一个单一的状态值，因此，ReducingState需要指定ReduceFucntion完成状态数据的聚合。

ReducingState获取元素使用T get()方法。

接下来我们通过一个具体的实例介绍如何通过ReducingState 计算每个人的当前最高体温。

定义ReduceFunction
实现 reduce方法，求当前最大值

new ReduceFunction() {

      @Override
      public Integer reduce(Integer integer, Integer t1) throws Exception {
        return integer > t1 ? integer : t1;
      }
    }

实现KeyedProcessFunction
声明ReducingState tempState 用于记录用户当前的最高体温；
在open(Configuration parameters)中利用 getRuntimeContext().getReducingState 对 tempState进行初始化，getReducingState需要传入ReducingStateDescriptor，ReducingStateDescriptor构建的时候，第二个参数要参入ReduceFunction;
在 processElement中，将当前用户的当前体温传入到 tempState中(tempState在内部会调用ReduceFunction), 然后从tempState 获取用户目前为止的最高提问，和用户名一起放入到Collector
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.common.state.ReducingState;
import org.apache.flink.api.common.state.ReducingStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class ReducingStateKeyedProcessFunction
extends KeyedProcessFunction , Tuple2> {

private ReducingState tempState;

@Override
public void open(Configuration parameters) throws Exception {

// super.open(parameters);
tempState = getRuntimeContext().getReducingState(new ReducingStateDescriptor("reduce",
    new ReduceFunction() {
      @Override
      public Integer reduce(Integer integer, Integer t1) throws Exception {
        return integer > t1 ? integer : t1;
      }
    }, Integer.class));

}

@Override
public void processElement(

  Tuple2 stringIntegerTuple2,
  KeyedProcessFunction, Tuple2>.Context context,
  Collector> collector) throws Exception {

tempState.add(stringIntegerTuple2.f1);
collector.collect(Tuple2.of(stringIntegerTuple2.f0, tempState.get()));

}
}
代码地址：ReducingStateKeyedProcessFunction.java

验证代码
private static void reducingStateUserTemperature() throws Exception {

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(1);
DataStream> inputStream = env.fromElements(
    new Tuple2<>("zhangsan",36),
    new Tuple2<>("lisi",37),
    new Tuple2<>("zhangsan",35),
    new Tuple2<>("lisi",38),
    new Tuple2<>("wangwu",37)
);

inputStream.keyBy(new KeySelector, String>() {
      @Override
      public String getKey(Tuple2 integerLongTuple2) throws Exception {
        return integerLongTuple2.f0;
      }
    })
    .process(new ReducingStateKeyedProcessFunction())
    .print();

env.execute("reducingStateUserTemperature");

}
代码地址：reducingStateUserTemperature

程序运行结果如下

(zhangsan,36)
(lisi,37)
(zhangsan,36)
(lisi,38)
(wangwu,37)
达到预期效果

AggregatingState
AggregatingState 聚合State和ReducingState非常类似，不同的是，这里聚合的类型可以是不同的元素类型，使用add（IN）来加入元素，并使用AggregateFunction函数计算聚合结果。

AggregatingState这种State通过用户传入的AggregateFunction，每次调用add(IN)方法添加元素时，会调用AggregateFunction，最后合并到一个单一的状态值，因此，ReducingState需要指定AggregateFunction完成状态数据的聚合。

定义 AggregateFunction
AggregateFunction 中的三个类型参数，分别对应
IN: 流元素的类型;
ACC: AggregateFunction内部累加器的类型
OUT: 最终输出的聚合结果的类型
AggregateFunction 需要重写 createAccumulator, add, getResult, merge这四个函数
createAccumulator 用于创建累加器Accumulator
add 用于将流元素加入到累加器Accumulator
getResult 用于从累加器Accumulator中计算获取聚合结果
merge 目前暂时用不到
代码如下

import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.java.tuple.Tuple2;

public class AvgTempAggregateFunction

implements AggregateFunction, Tuple2, Double> {

@Override
public Tuple2 createAccumulator() {

return Tuple2.of(0, 0);

}

@Override
public Tuple2 add(

  Tuple2 in, Tuple2 acc) {
  // in 流元素， acc 内部累加器
acc.f0 = acc.f0 + in.f1;
acc.f1 = acc.f1 + 1;
return acc;

}

@Override
public Double getResult(Tuple2 acc) {

return new Double(acc.f0)/ acc.f1;

}

@Override
public Tuple2 merge(

  Tuple2 a, Tuple2 b) {
return new Tuple2<>(a.f0 + b.f0, a.f1 + b.f1);

}
}
代码地址：AvgTempAggregateFunction.java

实现 KeyedProcesssFunction
声明AggregatingState, Double> avgState 用于记录用户当前的平均体温。其中第一个类型参数标识流元素类型，第二个类型参数标识聚合结果的类型；
在open(Configuration parameters)中利用 getRuntimeContext().getAggregatingState 对 avgState进行初始化，getAggregatingState需要传入AggregatingStateDescriptor，AggregatingStateDescriptor构建的时候，第二个参数要参入AggregateFunction，第三个参数要传入AggregateFunction中累加器的TypeInformation；
在 processElement中，将当前用户的当前体温传入到 avgState中(avgState内部会调用add)，然后从avgState 获取用户体温的聚合结果(avgState内部调用getResult )，和用户名一起放入到Collector
import org.apache.flink.api.common.state.AggregatingState;
import org.apache.flink.api.common.state.AggregatingStateDescriptor;
import org.apache.flink.api.common.typeinfo.TypeHint;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class AggregatingStateKeyedProcessFunction
extends KeyedProcessFunction, Tuple2> {
private AggregatingState, Double> avgState;

@Override
public void open(Configuration parameters) throws Exception {

// super.open(parameters);
avgState = getRuntimeContext().getAggregatingState(new AggregatingStateDescriptor,
    Tuple2, Double>("aggregating", new AvgTempAggregateFunction(),
    TypeInformation.of(new TypeHint>() {})));

}

@Override
public void processElement(

  Tuple2 in,
  KeyedProcessFunction, Tuple2>.Context context,
  Collector> collector) throws Exception {

avgState.add(in);
collector.collect(Tuple2.of(in.f0, avgState.get().doubleValue()));

}
}
代码地址：AggregatingStateKeyedProcessFunction.java

验证代码
private static void aggregatingStateAvgUserTemperature() throws Exception {

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(1);
DataStream> inputStream = env.fromElements(
    new Tuple2<>("zhangsan",36),
    new Tuple2<>("lisi",37),
    new Tuple2<>("zhangsan",35),
    new Tuple2<>("lisi",38),
    new Tuple2<>("wangwu",37)
);

inputStream.keyBy(new KeySelector, String>() {
      @Override
      public String getKey(Tuple2 integerLongTuple2) throws Exception {
        return integerLongTuple2.f0;
      }
    })
    .process(new AggregatingStateKeyedProcessFunction())
    .print();

env.execute("aggregatingStateAvgUserTemperature");

}
代码地址：aggregatingStateAvgUserTemperature，程序运行结果如下

(zhangsan,36.0)
(lisi,37.0)
(zhangsan,35.5)
(lisi,37.5)
(wangwu,37.0)
可以看到对于每一条流元素，输出了用户以及当前的平均体温，完成了预期功能需求。

总结
本文通过典型的场景用例，展示了不同数据结构的State在不同计算场景下的使用方法，帮助Flink开发者熟悉State相关API以及State在相应的计算场景中如何存储、查询相关的中间计算信息从而完成计算目的。

参考资料
《Flink原理、实战与性能优化》5.1 有状态计算
《Flink内核原理与实现》第7章 状态原理
Flink教程(17) Keyed State状态管理之AggregatingState使用案例 求平均值 https://blog.csdn.net/winterk...
发布于 2022-03-11 09:57

你可能感兴趣的:(flinkspark)

  • Hudi 系列-基础概念-索引机制 别惹猪儿虫 Hudi大数据大数据hudiJava
    目录前言问题作用减少开销怎么理解数据变更基础类型全局索引FlinkSpark总结前言Hudi系列文章在这个这里查看https://github.com/leosanqing/big-data-study索引(Index)是Hudi最重要的特性之一,也是区别于之前传统数仓Hive的重要特点,是实现TimeTravel,Update/Delete,事务等重要特性的基础Hudiprovideseffic
  • Flink（1.12版本） Loreeta flinkbigdataspark
    spark和Flink的对比：事件驱动、时间语义、没有共享组：slot个数=最大算子的并行度共享组：slot的个数=组内最大算子的并行度之和一、Flink的重要特点1.1分层API1.2Flink与Spark的对比FlinkSpark①流处理批处理②事件驱动型，节省资源，被动时间驱动型，浪费资源（主动）③在流的基础上做批处理在批的基础上做流处理④Flink窗口比Spark灵活-⑤精准一次语义保证，
  • Flink（一）：部署及运行架构 McGrady_Durant 大数据flink
    文章目录Flink简介前言什么是FlinkSpark对比FlinkFlink应用场景环境安装快速入门编程模型代码程序部署Flink运行架构TasksandOperatorChainsJobManagers,TaskManagers,ClientsTaskSlotsandResources(难点)StateBackendsCheckpoint/Savepoints总结Flink简介前言2006年2月
  • 大数据(1)-流式处理-状态 杨东冬 技术随笔大数据大数据实时大数据sparkflink流处理
    转行搞了三年大数据，计划写些的东西，对这个方向总结一下，包括架构，工具，格式，库等等。最近准备造轮子，就先从一些目前最常见的流式数据处理手段开始。Spark&FlinkSpark，Flink是最知名的通用数据处理工具，不限定场景，不限定数据量。支持分布式，支持自定义状态，灵活定义数据处理逻辑（执行计划）。当然缺点就是：人工参与程度大，速度慢，系统臃肿。缺点与优点是相互取舍的，因为本身就是通用平台，
  • 大数据（三）大数据计算引擎 羽落风起 大数据bigdatahadoopspark
    文章目录说明分享大数据计算引擎批处理MapReducetez流批处理Flinkspark总结说明本博客每周五更新一次。介绍过大数据平台的搭建、应用和存储，本期分享下大数据计算。分享大数据博客列表大数据计算引擎什么是计算引擎？计算引擎就是一种计算规则的高度抽象聚合体，使用者按照指定的方式编写对应接口代码，然后执行就能得到需要的结果（前提没有bug）。大数据计算场景分为两个种：批处理（历史文件）和流处
  • 数据湖之 Flink Spark 集成 iceberg 爱搬数据的米老鼠 flinkspark大数据hadoophive
    数据湖之FlinkSpark集成iceberg一、iceberg优点二、安装部署三、iceberg集成flink四、hive查询iceberg表五、spark集成iceberg表一、iceberg优点提供ACID事物，上游数据写入即可见，提供了upsert、mergeinto能力支持计算引擎有Spark、Flink、Presto以及Hive支持Parquet、Avro以及ORC等存储格式增量读取处
  • Spark Core随笔 南宫齐世伟 Spark大数据SparkCore随笔
    SparkCore随笔第一章SparkCore概述1.1概念Spark是一种基于内存的快速、通用、可扩展的大数据的分析计算引擎。1.2Spark&FlinkSpark:主要适用于离线计算业务中Flink:主要适用于实时计算业务中1.3Spark&Hadoop出现的时机：Hadoop1.x~Hadoop2.xHadoopSpark典型基础平台，包含计算，存储调度分布式计算工具场景大规模数据集的批处理
  • java数字签名三种方式 知了ing javajdk
    以下3钟数字签名都是基于jdk7的 1，RSA String password="test"; // 1.初始化密钥 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(51
  • Hibernate学习笔记 caoyong Hibernate
    1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 2>、搭建Hibernate的开发环境      a>、添加jar包:      aa>、hibernatte开发包中/lib/required/所
  • 设计模式之装饰器模式Decorator（结构型） 漂泊一剑客 Decorator
    1. 概述        若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。      
  • 读取磁盘文件txt，并输入String 一炮送你回车库 String
    public static void main(String[] args) throws IOException {    String fileContent = readFileContent("d:/aaa.txt");    System.out.println(fileContent);   
  • js三级联动下拉框 3213213333332132 三级联动
    //三级联动 省/直辖市<select id="province"></select> 市/省直辖<select id="city"></select> 县/区 <select id="area"></select>
  • erlang之parse_transform编译选项的应用 616050468 parse_transform游戏服务器属性同步abstract_code
             最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
  • JAVA JSON的解析 darkranger java
    // { // “Total”：“条数”， // Code: 1, // // “PaymentItems”:[ // { // “PaymentItemID”:”支款单ID”, // “PaymentCode”:”支款单编号”, // “PaymentTime”:”支款日期”, // ”ContractNo”:”合同号”， //
  • POJ-1273-Drainage Ditches aijuans ACM_POJ
    POJ-1273-Drainage Ditches http://poj.org/problem?id=1273 基本的最大流，按LRJ的白书写的 #include<iostream> #include<cstring> #include<queue> using namespace std; #define INF 0x7fffffff int ma
  • 工作流Activiti5表的命名及含义 atongyeye 工作流Activiti
    activiti5 - http://activiti.org/designer/update在线插件安装 activiti5一共23张表 Activiti的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。 ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。 A
  • android的广播机制和广播的简单使用 百合不是茶 android广播机制广播的注册
          Android广播机制简介 在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
  • Spring事务传播行为详解 bijian1013 javaspring事务传播行为
            在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。         Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
  • eidtplus operate 征客丶 eidtplus
    开启列模式: Alt+C 鼠标选择   OR   Alt+鼠标左键拖动 列模式替换或复制内容(多行): 右键-->格式-->填充所选内容-->选择相应操作 OR Ctrl+Shift+V(复制多行数据,必须行数一致) -------------------------------------------------------
  • 【Kafka一】Kafka入门 bit1129 kafka
    这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧   下载Kafka http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 2.10表示Scala的版本，而0.8.1.1表示Kafka
  • Spring 事务实现机制 BlueSkator spring代理事务
    Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口
  • bootstrap源码学习与示例：bootstrap-dropdown（转帖） BreakingBad bootstrapdropdown
    bootstrap-dropdown组件是个烂东西，我读后的整体感觉。 一个下拉开菜单的设计： <ul class="nav pull-right"> <li id="fat-menu" class="dropdown">
  • 读《研磨设计模式》-代码笔记-中介者模式-Mediator bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /* * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 * * 在我看来，Mediator模式是把多个对象（
  • 常用代码记录 chenjunt3 UIExcelJ#
      1、单据设置某行或某字段不能修改 //i是行号,"cash"是字段名称 getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false); //取得单据表体所有项用以上语句做循环就能设置整行了 getBillC
  • 搜索引擎与工作流引擎 comsci 算法工作搜索引擎网络应用
          最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想)   -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
  • oracle Health Monitor daizj oracleHealth Monitor
    About Health Monitor Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. About Health Monitor Checks Health M
  • JSON字符串转换为对象 dieslrae javajson
        作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.   
  • C语言学习八结构体，综合应用，学生管理系统 dcj3sjt126com C语言
    实现功能的代码： # include <stdio.h> # include <malloc.h> struct Student { int age; float score; char name[100]; }; int main(void) { int len; struct Student * pArr; int i,
  • vagrant学习笔记 dcj3sjt126com vagrant
    想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant   1. vagrant virtualbox 下载安装 https://www.vagrantup.com/downloads.html https://www.virtualbox.org/wiki/Downloads   查看安装在命令行输入vagrant     2.
  • 14.性能优化-优化-软件配置优化 frank1234 软件配置性能优化
    1.Tomcat线程池 修改tomcat的server.xml文件： <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
  • 一个不错的shell 脚本教程 入门级 HarborChung linuxshell
    一个不错的shell 脚本教程 入门级 建立一个脚本 　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。 　　如同其他语言一样
  • Spring4新特性——核心容器的其他改进 jinnianshilongnian spring动态代理spring4依赖注入
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • Linux设置tomcat开机启动 liuxingguome tomcatlinux开机自启动
    执行命令sudo gedit /etc/init.d/tomcat6 然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 #!/bin/bash # # /etc/rc.d/init.d/tomcat # init script for tomcat precesses
  • 第13章 Ajax进阶（下） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • Troubleshooting Crystal Reports off BW blueoxygen BO
    http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE   Quite useful, especially this part: SAP BW connectivity For t
  • Java开发熟手该当心的11个错误 tomcat_oracle javajvm多线程单元测试
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
  • 正则表达式大全 yang852220741 html编程正则表达式
    今天向大家分享正则表达式大全，它可以大提高你的工作效率 正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。 一、校验数字的表达式 数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他