重新定义cloud 第10章基础综合案例和推荐配置.md

今天药忘吃喽~ 2022-12-05 15:18 140阅读 0赞

*  注册中心 eureka
 *  配置中心 Spring Cloud Config
 *  Api网关 Zuul
 *  客户负载均衡 Ribbon
 *  断路器 Hystrix 。Hystrix dashboard turbine
 *  用户服务 sc-user-service
 *  数据服务 sc-data-service

# saas 和 paas #

*  *SaaS*，是Software-as-a-Service的缩写名称，意思为软件即服务，即通过网络提供软件服务。
 *  *PaaS*是（Platform as a Service）的缩写，是指平台即服务。 把服务器平台作为一种服务提供的商业模式，通过网络进行程序提供的服务称之为SaaS(Software as a Service)

# consumer：user-service #

## xml ##

<dependencies>
            <dependency> //引用公共的依赖
    			<groupId>cn.springcloud.book</groupId>
    			 <artifactId>ch10-1-common</artifactId>
    			 <version>${parent.version}</version>
            </dependency>
            <dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    		</dependency>
             <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-config-client</artifactId>
            </dependency>
    
        </dependencies>

## action ##

@RestCodntroller
    public class UserController { 
    
    	@Autowired
    	private IUserService userService;
    	
    	/** * 获取配置文件中系统默认用户 * @return */
        @GetMapping("/getDefaultUser")
        public String getDefaultUser(){ 
            return userService.getDefaultUser();
        }
        
        /** * 获取上下文用户 * @return */
        @GetMapping("/getContextUserId")
        public String getContextUserId(){ 
            return userService.getContextUserId();
        }
        
        /** * 获取供应商数据 * @return */
        @GetMapping("/getProviderData")
        public List<String> getProviderData(){ 
            return userService.getProviderData();
        }
    }

## service ##

@Component
    public class UserService implements IUserService{ 
    	
        @Autowired
        private DataService dataService;
        
        @Autowired
        private RestTemplate restTemplate;
        
    	@Override
    	public String getDefaultUser() { 
    		return dataService.getDefaultUser();
    	}
    
    	@Override
    	public String getContextUserId() { 
    		return dataService.getContextUserId();
    	}
    
    	@Override
    	public List<String> getProviderData() { 
    		List<String> result = restTemplate.getForObject("http://sc-data-service/getProviderData", List.class);
    		return result;
    	}
    }
    
    
    @FeignClient(name = "sc-data-service", fallback=UserClientFallback.class)
    public interface DataService { 
    	
    	@RequestMapping(value = "/getDefaultUser", method = RequestMethod.GET)
        public String getDefaultUser();
        
        @RequestMapping(value = "/getContextUserId", method = RequestMethod.GET)
        public String getContextUserId();
    
    }

# provider: data-service #

## action 和 service ##

@RestController
    public class DataController { 
        
    	@Autowired
    	private DataConfig dataConfig;
    	
        @GetMapping("/getContextUserId")
        public String getContextUserId(){ 
            return UserContextHolder.currentUser().getUserId();
        }
        
        @GetMapping("/getDefaultUser")
        public String getDefaultUser(){ 
            return dataConfig.getDefaultUser();
        }
        
        @GetMapping("/getProviderData")
        public List<String> getProviderData(){ 
        	List<String> provider = new ArrayList<String>();
        	provider.add("Beijing Company");
        	provider.add("Shanghai Company");
        	provider.add("Shenzhen Company");
            return provider;
        }
        
    }
    
    
    
    
    @Component
    @ConfigurationProperties(prefix = "cn.springcloud.book")
    public class DataConfig { 
    
        private String defaultUser;
    
    	public String getDefaultUser() { 
    		return defaultUser;
    	}
    
    	public void setDefaultUser(String defaultUser) { 
    		this.defaultUser = defaultUser;
    	}
        
    }

## ThreadLocal 配置 ##

public class UserContextHolder { 
    	
    	public static ThreadLocal<User> context = new ThreadLocal<User>();
    	
    	public static User currentUser() { 
    		return context.get();
    	}
    
    	public static void set(User user) { 
    		context.set(user);
    	}
    
    	public static void shutdown() { 
    		context.remove();
    	}
    }

public class UserContextInterceptor implements HandlerInterceptor
    pre方法中：	UserContextHolder.set(user);

# 网关 #

*  鉴权 filter

/** * 鉴权filter */
    public class AuthFilter extends ZuulFilter { 
    	private static final Logger logger = LoggerFactory.getLogger(AuthFilter.class);
    	
    	@Override
    	public boolean shouldFilter() { 
    		// 判断是否需要进行处理
    		return true;
    	}
    
    	@Override
    	public Object run() { 
    		RequestContext rc = RequestContext.getCurrentContext();
    		authUser(rc);
    		return null;
    	}
    
    	@Override
    	public String filterType() { 
    		return "pre";
    	}
    
    	@Override
    	public int filterOrder() { 
    		return 0;
    	}
    	
    	private static Map<String, String> httpRequestToMap(HttpServletRequest request) { 
            Enumeration<String> headerNames = request.getHeaderNames();
            Map<String, String> headers = new HashMap<>();
            while (headerNames.hasMoreElements()) { 
                String headerName = headerNames.nextElement();
                headers.put(headerName, request.getHeader(headerName));
            }
            return headers;
        }
    	
    	public static void authUser(RequestContext ctx) { 
    		HttpServletRequest request = ctx.getRequest();
    		Map<String, String> header = httpRequestToMap(request);
    		String userId = header.get(User.CONTEXT_KEY_USERID);
    		if(StringUtils.isEmpty(userId)) { 
    			try { 
    				BaseException BaseException = new BaseException(CommonError.AUTH_EMPTY_ERROR.getCode(),CommonError.AUTH_EMPTY_ERROR.getCodeEn(),CommonError.AUTH_EMPTY_ERROR.getMessage(),1L);
    				BaseExceptionBody errorBody = new BaseExceptionBody(BaseException);
    				ctx.setSendZuulResponse(false);
    				ctx.setResponseStatusCode(401);
    				ctx.setResponseBody(JSONObject.toJSON(errorBody).toString());
    			} catch (Exception e) { 
    				logger.error("println message error",e);
    			}
    		}else { 
    			for (Map.Entry<String, String> entry : header.entrySet()) { 
    				ctx.addZuulRequestHeader(entry.getKey(), entry.getValue());
    			}
    		}
    	}
    	
    }

*  http://localhost:7777/sc-user-service/getContextUserId
 *

# 实战扩展 #

## 用户上下文对象传递 ##

#### User类 ####

public class User implements Serializable { 
    	private static final long serialVersionUID = -4083327605430665846L;
    	public final static String CONTEXT_KEY_USERID = "x-customs-user";
    
    	/** * 用户ID */
    	private String userId;
    	
    	private String userName;
    
    	public User() { 
    	}
    
    	public User(Map<String, String> headers) { 
    		userId = headers.get(CONTEXT_KEY_USERID);
    	}
    	
    
    	/** * 将user对象转换成为http对象头 * @return http头键值对 */
    	public Map<String, String> toHttpHeaders() { 
    		Map<String, String> headers = new HashMap<>();
    		headers.put(CONTEXT_KEY_USERID,userId);
    		return headers;
    	}
    
    }

### feign拦截器 ###

public class FeignUserContextInterceptor implements RequestInterceptor { 
    
    	@Override
    	public void apply(RequestTemplate template) { 
    // User user = UserContextHolder.currentUser();
    		ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();//上下文获取到 servlet request 属性
    		HttpServletRequest request = attributes.getRequest();//获取 HttpServletRequest
            
            Enumeration<String> headerNames = request.getHeaderNames();//获取所有的hader头
            
            if (headerNames != null) { 
                while (headerNames.hasMoreElements()) { 
                    String name = headerNames.nextElement();
                    String values = request.getHeader(name);
                    template.header(name, values);
                }
            }
    
    	}
    }
    
    
    public class UserContextHolder { 
    	public static ThreadLocal<User> context = new ThreadLocal<User>();
    	
    	public static User currentUser() { 
    		return context.get();
    	}
    
    	public static void set(User user) { 
    		context.set(user);
    	}
    
    	public static void shutdown() { 
    		context.remove();
    	}
    }

### RestTemplate ###

*  RestTemplate 进行服务间调用 时会拦截到 请求，将用户属性放到 hearder里

public class RestTemplateUserContextInterceptor implements ClientHttpRequestInterceptor { 
    
    	@Override
    	public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)
    			throws IOException { 
    		User user = UserContextHolder.currentUser();
    		Map<String, String> headers = user.toHttpHeaders();
    		for (Map.Entry<String, String> header : headers.entrySet()) { 
    			request.getHeaders().add(header.getKey(), header.getValue());
    		}
    		// 调用
    		return execution.execute(request, body);
    	}
    }

### UserContextInterceptor ###

public class UserContextInterceptor implements HandlerInterceptor { 
    	private static final Logger log = LoggerFactory.getLogger(UserContextInterceptor.class);
    	
    	@Override
    	public boolean preHandle(HttpServletRequest request, HttpServletResponse respone, Object arg2) throws Exception { 
    		User user = new User(HttpConvertUtil.httpRequestToMap(request));
    		if(StringUtils.isEmpty(user.getUserId()) && StringUtils.isEmpty(user.getUserName())) { 
    			log.error("the user is null, please access from gateway or check user info");
    			return false;
    		}
    		UserContextHolder.set(user);
    		return true;
    	}
    
    	@Override
    	public void postHandle(HttpServletRequest request, HttpServletResponse respone, Object arg2, ModelAndView arg3)
    			throws Exception { 
    		// DOING NOTHING
    	}
    
    	@Override
    	public void afterCompletion(HttpServletRequest request, HttpServletResponse respone, Object arg2, Exception arg3)
    			throws Exception { 
    		UserContextHolder.shutdown();
    	}
    }
    
    
    
    public class HttpConvertUtil { 
    
        /** * convert the httpServletRequest headers to headers map * @param request * @return */
        public static Map<String, String> httpRequestToMap(HttpServletRequest request) { 
            Enumeration<String> headerNames = request.getHeaderNames();
            Map<String, String> headers = new HashMap<>();
            while (headerNames.hasMoreElements()) { 
                String headerName = headerNames.nextElement();
                headers.put(headerName, request.getHeader(headerName));
            }
            return headers;
        }
    }

### Hystrix策略 ###

public class SpringCloudHystrixConcurrencyStrategy extends HystrixConcurrencyStrategy { 
        private HystrixConcurrencyStrategy delegateHystrixConcurrencyStrategy;
        
        @Override
        public <T> Callable<T> wrapCallable(Callable<T> callable) { 
            return new HystrixThreadCallable<>(callable, RequestContextHolder.getRequestAttributes(),HystrixThreadLocal.threadLocal.get());
        }
    }

*  ThreadLocal 对象保存用户信息，线程池隔离的模式下，会导致前后线程传递对象丢失。
 *  使用自定义并发策略 HystrixConcurrencyStrategy 即可解决此问题。
 *

### 配置拦截器 ###

@Configuration
    @EnableWebMvc
    public class CommonConfiguration extends WebMvcConfigurerAdapter{ 
    	/** * 请求拦截器 */
    	@Override
        public void addInterceptors(InterceptorRegistry registry) { 
            registry.addInterceptor(new UserContextInterceptor());
        }
    	
        /** * 创建Feign请求拦截器，在发送请求前设置认证的用户上下文信息 */
        @Bean
        @ConditionalOnClass(Feign.class)
        public FeignUserContextInterceptor feignTokenInterceptor() { 
            return new FeignUserContextInterceptor();
        }
    
        /** * RestTemplate拦截器 * @return */
        @LoadBalanced
        @Bean
        public RestTemplate restTemplate() { 
            RestTemplate restTemplate = new RestTemplate();
            restTemplate.getInterceptors().add(new RestTemplateUserContextInterceptor());
            return restTemplate;
        }
        
        @Bean
    	public SpringCloudHystrixConcurrencyStrategy springCloudHystrixConcurrencyStrategy() { 
    		return new SpringCloudHystrixConcurrencyStrategy();
    	}
       
    }

# zuul 的 Fallback 机制 #

*  实现 FallbackProvider接口
 *  老版本 zuulFallbackProvider接口

@Component
    public class ZuulFallback implements FallbackProvider{ 
    
    	@Override
    	public String getRoute() { 
    		return "*"; //可以配置指定的路由，值为serviceId，如sc-user-service
    	}
    
    	@Override
    	public ClientHttpResponse fallbackResponse(String route, Throwable cause) { 
    		 return new ClientHttpResponse() { 
    	            @Override
    	            public HttpStatus getStatusCode() throws IOException { 
    	                return HttpStatus.INTERNAL_SERVER_ERROR;//500
    	            }
    
    	            @Override
    	            public String getStatusText() throws IOException { //错误Internal Server Error
    	                return HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase();
    	            }
    
    	            @Override
    	            public void close() { 
    	            }
    	           
    	            @Override
    	            public InputStream getBody() throws IOException { 
    	            	  //定义自己的错误信息
    	                return new ByteArrayInputStream(("microservice error").getBytes());
    	            }
    
    	            @Override
    	            public HttpHeaders getHeaders() { //application/json
    	                HttpHeaders headers = new HttpHeaders();
    	                headers.setContentType(MediaType.APPLICATION_JSON);
    	                return headers;
    	            }
    
    				@Override
    				public int getRawStatusCode() throws IOException { 
    					// TODO Auto-generated method stub Internal Server Error
    					return HttpStatus.INTERNAL_SERVER_ERROR.value();
    				}
    	        };
    	}
    }

# 生产环境 各个组件参考配置 #

*  底层可以用 httpClient

## eureka 的推荐配置 ##

*  服务端

eureka:
      client:
        serviceUrl:
          defaultZone: http://${ eureka.host:127.0.0.1}:${ eureka.port:8761}/eureka/
          ,http://127.0.0.2:8761/eureka/ #高可用需要配置多个
      instance:
        prefer-ip-address: true #用IP来注册
        #Eureka 客户端，只需要这两个属性就行了。
        
      server:
        enable-self-preservation: false #关闭自我保护，如果规模大，考虑不关闭
        eviction-interval-timer-in-ms: 30000 #主动失效时间，默认60s，设置短一点。

## ribbon推荐配置 ##

*  一般配置全局的，也可以配置单个的
 *  幂等性 或 网络不稳定，默认都不进行重试
 *  查询比较多的，可以开启重试

ribbon:
      ConnectTimeout: 6000 # 全局请求连接 的超时时间，默认2秒
      ReadTimeout: 6000 # 全局请求的超时时间，默认5秒
      MaxAutoRetries: 0 # 对第一次请求的服务的重试次数
      MaxAutoRetriesNextServer: 0 #要重试的下一个服务的最大数量（不包括第一个服务），切换下一个实例 重试次数
      OkToRetryOnAllOperations: false #对所有操作请求 都进行重试。

## hystrix 推荐配置 ##

hystrix:
      threadpool:
        default:
          coreSize: 20 #全局默认 核心线程池大小，默认为10
          maximumSize: 50 #全局默认最大 线程池 大小，默认为10
          maxQueueSize: -1 #
          allowMaximumSizeToDivergeFromCoreSize: true #这里是线程池的配置。允许配置线程池。
      command:
        default:
          execution:
            timeout:
              enabled: false
            isolation:
              thread:
                interruptOnTimeout: false
                timeoutInMilliseconds: 15000 #全局请求连接的超时时间，默认1s，推荐设置为10s

## Zuul 推荐配置 ##

zuul:
      ribbonIsolationStrategy: THREAD #线程池隔离
      threadPool:
        useSeparateThreadPools: true #
        threadPoolKeyPrefix: zuulgateway
      max:
        host:
          max-per-route-connections: 200 
          max-total-connections: 500
      host:
        socket-timeout-millis: 5000
        connect-timeout-millis: 10000