专栏首页邢成的架构笔记Spring Boot2.0 Oauth2 服务器和客户端配置及原理

Spring Boot2.0 Oauth2 服务器和客户端配置及原理

一、应用场景

为了理解OAuth的适用场合,让我举一个假设的例子。

有一个"云冲印"的网站,可以将用户储存在Google的照片,冲印出来。用户为了使用该服务,必须让"云冲印"读取自己储存在Google上的照片。

问题是只有得到用户的授权,Google才会同意"云冲印"读取这些照片。那么,"云冲印"怎样获得用户的授权呢?

传统方法是,用户将自己的Google用户名和密码,告诉"云冲印",后者就可以读取用户的照片了。这样的做法有以下几个严重的缺点。

  1. "云冲印"为了后续的服务,会保存用户的密码,这样很不安全。
  2. Google不得不部署密码登录,而我们知道,单纯的密码登录并不安全。
  3. "云冲印"拥有了获取用户储存在Google所有资料的权力,用户没法限制"云冲印"获得授权的范围和有效期。
  4. 用户只有修改密码,才能收回赋予"云冲印"的权力。但是这样做,会使得其他所有获得用户授权的第三方应用程序全部失效。
  5. 只要有一个第三方应用程序被破解,就会导致用户密码泄漏,以及所有被密码保护的数据泄漏。

 OAuth就是为了解决上面这些问题而诞生的。

二、名词定义

在详细讲解OAuth 2.0之前,需要了解几个专用名词。它们对读懂后面的讲解,尤其是几张图,至关重要。

  • Third-party application:第三方应用程序,本文中又称"客户端"(client),即上一节例子中的"云冲印"。
  • HTTP service:HTTP服务提供商,本文中简称"服务提供商",即上一节例子中的Google。
  • Resource Owner:资源所有者,本文中又称"用户"(user)。
  • User Agent:用户代理,本文中就是指浏览器。
  • Authorization server:认证服务器,即服务提供商专门用来处理认证的服务器。
  • Resource server:资源服务器,即服务提供商存放用户生成的资源的服务器。它与认证服务器,可以是同一台服务器,也可以是不同的服务器。  

知道了上面这些名词,就不难理解,OAuth的作用就是让"客户端"安全可控地获取"用户"的授权,与"服务商提供商"进行互动。

三、OAuth的思路

OAuth在"客户端"与"服务提供商"之间,设置了一个授权层(authorization layer)。"客户端"不能直接登录"服务提供商",只能登录授权层,以此将用户与客户端区分开来。"客户端"登录授权层所用的令牌(token),与用户的密码不同。用户可以在登录的时候,指定授权层令牌的权限范围和有效期。

"客户端"登录授权层以后,"服务提供商"根据令牌的权限范围和有效期,向"客户端"开放用户储存的资料。

四、客户端的授权模式

客户端必须得到用户的授权(authorization grant),才能获得令牌(access token)。OAuth 2.0定义了四种授权方式。

  • 授权码模式(authorization code)
  • 简化模式(implicit)
  • 密码模式(resource owner password credentials)
  • 客户端模式(client credentials)

五、授权码模式

授权码模式(authorization code)是功能最完整、流程最严密的授权模式。它的特点就是通过客户端的后台服务器,与"服务提供商"的认证服务器进行互动。

它的步骤如下:

(A)用户访问客户端,后者将前者导向认证服务器。 (B)用户选择是否给予客户端授权。 (C)假设用户给予授权,认证服务器将用户导向客户端事先指定的"重定向URI"(redirection URI),同时附上一个授权码。 (D)客户端收到授权码,附上早先的"重定向URI",向认证服务器申请令牌。这一步是在客户端的后台的服务器上完成的,对用户不可见。 (E)认证服务器核对了授权码和重定向URI,确认无误后,向客户端发送访问令牌(access token)和更新令牌(refresh token)。

六、简化模式

简化模式(implicit grant type)不通过第三方应用程序的服务器,直接在浏览器中向认证服务器申请令牌,跳过了"授权码"这个步骤,因此得名。所有步骤在浏览器中完成,令牌对访问者是可见的,且客户端不需要认证。

它的步骤如下:

(A)客户端将用户导向认证服务器。

(B)用户决定是否给于客户端授权。

(C)假设用户给予授权,认证服务器将用户导向客户端指定的"重定向URI",并在URI的Hash部分包含了访问令牌。

(D)浏览器向资源服务器发出请求,其中不包括上一步收到的Hash值。

(E)资源服务器返回一个网页,其中包含的代码可以获取Hash值中的令牌。

(F)浏览器执行上一步获得的脚本,提取出令牌。

(G)浏览器将令牌发给客户端。

七、密码模式

密码模式(Resource Owner Password Credentials Grant)中,用户向客户端提供自己的用户名和密码。客户端使用这些信息,向"服务商提供商"索要授权。

在这种模式中,用户必须把自己的密码给客户端,但是客户端不得储存密码。这通常用在用户对客户端高度信任的情况下,比如客户端是操作系统的一部分,或者由一个著名公司出品。而认证服务器只有在其他授权模式无法执行的情况下,才能考虑使用这种模式。

它的步骤如下:

(A)用户向客户端提供用户名和密码。

(B)客户端将用户名和密码发给认证服务器,向后者请求令牌。

(C)认证服务器确认无误后,向客户端提供访问令牌。

八、客户端模式

客户端模式(Client Credentials Grant)指客户端以自己的名义,而不是以用户的名义,向"服务提供商"进行认证。严格地说,客户端模式并不属于OAuth框架所要解决的问题。在这种模式中,用户直接向客户端注册,客户端以自己的名义要求"服务提供商"提供服务,其实不存在授权问题。

它的步骤如下:

(A)客户端向认证服务器进行身份认证,并要求一个访问令牌。

(B)认证服务器确认无误后,向客户端提供访问令牌。

九、更新令牌

如果用户访问的时候,客户端的"访问令牌"已经过期,则需要使用"更新令牌"申请一个新的访问令牌。

客户端发出更新令牌的HTTP请求,包含以下参数:

  • granttype:表示使用的授权模式,此处的值固定为"refreshtoken",必选项。
  • refresh_token:表示早前收到的更新令牌,必选项。
  • scope:表示申请的授权范围,不可以超出上一次申请的范围,如果省略该参数,则表示与上一次一致。

十、client_credentials代码示范

首先引入主要jar包:

 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
     <groupId>org.springframework.security.oauth</groupId>
     <artifactId>spring-security-oauth2</artifactId>
     <version>2.3.3.RELEASE</version>
</dependency>
<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
     <groupId>org.springframework.data</groupId>
     <artifactId>spring-data-redis</artifactId>
</dependency>
<dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
     <version>2.9.0</version>
</dependency>

下面配置获取token的配置文件:

package cn.chinotan.config.oauth;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.store.redis.RedisTokenStore;

/**
 * @program: test
 * @description: OAuth2服务配置
 * @author: xingcheng
 * @create: 2018-12-01 16:27
 **/
@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    @Qualifier("authenticationManagerBean")
    private AuthenticationManager authenticationManager ;

    @Autowired
    private RedisConnectionFactory connectionFactory;

    @Bean
    public RedisTokenStore tokenStore() {
        // redis 存储token,方便集群部署
        return new RedisTokenStore(connectionFactory);
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints
                .authenticationManager(authenticationManager) // 配置认证管理器
                .tokenStore(tokenStore()); // 使用redis进行token存储
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security
                .tokenKeyAccess("permitAll()") 
                .checkTokenAccess("isAuthenticated()")
                .allowFormAuthenticationForClients(); // 允许表单认证
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("start_test_two") // 获取token的客户端id
                .secret("start_test_two") // 获取token密钥
                .scopes("start_test_two") // 资源范围
                .authorizedGrantTypes("client_credentials", "password", "refresh_token") // 授权类型
                .resourceIds("oauth2-resource") // 资源id
                .accessTokenValiditySeconds(120); // token 有效时间
    }
}

其中,RedisTokenStore这个是基于Redis的实现,令牌(Access Token)会保存到Redis中,需要配置Redis的连接服务

# Redis数据库索引(默认为0)
spring.redis.database: 0
# Redis服务器地址
spring.redis.host: 127.0.0.1
# Redis服务器连接端口
spring.redis.port: 6379
# Redis服务器连接密码(默认为空)
spring.redis.password: 
# 连接池最大连接数(使用负值表示没有限制)
spring.redis.pool.max-active: 8
# 连接池最大阻塞等待时间(使用负值表示没有限制)
spring.redis.pool.max-wait: -1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle: 8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle: 0
# 连接超时时间(毫秒)
spring.redis.timeout: 100
package cn.chinotan.config.redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @program: test
 * @description: redis
 * @author: xingcheng
 * @create: 2018-12-01 17:09
 **/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;

    @Autowired
    private JedisConnectionFactory jedisConnectionFactory;

    /**
     * Logger
     */
    private static final Logger lg = LoggerFactory.getLogger(RedisConfig.class);

    @Bean
    @Override
    public KeyGenerator keyGenerator() {
        //  设置自动key的生成规则,配置spring boot的注解,进行方法级别的缓存
        // 使用:进行分割,可以很多显示出层级关系
        // 这里其实就是new了一个KeyGenerator对象
        return (target, method, params) -> {
            StringBuilder sb = new StringBuilder();
            sb.append(target.getClass().getName());
            sb.append(":");
            sb.append(method.getName());
            for (Object obj : params) {
                sb.append(":" + String.valueOf(obj));
            }
            String rsToUse = String.valueOf(sb);
            return rsToUse;
        };
    }

    //缓存管理器
    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        // 初始化缓存管理器,在这里我们可以缓存的整体过期时间什么的,我这里默认没有配置
        RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager
                .RedisCacheManagerBuilder
                .fromConnectionFactory(jedisConnectionFactory);
        return builder.build();
    }
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory){
        //设置序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置redisTemplate
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<Object, Object>();
        redisTemplate.setConnectionFactory(jedisConnectionFactory);
        RedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer); // key序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value序列化
        redisTemplate.setHashKeySerializer(stringSerializer); // Hash key序列化
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer); // Hash value序列化
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Override
    @Bean
    public CacheErrorHandler errorHandler() {
        // 异常处理,当Redis发生异常时,打印日志,但是程序正常走
        CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {
            @Override
            public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
                lg.error("Redis occur handleCacheGetError:key -> [{}]", key, e);
            }

            @Override
            public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
                lg.error("Redis occur handleCachePutError:key -> [{}];value -> [{}]", key, value, e);
            }

            @Override
            public void handleCacheEvictError(RuntimeException e, Cache cache, Object key)    {
                lg.error("Redis occur handleCacheEvictError:key -> [{}]", key, e);
            }

            @Override
            public void handleCacheClearError(RuntimeException e, Cache cache) {
                lg.error("Redis occur handleCacheClearError:", e);
            }
        };
        return cacheErrorHandler;
    }
}

之后配置资源服务器:

package cn.chinotan.config.oauth;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;

import javax.servlet.http.HttpServletResponse;

/**
 * @program: test
 * @description: Resource服务配置
 * @author: xingcheng
 * @create: 2018-12-01 16:30
 **/
@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {


}

以及Web安全配置:

package cn.chinotan.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.security.access.expression.method.MethodSecurityExpressionHandler;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.method.configuration.GlobalMethodSecurityConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.oauth2.provider.expression.OAuth2MethodSecurityExpressionHandler;

import javax.servlet.http.HttpServletResponse;

/**
 * @program: test
 * @description: WebSecurityConfig
 * @author: xingcheng
 * @create: 2018-12-01 17:29
 **/
@Configuration
@EnableWebSecurity
@Order(Ordered.HIGHEST_PRECEDENCE)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .exceptionHandling() // 统一异常处理
                .authenticationEntryPoint((request, response, authException) -> response.sendError(HttpServletResponse.SC_UNAUTHORIZED)) // 自定义异常返回
                .and()
                .authorizeRequests()
                .antMatchers("/api/**") 
                .authenticated() // 拦截所有/api开头下的资源路径,包括其/api本身
                .anyRequest()
                .permitAll()// 其他请求无需认证
                .and()
                .httpBasic(); // 启用httpBasic认证
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder()).withUser("start_test_two").password(new BCryptPasswordEncoder().encode("start_test_two")).roles("USER"); // 内存中配置httpBasic认证名和密码,使用BCryptPasswordEncoder加密
    }
}

其中注意WebSecurityConfigurerAdapter和ResourceServerConfigurerAdapter都有对于HttpSecurity的配置:

而在ResourceServerConfigurer中,默认所有接口都需要认证:

且一旦匹配上一个filter后就不会走其他的filter了,因此需要将WebSecurityConfigurerAdapter的调用顺序调到最高级:

@Order(Ordered.HIGHEST_PRECEDENCE)

配置完成后启动:

可以看到暴露了/oauth/token接口

Spring-Security-Oauth2的提供的jar包中内置了与token相关的基础端点。本文认证与授权token与/oauth/token有关,其处理的接口类为TokenEndpoint。下面我们来看一下对于认证与授权token流程的具体处理过程。

 1 @FrameworkEndpoint
 2 public class TokenEndpoint extends AbstractEndpoint {
 3     ... 
 4     @RequestMapping(value = "/oauth/token", method=RequestMethod.POST)
 5     public ResponseEntity<OAuth2AccessToken> postAccessToken(Principal principal, @RequestParam
 6     Map<String, String> parameters) throws HttpRequestMethodNotSupportedException {
 7     //首先对client信息进行校验
 8         if (!(principal instanceof Authentication)) {
 9             throw new InsufficientAuthenticationException(
10                     "There is no client authentication. Try adding an appropriate authentication filter.");
11         }
12         String clientId = getClientId(principal);
13         //根据请求中的clientId,加载client的具体信息
14         ClientDetails authenticatedClient = getClientDetailsService().loadClientByClientId(clientId);
15         TokenRequest tokenRequest = getOAuth2RequestFactory().createTokenRequest(parameters, authenticatedClient);
16         ... 
17         
18         //验证scope域范围
19         if (authenticatedClient != null) {
20             oAuth2RequestValidator.validateScope(tokenRequest, authenticatedClient);
21         }
22         //授权方式不能为空
23         if (!StringUtils.hasText(tokenRequest.getGrantType())) {
24             throw new InvalidRequestException("Missing grant type");
25         }
26         //token endpoint不支持Implicit模式
27         if (tokenRequest.getGrantType().equals("implicit")) {
28             throw new InvalidGrantException("Implicit grant type not supported from token endpoint");
29         }
30         ...
31         
32         //进入CompositeTokenGranter,匹配授权模式,然后进行password模式的身份验证和token的发放
33         OAuth2AccessToken token = getTokenGranter().grant(tokenRequest.getGrantType(), tokenRequest);
34         if (token == null) {
35             throw new UnsupportedGrantTypeException("Unsupported grant type: " + tokenRequest.getGrantType());
36         }
37         return getResponse(token);
38     }
39     ...

口处理的主要流程就是对authentication信息进行检查是否合法,不合法直接抛出异常,然后对请求的GrantType进行处理,根据GrantType,进行password模式的身份验证和token的发放。下面我们来看下TokenGranter的类图。

可以看出TokenGranter的实现类CompositeTokenGranter中有一个List<TokenGranter>,对应五种GrantType的实际授权实现。这边涉及到的getTokenGranter(),代码也列下:

 1 public class CompositeTokenGranter implements TokenGranter {
 2     //GrantType的集合,有五种,之前有讲
 3     private final List<TokenGranter> tokenGranters;
 4     public CompositeTokenGranter(List<TokenGranter> tokenGranters) {
 5         this.tokenGranters = new ArrayList<TokenGranter>(tokenGranters);
 6     }
 7     
 8     //遍历list,匹配到相应的grantType就进行处理
 9     public OAuth2AccessToken grant(String grantType, TokenRequest tokenRequest) {
10         for (TokenGranter granter : tokenGranters) {
11             OAuth2AccessToken grant = granter.grant(grantType, tokenRequest);
12             if (grant!=null) {
13                 return grant;
14             }
15         }
16         return null;
17     }
18     ...
19 }

启动后,访问下面的接口:

package cn.chinotan.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @program: test
 * @description: oauth2测试类
 * @author: xingcheng
 * @create: 2018-12-01 17:43
 **/
@RestController
public class WordController {

    @RequestMapping("/")
    public String index(){

        return "index" ;
    }

    @RequestMapping("/api")
    public String api(){
        return "api" ;
    }

    @RequestMapping("/login")
    public String login() {
        return "login";
    }


}

可以看到访问/api接口的时候被拦截了,但是其他接口可以访问

那么如何才能访问/api接口呢,首先得获取到access_token才行

通过暴露出的/oauth/token?grant_type=client_credentials接口就可以获取到access_token,其中expires_in为有效时间,看下我们的token是存储在哪里:

没错,被存在了redis中,相比存在本地内存和数据库中,redis这样的数据结构有着天然的时间特性,可以方便的来做失效处理

之后便可以通过access_token方便的访问/api接口了

NoSuchMethodError.RedisConnection.set([B[B)V #16错误

版本问题,spring-data-redis 2.0版本中set(String,String)被弃用了。然后我按照网页中的决解方法“spring-date-redis”改为2.3.3.RELEASE版本,下面是源码中的存储token过程:

(adsbygoogle = window.adsbygoogle || []).push({});

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Spring Cloud和聚合工程架构设计微服务框架

            最近在做游戏商人的过程中,发现很多的同行,都是用记事本记录交易相关信息,于是我觉得自己搭建一个针对游戏行业,搭建一个进销存的微服务管理系统。

    边鹏 [进阶者]
  • 分布式事务系列--SpringCloud整合byteTCC框架0.4.x版本

    版权声明:欢迎转载,请标明出处,如有问题,欢迎指正!谢谢!https://blog.csdn.net/weixin_39800144/article/detai...

    IT云清
  • SpringCloud初步介绍

      就目前而言,对于微服务业界并没有一个统一的、标准的定义。   但通常而言,微服务架构是一种架构模式或者说是一种架构风格,提倡将单一应用程序划分成一组小的服务...

    Java架构师历程
  • 一文带你看懂Spring事务!

    Spring事务管理我相信大家都用得很多,但可能仅仅局限于一个@Transactional注解或者在XML中配置事务相关的东西。不管怎么说,日常可能足够我们去用...

    Java3y
  • Netflix是什么,与Spring Cloud有什么关系

    1、首先,Netflix是一家做视频的网站,可以这么说该网站上的美剧应该是最火的。

    wuweixiang
  • Spring Cloud Zuul中DispatcherServlet和ZuulServlet

    Zuul是通过Servlet机制实现的。一般情况下,ZuulServet被嵌入到Spring Dispatch机制中,由DispatcherServlet分派处...

    java达人
  • Spring Cloud 入门教程3、服务消费者(Feign)

    Feign是基于Ribbon封装的HTTP Client工具包,Feign的目标是简化HTTP Client。Feign也确实做到了这一点,使用Feign发起H...

    wuweixiang
  • API数据加密框架monkey-api-encrypt

    主要是在Spring Boot中如何对接口的数据进行自动加解密操作,通过注解的方式来指定是否需要加解密。

    猿天地
  • Spring Cloud 完整的微服务架构实战

    边鹏 [进阶者]
  • 深入解读zookeeper一致性原理

    我们知道可以通过ZooKeeper对分布式系统进行Master选举,来解决分布式系统的单点故障,如图所示。

    用户1655470

扫码关注云+社区

领取腾讯云代金券