spring-cloud客户端负载均衡(初试)

最新推荐文章于 2024-03-18 19:31:39 发布
最新推荐文章于 2024-03-18 19:31:39 发布
阅读量5.9k 收藏
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hlgyy520/article/details/53641476
版权

目录结构


maven

	<groupId>WeiXinClient</groupId>
	<artifactId>WeiXinClient</artifactId>
	<version>1.0</version>
	<packaging>jar</packaging>

	<name>WeiXinClient</name>
	<description>weixin client of loadbalance</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.4.2.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
			<exclusions>
        		<exclusion>
            		<groupId>org.springframework.boot</groupId>
            		<artifactId>spring-boot-starter-logging</artifactId>
        		</exclusion>
    		</exclusions>
		</dependency>
		<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-log4j2</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-ribbon</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>Brixton.BUILD-SNAPSHOT</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<finalName>weixinclient</finalName>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

	<repositories>
		<repository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<snapshots>
				<enabled>true</enabled>
			</snapshots>
		</repository>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
	</repositories>

application.yml 

spring:
 application:
   name: WeiXinClient

server:
 port: 8999

logging:
 config: classpath:log4j2.xml
 
WeiXinClient:
 ribbon:
  eureka:
   enabled: false
  listOfServers: 172.24.3.64:8080,172.24.3.64:9092
  ServerListRefreshInterval: 15000

log4j2.xml 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE xml>
<!-- Log4j 2.x 配置文件。每30秒自动检查和应用配置文件的更新； -->
<Configuration status="warn" monitorInterval="30" strict="true" schema="Log4J-V2.2.xsd">
    <Appenders>
           <!-- 输出到控制台 -->
           <Console name="Console" target="SYSTEM_OUT">
               <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss,SSS}:%4p %t (%F:%L) - %m%n" />
          </Console>

          <!-- 输出到文件，按天或者超过80MB分割 -->
          <RollingFile name="InfoRollingFile" fileName="/root/logs/weixinclient/info.log"    filePattern="/root/logs/weixinclient/$${date:yyyy-MM-dd}/info-%d{yyyy-MM-dd}-%i.log">
               <!-- 需要记录的级别 -->
               <ThresholdFilter level="INFO"/>
               <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss,SSS}:%4p %t (%F:%L) - %m%n" />
               <Policies>
                    <OnStartupTriggeringPolicy />
                    <TimeBasedTriggeringPolicy />
                    <SizeBasedTriggeringPolicy size="80 MB" />
               </Policies>
          </RollingFile>
          
          <!-- 输出到文件，按天或者超过80MB分割 -->
          <RollingFile name="ErrorRollingFile" fileName="/root/logs/weixinclient/error.log"    filePattern="/root/logs/weixinclient/$${date:yyyy-MM-dd}/error-%d{yyyy-MM-dd}-%i.log">
               <!-- 需要记录的级别 -->
               <ThresholdFilter level="ERROR"/>
               <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss,SSS}:%4p %t (%F:%L) - %m%n" />
               <Policies>
                    <OnStartupTriggeringPolicy />
                    <TimeBasedTriggeringPolicy />
                    <SizeBasedTriggeringPolicy size="80 MB" />
               </Policies>
          </RollingFile>
     </Appenders>
     <Loggers>
          <Root level="info"> <!-- 全局配置 -->
          	<AppenderRef ref="Console" />
          	<AppenderRef ref="InfoRollingFile"/>
          	<AppenderRef ref="ErrorRollingFile"/>
          </Root>
     </Loggers>
</Configuration>

APP.java 

package com.guosen.weixin.client;

import java.nio.charset.Charset;
import java.util.List;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.context.annotation.Bean;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.client.RestTemplate;

/**
 * 发送微信client端
 * 
 * 创建于2016年12月12日
 * @author guosen
 *
 */
@SpringBootApplication
@RibbonClient(name = "WeiXinClient", configuration = WeiXinClientConfiguration.class)
public class App {
	
	@LoadBalanced
	@Bean
	RestTemplate restTemplate() {
		RestTemplate restTemplate = new RestTemplate();
		List<HttpMessageConverter<?>>  converterList = restTemplate.getMessageConverters();
		
		int count = -1;
		for (int i = 0; i < converterList.size(); i++) {
			HttpMessageConverter<?> message = converterList.get(i);
			if (message.getClass() == StringHttpMessageConverter.class) {
				count = i;
				break;
			}
		}
		StringHttpMessageConverter stringConverter = new StringHttpMessageConverter(Charset.forName("UTF-8"));
		converterList.set(count, stringConverter);
		return restTemplate;
	}
	
	
    public static void main( String[] args ){
    	SpringApplication.run(App.class, args);
    }
}

WeiXinClientConfiguration.java 

package com.guosen.weixin.client;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AvailabilityFilteringRule;
import com.netflix.loadbalancer.IPing;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.PingUrl;

public class WeiXinClientConfiguration {
	@Autowired
	IClientConfig ribbonClientConfig;
	
	@Bean
	public IPing ribbonPing(IClientConfig config) {
		return new PingUrl();
	}
	
	@Bean
	public IRule ribbonRule(IClientConfig config) {
		return new AvailabilityFilteringRule();
	}
}

ClientController.java 

package com.guosen.weixin.client;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

@RestController
public class ClientController {
	private static final Logger logger = LoggerFactory.getLogger(ClientController.class);
	@Autowired
	RestTemplate restTemplate;
	/**
	 * 通过get方法发送微信,get请求信息必须包括(touser、toparty、totag)中的一种、agentid、content
	 * @param request
	 * @return
	 */
	@RequestMapping(value = "/send/text/byget", method = RequestMethod.GET)
	public String sendTextByGet(HttpServletRequest request){
		// 消息
		Map<String, Object> map = new HashMap<String, Object>();
		ObjectMapper om = new ObjectMapper();
		Map<String, Object> results = new HashMap<String, Object>();
		String result = "";
		
		String touser = request.getParameter("touser");
		String toparty = request.getParameter("toparty");
		String totag = request.getParameter("totag");
		String agentid = request.getParameter("agentid");
		String content = request.getParameter("content");
		
		if ((null == touser || "".equals(touser)) && (null == toparty || "".equals(toparty)) && (null == totag || "".equals(totag))) {
			results.put("errcode", 9999);
			results.put("errmsg", "touser、toparty、totag必须选填一个");
			try {
				result = om.writeValueAsString(results);
			} catch (JsonProcessingException e) {
				e.printStackTrace();
			}
			return result;
		}
		
		boolean formatFlag = false;
		int agent = 0;
		try {
			agent = Integer.parseInt(agentid);
			formatFlag = true;
		} catch (NumberFormatException e2) {
			e2.printStackTrace();
		}
		if (null == agentid || "".equals(agentid) || !formatFlag) {
			results.put("errcode", 9999);
			results.put("errmsg", "agentid不能为空,并且为数字");
			try {
				result = om.writeValueAsString(results);
			} catch (JsonProcessingException e) {
				e.printStackTrace();
			}
			return result;
		}
		
		if (null == content || "".equals(content)) {
			results.put("errcode", 9999);
			results.put("errmsg", "content不能为空,并且必填");
			try {
				result = om.writeValueAsString(results);
			} catch (JsonProcessingException e) {
				e.printStackTrace();
			}
			return result;
		}
		
		Map<String, String> cmap = new HashMap<String, String>();
		cmap.put("content", content);
		map.put("safe", 0);
		map.put("msgtype", "text");
		map.put("agentid", agent);
		map.put("text", cmap);
		if (null != touser && !"".equals(touser)) {
			map.put("touser", touser);
		}
		if (null != toparty && !"".equals(toparty)) {
			map.put("toparty", toparty);
		}
		if (null != totag && !"".equals(totag)) {
			map.put("totag", totag);
		}
		
		// 将参数map转换为json对象并且请求发送服务
		try {
			String data = om.writeValueAsString(map);
			logger.info(data);
			result = this.restTemplate.postForObject("http://WeiXinClient/sendText", data, String.class);
		} catch (Exception e) {
			logger.error("发送微信信息异常", e);
			results.put("errcode", 9999);
			results.put("errmsg", e.getMessage());
			try {
				result = om.writeValueAsString(results);
			} catch (JsonProcessingException e1) {
				e1.printStackTrace();
			}
		}
		return result;
	}
	
	/**
	 * 通过post json字符串的方式发送微信,post内容为{"touser":"xxx|xxx","content":"xxx","agentid":xx} 其中touser可以改为toparty、totag
	 * @param requestData
	 * @return
	 */
	@SuppressWarnings("unchecked")
	@RequestMapping(value = "/send/text/bypost", method = RequestMethod.POST)
	public String sendTextByPost(@RequestBody String requestData){
		// 消息
		ObjectMapper om = new ObjectMapper();
		Map<String, Object> results = new HashMap<String, Object>();
		String result = "";
		
		// 将参数map转换为json对象并且请求发送服务
		try {
			Map<String, Object> requestMap = om.readValue(requestData, Map.class);
			requestMap.put("safe", 0);
			requestMap.put("msgtype", "text");
			Map<String, String> cmap = new HashMap<String, String>();
			cmap.put("content", (String)requestMap.get("content"));
			requestMap.put("text", cmap);
			requestMap.remove("content");
			String data = om.writeValueAsString(requestMap);
			
			result = this.restTemplate.postForObject("http://WeiXinClient/sendText", data, String.class);
		} catch (Exception e) {
			logger.error("发送微信信息异常", e);
			results.put("errcode", 9999);
			results.put("errmsg", e.getMessage());
			try {
				result = om.writeValueAsString(results);
			} catch (JsonProcessingException e1) {
				e1.printStackTrace();
			}
		}
		return result;
	}
	
	/**
	 * 通过post字符串的方式发送微信,post内容为content=xxxx&agentid=xxx&touser=xxx
	 * @param content
	 * @param touser
	 * @param agentid
	 * @return
	 */
	@RequestMapping(value = "/entp", method = RequestMethod.POST)
	public String sendText(String content, String touser, String agentid){
		// 消息
		ObjectMapper om = new ObjectMapper();
		Map<String, Object> results = new HashMap<String, Object>();
		String result = "";
		
		// 将参数map转换为json对象并且请求发送服务
		try {
			Map<String, Object> requestMap = new HashMap<String, Object>();
			requestMap.put("safe", 0);
			requestMap.put("msgtype", "text");
			Map<String, String> cmap = new HashMap<String, String>();
			cmap.put("content", content);
			requestMap.put("text", cmap);
			requestMap.put("touser", touser);
			requestMap.put("agentid", agentid);
			String data = om.writeValueAsString(requestMap);
			result = this.restTemplate.postForObject("http://WeiXinClient/sendText", data, String.class);
		} catch (Exception e) {
			logger.error("发送微信信息异常", e);
			results.put("errcode", 9999);
			results.put("errmsg", e.getMessage());
			try {
				result = om.writeValueAsString(results);
			} catch (JsonProcessingException e1) {
				e1.printStackTrace();
			}
		}
		return result;
	}
}


guoyayun2000
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
73-Spring Cloud客户端负载均衡Ribbon笔记1
08-08
Ribbon负载均衡机制Ribbon实现了客户端的负载均衡，调用服务使用的是用@LoadBalanced的RestTemplate：通过对其跟踪，定位到Load
SpringCloud之负载均衡详解
weixin_45717638的博客
09-05 1万+
SpringCloud之负载均衡详解 1.简介 1.1 什么是负载均衡（进程内LB） Load balancing，即负载均衡，是一种计算机技术，用来在多个计算机（计算机集群）、网络连接、CPU、磁盘驱动器或其他资源中分配负载，以达到最优化资源使用、最大化吞吐率、最小化响应时间、同时避免过载的目的。 1.2 为什么需要负载均衡 在分布式微服务架构中，往往有多个服务的提供者者注册在多个注册中心里，这个时候消费者需要使用服务时，决定由哪一个注册中心所在的服务提供者提供服务就是负载均衡。（也就是进程内LB，注：本
Spring Cloud 中 7 种负载均衡策略！
m0_71777195的博客
02-14 1836
Ribbon 是 Spring Cloud 技术栈中非常重要的基础框架，它为 Spring Cloud 提供了负载均衡的能力，比如 Fegin 和 OpenFegin 都是基于 Ribbon 实现的，就连 Nacos 中的负载均衡也使用了 Ribbon 框架。Ribbon 框架的强大之处在于，它不仅内置了 7 种负载均衡策略，同时还支持用户自定义负载均衡策略，所以其开放性和便利性也是它得以流行的主要原因。
SpringCloudLoadBalancer入门与实战系列
最新发布
qq_63218110的博客
03-18 966
本篇介绍了SpringCloudLoadBalancer的概念以及两种负载均衡策略。其实从源码角度解析了默认的轮询策略，以及如何实现随机负载均衡策略和Nacos的权重负载均衡策略，最后实现了自定义的负载均衡策略以及介绍了SpringCloudLoadBalancer的缓存机制。
Spring Cloud Loadbalancer (二) 如何实现LoadBalancerClient
huachangzai的博客
01-02 2743
RestTemplate 负载均衡最终是委托给了 LoadBalancerClient 去实现，核心逻辑是依靠 serviceId 去获取 ServiceInstance。为了达到灵活配置的作用，引入了 NamedContextFactory，为每个 serviceId 分配了一个子容器，每个子容器都拥有 ReactorLoadBalancer 的实现。ReactorLoadBalancer 才是真正实现负载均衡策略的地方。
3种方案扩展RestTemplate让其具备负载均衡
coolcooldeteng的博客
09-06 1938
实现负载均衡的多种思路 文章摘自公众号SpringBoot 方便查找
Spring Cloud微服务之loadbalancer负载平衡
play_big_knife的博客
12-12 2655
spring cloud微服务技术之负载平衡。负载平衡也是微服务中最重要的技术之一，无论是从理论还是技术实现，都需要形象的理解和实战的体会。这里从通俗的方法理解理论，并且从基本的实现方法实现其load balance的使用。
spring-cloud-loadbalancer:负载均衡器实现的探索性回购。 现在是spring-cloud-commons的一部分
05-01
Spring Cloud作为两个库提供了更多库：Spring Cloud Context和Spring Cloud Commons。 Spring Cloud Context为Spring Cloud应用程序的ApplicationContext （引导程序上下文，加密，刷新作用域和环境端点）提供实用...
SpringCloud微服务-客户端负载Ribbon
02-24
什么是客户端负载我们在做服务集群的时候，经常会听到负载均衡这个词，比如下图的一个架构：客户端在访问服务器的时候，中间一般会用一些硬件（F5）或软件（nginx）来作负载均衡，从而实现后端各服务器分摊请求压力...
SpringCloud客户端的负载均衡Ribbon的实现
08-27
微服务架构，不可避免的存在单个微服务有多个实例，这篇文章主要介绍了SpringCloud客户端的负载均衡Ribbon的实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring-cloud-netflix-hystrix应用
02-19
spring-cloud-netflix-hystrix应用
SpringBoot使用RestTemplate示例(微服务中多实例、负载均衡服务)
Be_insighted的博客
09-20 607
常用方法 构造URI @SpringBootApplication @Slf4j public class CustomerServiceApplication implements ApplicationRunner { @Autowired private RestTemplate restTemplate; public static void main(String[] args) { new SpringApplicationBuilder() ...
Spring Cloud 微服务架构--LoadBalancerClient--Feign)
m0_48102416的博客
02-27 3370
服务注负载均衡设计与实践 业务描述 一个服务实例可以处理请求是有限的,假如服务实例的并发访问比较大,我们会启动多个服务实例,让这些服务实例采用一定策略均衡(轮询,权重,随机,hash等)的处理并发请求 LoadBalancerClient应用 LoadBalancerClient对象可以从nacos中基于服务名获取服务实例，然后在工程中基于特点算法实现负载均衡方式的调用，案例实现如下： 第一步：修改ConsumerController类,注入LoadBalancerClient对象,并添加doRestEch
SpringCloud————客户端负载均衡
weixin_38910645的博客
02-25 433
负载均衡：是在处理高并发、网络压力和进行服务器扩容的重要手段之一。它可以将请求按照一定的规则分配到不同的服务器。
SpringCloud Ribbon负载均衡 + OpenFeign远程HTTP调用用法与原理
热门推荐
张维鹏的博客
02-14 2万+
openFeign 作为微服务架构下服务间调用的解决方案，是一种声明式、模板化的 HTTP 的模板，使 HTTP 请求就像调用本地方法一样，通过 openFeign 可以替代基于 RestTemplate 的远程服务调用，并且默认集成了 Ribbon 进行负载均衡。目标是减少 HTTP API 的复杂性，希望能将 HTTP 远程服务调用做到像 RPC 一样易用。...
SpringCloud集成LoadBalance，负载均衡
09-12 2033
前一篇文章《SpringCloud集成OpenFeign，轻松RPC》给大家介绍了，如何在SpringCloud的开发中集成OpenFeign，去实现RPC的调用， 这个知识点是作为SpringCloud的开发中最常用的技巧，作为使用SpringCloud进行微服务开发的朋友一定要熟练的操作；同时，通过SpringCloud的OpenFeign调用也就真正拉开了微服务开发的序幕，通过OpenFeign就可以把我们多个不同的SpringBoot的微服务实现，集成在一个微服务的云环境里面了；
一文详解 Spring Cloud 负载均衡！
m0_73311735的博客
02-07 1162
本篇深入讲解了 Spring Cloud 微服务中 负载均衡组件 Ribbon 架构原理，分为几大块：Ribbon 的六大核心组件Ribbon 如何拦截请求并进行转发的。Ribbon 初始化的原理。Ribbon 如何同步 Eureka 注册表的原理。Eureka 和 Ribbon 两种 心跳检测的原理Ribbon 的常用配置项。
自定义实现restTemplate负载均衡功能
qq_62408075的博客
11-17 97
注解上加上@Qualifier注解，然后注入字段的时候加上这个自定义注解，则之后注入使用这个注解的bean。如下面的代码，只会注入标了EnableLoadBalance注解的resttemplate。resttemplate执行的时候有很多拦截器，我们可以加入拦截器修改执行方法。创建拦截器LoadBalancerInterceptor。创建配置类RestTemplateProcessor。创建注解EnableLoadBalance。实现一个随机规则RandomRule。创建规则接口Rule。
【SpringCloud之LoadBalancer】学习笔记+操作步骤（基础版）
qq_35852228的博客
10-09 1654
使用Spring Cloud LoadBalancer进行负载均衡操作，利用了RestTemplate，本文是学习笔记！
spring-cloud-starter-openfeign里面自带负载均衡
07-28
是的，spring-cloud-starter-openfeign包含了负载均衡功能。具体来说，OpenFeign是一个声明式的Web服务客户端，它集成了Ribbon负载均衡器。通过使用OpenFeign，您可以轻松地定义和调用其他微服务的API，并且...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值