Fenêtre de process - Flink base représentative

flux de fenêtre

WindowedStream pur configuration API, l' exécution WindowedStream aux KeyedStream opérations de fusion sur une fenêtre et le fonctionnement.

 

agrégat

Par un champ ou une polymérisation par emplacement (tuple) convection / paquet

  agrégat de définition privée (aggregationType: AggregationType, field: String): DataStream [T] = { 
    Position val = fieldNames2Indices (getInputType (), Array (champ)) (0) 
    agrégat (aggregationType position) 
  } 

  def agrégat (aggregationType: AggregationType, Position: Int): DataStream [T] = { 

    val JStream = javaStream.asInstanceOf [JavaWStream [ Le produit, K, W]] 

    réducteur val = aggregationType correspondance { 
      cas AggregationType.SUM => 
        nouveau SumAggregator (position, jStream.getInputType, JStream. getExecutionEnvironment.getConfig) 

      cas _ => 
        nouvelle ComparableAggregator ( 
          position 
          jStream.getInputType, 
          aggregationType,
          vrai,
          jStream.getExecutionEnvironment.getConfig) 
    } 

    nouveau DataStream [Produit] (jStream.reduce (réducteur)). asInstanceOf [DataStream [T]] 
  }

fonction d'agrégation de classe abstraite

public abstract class AggregationFunction <T> outils ReduceFunction <T> { 
	finale statique privée de serialVersionUID = 1 litre; 

	/ ** 
	 * types d'agrégation qui peuvent être utilisés sur un flux fenêtré ou flux claveté. 
	 * / 
	Public enum AggregationType { 
		SUM, MIN, MAX, MINBY, MAXBY, 
	} 
}

Mettre en œuvre la classe abstraite a SumAggregator, ComparableAggregator

Par exemple SumAggregator, ReduceFunction implémente l'interface (par héritage sur AggregationFunction classe abstraite)

SumAggregator public class <T> étend AggregationFunction <T> { 

	private static finale longue serialVersionUID = 1 litre; 

	finale privée FieldAccessor <T, Objet> fieldAccessor; 
	finale privée sommateur SumFunction; 
	finale privée TypeSerializer <T> sérialiseur; 
	finale privée isTuple booléenne; 

	SumAggregator publique (int pos Les, TypeInformation <T> TYPEINFO, config ExecutionConfig) { 
		fieldAccessor = FieldAccessorFactory.getAccessor (TYPEINFO, pos, config); 
		additionneur = SumFunction.getForClass (fieldAccessor.getFieldType () getTypeClass ().); 
		si (TYPEINFO instanceof TupleTypeInfo) { 
			isTuple = true; 
			sérialiseur = null; 
		} Else { 
			isTuple = false;
			this.serializer = typeInfo.createSerializer (config); 
		} 
	} 

	SumAggregator publique (champ Chaîne, TypeInformation <T> TYPEINFO, ExecutionConfig config) { 
		fieldAccessor = FieldAccessorFactory.getAccessor (TYPEINFO, champ, config); 
		additionneur = SumFunction.getForClass (fieldAccessor.getFieldType () getTypeClass ().); 
		si (TYPEINFO instanceof TupleTypeInfo) { 
			isTuple = true; 
			sérialiseur = null; 
		} Else { 
			isTuple = false; 
			this.serializer = typeInfo.createSerializer (config); 
		} 
	} 

	@Override 
	@SuppressWarnings ( "sans contrôle") 
	T publique de réduire (T valeur1, T valeur2) throws Exception { 
		if (isTuple) { 
			résultat Tuple = ((Tuple) valeur1) .copy ();
			retour fieldAccessor.set ((T) suite, adder.add (fieldAccessor.get (valeur1), fieldAccessor.get (valeur2))); 
		} Else { 
			T result = serializer.copy (valeur1); 
			retour fieldAccessor.set (résultat, adder.add (fieldAccessor.get (valeur1), fieldAccessor.get (valeur2))); 
		} 
	} 
}

méthode de dérivation commune

somme

résumé def (position: Int): DataStream [T] = agrégat (AggregationType.SUM position)

maxBy

def maxBy (position: Int): DataStream [T] = agrégat (AggregationType.MAXBY position)

Exemple d'extrait de code

somme

val chiffres: DataStream [(String, Int)] = text.flatMap (_ toLowerCase () split ( "\\ W +")..) 
  .filter (_ non vide). 
  .map ((_, 1)) 
  .keyBy ( 0) 
  .countWindow (windowSize, SlideSize) 
  .sum (1)

maxBy

val chiffres: DataStream [(String, Int)] = text.flatMap (_ toLowerCase () split ( "\\ W +")..) 
  .filter (_ non vide). 
  .map ((_, 1)) 
  .keyBy ( 0) 
  .countWindow (windowSize, SlideSize) 
  .maxBy (1)

 

réduire

La même chose est appliqué séparément pour le gestionnaire fixé un élément clé de

réduire def (fonction: (T, T) => T): DataStream [T] = { 
    if (fonction == null) { 
      throw new NullPointerException ( "Réduire la fonction ne doit pas être null") 
    } 
    val = cleanFun propre (fonction ) 
    val réducteur = new ScalaReduceFunction [T] (cleanFun) 
    réduire (réducteur) 
  }

Interface également des outils ReduceFunction

ScalaReduceFunction de classe finale [T] (privé [ce] fonction val: (T, T) => T) 
    étend ReduceFunction [T] { 
  
  @throws (classof [Exception]) 
  override réduire def (a: T, b: T): T = { 
    fonction (a, b) 
  } 
}

appel Source

// fichier: org.apache.flink.streaming.api.datastream.WindowedStream 

publique <R> SingleOutputStreamOperator <R> réduire ( 
		ReduceFunction <T> reduceFunction, 
		fenêtrage <T, R, K, W> function, 
		TypeInformation <R> resultType ) { 

	if (reduceFunction instanceof RichFunction) { 
		throw new UnsupportedOperationException ( "reduceFunction de réduire ne peut pas être un RichFunction."); 
	} 

	// nettoyer les fermetures 
	fonctionnent = input.getExecutionEnvironment () propre (fonction). 
	reduceFunction = input.getExecutionEnvironment () propre (reduceFunction). 

	Chaîne finale Opname = generateOperatorName (windowAssigner, détente, expulseur, reduceFunction, fonction); 
	KeySelector <T, K> = keySel entrée.

	OneInputStreamOperator <T, R> opérateur; 

	si (expulseur! = null) { 
		@SuppressWarnings ({ "non vérifiées", "rawtypes"}) 
		TypeSerializer <StreamRecord <T >> streamRecordSerializer = 
			(TypeSerializer <StreamRecord <T >>) nouvelle StreamElementSerializer (input.getType (). createSerializer ( . getExecutionEnvironment () getConfig ())); 

		ListStateDescriptor <StreamRecord <T >> stateDesc = 
			nouveau ListStateDescriptor <> ( "fenêtres contenu", streamRecordSerializer); 

		opérateur = 
			nouveau EvictingWindowOperator <> (windowAssigner, 
				windowAssigner.getWindowSerializer (getExecutionEnvironment (). getConfig ()), 
				keySel, 
				input.getKeyType ().
				nouveau InternalIterableWindowFunction <> (nouveau ReduceApplyWindowFunction <> (reduceFunction, fonction)), 
				déclenchement, 
				expulseur, 
				allowedLateness, 
				lateDataOutputTag); 

	} Else { 
		ReducingStateDescriptor <T> stateDesc = new ReducingStateDescriptor <> ( "fenêtres contenu", 
			reduceFunction, 
			input.getType () createSerializer (getExecutionEnvironment () getConfig ())..); 

		opérateur = 
			nouveau WindowOperator <> (windowAssigner, 
				windowAssigner.getWindowSerializer (getExecutionEnvironment (). getConfig ()), 
				keySel, 
				input.getKeyType (). createSerializer (getExecutionEnvironment (). getConfig ()), 
				stateDesc,
				nouveau InternalSingleValueWindowFunction <> (fonction),
				déclenchement, 
				allowedLateness, 
				lateDataOutputTag); 
	} 

	Input.transform de retour (opname, resultType, opérateur); 
}

Exemple d'extrait de code

stream.keyBy (0) 
  .timeWindow (Time.of (2500, TimeUnit.MILLISECONDS), Time.of (500, TimeUnit.MILLISECONDS)) 
  .reduce ((valeur1; valeur2) => (value1._1, value1._2 + value2._2)) 
  .addSink (nouveau SinkFunction [(long, long)] {})

 

processus

 233

 

appliquer

233