SpringCloud微服务间安全调用实现（SpringSecurity+Oauth2+Jwt）

【Java中高级课程推荐-全部免费】http://www.maj...

SoXiaTea

47397人浏览 · 2018-04-04 13:47:00

SoXiaTea · 2018-04-04 13:47:00 发布

【Java中高级课程推荐-全部免费】

http://www.majiaxueyuan.com/

消息中间件，支付宝，Nginx高可用，Redis高可用，SpringBoot，SpringCloud，真实分布式微服务项目，全套教程看完百分之百大幅度涨薪。

如果对你有用，请记得点赞哦！！！！

SpringCloud服务间安全调用实现

目前项目中用到了微服务认证这块的技术，查看了相当一大部分的资料发现现在网上的资料都很不全，很零散。而且很多都运行不起来。

简单的介绍一下认证。传统的项目都是使用session来管理用户的登录信息，返回前端sessionId保存在cookie中。但是在分布式情况下利用session去管理的场景就很少了，也不是不可以，如果你对session很热爱使用它的话，那就没必要继续往下看了。

在我们微服务restful风格下，应该怎么去保证安全信息呢。相信大家可能了解过token，也就是我们熟说的令牌，有人问我什么是token，Token 和 Session ID 不同，并非只是一个 key。Token 一般会包含用户的相关信息，通过验证 Token 就可以完成身份校验。

这里我们先简单介绍一下我们使用的token格式。

采用jwt（JSON WEB TOKEN） JWT 是由三段信息构成的，第一段为头部（Header），第二段为载荷（Payload)，第三段为签名（Signature）。每一段内容都是一个 JSON 对象，将每一段 JSON 对象采用 BASE64 编码，将编码后的内容用. 链接一起就构成了 JWT 字符串。

认证协议采用Oauth2.0 OAuth 是一种开放的协议，为桌面程序或者基于 BS 的 web 应用提供了一种简单的，标准的方式去访问需要用户授权的 API 服务。OAUTH 认证授权具有以下特点：

简单：不管是 OAuth 服务提供者还是应用开发者，都很容易于理解与使用；

安全：没有涉及到用户密钥等信息，更安全更灵活；

开放：任何服务提供商都可以实现 OAuth，任何软件开发商都可以使用 OAuth；

关于jwt和Oauth我们就不做过多的介绍了。大家直接去百度一大堆，这种内容写出来就没有技术含量了。

思考一个问题：就是在分布式情况下，我们怎么去生成这个token？在哪里生成是最好的呢？

现在我们举例说明，有三个服务，会员，订单，支付，这个三个服务，他们都需要用户验证，我们不可能在每个系统中去写一个认证过程，所以，我们的认证是一个单独的服务。

认证流程：用户提供用户信息，到认证中心验证，成功就返回一个token，访问其他服务的时候在请求头携带上token信息，服务只需要去解析token的值就可以了，这样做既满足了微服务轻量级的需求，也避免了了浏览器禁用cookie的情况，岂不美哉。

我们要知道一个事情，对于我们的认证服务器来说，只有两种服务，那就是认证服务器和资源服务器，所有我们这里的会员，订单，支付服务，对于认证服务器来说都是资源服务器。

auth

搭建认证服务

我们采用SpringSecurity Oauth2.0 JWT Redis搭建服务

采用SpringSecurity的密码模式，其他模式请自行百度参考，这里提供当前认证的最需求的做法。

pom.xml

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.2.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</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>
		<dependency>
			<groupId>org.springframework.security.oauth</groupId>
			<artifactId>spring-security-oauth2</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-jwt</artifactId>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.40</version>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>Dalston.RC1</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<archive>
						<manifest>
							<mainClass>com.cdhenren.AuthApplication</mainClass>
						</manifest>
					</archive>
				</configuration>
			</plugin>
		</plugins>
	</build>
	<repositories>
		<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

server:
  port: 8080
spring:
  redis:
    host: 127.0.0.1
    password: null
    port: 6379
    pool:
      max-idle: 100
      min-idle: 1
      max-active: 1000
      max-wait: -1
logging:
  level: 
    per.lx: DEBUG

配置认证服务

@Configuration
@EnableAuthorizationServer
public class AuthServerConfig extends AuthorizationServerConfigurerAdapter {
	// 资源ID
	private static final String SOURCE_ID = "order";
	private static final int ACCESS_TOKEN_TIMER = 60 * 60 * 24;
	private static final int REFRESH_TOKEN_TIMER = 60 * 60 * 24 * 30;

	@Autowired
	AuthenticationManager authenticationManager;
	@Autowired
	RedisConnectionFactory redisConnectionFactory;

	@Override
	public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
		clients.inMemory().withClient("myapp").resourceIds(SOURCE_ID).authorizedGrantTypes("password", "refresh_token")
				.scopes("all").authorities("ADMIN").secret("lxapp").accessTokenValiditySeconds(ACCESS_TOKEN_TIMER)
				.refreshTokenValiditySeconds(REFRESH_TOKEN_TIMER);
	}

	@Override
	public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
		endpoints.accessTokenConverter(accessTokenConverter());
		endpoints.tokenStore(tokenStore()).authenticationManager(authenticationManager);
	}

	@Override
	public void configure(AuthorizationServerSecurityConfigurer oauthServer) throws Exception {
		// 允许表单认证
		oauthServer.allowFormAuthenticationForClients();
	}

	// JWT
	@Bean
	public JwtAccessTokenConverter accessTokenConverter() {
		JwtAccessTokenConverter accessTokenConverter = new JwtAccessTokenConverter() {
			/***
			 * 重写增强token方法,用于自定义一些token总需要封装的信息
			 */
			@Override
			public OAuth2AccessToken enhance(OAuth2AccessToken accessToken, OAuth2Authentication authentication) {
				String userName = authentication.getUserAuthentication().getName();
				// 得到用户名，去处理数据库可以拿到当前用户的信息和角色信息（需要传递到服务中用到的信息）
				final Map<String, Object> additionalInformation = new HashMap<>();
				// Map假装用户实体
				Map<String, String> userinfo = new HashMap<>();
				userinfo.put("id", "1");
				userinfo.put("username", "LiaoXiang");
				userinfo.put("qqnum", "438944209");
				userinfo.put("userFlag", "1");
				additionalInformation.put("userinfo", JSON.toJSONString(userinfo));
				((DefaultOAuth2AccessToken) accessToken).setAdditionalInformation(additionalInformation);
				OAuth2AccessToken enhancedToken = super.enhance(accessToken, authentication);
				return enhancedToken;
			}
		};
		// 测试用,资源服务使用相同的字符达到一个对称加密的效果,生产时候使用RSA非对称加密方式
		accessTokenConverter.setSigningKey("SigningKey");
		return accessTokenConverter;
	}

	@Bean
	public TokenStore tokenStore() {
		RedisTokenStore tokenStore = new RedisTokenStore(redisConnectionFactory);
		return tokenStore;
	}

}

安全认证配置

@Configuration
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

	// 请配置这个，以保证在刷新Token时能成功刷新
	@Autowired
	public void globalUserDetails(AuthenticationManagerBuilder auth) throws Exception {
		// 配置用户来源于数据库
                // 配置密码加密方式  BCryptPasswordEncoder，添加用户加密的时候请也用这个加密
		auth.userDetailsService(userDetailsService()).passwordEncoder(new BCryptPasswordEncoder());
	}

	@Bean
	@Override
	protected UserDetailsService userDetailsService() {

		// 这里是添加两个用户到内存中去，实际中是从#下面去通过数据库判断用户是否存在
		InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
		
                BCryptPasswordEncoder passwordEncode = new BCryptPasswordEncoder();
                String pwd = passwordEncode.encode("123456");
                manager.createUser(User.withUsername("user_1").password(pwd).authorities("USER").build());
		manager.createUser(User.withUsername("user_2").password(pwd).authorities("USER").build());
		return manager;

		// #####################实际开发中在下面写从数据库获取数据###############################
		// return new UserDetailsService() {
		// @Override
		// public UserDetails loadUserByUsername(String username) throws
		// UsernameNotFoundException {
		// // 通过用户名获取用户信息
		// boolean isUserExist = false;
		// if (isUserExist) {
		// //创建spring security安全用户和对应的权限（从数据库查找）
		// User user = new User("username", "password",
		// AuthorityUtils.createAuthorityList("admin", "manager"));
		// return user;
		// } else {
		// throw new UsernameNotFoundException("用户[" + username + "]不存在");
		// }
		// }
		// };

	}

	@Override
	protected void configure(HttpSecurity http) throws Exception {
		// @formatter:off
		http.requestMatchers().anyRequest().and().authorizeRequests().antMatchers("/oauth/**").permitAll();
		// @formatter:on
	}
}

到这里一个认证服务器就搭建成功了。

我们写一个启动类来启动

@SpringBootApplication
public class AuthApp {
	public static void main(String[] args) {
		SpringApplication.run(AuthApp.class, args);
	}
}

启动后发现控制台输出了我们的请求连接（表明集成成功）

console

然后我们用postman进行请求模拟

req

请求参数中的信息来自于配置文件，不同的话不能生成成功。用户信息请自行修改代码从数据库获取

可以看到我们的返回信息中包含的信息，其中有固定的信息和我们自定义的信息。

resp

顺便看看我们的Redis中存储的认证信息，可以看到redis新增了很多信息

redis

到这里我们的认证服务就搭建成功了，就可以用来访问其他的服务了 #######################################################################

我们这里来搭建资源服务器，也就是通过TOKEN去访问的服务

pom.xml

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.2.RELEASE</version>
		<relativePath />
	</parent>

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

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</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>
		<dependency>
			<groupId>org.springframework.security.oauth</groupId>
			<artifactId>spring-security-oauth2</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-jwt</artifactId>
		</dependency>
		<dependency>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>2.6</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.40</version>
		</dependency>
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt</artifactId>
			<version>0.7.0</version>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>Dalston.RC1</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<archive>
						<manifest>
							<mainClass>com.cdhenren.AuthApplication</mainClass>
						</manifest>
					</archive>
				</configuration>
			</plugin>
		</plugins>
	</build>
	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
	</repositories>

新建一个资源服务配置文件ResourceConfiguration.java 我们这里配置以/order/*开头的请求不用认证

@Configuration
@EnableResourceServer
public class ResourceConfiguration extends ResourceServerConfigurerAdapter {

	private static final String SOURCE_ID = "order";

	@Autowired
	private RedisConnectionFactory redisConnectionFactory;

	@Override
	@CrossOrigin
	public void configure(ResourceServerSecurityConfigurer resources) {
		resources.resourceId(SOURCE_ID).stateless(true);
		resources.tokenServices(defaultTokenServices());
	}

	@Override
	public void configure(HttpSecurity http) throws Exception {
		// @formatter:off
                // 我们这里放开/order/*的请求，以/order/*开头的请求不用认证
		http.authorizeRequests().antMatchers("/order/*").permitAll().and().authorizeRequests()
				.antMatchers(HttpMethod.OPTIONS).permitAll().anyRequest().authenticated();
		// @formatter:on
	}

	// 自定义的Token存储器，存到Redis中
	@Bean
	public TokenStore tokenStore() {
		RedisTokenStore tokenStore = new RedisTokenStore(redisConnectionFactory);
		return tokenStore;
	}

	// Token转换器
	@Bean
	public JwtAccessTokenConverter accessTokenConverter() {
		JwtAccessTokenConverter accessTokenConverter = new JwtAccessTokenConverter() {
		};
		accessTokenConverter.setSigningKey("SigningKey");
		return accessTokenConverter;
	}

	/**
	 * 创建一个默认的资源服务token
	 */
	@Bean
	public ResourceServerTokenServices defaultTokenServices() {
		final DefaultTokenServices defaultTokenServices = new DefaultTokenServices();
		// 使用自定义的Token转换器
		defaultTokenServices.setTokenEnhancer(accessTokenConverter());
		// 使用自定义的tokenStore
		defaultTokenServices.setTokenStore(tokenStore());
		return defaultTokenServices;
	}
}

然后我们写一个工具类，去获取我们在认证端传过来的userinfo

public class AuthUtils {
	public static String getReqUser(HttpServletRequest req) {
		String header = req.getHeader("Authorization");
		String token = StringUtils.substringAfter(header, "bearer");
		Claims claims;
		try {
			claims = Jwts.parser().setSigningKey("SigningKey".getBytes("UTF-8")).parseClaimsJws(token).getBody();
		} catch (Exception e) {
			return null;
		}
		String localUser = (String) claims.get("userinfo");
		// 拿到当前用户
		return localUser;
	}
}

到这里我们就配置完了我们的所有请求，我们编写一个Controller进行验证。

@RestController
public class TestEndpoints {
	@GetMapping("/product/{id}")
	public String getProduct(@PathVariable String id, HttpServletRequest req) {
		Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
		System.out.println("用户名  : " + JSON.toJSONString(authentication.getPrincipal()));
		System.out.println("封装的传递信息  : " + AuthUtils.getReqUser(req));
		return "(Need Auth Request)product id : " + id;
	}

	@GetMapping("/order/{id}")
	public String getOrder(@PathVariable String id) {
		return "(No Auth Request)order id : " + id;
	}
}

这下我们就测试完成了首先访问我们不需要认证的请求：127.0.0.1:8081/order/1，可以正常访问返回数据

noauth

然后不带我们的token进行访问另外一个链接（需要认证）：127.0.0.1:8081/product/1

可以看到返回没有认证不能访问的提示，如下图

authno

下面我们在请求头里面带上我们的token，这里注意一下，token是携带在Header中的Authorization属性中，而且我们需要用token类型+token的方式进行传递，这里我们的类型默认是bearer，加上我们的请求头就可以正常访问到数据了。如下图

authyes

现在，我们可以直接拿去集成到我们真实的微服务项目中去了，保证我们的项目从这一篇博客开始。

如果对你有用，请记得点赞。

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

云原生

所有评论(0)

查看更多评论

SoXiaTea

@q438944209

已为社区贡献1条内容