溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹了Spring Security如何實現分布式系統授權，具有一定借鑒價值，感興趣的朋友可以參考下，希望大家閱讀完這篇文章之后大有收獲，下面讓小編帶著大家一起了解一下。
回顧技術方案如下：
1、UAA認證服務負責認證授權。
2、所有請求經過 網關到達微服務
3、網關負責鑒權客戶端以及請求轉發
4、網關將token解析后傳給微服務，微服務進行授權。
所有微服務的請求都經過網關，網關從注冊中心讀取微服務的地址，將請求轉發至微服務。
本節完成注冊中心的搭建，注冊中心采用Eureka。
1、創建maven工程
2、pom.xml依賴如下
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven- 4.0.0.xsd"> <parent> <artifactId>distributed-security</artifactId> <groupId>com.lw.security</groupId> <version>1.0-SNAPSHOT</version> </parent> <modelVersion>4.0.0</modelVersion> <artifactId>distributed-security-discovery</artifactId> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> </dependencies> </project>
3、配置文件
在resources中配置application.yml
spring: application: name: distributed-discovery server: port: 53000 #啟動端口 eureka: server: enable-self-preservation: false #關閉服務器自我保護，客戶端心跳檢測15分鐘內錯誤達到80%服務會保護，導致別人還認為是好用的服務 eviction-interval-timer-in-ms: 10000 #清理間隔（單位毫秒，默認是60*1000）5秒將客戶端剔除的服務在服務注冊列表中剔除# shouldUseReadOnlyResponseCache: true #eureka是CAP理論種基于AP策略，為了保證強一致性關閉此切換CP默認不關閉 false關閉 client: register-with-eureka: false #false:不作為一個客戶端注冊到注冊中心 fetch-registry: false #為true時，可以啟動，但報異常：Cannot execute request on any known server instance-info-replication-interval-seconds: 10 serviceUrl: defaultZone: http://localhost:${server.port}/eureka/ instance: hostname: ${spring.cloud.client.ip-address} prefer-ip-address: true instance-id: ${spring.application.name}:${spring.cloud.client.ip-address}:${spring.application.instance_id:${server.port}}
啟動類：
@SpringBootApplication
@EnableEurekaServer
public class DiscoveryServer {
public static void main(String[] args) {
SpringApplication.run(DiscoveryServer.class, args);
}
}網關整合 OAuth3.0 有兩種思路，一種是認證服務器生成jwt令牌, 所有請求統一在網關層驗證，判斷權限等操作；另一種是由各資源服務處理，網關只做請求轉發。
我們選用第一種。我們把API網關作為OAuth3.0的資源服務器角色，實現接入客戶端權限攔截、令牌解析并轉發當前登錄用戶信息(jsonToken)給微服務，這樣下游微服務就不需要關心令牌格式解析以及OAuth3.0相關機制了。
API網關在認證授權體系里主要負責兩件事：
（1）作為OAuth3.0的資源服務器角色，實現接入方權限攔截。
（2）令牌解析并轉發當前登錄用戶信息（明文token）給微服務
微服務拿到明文token(明文token中包含登錄用戶的身份和權限信息)后也需要做兩件事：
（1）用戶授權攔截（看當前用戶是否有權訪問該資源）
（2）將用戶信息存儲進當前線程上下文（有利于后續業務邏輯隨時獲取當前用戶信息）
1、pom.xml
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven- 4.0.0.xsd"> <parent> <artifactId>distributed-security</artifactId> <groupId>com.lw.security</groupId> <version>1.0-SNAPSHOT</version> </parent> <modelVersion>4.0.0</modelVersion> <artifactId>distributed-security-gateway</artifactId> <dependencies> <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-starter-netflix-ribbon</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency> <dependency> <groupId>com.netflix.hystrix</groupId> <artifactId>hystrix-javanica</artifactId> </dependency> <dependency> <groupId>org.springframework.retry</groupId> <artifactId>spring-retry</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-zuul</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-oauth3</artifactId> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-jwt</artifactId> </dependency> <dependency> <groupId>javax.interceptor</groupId> <artifactId>javax.interceptor-api</artifactId> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </dependency> </dependencies> </project>
2、配置文件
配置application.properties
spring.application.name=gateway-server
server.port=53010
spring.main.allow-bean-definition-overriding = true
logging.level.root = info
logging.level.org.springframework = info
zuul.retryable = true
zuul.ignoredServices = *
zuul.add-host-header = true
zuul.sensitiveHeaders = *
zuul.routes.uaa-service.stripPrefix = false
zuul.routes.uaa-service.path = /uaa/**
zuul.routes.order-service.stripPrefix = false
zuul.routes.order-service.path = /order/**
eureka.client.serviceUrl.defaultZone = http://localhost:53000/eureka/
eureka.instance.preferIpAddress = true
eureka.instance.instance-id = ${spring.application.name}:${spring.cloud.client.ip-address}:${spring.application.instance_id:${server.port}}
management.endpoints.web.exposure.include = refresh,health,info,env
feign.hystrix.enabled = true
feign.compression.request.enabled = true
feign.compression.request.mime-types[0] = text/xml
feign.compression.request.mime-types[1] = application/xml
feign.compression.request.mime-types[2] = application/json
feign.compression.request.min-request-size = 2048
feign.compression.response.enabled = true統一認證服務（UAA）與統一用戶服務都是網關下微服務，需要在網關上新增路由配置：
zuul.routes.uaa-service.stripPrefix = false zuul.routes.uaa-service.path = /uaa/** zuul.routes.user-service.stripPrefix = false zuul.routes.user-service.path = /order/**
上面配置了網關接收的請求url若符合/order/**表達式，將被被轉發至order-service(統一用戶服務)。
啟動類：
@SpringBootApplication
@EnableZuulProxy
@EnableDiscoveryClient
public class GatewayServer {
public static void main(String[] args) {
SpringApplication.run(GatewayServer.class, args);
}
}前面也介紹了，資源服務器由于需要驗證并解析令牌，往往可以通過在授權服務器暴露check_token的Endpoint來完成，而我們在授權服務器使用的是對稱加密的jwt，因此知道密鑰即可，資源服務與授權服務本就是對稱設計，那我們把授權服務的TokenConfig兩個類拷貝過來就行 。
@Configuration
public class TokenConfig {
private String SIGNING_KEY = "uaa123";
@Bean
public TokenStore tokenStore() {
return new JwtTokenStore(accessTokenConverter());
}
@Bean
public JwtAccessTokenConverter accessTokenConverter() {
JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
converter.setSigningKey(SIGNING_KEY); //對稱秘鑰，資源服務器使用該秘鑰來解密
return converter;
}
}在ResouceServerConfig中定義資源服務配置，主要配置的內容就是定義一些匹配規則，描述某個接入客戶端需要什么樣的權限才能訪問某個微服務，如：
@Configuration
public class ResouceServerConfig {
public static final String RESOURCE_ID = "res1";
/**
* 統一認證服務(UAA) 資源攔截
*/
@Configuration
@EnableResourceServer
public class UAAServerConfig extends
ResourceServerConfigurerAdapter {
@Autowired
private TokenStore tokenStore;
@Override
public void configure(ResourceServerSecurityConfigurer resources){
resources.tokenStore(tokenStore).resourceId(RESOURCE_ID)
.stateless(true);
}
@Override
public void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.antMatchers("/uaa/**").permitAll();
}
}
/**
* 訂單服務
*/
@Configuration
@EnableResourceServer
public class OrderServerConfig extends
ResourceServerConfigurerAdapter {
@Autowired
private TokenStore tokenStore;
@Override
public void configure(ResourceServerSecurityConfigurer resources) {
resources.tokenStore(tokenStore).resourceId(RESOURCE_ID)
.stateless(true);
}
@Override
public void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/order/**").access("#oauth3.hasScope('ROLE_API')");
}
}
}上面定義了兩個微服務的資源，其中：
UAAServerConfig指定了若請求匹配/uaa/**網關不進行攔截。
OrderServerConfig指定了若請求匹配/order/**，也就是訪問統一用戶服務，接入客戶端需要有scope中包含read，并且authorities(權限)中需要包含ROLE_USER。
由于res1這個接入客戶端，read包括ROLE_ADMIN,ROLE_USER,ROLE_API三個權限。
@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/**").permitAll()
.and().csrf().disable();
}
}通過Zuul過濾器的方式實現，目的是讓下游微服務能夠很方便的獲取到當前的登錄用戶信息（明文token）
（ 1）實現Zuul前置過濾器，完成當前登錄用戶信息提取，并放入轉發微服務的request中
/**
* token傳遞攔截
*/
public class AuthFilter extends ZuulFilter {
@Override
public boolean shouldFilter() {
return true;
}
@Override
public String filterType() {
return "pre";
}
@Override
public int filterOrder() {
return 0;
}
@Override
public Object run() {
/**
* 1.獲取令牌內容
*/
RequestContext ctx = RequestContext.getCurrentContext();
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
if(!(authentication instanceof OAuth3Authentication)){ // 無token訪問網關內資源的情況，目前僅有uua服務直接暴露
return null;
}
OAuth3Authentication oauth3Authentication = (OAuth3Authentication)authentication;
Authentication userAuthentication = oauth3Authentication.getUserAuthentication();
Object principal = userAuthentication.getPrincipal();
/**
* 2.組裝明文token，轉發給微服務，放入header，名稱為json-token
*/
List<String> authorities = new ArrayList();
userAuthentication.getAuthorities().stream().forEach(s ->authorities.add(((GrantedAuthority) s).getAuthority()));
OAuth3Request oAuth3Request = oauth3Authentication.getOAuth3Request();
Map<String, String> requestParameters = oAuth3Request.getRequestParameters();
Map<String,Object> jsonToken = new HashMap<>(requestParameters);
if(userAuthentication != null){
jsonToken.put("principal",userAuthentication.getName());
jsonToken.put("authorities",authorities);
}
ctx.addZuulRequestHeader("json-token", EncryptUtil.encodeUTF8StringBase64(JSON.toJSONString(jsonToken)));
return null;
}
}common包下建EncryptUtil類 UTF8互轉Base64
public class EncryptUtil {
private static final Logger logger = LoggerFactory.getLogger(EncryptUtil.class);
public static String encodeBase64(byte[] bytes){
String encoded = Base64.getEncoder().encodeToString(bytes);
return encoded;
}
public static byte[] decodeBase64(String str){
byte[] bytes = null;
bytes = Base64.getDecoder().decode(str);
return bytes;
public static String encodeUTF8StringBase64(String str){
String encoded = null;
try {
encoded = Base64.getEncoder().encodeToString(str.getBytes("utf-8"));
} catch (UnsupportedEncodingException e) {
logger.warn("不支持的編碼格式",e);
}
public static String decodeUTF8StringBase64(String str){
String decoded = null;
byte[] bytes = Base64.getDecoder().decode(str);
decoded = new String(bytes,"utf-8");
}catch(UnsupportedEncodingException e){
return decoded;
public static String encodeURL(String url) {
String encoded = null;
try {
encoded = URLEncoder.encode(url, "utf-8");
} catch (UnsupportedEncodingException e) {
logger.warn("URLEncode失敗", e);
}
return encoded;
}
public static String decodeURL(String url) {
String decoded = null;
decoded = URLDecoder.decode(url, "utf-8");
logger.warn("URLDecode失敗", e);
return decoded;
public static void main(String [] args){
String str = "abcd{'a':'b'}";
String encoded = EncryptUtil.encodeUTF8StringBase64(str);
String decoded = EncryptUtil.decodeUTF8StringBase64(encoded);
System.out.println(str);
System.out.println(encoded);
System.out.println(decoded);
String url = "== wo";
String urlEncoded = EncryptUtil.encodeURL(url);
String urlDecoded = EncryptUtil.decodeURL(urlEncoded);
System.out.println(url);
System.out.println(urlEncoded);
System.out.println(urlDecoded);
}（ 2）將filter納入spring 容器：
配置AuthFilter
@Configuration
public class ZuulConfig {
@Bean
public AuthFilter preFileter() {
return new AuthFilter();
}
@Bean
public FilterRegistrationBean corsFilter() {
final UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
final CorsConfiguration config = new CorsConfiguration();
config.setAllowCredentials(true);
config.addAllowedOrigin("*");
config.addAllowedHeader("*");
config.addAllowedMethod("*");
config.setMaxAge(18000L);
source.registerCorsConfiguration("/**", config);
CorsFilter corsFilter = new CorsFilter(source);
FilterRegistrationBean bean = new FilterRegistrationBean(corsFilter);
bean.setOrder(Ordered.HIGHEST_PRECEDENCE);
return bean;
}
}當微服務收到明文token時，應該怎么鑒權攔截呢？自己實現一個filter？自己解析明文token，自己定義一套資源訪問策略？能不能適配Spring Security呢，是不是突然想起了前面我們實現的Spring Security基于token認證例子。咱們還拿統一用戶服務作為網關下游微服務，對它進行改造，增加微服務用戶鑒權攔截功能。
（1）增加測試資源
OrderController增加以下endpoint
@PreAuthorize("hasAuthority('p1')")
@GetMapping(value = "/r1")
public String r1(){
UserDTO user = (UserDTO)
SecurityContextHolder.getContext().getAuthentication().getPrincipal();
return user.getUsername() + "訪問資源1";
}
@PreAuthorize("hasAuthority('p2')")
@GetMapping(value = "/r2")
public String r2(){//通過Spring Security API獲取當前登錄用戶
UserDTO user =
(UserDTO)SecurityContextHolder.getContext().getAuthentication().getPrincipal();
return user.getUsername() + "訪問資源2";
}model包下加實體類UserDto
@Data
public class UserDTO {
private String id;
private String username;
private String mobile;
private String fullname;
}（2）Spring Security配置
開啟方法保護，并增加Spring配置策略，除了/login方法不受保護(統一認證要調用)，其他資源全部需要認證才能訪問。
@Override
public void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/**").access("#oauth3.hasScope('ROLE_ADMIN')")
.and().csrf().disable()
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
}綜合上面的配置，咱們共定義了三個資源了，擁有p1權限可以訪問r1資源，擁有p2權限可以訪問r2資源，只要認證通過就能訪問r3資源。
（3）定義filter攔截token，并形成Spring Security的Authentication對象
@Component
public class TokenAuthenticationFilter extends OncePerRequestFilter {
@Override
protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse
httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
String token = httpServletRequest.getHeader("json-token");
if (token != null){
//1.解析token
String json = EncryptUtil.decodeUTF8StringBase64(token);
JSONObject userJson = JSON.parseObject(json);
UserDTO user = new UserDTO();
user.setUsername(userJson.getString("principal"));
JSONArray authoritiesArray = userJson.getJSONArray("authorities");
String [] authorities = authoritiesArray.toArray( new
String[authoritiesArray.size()]);
//2.新建并填充authentication
UsernamePasswordAuthenticationToken authentication = new
UsernamePasswordAuthenticationToken(
user, null, AuthorityUtils.createAuthorityList(authorities));
authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(
httpServletRequest));
//3.將authentication保存進安全上下文
SecurityContextHolder.getContext().setAuthentication(authentication);
}
filterChain.doFilter(httpServletRequest, httpServletResponse);
}
}經過上邊的過慮 器，資源 服務中就可以方便到的獲取用戶的身份信息：
UserDTO user = (UserDTO) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
還是三個步驟：
1.解析token
2.新建并填充authentication
3.將authentication保存進安全上下文
剩下的事兒就交給Spring Security好了。
注意:記得uaa跟order的pom導入eurika坐標,以及application.properties配置eurika
本案例測試過程描述：
1、采用OAuth3.0的密碼模式從UAA獲取token
2、使用該token通過網關訪問訂單服務的測試資源
（1）過網關訪問uaa的授權及獲取令牌，獲取token。注意端口是53010，網關的端口。
如授權 endpoint：
http://localhost:53010/uaa/oauth/authorize?response_type=code&client_id=c1
令牌endpoint
http://localhost:53010/uaa/oauth/token
（2）使用Token過網關訪問訂單服務中的r1-r2測試資源進行測試。
結果：
使用張三token訪問p1，訪問成功
使用張三token訪問p2，訪問失敗
使用李四token訪問p1，訪問失敗
使用李四token訪問p2，訪問成功
符合預期結果。
（3）破壞token測試
無token測試返回內容：
{
"error": "unauthorized",
"error_description": "Full authentication is required to access this resource"
}破壞token測試返回內容：
{
"error": "invalid_token",
"error_description": "Cannot convert access token to JSON"
}目前jwt令牌存儲了用戶的身份信息、權限信息，網關將token明文化轉發給微服務使用，目前用戶身份信息僅包括了用戶的賬號，微服務還需要用戶的ID、手機號等重要信息。
所以，本案例將提供擴展用戶信息的思路和方法，滿足微服務使用用戶信息的需求。
下邊分析JWT令牌中擴展用戶信息的方案：
在認證階段DaoAuthenticationProvider會調用UserDetailService查詢用戶的信息，這里是可以獲取到齊全的用戶信息的。由于JWT令牌中用戶身份信息來源于UserDetails，UserDetails中僅定義了username為用戶的身份信息，這里有兩個思路：第一是可以擴展UserDetails，使之包括更多的自定義屬性，第二也可以擴展username的內容，比如存入json數據內容作為username的內容。相比較而言，方案二比較簡單還不用破壞UserDetails的結構，我們采用方案二。
從數據庫查詢到user，將整體user轉成json存入userDetails對象。
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//登錄賬號
System.out.println("username="+username);
//根據賬號去數據庫查詢...
UserDto user = userDao.getUserByUsername(username);
if(user == null){
return null;
}
//查詢用戶權限
List<String> permissions = userDao.findPermissionsByUserId(user.getId());
String[] perarray = new String[permissions.size()];
permissions.toArray(perarray);
//創建userDetails
//這里將user轉為json，將整體user存入userDetails
String principal = JSON.toJSONString(user);
UserDetails userDetails =
User.withUsername(principal).password(user.getPassword()).authorities(perarray).build();
return userDetails;
}資源服務中的過慮 器負責 從header中解析json-token，從中即可拿網關放入的用戶身份信息，部分關鍵代碼如下：
...
if (token != null){
//1.解析token
String json = EncryptUtil.decodeUTF8StringBase64(token);
JSONObject userJson = JSON.parseObject(json);
//取出用戶身份信息
String principal = userJson.getString("principal");
//將json轉成對象
UserDTO userDTO = JSON.parseObject(principal, UserDTO.class);
JSONArray authoritiesArray = userJson.getJSONArray("authorities");
...感謝你能夠認真閱讀完這篇文章，希望小編分享的“Spring Security如何實現分布式系統授權”這篇文章對大家有幫助，同時也希望大家多多支持億速云，關注億速云行業資訊頻道，更多相關知識等著你來學習!
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
