Sentinel 规则持久化

1.Sentinel 三种管理模式

推送方式说明        优点缺点
默认方式Api将规则推送到客户端存储在内存中，扩展写数据源（WritableDataSource）简单无任何依赖不保证一致性，规则无持久化，重新启动规则消失
Pull方式扩展写数据源（WritableDataSource），客户端定时向规则管理中心拉取规则，这个规则管理中心可以是RDBS、文件等简单无任何依赖，规则持久化不保证一直性，实时性保证，拉取频繁有性能问题
push方式扩展读数据源（ReadableDataSource），规则中心统一推送数据，客户端通过注册监听器的方式监听变化（Nacos Zookeeper）规则持久化，一致性引入三方

2.原始模式（测试环境模式）

不保证一致性，规则无持久化，重新启动规则消失。

3.Pull方式

客户端主动向某个规则管理中心定期轮询拉取规则，这个规则中心可以是 RDBMS、文件，甚至是 VCS 等。这样做的方式是简单，缺点是无法及时获取变更。

Pull-based: 动态文件数据源、Consul, Eureka。

4.Push方式（生产环境模式）

​规则中心统一推送，客户端通过注册监听器的方式时刻监听变化，比如使用 Nacos、Zookeeper 等配置中心。这种方式有更好的实时性和一致性保证。

Push-based: ZooKeeper, Redis, Nacos, Apollo, etcd。

5.客户端集成Nacos持久化规则

5.1 客户端集成Nacos配置中心

Springcloud 集成 Nacos配置中心_springcloud整合nacos配置中心-CSDN博客

5.2 pom中添加依赖包

  1.         <dependency>
  2.             <groupId>com.alibaba.csp</groupId>
  3.             <artifactId>sentinel-datasource-nacos</artifactId>
  4.         </dependency>

5.3 配置文件（bootstrap.yml）

  1. spring:
  2.   application:
  3.     name: user
  4.   cloud:
  5.     nacos:
  6.       config:
  7.         server-addr: 127.0.0.1:8848
  8.         prefix: dubbo-user-api
  9.         file-extension: yml
  10.     sentinel:
  11.       transport:
  12.         dashboard: 127.0.0.1:6780
  13.       eager: true # 取消懒加载
  14.       datasource:
  15.         ds-user-flow-rule:
  16.           nacos:
  17.             server-addr: 127.0.0.1:8848
  18.             dataId: user-flow-rule
  19.             groupId: user-sentinel
  20.             namespace: sentinel
  21.             rule-type: flow # AUTHORITY(授权规则) DEGRADE(熔断规则) FLOW(流控规则) GW_API_GROUP GW_FLOW PARAM_FLOW(热点规则) SYSTEM(系统规则)
  22.         ds-user-degrade-rule:
  23.           nacos:
  24.             server-addr: 127.0.0.1:8848
  25.             dataId: user-degrade-rule
  26.             groupId: user-sentinel
  27.             namespace: sentinel
  28.             rule-type: degrade # AUTHORITY(授权规则) DEGRADE(熔断规则) FLOW(流控规则) GW_API_GROUP GW_FLOW PARAM_FLOW(热点规则) SYSTEM(系统规则)

5.4 Nacos中添加配置文件

5.4.1 user-flow-rule

  1. [
  2.     {
  3.         "resource": "/api/user/getName",
  4.         "limitApp": "default",
  5.         "grade": 1,
  6.         "count": 1,
  7.         "strategy": 0,
  8.         "controlBehavior": 0,
  9.         "clusterMode": false
  10.     }
  11. ]

5.4.2 user-degrade-rule

  1. [
  2. 	{
  3. 		"resource": "/api/user/getName",
  4. 		"limitApp": "default",
  5. 		"count": 1,
  6. 		"timeWindow": 5,
  7. 		"grade": 0,
  8. 		"minRequestAmount": 3,
  9. 		"statIntervalMs": 1000,
  10. 		"slowRatioThreshold": 0.5
  11. 	}
  12. ]

5.5 总结

适合Nacos配置中心负责主要配置源，Sentinel控制台作为临时管理平台（处理突发问题）。

不足：Sentinel控制台信息调整无法同步到Nacos配置中心。

6.Sentinel控制台集成Nacos配置中心

以流控规则为例。

6.1客户端配置调整

  1. spring:
  2.   application:
  3.     name: user
  4.   cloud:
  5.     nacos:
  6.       config:
  7.         server-addr: 127.0.0.1:8848
  8.         prefix: dubbo-user-api
  9.         file-extension: yml
  10.     sentinel:
  11.       transport:
  12.         dashboard: 127.0.0.1:6780
  13.       eager: true # 取消懒加载
  14.       datasource:
  15.         ds-user-flow-rule:
  16.           nacos:
  17.             server-addr: 127.0.0.1:8848
  18.             #dataId: user-flow-rule
  19.             #groupId: user-sentinel
  20.             #namespace: sentinel
  21.             dataId: user-flow-rules
  22.             groupId: SENTINEL_GROUP
  23.             rule-type: flow # AUTHORITY(授权规则) DEGRADE(熔断规则) FLOW(流控规则) GW_API_GROUP GW_FLOW PARAM_FLOW(热点规则) SYSTEM(系统规则)
  24.  
  25.         ds-user-degrade-rule:
  26.           nacos:
  27.             server-addr: 127.0.0.1:8848
  28.             dataId: user-degrade-rule
  29.             groupId: user-sentinel
  30.             namespace: sentinel
  31.             rule-type: degrade # AUTHORITY(授权规则) DEGRADE(熔断规则) FLOW(流控规则) GW_API_GROUP GW_FLOW PARAM_FLOW(热点规则) SYSTEM(系统规则)

6.2 控台源码下载

githup地址：https://github.com/alibaba/Sentinel

源码地址：https://github.com/alibaba/Sentinel.git

6.3 修改（sentinel-dashboard）

6.3.1 pom文件修改

  1.         
  2.         <dependency>
  3.             <groupId>com.alibaba.cspgroupId>
  4.             <artifactId>sentinel-datasource-nacosartifactId>
  5.             
  6.         dependency>

6.3.2 代码迁移

test目录下的nacos文件件copy到main目录下的对应目录下。

6.3.3 修NacosConfig.java

添加自己的Nacos配置中心地址。

  1. @Bean
  2. public ConfigService nacosConfigService() throws Exception {
  3.     return ConfigFactory.createConfigService("127.0.0.1:8848");
  4. }

6.3.4 修FlowControllerV2.java

  1. //    NACOS 集成修改关闭
  2. //    @Autowired
  3. //    @Qualifier("flowRuleDefaultProvider")
  4. //    private DynamicRuleProvider> ruleProvider;
  5. //    @Autowired
  6. //    @Qualifier("flowRuleDefaultPublisher")
  7. //    private DynamicRulePublisher> rulePublisher;
  8.  
  9.     //    NACOS 集成修改添加
  10.     @Autowired
  11.     @Qualifier("flowRuleNacosProvider")
  12.     private DynamicRuleProvider> ruleProvider;
  13.     @Autowired
  14.     @Qualifier("flowRuleNacosPublisher")
  15.     private DynamicRulePublisher> rulePublisher;

6.3.5 修sidebar.html

打开注释掉的代码

注释掉如下代码

6.4 打包运行

java -Dserver.port=6780 -jar sentinel-dashboard.jar

6.5 控制台添加规则

6.6 Nacos 配置中心查看

id="article_content" class="article_content clearfix"> id="content_views" class="markdown_views prism-atom-one-light">

作者推荐

【动态规划】458:可怜的小猪

本文涉及知识点

动态规划 记忆化搜索

LeetCode546. 移除盒子

给出一些不同颜色的盒子 boxes ，盒子的颜色由不同的正数表示。
你将经过若干轮操作去去掉盒子，直到所有的盒子都去掉为止。每一轮你可以移除具有相同颜色的连续 k 个盒子（k >= 1），这样一轮之后你将得到 k * k 个积分。
返回 你能获得的最大积分和 。
示例 1：
输入：boxes = [1,3,2,2,2,3,4,3,1]
输出：23
解释：
[1, 3, 2, 2, 2, 3, 4, 3, 1]
----> [1, 3, 3, 4, 3, 1] (33=9 分)
----> [1, 3, 3, 3, 1] (11=1 分)
----> [1, 1] (33=9 分)
----> [] (22=4 分)
示例 2：
输入：boxes = [1,1,1]
输出：9
示例 3：
输入：boxes = [1]
输出：1
提示：
1 <= boxes.length <= 100
1 <= boxes[i] <= 100

动态规划

动态规划的状态表示：

dp[l][r][k]表示消除以下子序列获得的最大得分。
boxes[0,l)已经消除或不会对消除此子序列有影响。
boxes[l,r]全部没有消除。
boxes(r,n)除k个boxes[r]外，全部消除。

思路

假定boxs[i1]、boxs[i2]、boxs[i3]、boxes[i4]相等，且不存在其它等于boxs[i4]的盒子。消除i4时有如下可能。
为了方便，用g(l,r)代替 dp[l+1][r-1][0] f(r,k)代替dp[0][r][k]

class="table-box">
i4f[i4-1][0]+(k+1) ^2l ,i4,0
i3 i4f[i3][1]+g(i3,i4)l ,i4,0 -->l,i3,1
i2 i4f[i2][1]+g(i2,i4)l ,i4,0 ->l,i2,1
i1 i4f[i1][1]+g(i1,i4)l ,i4,0 >l,i1,1
i1 i2 i4f[i1][2]+g(i1,i2)+g{i2,i4)l ,i4,0 --> l,i2,1 -> l,i1->2
i1 i3 i4f[i1][2]+g(i1,i3)+g{i3,i4)l ,i4,0 --> l,i3,1 -> l,i1->2
i2 i3 i4f[i2][2]+g(i2,i3)+g{i3,i4)l ,i4,0 --> l,i3,1 -> l,i2->2
i1 i2 i3 i4f[i1][3]+g(i1,i2)+g{i2,i3)++g{i3,i4)l ,i4,0 --> l,i3,1 ->l,i2->2–>l,i1,3

我们以i1 i2 i4 为例：
f[i4][0]可能等于 f[i2][1] + g[i2,i4]
f[i2][1]可能等于f[i1][2] + g[i1+i2]
==> f[i4][0] 可能等于 f[i1]i2] + g[i1][i2] + g[i2][i4]
** 结论** 枚举消除时，不用枚举所有一同消除的下标，只需要枚举前一个下标。这意味着转移方程的时间复杂度从O(2n)降为O(n)。
状态数为n3，故空间复杂度为O(n3)，时间复杂度为:O(n4)。许多状态不可能同时存在，实际时间复杂度低得多。

动态规划分析

动态规划的转移方程表示：
所有盒子都会被消除，所以boxes[r]也是，枚举boxes[r]被消除的可能：
情况一：boxes[r]被消除时，r的下标最小（最左边)。转移方程为:(k+1)*(k+1) + dp[l][r-1][0]
情况二：boxes[r]被消除时，i的小标比r小，如果有多个i取最大值。转移方程为：dp[i+1][r+1][0] + dp[l][i][k+1]

动态规划的初始状态：
全部为0，表示未计算。

动态规划的填表顺序：
计算dp[0][n-1][0]需要的状态。

动态规划的返回值：
dp[0][n-1][0]

枚举了不可能的情况

比如： {1,2,1,1} 由于boxs[2]和boxs[3]之间没有其它数字，所以它们一定同时被消除。
假定boxs[i1]boxs[i2]=x，且i1+1i2。
假定一：i1和i2被两次消除。 不失一般性，假定i1先被消除。包括i1共k1个x被消除，包括i2共k2个x被消除。
假定二：假定i1和i2之间没数据。除不消i1外，其它操作及顺序和假定一相同，直到消除i2。则时消除k0+k1+k2个x。 k1个boxs[i1]左边可以有k0个可以一并消除。在假定1中，这个k0x无论是一次消除还是多次消除都小于等于k0k0。除了这些x外,其它完全一样。假定一<=k0k0+k1k2+k2k2 假定二：(k0+k1+k2)^2。显然假定一 <= 假定二
这k0个x可能在假定一中和更左边的结合，那假定二可能等待这些都消除了，再消除i2。
结论： 假定一不存在，但它一定不优于假定二，假定二存在，所以多枚举了假定一，不会带来错误结果。

代码

核心代码

class Solution {
public:
	int removeBoxes(vector<int>& boxes) {
		m_c = boxes.size();
		m_boxes = boxes;
		for (int i = 0; i < m_c; i++)
		{
			m_dp[i].assign(m_c, vector<int>(m_c));
		}
		return Cal(0,m_c-1,0);
	}
	int Cal(const int& l, const int& r, const int& k)
	{
		if (l > r)
		{
			return 0;
		}
		if (0 != m_dp[l][r][k])
		{
			return m_dp[l][r][k];
		}
		m_dp[l][r][k] = Cal(l, r - 1, 0) + (k + 1) * (k + 1);
		for (int i = l; i < r; i++)
		{
			if (m_boxes[i] == m_boxes[r])
			{
				m_dp[l][r][k] = max(m_dp[l][r][k], Cal(l, i, k + 1)+ Cal(i+1,r-1,0));
			}
		}
		return m_dp[l][r][k];
	}
	int m_c;
	vector<int> m_boxes;
	vector < vector<int>> m_dp[100];
};
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
class="hide-preCode-box">
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

测试用例

template<class T>
void Assert(const T& t1, const T& t2)
{
	assert(t1 == t2);
}

template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{
	if (v1.size() != v2.size())
	{
		assert(false);
		return;
	}
	for (int i = 0; i < v1.size(); i++)
	{
		Assert(v1[i], v2[i]);
	}
}


int main()
{
	vector<int> boxes;

	{
		Solution sln;
		boxes = { 1, 2, 2, 1, 1, 1, 2, 1 };
		auto res = sln.removeBoxes(boxes);
		Assert(30, res);
	}
	{
		Solution sln;
		boxes = { 1, 3, 2, 2, 2, 3, 4, 3, 1 };
		auto res = sln.removeBoxes(boxes);
		Assert(23, res);
	}
	{
		Solution sln;
		boxes = { 1,1,1 };
		auto res = sln.removeBoxes(boxes);
		Assert(9, res);
	}
	{
		Solution sln;
		boxes = { 1 };
		auto res = sln.removeBoxes(boxes);
		Assert(1, res);
	}
	{
		Solution sln;
		boxes = { 1,2,1 };
		auto res = sln.removeBoxes(boxes);
		Assert(5, res);
	}
	{
		Solution sln;
		boxes = { 1,2,2,1,1,1,2,1,1,2,1,2,1,1,2,2,1,1,2,2,1,1,1,2,2,2,2,1,2,1,1,2,2,1,2,1,2,2,2,2,2,1,2,1,2,2,1,1,1,2,2,1,2,1,2,2,1,2,1,1,1,2,2,2,2,2,1,2,2,2,2,2,1,1,1,1,1,2,2,2,2,2,1,1,1,1,2,2,1,1,1,1,1,1,1,2,1,2,2,1 };
		auto res = sln.removeBoxes(boxes);
		Assert(2758, res);
	}
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
class="hide-preCode-box">

2023年1月代码

class Solution {
public:
int removeBoxes(vector& boxes) {
memset(m_dp, 0, sizeof(m_dp));
return Cal(boxes,0, boxes.size() - 1, 0);
}
int Cal(const vector& boxes,int l, int r, int k)
{
if (l > r)
{
return 0;
}
if (0 != m_dp[l][r][k])
{
return m_dp[l][r][k];
}
int iSum = Cal(boxes,l, r - 1, 0) + (k + 1)*(k + 1);
for (int i = l; i < r; i++)
{
if (boxes[i] != boxes[r])
{
continue;
}
iSum = max(iSum, Cal(boxes, l, i, k + 1) + Cal(boxes, i + 1, r - 1, 0));
}
m_dp[l][r][k] = iSum;
return m_dp[l][r][k];
}
int m_dp[100][100][100] ;
};

2023年6月代码

class Solution {
public:
int removeBoxes(vector& boxes) {
m_c = boxes.size();
memset(m_aLRNum, -1, sizeof(m_aLRNum));
return remove(boxes,0, m_c - 1, 0);
}
int remove(const vector& boxes,const int left, const int right, int k)
{
if (right < left)
{
return 0;
}
int& iRet = m_aLRNum[left][right][k];
if (iRet >= 0)
{
return iRet;
}
iRet = (1 + k)*(1 + k) + remove(boxes,left, right - 1, 0);
int tmp = right-1;
//[1, 2, 1, 2, 2, 1, 2, 1, 2, 2, 2, 2, 2, 1],可以先消除中间，只保留两个1
while (tmp >= left)
{
while ((tmp >= left) && (boxes[tmp] != boxes[right]))
{
tmp–;
}
if (tmp < left)
{
return iRet;
}
iRet = max(iRet, remove(boxes, tmp + 1, right - 1, 0) + remove(boxes, left, tmp, k + 1));
tmp–;
}
return iRet;
}
int m_c;
int m_aLRNum[100][100][100];//m_aLRNum[l][r][k] 消除nums的[l.r]及和nums[r]相等的k个数
};

2023年8月代码

class Solution {
public:
int removeBoxes(vector& boxes) {
m_boxes = boxes;
//dp[l][r][k]表示 boxes[l] 到boxes[r] 是最后消除的，消除时后面有k同颜色的数
memset(m_dp, 0, sizeof(m_dp));
return Cal(0, boxes.size() - 1, 0);
}
int Cal(int left, int r, int k)
{
if (r < left)
{
return 0;
}
int& iRet = m_dp[left][r][k];
if (0 != iRet)
{
return iRet;
}
iRet = Cal(left, r - 1, 0) + (k + 1) * (k + 1);//直接消除
for (int i = r - 1; i >= left; i–)
{
if (m_boxes[i] != m_boxes[r])
{
continue;
}
iRet = max(iRet, Cal(left, i, k + 1) + Cal(i + 1, r - 1, 0));
}
return iRet;
}
int m_dp[100][100][100];
vector m_boxes;
};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快

速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关

下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

class="table-box">
我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 **C+

+17**
如无特殊说明，本算法用**C++**实现。

data-report-view="{"mod":"1585297308_001","spm":"1001.2101.3001.6548","dest":"https://blog.csdn.net/he_zhidan/article/details/135543157","extend1":"pc","ab":"new"}">> id="blogExtensionBox" style="width:400px;margin:auto;margin-top:12px" class="blog-extension-box"> class="blog_extension blog_extension_type5" id="blog_extension"> class="extension_official" data-report-click="{"spm":"1001.2101.3001.6471"}" data-report-view="{"spm":"1001.2101.3001.6471"}"> class="blog_extension_card_left"> class="blog_extension_card_cont"> 群中有博文配套源码 class="blog_extension_card_cont_r"> QQ群名片
注：本文转载自blog.csdn.net的Ocean@上源码的文章"https://blog.csdn.net/qq_34253002/article/details/134422314"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！