1 public void createBecAppBlbV2(BecClient client) {
2        CreateBecAppBlbRequest request = CreateBecAppBlbRequest.builder()
3        // 负载均衡描述，非必需
4        .desc("desc")
5        // 负载均衡名称，必需
6        .name("name")
7        // 是否需要公网IPV4，非必需
8        .needPublicIp(true)
9        // 负载均衡所在节点ID，必需
10        .regionId("cn-huhehaote2-ix")
11        // 指定运营商，取值为"ct"、"un"、"cm"，分别是电信、联通、移动，目前仅支持指定一个运营商，非必需
12        .subServiceProviders(Collections.singletonList("cm"))
13        // 负载均衡子网ID，非必需
14        .subnetId("subnetId")
15        // 负载均衡VPC ID，非必需
16        .vpcId("vpcId")
17        // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
18        .clientToken("123456789")
19        .build();
20
21        CreateBecAppBlbResponse response = client.createBecAppBlbV2(request);
22    }

1public void updateBecAppBlbV2(BecClient client) {
2        UpdateBecAppBlbRequest request = UpdateBecAppBlbRequest.builder()
3            // 负载均衡ID，必需
4            .blbId("blbId")
5            // 负载均衡名称，非必需
6            .name("name")
7            // 负载均衡描述，非必需
8            .desc("desc")
9            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
10            .clientToken("123456789")
11            .build();
12
13        UpdateBecAppBlbResponse response = client.updateBecAppBlbV2(request);
14    }

1public void getBecAppBlbsV2(BecClient client) {
2        // 标记查询的起始位置，非必需
3        ListRequest listRequest = new ListRequest();
4        listRequest.setMarker("marker"); // 标记查询的起始位置，填blbId
5        listRequest.setMaxKeys(1000); // 每页包含的最大数量，1-1000，默认1000
6
7        GetBecAppBlbsRequest request = GetBecAppBlbsRequest.builder()
8            .listRequest(listRequest)
9            .build();
10
11        GetBecAppBlbsResponse response = client.getBecAppBlbsV2(request);
12    }

1  public void getBecAppBlbV2(BecClient client) {
2        GetBecAppBlbRequest request = GetBecAppBlbRequest.builder()
3        // 负载均衡ID，必需
4        .blbId("applbId")
5        .build();
6
7        GetBecAppBlbResponse response = client.getBecAppBlbV2(request);
8    }

1public void deleteBecAppBlbV2(BecClient client) {
2        DeleteBecAppBlbRequest request = DeleteBecAppBlbRequest.builder()
3        // 负载均衡ID，必需
4        .blbId("applb-cn-huhehaote2-ix-gkipu2cu")
5        // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
6        .clientToken("123456789")
7        .build();
8
9        DeleteBecAppBlbResponse response = client.deleteBecAppBlbV2(request);
10    }

1public void createBecAppBlbTCPListenerV2(BecClient client) {
2        CreateBecAppBlbTCPListenerRequest request = CreateBecAppBlbTCPListenerRequest.builder()
3            // 负载均衡ID，必需
4            .blbId("blbId")
5            // 监听器的监听端口，需为1-65535间的整数，必需
6            .listenerPort(8090)
7            // 负载均衡算法，支持3种方式：RoundRobin、LeastConnection、Hash，必需
8            .scheduler("RoundRobin")
9            // TCP设置连接超时时间（单位：秒），默认900，需为10-4000间的整数，非必需
10            .tcpSessionTimeout(1000)
11            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
12            .clientToken("123456789")
13            .build();
14        CreateBecAppBlbTCPListenerResponse response = client.createBecAppBlbTCPListenerV2(request);
15    }

1 public void createBecAppBlbUDPListenerV2(BecClient client) {
2        CreateBecAppBlbUDPListenerRequest request = CreateBecAppBlbUDPListenerRequest.builder()
3            // 负载均衡ID，必需
4            .blbId("blbId")
5            // 监听器的监听端口，需为1-65535间的整数，必需
6            .listenerPort(8090)
7            // 负载均衡算法，支持3种方式：RoundRobin、LeastConnection、Hash，必需
8            .scheduler("RoundRobin")
9            // UDP会话超时时间（单位：秒），默认900，需为10-4000间的整数，非必需
10            .udpSessionTimeout(1000)
11            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
12            .clientToken("123456789")
13            .build();
14        CreateBecAppBlbUDPListenerResponse response = client.createBecAppBlbUDPListenerV2(request);
15    }

1 public void createBecAppBlbListenerPoliciesV2(BecClient client) {
2        CreateAppPolicy createAppPolicy = new CreateAppPolicy();
3        // 策略绑定IP组标识符，必需
4        createAppPolicy.setAppIpGroupId("bec_ip_group-4kwh21sf");
5        // 策略优先级，有效取值范围是1-32768，必需
6        createAppPolicy.setPriority(1);
7        // 策略描述默认为空，非必需
8        createAppPolicy.setDesc("description");
9        CreateBecAppBlbListenerPoliciesRequest request = CreateBecAppBlbListenerPoliciesRequest.builder()
10            // 负载均衡ID，必需
11            .blbId("blbId")
12            // 监听器的监听端口，必需
13            .listenerPort(8090)
14            // 当监听器端口下有多个协议时，type必传
15            .type("TCP")
16            // 监听器绑定策略列表，必需
17            .appPolicyVos(Arrays.asList(createAppPolicy))
18            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
19            .clientToken("123456789")
20            .build();
21        CreateBecAppBlbListenerPoliciesResponse response = client.createBecAppBlbListenerPoliciesV2(request);
22    }

1public void updateBecAppBlbTCPListenerV2(BecClient client) {
2        UpdateBecAppBlbTCPListenerRequest request = UpdateBecAppBlbTCPListenerRequest.builder()
3            // 负载均衡ID，必需
4            .blbId("blbId")
5            // TCP监听器端口，必需
6            .listenerPort(8090)
7            // 负载均衡算法，支持3种方式：RoundRobin、LeastConnection、Hash，非必需
8            .scheduler("LeastConnection")
9            // TCP设置连接超时时间（单位：秒），需为10-4000间的整数，非必需
10            .tcpSessionTimeout(2000)
11            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
12            .clientToken("123456789")
13            .build();
14        UpdateBecAppBlbTCPListenerResponse response = client.updateBecAppBlbTCPListenerV2(request);
15    }

1   public void updateBecAppBlbUDPListenerV2(BecClient client) {
2        UpdateBecAppBlbUDPListenerRequest request = UpdateBecAppBlbUDPListenerRequest.builder()
3            // 负载均衡ID，必需
4            .blbId("blbId")
5            // UDP监听器端口，必需
6            .listenerPort(8090)
7            // 负载均衡算法，支持3种方式：RoundRobin、LeastConnection、Hash，非必需
8            .scheduler("LeastConnection")
9            // UDP会话超时时间（单位：秒），需为10-4000间的整数，非必需
10            .udpSessionTimeout(2000)
11            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
12            .clientToken("123456789")
13            .build();
14        UpdateBecAppBlbUDPListenerResponse response = client.updateBecAppBlbUDPListenerV2(request);
15    }

1public void getBecAppBlbTCPListenersV2(BecClient client) {
2        ListRequest listRequest = new ListRequest();
3        // 标记查询的起始位置，非必需
4        listRequest.setMarker("marker");
5        // 每页包含的最大数量，1-1000，默认1000，非必需
6        listRequest.setMaxKeys(100);
7        GetBecAppBlbTCPListenersRequest request = GetBecAppBlbTCPListenersRequest.builder()
8            // 负载均衡ID，必需
9            .blbId("blbId")
10            // 监听器端口，非必需
11            .listenerPort(8090)
12            // 分页参数，非必需
13            .listRequest(listRequest)
14            .build();
15        GetBecAppBlbTCPListenersResponse response = client.getBecAppBlbTCPListenersV2(request);
16    }

1public void getBecAppBlbUDPListenersV2(BecClient client) {
2        ListRequest listRequest = new ListRequest();
3        // 标记查询的起始位置，非必需
4        listRequest.setMarker("marker");
5        // 每页包含的最大数量，1-1000，默认1000，非必需
6        listRequest.setMaxKeys(100);
7        GetBecAppBlbUDPListenersRequest request = GetBecAppBlbUDPListenersRequest.builder()
8            // 负载均衡ID，必需
9            .blbId("blbId")
10            // 监听器端口，非必需
11            .listenerPort(8090)
12            // 分页参数，非必需
13            .listRequest(listRequest)
14            .build();
15        GetBecAppBlbUDPListenersResponse response = client.getBecAppBlbUDPListenersV2(request);
16    }

1public void getBecAppBlbListenerPoliciesV2(BecClient client) {
2        ListRequest listRequest = new ListRequest();
3        // 标记查询的起始位置，非必需
4        listRequest.setMarker("marker");
5        // 每页包含的最大数量，1-1000，默认1000，非必需
6        listRequest.setMaxKeys(100);
7        GetBecAppBlbListenerPoliciesRequest request = GetBecAppBlbListenerPoliciesRequest.builder()
8            // 负载均衡ID，必需
9            .blbId("blbId")
10            // BLB下监听器端口号，必需
11            .port(8090)
12            // 当监听器端口下有多个协议时，type必传，非必需
13            .type("TCP")
14            // 分页参数，非必需
15            .listRequest(listRequest)
16            .build();
17        GetBecAppBlbListenerPoliciesResponse response = client.getBecAppBlbListenerPoliciesV2(request);
18    }

1public void deleteBecAppBlbListenerPoliciesV2(BecClient client) {
2        DeleteBecAppBlbListenerPoliciesRequest request = DeleteBecAppBlbListenerPoliciesRequest.builder()
3            // 负载均衡ID，必需
4            .blbId("blbId")
5            // 策略前端端口，必需
6            .port(8090)
7            // 所有待释放的策略标识符，一起组成一个数组，必需
8            .policyIdList(java.util.Arrays.asList("bec_policy-vunwgg0n"))
9            // 当监听器端口下有多个协议时，type必传，非必需
10            .type("TCP")
11            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
12            .clientToken("123456789")
13            .build();
14        DeleteBecAppBlbListenerPoliciesResponse response = client.deleteBecAppBlbListenerPoliciesV2(request);
15    }

1public void batchDeleteBecAppBlbListenersV2(BecClient client) {
2        ListenerModel tcpListener = new ListenerModel();
3        // 监听器端口，必需
4        tcpListener.setPort("8090");
5        // 监听器协议类型，必需
6        tcpListener.setType("TCP");
7        ListenerModel udpListener = new ListenerModel();
8        // 监听器端口，必需
9        udpListener.setPort("8090");
10        // 监听器协议类型，必需
11        udpListener.setType("UDP");
12        BatchDeleteBecAppBlbListenersRequest request = BatchDeleteBecAppBlbListenersRequest.builder()
13            // 负载均衡ID，必需
14            .blbId("blbId")
15            // 待删除的监听器端口和协议列表，必需
16            .portTypeList(java.util.Arrays.asList(tcpListener, udpListener))
17            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
18            .clientToken("123456789")
19            .build();
20        BatchDeleteBecAppBlbListenersResponse response = client.batchDeleteBecAppBlbListenersV2(request);
21    }

1public void createBecAppBlbIpGroupV2(BecClient client) {
2        IpGroupMemberForm member = new IpGroupMemberForm();
3        // IP地址，必需
4        member.setIp("192.168.1.1");
5        // 端口号，取值范围1~65535，必需
6        member.setPort(8080);
7        // 权重，取值范围0~100，必需
8        member.setWeight(50);
9        CreateBecAppBlbIpGroupRequest request = CreateBecAppBlbIpGroupRequest.builder()
10            // IP组描述，非必需
11            .desc("desc")
12            // IP组挂载的IP组成员列表，非必需
13            .memberList(Arrays.asList(member))
14            // IP组名称，必需
15            .name("name")
16            // 负载均衡ID，必需
17            .blbId("applb-cn-baoding-ct-tzk0hlpm")
18            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
19            .clientToken("123456789")
20            .build();
21        CreateBecAppBlbIpGroupResponse response = client.createBecAppBlbIpGroupV2(request);
22    }

1public void updateBecAppBlbIpGroupV2(BecClient client) {
2        UpdateBecAppBlbIpGroupRequest request = UpdateBecAppBlbIpGroupRequest.builder()
3            // IP组描述，非必需
4            .desc("new desc")
5            // IP组ID，必需
6            .ipGroupId("bec_ip_group-ahif0bgr")
7            // IP组名称，非必需
8            .name("new name")
9            // 负载均衡ID，必需
10            .blbId("applb-cn-baoding-ct-tzk0hlpm")
11            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
12            .clientToken("123456789")
13            .build();
14        UpdateBecAppBlbIpGroupResponse response = client.updateBecAppBlbIpGroupV2(request);
15    }

1public void getBecAppBlbIpGroupsV2(BecClient client) {
2        ListRequest listRequest = new ListRequest();
3        // 标记查询的起始位置，非必需
4        listRequest.setMarker("marker-value");
5        // 每页包含的最大数量，1-1000，默认1000，非必需
6        listRequest.setMaxKeys(100);
7        GetBecAppBlbIpGroupsRequest request = GetBecAppBlbIpGroupsRequest.builder()
8            // 负载均衡ID，必需
9            .blbId("applb-cn-baoding-ct-tzk0hlpm")
10            // 设置name是否完全匹配，非必需
11            .exactlyMatch(true)
12            // IP组名称，非必需
13            .name("new name")
14            // 分页参数，非必需
15            .listRequest(listRequest)
16            .build();
17        GetBecAppBlbIpGroupsResponse response = client.getBecAppBlbIpGroupsV2(request);
18    }

1public void deleteBecAppBlbIpGroupV2(BecClient client) {
2        DeleteBecAppBlbIpGroupRequest request = DeleteBecAppBlbIpGroupRequest.builder()
3            // IP组ID，必需
4            .ipGroupId("bec_ip_group-ahif0bgr")
5            // 负载均衡ID，必需
6            .blbId("applb-cn-baoding-ct-tzk0hlpm")
7            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
8            .clientToken("123456789")
9            .build();
10        DeleteBecAppBlbIpGroupResponse response = client.deleteBecAppBlbIpGroupV2(request);
11    }

1public void createBecAppBlbIpGroupBackendPoliciesV2(BecClient client) {
2        CreateBecAppBlbIpGroupBackendPolicyRequest request = CreateBecAppBlbIpGroupBackendPolicyRequest.builder()
3            // 健康检查类型，TCP、HTTP、UDP、ICMP，必需
4            .healthCheck("TCP")
5            // 不健康阈值，即连续多少次健康检查失败后，屏蔽该后端服务器。默认为3，需为2-5间的整数，非必需
6            .healthCheckDownRetry(3)
7            // 发往后端服务器的健康检查请求的Host头域，例如”localhost”，默认为空，当健康检查协议为HTTP时生效，非必需
8            .healthCheckHost("localhost")
9            // 健康检查间隔（单位：秒），默认为3，需为1-10间的整数，非必需
10            .healthCheckIntervalInSecond(3)
11            // 健康检查正常时的HTTP状态码，支持5类状态码的组合，例如”http_1xx|http_2xx”。当健康检查协议为HTTP时生效，非必需
12            .healthCheckNormalStatus("http_2xx")
13            // 健康检查端口，IP组协议为HTTP协议时必传
14            .healthCheckPort(8080)
15            // 健康检查超时（单位：秒），默认为3，需为1-60间的整数，非必需
16            .healthCheckTimeoutInSecond(3)
17            // 健康阈值，即连续多少次健康检查成功后，重新将该后端服务器置为可用，默认为3，需为2-5间的整数，非必需
18            .healthCheckUpRetry(3)
19            // 健康检查路径，默认/，当健康检查协议为HTTP时生效，非必需
20            .healthCheckUrlPath("/")
21            // IP组ID，必需
22            .ipGroupId("bec_ip_group-ashmmqhb")
23            // IP组协议类型，TCP、HTTP、UDP，必需
24            .type("TCP")
25            // UDP健康检查字符串，UDP健康检查字符串，当健康检查协议为UDP时必传
26            .udpHealthCheckString("test-udp-check")
27            // 负载均衡ID，必需
28            .blbId("applb-cn-baoding-ct-tzk0hlpm")
29            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
30            .clientToken("123456789")
31            .build();
32        CreateBecAppBlbIpGroupBackendPolicyResponse response = client.createBecAppBlbIpGroupBackendPoliciesV2(request);
33    }

1public void updateBecAppBlbIpGroupPolicyV2(BecClient client) {
2    UpdateBecAppBlbIpGroupBackendPolicyRequest request = UpdateBecAppBlbIpGroupBackendPolicyRequest.builder()
3        // 不健康阈值，即连续多少次健康检查失败后，屏蔽该后端服务器。默认为3，需为2-5间的整数，非必需
4        .healthCheckDownRetry(3)
5        // 发往后端服务器的健康检查请求的Host头域，例如”localhost”，默认为空，当健康检查协议为HTTP时生效，非必需
6        .healthCheckHost("localhost")
7        // 健康检查间隔（单位：秒），默认为3，需为1-10间的整数，非必需
8        .healthCheckIntervalInSecond(3)
9        // 健康检查正常时的HTTP状态码，支持5类状态码的组合，例如”http_1xx|http_2xx”。当健康检查协议为HTTP时生效，非必需
10        .healthCheckNormalStatus("http_2xx")
11        // 健康检查端口，IP组协议为HTTP协议时必传
12        .healthCheckPort(8080)
13        // 健康检查超时（单位：秒），默认为3，需为1-60间的整数，非必需
14        .healthCheckTimeoutInSecond(3)
15        // 健康阈值，即连续多少次健康检查成功后，重新将该后端服务器置为可用，默认为3，需为2-5间的整数，非必需
16        .healthCheckUpRetry(3)
17        // 健康检查路径，默认/，当健康检查协议为HTTP时生效，非必需
18        .healthCheckUrlPath("/")
19        // IP组协议ID，必需
20        .id("bec_ip_group_policy-ykyv9bti")
21        // IP组ID，必需
22        .ipGroupId("bec_ip_group-ashmmqhb")
23        // UDP健康检查字符串，UDP健康检查字符串，当健康检查协议为UDP时必传
24        .udpHealthCheckString("new-check")
25        // 负载均衡ID，必需
26        .blbId("applb-cn-baoding-ct-tzk0hlpm")
27        // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
28        .clientToken("123456789")
29        .build();
30    UpdateBecAppBlbIpGroupBackendPolicyResponse response = client.updateBecAppBlbIpGroupPolicyV2(request);
31}

1 public void getBecAppBlbIpGroupPoliciesV2(BecClient client) {
2        ListRequest listRequest = new ListRequest();
3        // 标记查询的起始位置，非必需
4        listRequest.setMarker("marker-value");
5        // 每页包含的最大数量，1-1000，默认1000，非必需
6        listRequest.setMaxKeys(100);
7        GetBecAppBlbIpGroupBackendPoliciesRequest request = GetBecAppBlbIpGroupBackendPoliciesRequest.builder()
8            // 负载均衡ID，必需
9            .blbId("applb-cn-baoding-ct-tzk0hlpm")
10            // IP组ID，必需
11            .ipGroupId("bec_ip_group-ashmmqhb")
12            // 分页参数，非必需
13            .listRequest(listRequest)
14            .build();
15        GetBecAppBlbIpGroupBackendPoliciesResponse response = client.getBecAppBlbIpGroupPoliciesV2(request);
16    }

1public void deleteBecAppBlbIpGroupBackendPoliciesV2(BecClient client) {
2        DeleteBecAppBlbIpGroupBackendPoliciesRequest request = DeleteBecAppBlbIpGroupBackendPoliciesRequest.builder()
3            // IP组协议ID列表，必需
4            .backendPolicyIdList(java.util.Arrays.asList("bec_ip_group_policy-ykyv9bti"))
5            // IP组ID，必需
6            .ipGroupId("bec_ip_group-ashmmqhb")
7            // 负载均衡ID，必需
8            .blbId("applb-cn-baoding-ct-tzk0hlpm")
9            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
10            .clientToken("123456789")
11            .build();
12        DeleteBecAppBlbIpGroupBackendPoliciesResponse response = client.deleteBecAppBlbIpGroupBackendPoliciesV2(request);
13    }

1public void createBecAppBlbIpGroupMembersV2(BecClient client) {
2        IpGroupMemberForm member = new IpGroupMemberForm();
3        // IP地址，必需
4        member.setIp("192.168.1.2");
5        // 端口号，取值范围1~65535，必需
6        member.setPort(8081);
7        // 权重，取值范围0~100，必需
8        member.setWeight(60);
9        CreateBecAppBlbIpGroupMembersRequest request = CreateBecAppBlbIpGroupMembersRequest.builder()
10            // IP组ID，必需
11            .ipGroupId("bec_ip_group-ashmmqhb")
12            // IP组成员列表，必需
13            .memberList(Arrays.asList(member))
14            // 负载均衡ID，必需
15            .blbId("applb-cn-baoding-ct-tzk0hlpm")
16            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
17            .clientToken("123456789")
18            .build();
19        CreateBecAppBlbIpGroupMembersResponse response = client.createBecAppBlbIpGroupMembersV2(request);
20    }

1 public void updateBecAppBlbIpGroupMembersV2(BecClient client) {
2        UpdateIpGroupMemberForm member = new UpdateIpGroupMemberForm();
3        // IP组成员ID，必需
4        member.setMemberId("bec_ip_member-y0h0prxz");
5        // 端口，非必需
6        member.setPort(8082);
7        // 权重，非必需
8        member.setWeight(70);
9        UpdateBecAppBlbIpGroupMembersRequest request = UpdateBecAppBlbIpGroupMembersRequest.builder()
10            // IP组ID，必需
11            .ipGroupId("bec_ip_group-ashmmqhb")
12            // IP组成员列表，必需
13            .memberList(Arrays.asList(member))
14            // 负载均衡ID，必需
15            .blbId("applb-cn-baoding-ct-tzk0hlpm")
16            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
17            .clientToken("123456789")
18            .build();
19        UpdateBecAppBlbIpGroupMembersResponse response = client.updateBecAppBlbIpGroupMembersV2(request);
20    }

1public void getBecAppBlbIpGroupMembersV2(BecClient client) {
2        ListRequest listRequest = new ListRequest();
3        // 标记查询的起始位置，非必需
4        listRequest.setMarker("marker-value");
5        // 每页包含的最大数量，1-1000，默认1000，非必需
6        listRequest.setMaxKeys(100);
7        GetBecAppBlbIpGroupMembersRequest request = GetBecAppBlbIpGroupMembersRequest.builder()
8            // 负载均衡ID，必需
9            .blbId("applb-cn-baoding-ct-tzk0hlpm")
10            // IP组ID，必需
11            .ipGroupId("bec_ip_group-ashmmqhb")
12            // 分页参数，非必需
13            .listRequest(listRequest)
14            .build();
15        GetBecAppBlbIpGroupMembersResponse response = client.getBecAppBlbIpGroupMembersV2(request);
16    }

1public void deleteBecAppBlbIpGroupMembersV2(BecClient client) {
2        DeleteBecAppBlbIpGroupMembersRequest request = DeleteBecAppBlbIpGroupMembersRequest.builder()
3            // IP组ID，必需
4            .ipGroupId("bec_ip_group-ashmmqhb")
5            // IP组成员ID列表，必需
6            .memberIdList(Arrays.asList("bec_ip_member-y0h0prxz"))
7            // 负载均衡ID，必需
8            .blbId("applb-cn-baoding-ct-tzk0hlpm")
9            // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
10            .clientToken("123456789")
11            .build();
12        DeleteBecAppBlbIpGroupMembersResponse response = client.deleteBecAppBlbIpGroupMembersV2(request);
13    }

1public void createBecAppBlbServerGroupV2(BecClient client) {
2    BackendServerReq backendServerReq = new BackendServerReq();
3    // 实例ID，必需
4    backendServerReq.setInstanceId("vm-hj4tcvq4-cn-baoding-ct-o4bpk");
5    // 权重，取值范围0~100，必需
6    backendServerReq.setWeight(20);
7
8    CreateBecAppBlbServerGroupRequest request = CreateBecAppBlbServerGroupRequest.builder()
9            // blbId，必需
10            .blbId("applb-cn-baoding-ct-9iixorq5")
11            // 服务器组描述，非必需
12            .desc("test")
13            // 服务器组名称，必需
14            .name("test")
15            // 服务器组挂载的成员列表，非必需
16            .backendServerReqList(Collections.singletonList(backendServerReq))
17            .build();
18
19    CreateBecAppBlbServerGroupResponse response = client.createBecAppBlbServerGroupV2(request);
20}

1public void updateBecAppBlbServerGroupV2(BecClient client) {
2    UpdateBecAppBlbServerGroupRequest request = UpdateBecAppBlbServerGroupRequest.builder()
3            // blbId，必需
4            .blbId("applb-cn-baoding-ct-9iixorq5")
5            // 服务器组描述，非必需
6            .desc("new desc")
7            // 服务器组名称，非必需
8            .name("new name")
9            // 服务器组ID，必需
10            .sgId("svg-lkxlymix")
11            .build();
12
13    UpdateBecAppBlbServerGroupResponse response = client.updateBecAppBlbServerGroupV2(request);
14}

1public void getBecAppBlbServerGroupsV2(BecClient client) {
2    ListRequest listRequest = new ListRequest();
3    listRequest.setMarker(""); // 标记查询的起始位置，非必需
4    listRequest.setMaxKeys(10); // 每页包含的最大数量，1-1000，默认1000，非必需
5    GetBecAppBlbServerGroupsRequest request = GetBecAppBlbServerGroupsRequest.builder()
6            .blbId("applb-cn-baoding-ct-9iixorq5") // blbId，必需
7            .listRequest(listRequest)
8            .exactlyMatch(true) // 设置name是否完全匹配，非必需
9            .name("new name") // 服务器组名称，非必需
10            .build();
11    GetBecAppBlbServerGroupsResponse response = client.getBecAppBlbServerGroupsV2(request);
12}

1public void deleteBecAppBlbServerGroupV2(BecClient client) {
2    DeleteBecAppBlbServerGroupRequest request = DeleteBecAppBlbServerGroupRequest.builder()
3            .blbId("applb-cn-baoding-ct-9iixorq5") // blbId，必需
4            .sgId("svg-lkxlymix") // 服务器组ID，必需
5            .build();
6    DeleteBecAppBlbServerGroupResponse response = client.deleteBecAppBlbServerGroupV2(request);
7}

1public void createBecAppBlbServerGroupPortV2(BecClient client) {
2    CreateBecAppBlbServerGroupPortRequest request = CreateBecAppBlbServerGroupPortRequest.builder()
3            .blbId("applb-cn-baoding-ct-9iixorq5") // blbId，必需
4            .healthCheck("TCP") // 健康检查类型，TCP、HTTP、UDP、ICMP，非必需
5            .healthCheckDownRetry(3) // 不健康阈值，即连续多少次健康检查失败后，屏蔽该后端服务器。默认为3，需为2-5间的整数，非必需
6            .healthCheckHost("") // 发往后端服务器的健康检查请求的Host头域，例如”localhost”，默认为空，当健康检查协议为HTTP时生效，非必需
7            .healthCheckIntervalInSecond(2) // 健康检查间隔（单位：秒），默认为3，需为1-10间的整数，非必需
8            .healthCheckNormalStatus("") // 健康检查正常时的HTTP状态码，支持5类状态码的组合，例如”http_1xx http_2xx”。当健康检查协议为HTTP时生效，非必需
9            .healthCheckPort(8030) // 健康检查端口，IP组协议为HTTP协议时必传，非必需
10            .healthCheckTimeoutInSecond(20) // 健康检查超时（单位：秒），默认为3，需为1-60间的整数，非必需
11            .healthCheckUpRetry(2) // 健康阈值，即连续多少次健康检查成功后，重新将该后端服务器置为可用。默认为3，需为2-5间的整数，非必需
12            .healthCheckUrlPath("") // 健康检查路径，默认/，当健康检查协议为HTTP时生效，非必需
13            .port(8014) // 端口号，需为1-65535间的整数，非必需
14            .sgId("svg-lkxlymix") // 服务器组ID，必需
15            .type("TCP") // 服务器组端口类型，TCP、HTTP、UDP，必需
16            .udpHealthCheckString("") // UDP健康检查字符串，当健康检查协议为UDP时必传，非必需
17            .build();
18    CreateBecAppBlbServerGroupPortResponse response = client.createBecAppBlbServerGroupPortV2(request);
19}

1public void updateBecAppBlbServerGroupPortV2(BecClient client) {
2    UpdateBecAppBlbServerGroupPortRequest request = UpdateBecAppBlbServerGroupPortRequest.builder()
3            .blbId("applb-cn-baoding-ct-9iixorq5") // blbId，必需
4            .healthCheckDownRetry(3) // 不健康阈值，即连续多少次健康检查失败后，屏蔽该后端服务器。默认为3，需为2-5间的整数，非必需
5            .healthCheckHost("") // 发往后端服务器的健康检查请求的Host头域，例如”localhost”，默认为空，当健康检查协议为HTTP时生效，非必需
6            .healthCheckIntervalInSecond(2) // 健康检查间隔（单位：秒），默认为3，需为1-10间的整数，非必需
7            .healthCheckNormalStatus("") // 健康检查正常时的HTTP状态码，支持5类状态码的组合，例如”http_1xx http_2xx”。当健康检查协议为HTTP时生效，非必需
8            .healthCheckTimeoutInSecond(34) // 健康检查超时（单位：秒），默认为3，需为1-60间的整数，非必需
9            .healthCheckUpRetry(2) // 健康阈值，即连续多少次健康检查成功后，重新将该后端服务器置为可用。默认为3，需为2-5间的整数，非必需
10            .healthCheckUrlPath("") // 健康检查路径，默认/，当健康检查协议为HTTP时生效，非必需
11            .portId("port-x9zxwcgn") // 服务器组端口ID，必需
12            .sgId("svg-lkxlymix") // 服务器组ID，必需
13            .udpHealthCheckString("") // UDP健康检查字符串，当健康检查协议为UDP时必传，非必需
14            .build();
15    UpdateBecAppBlbServerGroupPortResponse response = client.updateBecAppBlbServerGroupPortV2(request);
16}

1public void deleteBecAppBlbServerGroupPortV2(BecClient client) {
2    DeleteBecAppBlbServerGroupPortRequest request = DeleteBecAppBlbServerGroupPortRequest.builder()
3            .blbId("applb-cn-baoding-ct-9iixorq5") // blbId，必需
4            .portIdList(Arrays.asList("port-x9zxwcgn")) // 服务器组端口ID列表，必需
5            .sgId("svg-lkxlymix") // 服务器组ID，必需
6            .build();
7    DeleteBecAppBlbServerGroupPortResponse response = client.deleteBecAppBlbServerGroupPortV2(request);
8}

1public void createBecAppBlbServerGroupMemberV2(BecClient client) {
2    BackendServerReq backendServerReq = new BackendServerReq();
3    backendServerReq.setInstanceId("vm-hj4tcvq4-cn-baoding-ct-ingmp"); // 实例ID，必需
4    backendServerReq.setWeight(20); // 权重，取值范围0~100，必需
5    CreateBecAppBlbServerGroupMemberRequest request = CreateBecAppBlbServerGroupMemberRequest.builder()
6            .blbId("applb-cn-baoding-ct-9iixorq5") // blbId，必需
7            .backendServerList(Collections.singletonList(backendServerReq)) // 服务器组成员列表，必需
8            .sgId("svg-lkxlymix") // 服务器组ID，必需
9            .build();
10    CreateBecAppBlbServerGroupMemberResponse response = client.createBecAppBlbServerGroupMemberV2(request);
11}

1public void getBecAppBlbServerGroupMembersV2(BecClient client) {
2    ListRequest listRequest = new ListRequest();
3    listRequest.setMarker(""); // 标记查询的起始位置，非必需
4    listRequest.setMaxKeys(10); // 每页包含的最大数量，1-1000，默认1000，非必需
5    GetBecAppBlbServerGroupMembersRequest request = GetBecAppBlbServerGroupMembersRequest.builder()
6            .blbId("applb-cn-baoding-ct-9iixorq5") // blbId，必需
7            .sgId("svg-lkxlymix") // 服务器组ID，必需
8            .listRequest(listRequest)
9            .build();
10    GetBecAppBlbServerGroupMembersResponse response = client.getBecAppBlbServerGroupMembersV2(request);
11}

1public void getBecAppBlbServerGroupUnboundMembersV2(BecClient client) {
2    ListRequest listRequest = new ListRequest();
3    listRequest.setMarker(""); // 标记查询的起始位置，非必需
4    listRequest.setMaxKeys(10); // 每页包含的最大数量，1-1000，默认1000，非必需
5
6    GetBecAppBlbServerGroupUnmountedMembersRequest request = GetBecAppBlbServerGroupUnmountedMembersRequest.builder()
7            .blbId("applb-cn-baoding-ct-9iixorq5") // blbId，必需
8            .sgId("svg-lkxlymix") // 服务器组ID，必需
9            .listRequest(listRequest)
10            .build();
11
12    GetBecAppBlbServerGroupUnmountedMembersResponse response = client.getBecAppBlbServerGroupUnboundMembersV2(request);
13}

1public void getBecAppBlbServerGroupMountedMembersV2(BecClient client) {
2    ListRequest listRequest = new ListRequest();
3    listRequest.setMarker(""); // 标记查询的起始位置，非必需
4    listRequest.setMaxKeys(10); // 每页包含的最大数量，1-1000，默认1000，非必需
5    GetBecAppBlbServerGroupMountedMembersRequest request = GetBecAppBlbServerGroupMountedMembersRequest.builder()
6            .blbId("applb-cn-baoding-ct-9iixorq5") // blbId，必需
7            .sgId("svg-lkxlymix") // 服务器组ID，必需
8            .listRequest(listRequest)
9            .build();
10    GetBecAppBlbServerGroupMountedMembersResponse response = client.getBecAppBlbServerGroupMountedMembersV2(request);
11}

1public void updateBecAppBlbServerGroupMembersV2(BecClient client) {
2    BackendServerReq backendServerReq = new BackendServerReq();
3    backendServerReq.setInstanceId("vm-hj4tcvq4-cn-baoding-ct-ingmp"); // 实例ID，必需
4    backendServerReq.setWeight(40); // 权重，取值范围0~100，必需
5    UpdateBecAppBlbServerGroupMembersRequest request = UpdateBecAppBlbServerGroupMembersRequest.builder()
6            .blbId("applb-cn-baoding-ct-9iixorq5") // blbId，必需
7            .backendServerList(Arrays.asList(backendServerReq)) // 服务器组成员列表，必需
8            .sgId("svg-lkxlymix") // 服务器组ID，必需
9            .build();
10    UpdateBecAppBlbServerGroupMembersResponse response = client.updateBecAppBlbServerGroupMembersV2(request);
11}

1public void deleteBecAppBlbServerGroupMembersV2(BecClient client) {
2    DeleteBecAppBlbServerGroupMembersRequest request = DeleteBecAppBlbServerGroupMembersRequest.builder()
3            .blbId("applb-cn-baoding-ct-9iixorq5") // blbId，必需
4            .sgId("svg-lkxlymix") // 服务器组ID，必需
5            .backendServerIdList(Arrays.asList("vm-hj4tcvq4-cn-baoding-ct-ingmp")) // 服务器组成员ID列表，必需
6            .build();
7    DeleteBecAppBlbServerGroupMembersResponse response = client.deleteBecAppBlbServerGroupMembersV2(request);
8}