spring security 登入、許可權管理配置

阿新 • • 發佈：2019-01-27

登入流程

1）容器啟動(MySecurityMetadataSource：loadResourceDefine載入系統資源與許可權列表)
2）使用者發出請求
3）過濾器攔截(MySecurityFilter:doFilter)
4）取得請求資源所需許可權(MySecurityMetadataSource:getAttributes)
5）匹配使用者擁有許可權和請求許可權(MyAccessDecisionManager:decide)，如果使用者沒有相應的許可權，

執行第6步，否則執行第7步。
6）登入
7）驗證並授權(MyUserDetailServiceImpl:loadUserByUsername)

1、web.xml中加入過濾器

<!-- SpringSecurity 核心過濾器配置 -->
<filter>
    <filter-name>springSecurityFilterChain</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>
<filter-mapping>
    <filter-name>springSecurityFilterChain</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

2、新建spring-security.xml檔案

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/security"
	xmlns:beans="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/security
	http://www.springframework.org/schema/security/spring-security.xsd">

	<!-- entry-point-ref 配置自定義登入 -->
	<http use-expressions="true" entry-point-ref="authenticationProcessingFilterEntryPoint">
		
		<!-- 登出配置 -->
		<logout logout-url="/j_spring_security_logout" logout-success-url="/login" />

		<access-denied-handler error-page="/noPower" />
		
		<!-- 過濾不被攔截的請求 -->
		<intercept-url pattern="/login*" access="permitAll" />
		<intercept-url pattern="/resources/**" access="permitAll" />
		
		<!-- 只有許可權才能訪問的請求 -->
		<intercept-url pattern="/admin/**" access="isAuthenticated()" />

		<custom-filter ref="loginFilter" position="FORM_LOGIN_FILTER" />
		<custom-filter ref="securityFilter" before="FILTER_SECURITY_INTERCEPTOR" />

	</http>

	<beans:bean id="loginFilter"
		class="cn.com.abel.test.service.security.MyUsernamePasswordAuthenticationFilter">
		
		<!-- 登入提交處理 -->
		<beans:property name="filterProcessesUrl" value="/j_spring_security_check"></beans:property>
		
		<!-- 登入成功跳轉 -->
		<beans:property name="authenticationSuccessHandler"
			ref="loginLogAuthenticationSuccessHandler"></beans:property>
		
		<!-- 設定登入失敗的網址 -->
		<beans:property name="authenticationFailureHandler"
			ref="simpleUrlAuthenticationFailureHandler"></beans:property>
		
		<!-- 使用者擁有許可權 -->	
		<beans:property name="authenticationManager" ref="myAuthenticationManager"></beans:property>
	</beans:bean>

	<beans:bean id="loginLogAuthenticationSuccessHandler"
		class="org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler">
		<beans:property name="defaultTargetUrl" value="/admin/index"></beans:property>
	</beans:bean>
	<beans:bean id="simpleUrlAuthenticationFailureHandler"
		class="org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler">
		<beans:property name="defaultFailureUrl" value="/login"></beans:property>
	</beans:bean>

	<authentication-manager alias="myAuthenticationManager">
		<authentication-provider user-service-ref="myUserDetailServiceImpl">
			<password-encoder ref="encoder" />
		</authentication-provider>
	</authentication-manager>

	<beans:bean id="myUserDetailServiceImpl"
		class="cn.com.abel.test.service.security.AdminUserDetailServiceImpl">
	</beans:bean>

	<beans:bean id="authenticationProcessingFilterEntryPoint"
		class="org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint">
		<beans:property name="loginFormUrl" value="/login"></beans:property>
	</beans:bean>

	<!-- 認證過濾器 -->
	<beans:bean id="securityFilter"
		class="cn.com.abel.test.service.security.MySecurityFilter">
		<!-- 使用者擁有的角色 -->
		<beans:property name="authenticationManager" ref="myAuthenticationManager" />
		<!-- 使用者是否擁有所請求資源的許可權 -->
		<beans:property name="accessDecisionManager" ref="myAccessDecisionManager" />
		<!-- 資源與角色的對應關係 -->
		<beans:property name="securityMetadataSource" ref="mySecurityMetadataSource" />
		<!-- <beans:property name="rejectPublicInvocations" value="true"/> -->

	</beans:bean>
	
	<beans:bean id="myAccessDecisionManager" class="myAccessDecisionManager"></beans:bean>
	
	<beans:bean id="mySecurityMetadataSource"
		class="cn.com.abel.test.service.security.MySecurityMetadataSource">
		<beans:constructor-arg>
			<beans:ref bean="resourceService" />
		</beans:constructor-arg>
	</beans:bean>

	<beans:bean id="encoder" class="org.springframework.security.authentication.encoding.Md5PasswordEncoder"></beans:bean>
  
</beans:beans>

3、MyUsernamePasswordAuthenticationFilter.java

package cn.com.abel.test.service.security;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.security.authentication.AuthenticationServiceException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

public class MyUsernamePasswordAuthenticationFilter extends UsernamePasswordAuthenticationFilter{

	@Override
	public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {

		if (!request.getMethod().equals("POST")) {
			throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
		}

		String username = obtainUsername(request);
		String password = obtainPassword(request);

		if (username == null) {
			username = "";
		}

		if (password == null) {
			password = "";
		}

		username = username.trim();

		UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(username, password);

		// Allow subclasses to set the "details" property
		setDetails(request, authRequest);

//		//登入驗證碼，如需要開啟把下面註釋去掉則可
//		String authCode = StringUtils.defaultString(request.getParameter("authCode"));
//		if(!AdwImageCaptchaServlet.validateResponse(request, authCode)){
//			throw new AuthenticationServiceException("validCode.auth.fail");
//		}

		return this.getAuthenticationManager().authenticate(authRequest);
	}
}

4、MySecurityFilter.java

package cn.com.abel.test.service.security;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import org.springframework.security.access.SecurityMetadataSource;
import org.springframework.security.access.intercept.AbstractSecurityInterceptor;
import org.springframework.security.access.intercept.InterceptorStatusToken;
import org.springframework.security.web.FilterInvocation;
import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;

public class MySecurityFilter extends AbstractSecurityInterceptor implements Filter {
	//與applicationContext-security.xml裡的myFilter的屬性securityMetadataSource對應，
	//其他的兩個元件，已經在AbstractSecurityInterceptor定義
	private FilterInvocationSecurityMetadataSource securityMetadataSource;

	@Override
	public SecurityMetadataSource obtainSecurityMetadataSource() {
		return this.securityMetadataSource;
	}

	public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {
		FilterInvocation fi = new FilterInvocation(request, response, chain);
		invoke(fi);
	}
	
	private void invoke(FilterInvocation fi) throws IOException, ServletException {
		// object為FilterInvocation物件
		//1.獲取請求資源的許可權
		//執行Collection<ConfigAttribute> attributes = SecurityMetadataSource.getAttributes(object);
		//2.是否擁有許可權
		//獲取安全主體，可以強制轉換為UserDetails的例項
		//1) UserDetails
		// Authentication authenticated = authenticateIfRequired();
		//this.accessDecisionManager.decide(authenticated, object, attributes);
		//使用者擁有的許可權
		//2) GrantedAuthority
		//Collection<GrantedAuthority> authenticated.getAuthorities()
		//System.out.println("使用者傳送請求！ ");
		InterceptorStatusToken token = null;
		
		token = super.beforeInvocation(fi);
		
		try {
			fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
		} finally {
			super.afterInvocation(token, null);
		}
	}

	public FilterInvocationSecurityMetadataSource getSecurityMetadataSource() {
		return securityMetadataSource;
	}

	public void setSecurityMetadataSource(FilterInvocationSecurityMetadataSource securityMetadataSource) {
		this.securityMetadataSource = securityMetadataSource;
	}
	
	public void init(FilterConfig arg0) throws ServletException {
		// TODO Auto-generated method stub
	}
	
	public void destroy() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public Class<? extends Object> getSecureObjectClass() {
		//下面的MyAccessDecisionManager的supports方面必須放回true,否則會提醒型別錯誤
		return FilterInvocation.class;
	}
}

5、AdminUserDetailServiceImpl.java

package cn.com.abel.test.service.security;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;

import cn.com.abel.test.model.RoleModel;
import cn.com.abel.test.model.MemberModel;
import cn.com.abel.test.service.RoleService;
import cn.com.abel.test.service.MemberService;

public class AdminUserDetailServiceImpl implements UserDetailsService {
	@Autowired
	private MemberService memberService;
	@Autowired
	RoleService roleService;
 
	//登入驗證
	public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
		
	 
		MemberModel member = memberService.getUserDetailsByUserName(username);
		
		if(member==null){
			throw new UsernameNotFoundException("member "+username +" not found.");
		}
		Set<GrantedAuthority> grantedAuths = obtionGrantedAuthorities(member);

                //封裝成spring security的user
                User userdetail = new User(user.getUserName(), user.getPassword(),
                true, // 賬號狀態 0 表示停用 1表示啟用
                true, true, true, grantedAuths // 使用者的許可權
                );
                return userdetail;
	}
	
	//取得使用者的許可權
	private Set<GrantedAuthority> obtionGrantedAuthorities(MemberModel member) {
		
		Set<GrantedAuthority> authSet = new HashSet<GrantedAuthority>();
		
		List<RoleModel> roles = roleService.getRoleByUser(member)<span style="font-family:Arial, Helvetica, sans-serif;">;</span>
		if(roles!=null){
			for(RoleModel role : roles) {
				authSet.add(new SimpleGrantedAuthority(role.getRoleCode().trim()));
			}
		}
 
		return authSet;
	}
	
}

6、MyAccessDecisionManager.java

package cn.com.abel.test.service.security;

import java.util.Collection;
import java.util.Iterator;

import org.springframework.security.access.AccessDecisionManager;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.authentication.InsufficientAuthenticationException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;

public class MyAccessDecisionManager implements AccessDecisionManager {
	
	public void decide(Authentication authentication, Object object, Collection<ConfigAttribute> configAttributes) throws AccessDeniedException, InsufficientAuthenticationException {
		if(configAttributes == null) {
			return;
		}
		//所請求的資源擁有的許可權(一個資源對多個許可權)
		Iterator<ConfigAttribute> iterator = configAttributes.iterator();
		while(iterator.hasNext()) {
			ConfigAttribute configAttribute = iterator.next();
			//訪問所請求資源所需要的許可權
			String needPermission = configAttribute.getAttribute();
			System.out.println("needPermission is " + needPermission);
			//使用者所擁有的許可權authentication
			for(GrantedAuthority ga : authentication.getAuthorities()) {
				if(needPermission.equals(ga.getAuthority())) {
					return;
				}
			}
		}
		//沒有許可權讓我們去捕捉
		throw new AccessDeniedException(" 沒有許可權訪問！");
	}

	public boolean supports(ConfigAttribute attribute) {
		// TODO Auto-generated method stub
		return true;
	}

	public boolean supports(Class<?> clazz) {
		// TODO Auto-generated method stub
		return true;
	}
	
}

7、MySecurityMetadataSource.java

package cn.com.abel.test.service.security;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.access.SecurityConfig;
import org.springframework.security.web.FilterInvocation;
import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
import org.springframework.security.web.util.matcher.RequestMatcher;

import cn.com.abel.test.model.RoleModel;
import cn.com.abel.test.service.ResourceService;

public class MySecurityMetadataSource  implements FilterInvocationSecurityMetadataSource,InitializingBean {

	
	private static final String AUTH_NO_ROLE =" __AUTH_NO_ROLE__";
	
	private ResourceService resourceService;
	
	public MySecurityMetadataSource(ResourceService resourceService) {
		this.resourceService = resourceService;
	}

	private static Map<String, Collection<ConfigAttribute>> resourceMap = null;

	public Collection<ConfigAttribute> getAllConfigAttributes() {
		return null;
	}

	public boolean supports(Class<?> clazz) {
		return true;
	}
	private void loadResourceDefine() {
		if(resourceMap == null) {
			resourceMap = new ConcurrentHashMap<String, Collection<ConfigAttribute>>();
		}else{
			resourceMap.clear();
		}
		
		Map<String,List<RoleModel>> resourceRoleMap = resourceService.getAllResourceRole();
		
		for (Entry<String,List<RoleModel>> entry : resourceRoleMap.entrySet()) {
			String url = entry.getKey();
			List<RoleModel> values = entry.getValue();
			
			Collection<ConfigAttribute> configAttributes = new ArrayList<ConfigAttribute>();
			for(RoleModel secRoleModel : values){
				ConfigAttribute configAttribute = new SecurityConfig(StringUtils.defaultString(secRoleModel.getRoleCode(),AUTH_NO_ROLE));
				configAttributes.add(configAttribute);
			}
			resourceMap.put(url, configAttributes);
		}
	}
	public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {
		
		HttpServletRequest request = ((FilterInvocation) object).getHttpRequest();  
 
		TreeMap<String, Collection<ConfigAttribute>> attrMap = new TreeMap<String, Collection<ConfigAttribute>>(resourceMap);
		
		Iterator<String> ite = attrMap.keySet().iterator();  
		
		RequestMatcher urlMatcher = null;  

		Collection<ConfigAttribute> attrSet = new HashSet<ConfigAttribute>();
		//match all of /admin/**  a/b/**
		while (ite.hasNext()) {  
			
			String resURL = ite.next();  
			urlMatcher = new AntPathRequestMatcher(resURL);

			if (urlMatcher.matches(request)||StringUtils.equals(request.getRequestURI(),resURL)) {  
				attrSet.addAll(attrMap.get(resURL));  
			}  
		}  

		if(!attrSet.isEmpty()){
			return attrSet;
		}
		return null;
	}
 
	@Override
	public void afterPropertiesSet() throws Exception {
		loadResourceDefine() ;
	}
	
}

8、ResourceService.java

此類是為從資料庫獲取系統中的資源所屬的角色，根據自己的資料表自行編寫。

package cn.com.abel.test.service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;

import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cn.com.abel.test.mapper.ResourceModelMapper;
import cn.com.abel.test.mapper.RoleModelMapper;
import cn.com.abel.test.mapper.RoleResourcetModelMapper;
import cn.com.abel.test.model.ResourceModel;
import cn.com.abel.test.model.ResourceModelCriteria;
import cn.com.abel.test.model.RoleModel;
import cn.com.abel.test.model.RoleModelCriteria;
import cn.com.abel.test.model.RoleResourcetModel;
import cn.com.abel.test.model.RoleResourcetModelCriteria;

@Service
public class ResourceService {
	
	@Autowired
	ResourceModelMapper resourceModelMapper;
	
	@Autowired
	RoleModelMapper roleMapper;
	
	@Autowired
	RoleResourcetModelMapper  roleResMapper;
	
	/**
	 * 獲取各個資源（url）對應的角色
	 * @return
	 */
	public Map<String,List<RoleModel>> getAllResourceRole(){
		
		 Map<String,List<RoleModel>> resultMap = new HashMap<String,List<RoleModel>>();
		 
		ResourceModelCriteria secResourceModelExample = new ResourceModelCriteria();
		List<ResourceModel> resourceList = resourceModelMapper.selectByExample(secResourceModelExample);
		
		if(CollectionUtils.isNotEmpty(resourceList)){
			for(ResourceModel secResourceModel : resourceList){
				RoleModelCriteria roleCriteria = new RoleModelCriteria();
				roleCriteria.createCriteria().andIdIn(getRoleIdsByResourceId(secResourceModel.getId()));
				List<RoleModel> roleList = roleMapper.selectByExample(roleCriteria);
				resultMap.put(secResourceModel.getValue(), roleList);
				
			}
		}
	 
		return resultMap;
	}
	
	public List<Integer> getRoleIdsByResourceId(Integer resourceId){
		List<Integer> roleIds = new ArrayList<Integer>();
		
		RoleResourcetModelCriteria criteria = new RoleResourcetModelCriteria();
		criteria.createCriteria().andResourceIdEqualTo(resourceId);
		List<RoleResourcetModel> list = roleResMapper.selectByExample(criteria);
		if(CollectionUtils.isNotEmpty(list)){
			for(RoleResourcetModel model : list){
				roleIds.add(model.getRoleId());
			}
		}
		
		HashSet<Integer> h  =   new  HashSet<Integer>(roleIds);     
		roleIds.clear();     
		roleIds.addAll(h);   
		return roleIds;
	}
}

最後附上資料表的SQL：

CREATE TABLE `auth_resource` (
	`id` INT(11) NOT NULL AUTO_INCREMENT,
	`name` VARCHAR(100) NULL DEFAULT NULL COMMENT '資源名稱',
	`value` VARCHAR(100) NULL DEFAULT NULL COMMENT '資源值',
	`summary` VARCHAR(1000) NULL DEFAULT NULL COMMENT '資源描述',
	`updated_time` DATETIME NULL DEFAULT NULL,
	`updated_user` VARCHAR(100) NULL DEFAULT NULL,
	PRIMARY KEY (`id`)
)
COMMENT='資源訪問表'
COLLATE='utf8_general_ci'
ENGINE=InnoDB;

CREATE TABLE `auth_role` (
	`id` INT(11) NOT NULL AUTO_INCREMENT,
	`role_name` VARCHAR(100) NULL DEFAULT NULL COMMENT '角色名稱',
	`role_code` VARCHAR(100) NULL DEFAULT NULL COMMENT '角色程式碼',
	`updated_time` DATETIME NULL DEFAULT NULL,
	`updated_user` VARCHAR(100) NULL DEFAULT NULL,
	PRIMARY KEY (`id`)
)
COMMENT='角色表'
COLLATE='utf8_general_ci'
ENGINE=InnoDB;

CREATE TABLE `role_resource` (
	`id` INT(11) NOT NULL AUTO_INCREMENT,
	`role_id` INT(11) NOT NULL,
	`resource_id` INT(11) NOT NULL,
	PRIMARY KEY (`id`),
	UNIQUE INDEX `role_id_resource_id` (`role_id`, `resource_id`)
)
COMMENT='資源角色關聯表'
COLLATE='utf8_general_ci'
ENGINE=InnoDB;

CREATE TABLE `member` (
	`id` INT(11) NOT NULL AUTO_INCREMENT,
	`user_name` VARCHAR(100) NULL DEFAULT NULL,
	`nick` VARCHAR(100) NULL DEFAULT NULL,
	`password` VARCHAR(100) NULL DEFAULT NULL,
	`sex` INT(11) NULL DEFAULT NULL,
	`birthday` DATE NULL DEFAULT NULL,
	`mobile` VARCHAR(50) NULL DEFAULT NULL,
	`email` VARCHAR(50) NULL DEFAULT NULL,
	`address` VARCHAR(512) NULL DEFAULT NULL,
	`regip` VARCHAR(100) NULL DEFAULT NULL,
	`created_time` DATETIME NULL DEFAULT NULL,
	PRIMARY KEY (`id`)
)
COMMENT='使用者表'
COLLATE='utf8_general_ci'
ENGINE=InnoDB
AUTO_INCREMENT=2;

CREATE TABLE `member_role` (
	`id` INT(11) NOT NULL AUTO_INCREMENT,
	`member_id` INT(11) NOT NULL,
	`role_id` INT(11) NOT NULL,
	PRIMARY KEY (`id`),
	UNIQUE INDEX `member_id_role_id` (`member_id`, `role_id`)
)
COMMENT='使用者角色關聯表'
COLLATE='utf8_general_ci'
ENGINE=InnoDB;

完整程式碼下載（包含資料庫）：http://download.csdn.net/download/rongku/9931455

spring security 登入、許可權管理配置

登入流程 1）容器啟動(MySecurityMetadataSource：loadResourceDefine載入系統資源與許可權列表) 2）使用者發出請求 3）過濾器攔截(MySecurityFilter:doFilter) 4）取得請求資源所需許可權(MySe

springBoot整合spring security+JWT實現單點登入與許可權管理前後端分離--築基中期

## 寫在前面在前一篇文章當中，我們介紹了springBoot整合spring security單體應用版，在這篇文章當中，我將介紹springBoot整合spring secury+JWT實現單點登入與許可權管理。本文涉及的許可權管理模型是**基於資源的動態許可權管理**。資料庫設計的表有 user

spring實戰-Spring-security實現使用者許可權認證登入

第八篇：Spring-security實現使用者許可權認證登入 spring-security原本是Acegi Security元件，該元件是一個強大的安全框架，但是使用方式很繁瑣，要配置幾百行XML。整合進Spring後，就可以通過xml或者JavaConfig的方式，很容易的就實現了系統

ssm下的spring-security登入許可權與角色記錄

配置檔案記錄 <?xml version="1.0" encoding="UTF-8"?> <beans:beans xmlns="http://www.springframework.org/schema/security" xmlns:b

Jenkins使用者配置(安裝好jenkins後，怎麼配置使用者管理、許可權管理)

直奔主題安裝完成後，先開啟使用者配置 1. 系統管理--》配置許可權 2. 啟用安全，並選中“安全矩陣” 如上，搞定；可以按使用者去設定各專案的操作許可權了；輕鬆實現，jenki

Spring Boot 2.X(十八)：整合 Spring Security-登入認證和許可權控制

前言在企業專案開發中，對系統的安全和許可權控制往往是必需的，常見的安全框架有 Spring Security、Apache Shiro 等。本文主要簡單介紹一下 Spring Security，再通過 Spring Boot 整合開一個簡單的示例。 Spring Security 什麼是 Spring Se

spring整合mybatis的事物管理配置

AR nbsp 修改 HA nag word per 進行 rem 一、基本配置 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/sc

linux 使用者、組、許可權管理

使用者(user）和使用者組（group） Linux 系統中存在三種使用者：root 使用者、系統使用者（也稱之為偽用戶）、普通使用者系統約定： RHEL6 uid: 0 特權使用者 uid: 1~499 系統使用者 uid: 500+ 普通使用者使用者和使用者組的對應關係是：一

springboot使用Spring Security+OAuth2做許可權控制

文章來源：http://lxgandlz.cn/404.html 前面有一篇文章Spring+Spring Security+OAuth2實現REST API許可權控制，講了Spring+Spring Security+OAuth2來實現REST API許可權

1、shell 重定向、使用者及組、許可權管理

1、重定向操作 1.1、< 將命令中接收輸入的途徑由預設的鍵盤更改為指定的檔案 1.2、 > 將命令的結果覆蓋地寫入檔案中，而不在螢幕上顯示 1.3、 >> 將命令的結果追加到指定檔案 1.4、 2> 將錯誤資訊覆蓋地寫入指定檔案中 1.5、 2>&

ssm整合shiro通過自定義Realm實現認證登入、許可權處理、自定義role攔截、MD5加密

整合後實現功能 1.登入認證 2.許可權處理 3.自定義role攔截 4.md5加密 ssm整合shiro步驟先看看整合完成後的專案結構新建一個maven專案配置pom.xml檔案 <?xml version="1.0" encoding="UT

shiro的使用者登入和許可權管理

shiro能做什麼？登入驗證: 不是登入使用者不能訪問敏感資源,只有登入了才可以訪問敏感資源許可權驗證：不同的使用者賬號登入成功之後,使用者所使用的功能不同類似的安全框架: 1.spring security 功能完善,學習成本偏高 2.

【Linux】使用者和使用者組管理、許可權管理、vi編輯器、sudo許可權管理

使用者和使用者組管理 1、使用者配置檔案位置 -》cat /etc/passwd 2、root: x:0:0:root:/root:/bin/bash -》root 代表使用者名稱 -》x 密碼標識，

spring security登入

form-login是spring security名稱空間配置登入相關資訊的標籤,它包含如下屬性： 1. login-page 自定義登入頁url,預設為/login 2. login-processing-url 登入請求攔截的url,也就是form表單提交時指定的act

linux常用基本命令之使用者、許可權管理（一）

簡介⽤戶是Unix/Linux系統⼯作中重要的⼀環，⽤戶管理包括⽤戶與組賬號的管理。在Unix/Linux系統中，不論是由本機或是遠端登入系統，每個系統都必須擁有⼀個賬號，並且對於不同的系統資源擁有不同的使⽤許可權。Unix/Linux系統中的root賬號通常

電商專案day06(繼承spring-security框架到商家管理&商家商品錄入)

今日目標: 1、完成商家管理的安全框架控制 2、完成登入的密碼加密（BCrypt加密演算法） 3、商家登入登出的使用者名稱顯示 4、商品錄入功能實現之商品基本資訊錄入一、商家管理加入安全框架分析：在運營商管理的中我們，我們的使用者名稱和密碼都是在spring-srcu

Linux使用者、許可權管理命令

目錄使用者是Unix/Linux系統工作中重要的一環，使用者管理包括使用者與組賬號的管理。在Unix/Linux系統中，不論是由本機或是遠端登入系統，每個系統都必須擁有一個賬號，並且對於不同的系統資源擁有不同的使

Spring Security系列之Session管理(十四)

Session:在計算機中，尤其是在網路應用中，稱為“會話控制”。Session 物件儲存特定使用者會話所需的屬性及配置資訊。這樣，當用戶在應用程式的 Web 頁之間跳轉時，儲存在 Session 物件中的變數將不會丟失，而是在整個使用者會話中一直存在下去。當用戶請求來自應用程式的 Web 頁時

mysql 基礎篇(二) 賬號、許可權管理

mysql 基礎篇(二) 賬號、許可權管理、備份與還原建立賬號密碼：Grant all on test.* to “cj”@”localhost” identified by “cj”; 建立賬號如果報錯：需要執行flush privileges 後，在重新執行新增使用者就可

freemarker 使用spring security標籤進行許可權判斷以及錯誤解決

freemarker 使用spring security標籤進行許可權判斷，配置起來非常簡單。網上有很多例子，簡單配置步驟如下： pom.xml 中加入spring security支援 <dependency>

spring security 登入、許可權管理配置

相關推薦