description: "Java、前端、大数据、区块链、AI应用开发求职必备技能：计算机基础，设计模式、DDD及各大中台和业务系统设计真实案例...软件开发的一站式终身学习网站！"

text: 'kubectl命令',

link: '/md/k8s/kubectl命令.md'

title: "Kubernetes",

collapsable: false,

sidebarDepth: 0,

children: [

"00-Kubernetes的基本架构",

"01-一键部署神器kubeadm",

"02-Kubernetes核心组件之kube-proxy实现原理",

"kubectl命令",

"Kubernetes容器日志处理方案",

"23-0-声明式API",

"23-1-Envoy",

]

}],

为了更好的理解它，看下面的例子。给定

- 模式如`"(a+ until b)"` (一个或者更多的`"a"`直到`"b"`)

- 到来的事件序列`"a1" "c" "a2" "b" "a3"`

- 输出结果会是： `{a1 a2} {a1} {a2} {a3}`.

你可以看到`{a1 a2 a3}`和`{a2 a3}`由于停止条件没有被输出。

为当前模式定义一个条件。为了匹配这个模式，一个事件必须满足某些条件。 多个连续的 where() 语句取与组成判断条件。

pattern.where(new IterativeCondition<Event>() {

@Override

public boolean filter(Event value, Context ctx) throws Exception {

return ... // 一些判断条件

}

});

增加一个新的判断，和当前的判断取或。一个事件只要满足至少一个判断条件就匹配到模式。

pattern.where(new IterativeCondition<Event>() {

@Override

public boolean filter(Event value, Context ctx) throws Exception {

return ...; // 一些判断条件

}

}).or(new IterativeCondition<Event>() {

@Override

public boolean filter(Event value, Context ctx) throws Exception {

return ...; // 替代条件

}

});

为循环模式指定一个停止条件。意思是满足了给定的条件的事件出现后，就不会再有事件被接受进入模式了。 只适用于和oneOrMore()同时使用。 `NOTE:` 在基于事件的条件中，它可用于清理对应模式的状态。

pattern.oneOrMore().until(new IterativeCondition<Event>() {

@Override

public boolean filter(Event value, Context ctx) throws Exception {

return ...; // 替代条件

}

});

为当前模式定义一个子类型条件。一个事件只有是这个子类型的时候才能匹配到模式。

pattern.subtype(SubEvent.class);

指定模式期望匹配到的事件至少出现一次。 默认（在子事件间）使用松散的内部连续性。 关于内部连续性的更多信息可以参考连续性。 推荐使用 until()或者 within()来清理状态。

pattern.oneOrMore();

指定模式期望匹配到的事件至少出现 #times 次。 默认（在子事件间）使用松散的内部连续性。 关于内部连续性的更多信息可以参考连续性。

pattern.timesOrMore(2);

指定模式期望匹配到的事件正好出现的次数。 默认（在子事件间）使用松散的内部连续性。 关于内部连续性的更多信息可以参考连续性。

pattern.times(2);

指定模式期望匹配到的事件出现次数在#fromTimes和#toTimes之间。 默认（在子事件间）使用松散的内部连续性。 关于内部连续性的更多信息可以参考连续性。

pattern.times(2, 4);

指定这个模式是可选的，也就是说，它可能根本不出现。这对所有之前提到的量词都适用。

pattern.oneOrMore().optional();

指定这个模式是贪心的，也就是说，它会重复尽可能多的次数。这只对量词适用，现在还不支持模式组。

pattern.oneOrMore().greedy();

输入：C D A1 A2 A3 D A4 B，会产生下面的输出：

如果施加严格连续性： {C A1 B}，{C A1 A2 B}，{C A1 A2 A3 B}

不施加严格连续性： {C A1 B}，{C A1 A2 B}，{C A1 A2 A3 B}，{C A1 A2 A3 A4 B}

例如，一个如下的模式：

Pattern.<Event>begin("start")

.where(SimpleCondition.of(value -> value.getName().equals("c")))

.followedBy("middle")

.where(SimpleCondition.of(value -> value.getName().equals("a")))

.oneOrMore()

.allowCombinations()

.followedBy("end1")

.where(SimpleCondition.of(value -> value.getName().equals("b")));

输入：C D A1 A2 A3 D A4 B，会产生如下的输出：

如果使用不确定松散连续： {C A1 B}，{C A1 A2 B}，{C A1 A3 B}，{C A1 A4 B}，{C A1 A2 A3 B}，{C A1 A2 A4 B}，{C A1 A3 A4 B}，{C A1 A2 A3 A4 B}

如果不使用：{C A1 B}，{C A1 A2 B}，{C A1 A2 A3 B}，{C A1 A2 A3 A4 B}

| 模式操作 | 描述 |

| ----------------- | ------------------------------------------------------------ |

| **consecutive()** | 与`oneOrMore()`和`times()`一起使用， 在匹配的事件之间施加严格的连续性， 也就是说，任何不匹配的事件都会终止匹配（和`next()`一样）。如果不使用它，那么就是松散连续（和`followedBy()`一样）。 |

例如，一个如下的模式：

Pattern.begin("start").where(_.getName().equals("c"))

.followedBy("middle").where(_.getName().equals("a"))

.oneOrMore().consecutive()

.followedBy("end1").where(_.getName().equals("b"))

输入：C D A1 A2 A3 D A4 B，会产生下面的输出：

如果施加严格连续性： {C A1 B}，{C A1 A2 B}，{C A1 A2 A3 B}

不施加严格连续性： {C A1 B}，{C A1 A2 B}，{C A1 A2 A3 B}，{C A1 A2 A3 A4 B}

例如，一个如下的模式：

Pattern.begin("start").where(_.getName().equals("c"))

.followedBy("middle").where(_.getName().equals("a"))

.oneOrMore().allowCombinations()

.followedBy("end1").where(_.getName().equals("b"))

输入：C D A1 A2 A3 D A4 B，会产生如下的输出：

如果使用不确定松散连续： {C A1 B}，{C A1 A2 B}，{C A1 A3 B}，{C A1 A4 B}，{C A1 A2 A3 B}，{C A1 A2 A4 B}，{C A1 A3 A4 B}，{C A1 A2 A3 A4 B}

如果不使用：{C A1 B}，{C A1 A2 B}，{C A1 A2 A3 B}，{C A1 A2 A3 A4 B}