- Spring Security的前身是Acegi Security，是 Spring项目组中用来提供安全认证服务的框架。
1. Spring Security安全包括两个主要操作：
a. “认证”
是为用户建立一个他所声明的主体。
主体一般是指用户，设备或可以在你系统中执行动作的其他系统。
b. “授权”
指的是一个用户能否在你的应用中执行某个操作
在到达授权判断之前，身份的主题已经由身份验证过程建立了。
- Spring Security使用
1. 导入相应jar包
spring-security-web.jar
spring-security-config.jar
2. 在web.xml配置文件中创建filter进行权限控制
* filter-name固定不可修改
<filter>
<filter-name>springSecurityFilterChain</filter-name>
<fliter-class>DelegatingFilterProxy</filter-class>
</filter>
<filter-mapping>
<filter-name>springSecurityFilterChain</filter-name>
<filter-pattern>/*</filter-pattern>
</filter-mapping>
3. 在xml配置文件中配置用户信息
/resours/spring-security.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:security="http://www.springframework.org/schema/security"
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">
<!-- 配置不过滤的资源（静态资源及登录相关） -->
<security:http security="none" pattern="/login.html" />
<security:http security="none" pattern="/failer.html" />
<security:http auto-config="true" use-expressions="false" >
<!-- 配置资料连接，表示任意路径都需要ROLE_USER权限 -->
<security:intercept-url pattern="/**" access="ROLE_USER" />
<!--
自定义登陆页面
login-page：自定义登陆页面
authentication-failure-url：用户权限校验失败之后才会跳转到这个页面
如果数据库中没有这个用户则不会跳转到这个页面。
default-target-url：登陆成功后跳转的页面(只要用户名和密码正确，不论权限是否足够)。
authentication-failure-url：登陆成功后跳转的页面
注：登陆页面用户名固定：username，密码：password，action:login
-->
<security:form-login login-page="/login.html"
login-processing-url="/login" username-parameter="username"
password-parameter="password" authentication-failure-url="/failer.html"
default-target-url="/success.html"
/>
<!-- 登出， invalidate-session 是否删除session logout-url：登出处理链接 logout-success-url：登出成功页面
注：登出操作 只需要链接到 logout即可登出当前用户 -->
<security:logout invalidate-session="true" logout-url="/logout"
logout-success-url="/login.jsp" />
<!-- 关闭CSRF,默认是开启的 -->
<security:csrf disabled="true" />
</security:http>
<security:authentication-manager>
<security:authentication-provider>
<!--
此处是在配置文件中指定用户
实际使用应该在数据库中判定用户信息
-->
<security:user-service>
<security:user name="user" password="{noop}user"
authorities="ROLE_USER" />
<security:user name="admin" password="{noop}admin"
authorities="ROLE_ADMIN" />
</security:user-service>
</security:authentication-provider>
</security:authentication-manager>
</beans>
- spring security使用数据库来进行权限认证
1. 使用UserDetail和UserDetailService完成认证操作
a. 使用UserDetail接口的实现类对象User，用户封装认证的用户信息
b. UserDetailService接口规范了认证时的方法是哪一个
2. 登陆流程
* 原本的用户登陆认证是自定义controller来操作
现在登陆认证由spring security来控制
* 原本用户登陆的认证由自定义service来操作
现在登陆认证的service必须实现UserDetailService接口，实现规范的登陆认证方法
* 原本由Dao查询获得的是自定义的用户Bean对象
现在必须规范的转化为UserDetail对象
使用数据库查询出来的用户名，密码，权限创建UserDetail接口的实现类User对象
User类有两个构造方法，其中可以控制用户的启用与否
3. 在xml配置文件中数据库中用户验证
/resources/spring-security.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:security="http://www.springframework.org/schema/security"
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">
<!-- 配置不拦截的资源 -->
<security:http pattern="/login.jsp" security="none"/>
<security:http pattern="/failer.jsp" security="none"/>
<security:http pattern="/css/**" security="none"/>
<security:http pattern="/img/**" security="none"/>
<security:http pattern="/plugins/**" security="none"/>
<!--
配置具体的规则
auto-config="true" 不用自己编写登录的页面，框架提供默认登录页面
use-expressions="false" 是否使用SPEL表达式（没学习过）
-->
<security:http auto-config="true" use-expressions="false">
<!-- 配置具体的拦截的规则 pattern="请求路径的规则" access="访问系统的人，必须有ROLE_USER的角色" -->
<security:intercept-url pattern="/**" access="ROLE_USER,ROLE_ADMIN"/>
<!-- 定义跳转的具体的页面 -->
<security:form-login
login-page="/login.jsp"
login-processing-url="/login.do"
default-target-url="/index.jsp"
authentication-failure-url="/failer.jsp"/>
<!-- 关闭跨域请求 -->
<security:csrf disabled="true"/>
<!-- 退出 -->
<security:logout invalidate-session="true" logout-url="/logout.do" logout-success-url="/login.jsp"
/>
</security:http>
<!-- 切换成数据库中的用户名和密码 -->
<security:authentication-manager>
<!--user-service-ref属性指定service层中提供验证的自定义类-->
<security:authentication-provider user-service-ref="userService">
<!-- 配置加密的方式，只有配置了才会在验证时将明文转为密文验证-->
<security:password-encoder ref="passwordEncoder"/>
</security:authentication-provider>
</security:authentication-manager>
<!-- 配置加密类，该工具类在service层存储用户前，对密码进行加密操作-->
<bean id="passwordEncoder" class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder"/>
<!-- 提供了入门的方式，在内存中存入用户名和密码
<security:authentication-manager>
<security:authentication-provider>
<security:user-service>
<security:user name="admin" password="{noop}admin" authorities="ROLE_USER"/>
</security:user-service>
</security:authentication-provider>
</security:authentication-manager>
-->
</beans>
- 权限控制
1. 服务器端：基于方法的权限控制
a. 三种方式：
* JSR-250注解
jsr250-api.jar
* @Secured注解
spring security提供的注解
* 支持表达式注解
该三种注解方式默认没有启用，需要在spring-security配置文件中配置/或者通过注解开启
xml配置文件：
<security:global-method-security jsr250-annotations="enabled"/>
<!--
<security:global-method-security secured-annotations="enabled"/>
<security:global-method-security pre-post-annotations="enabled"/>
-->
注解配置：
@EnableGlobalMethodSecurity：
Spring Security默认是禁用注解的
要想开启注解，需要在继承WebSecurityConfigurerAdapter的类上加@EnableGlobalMethodSecurity注解
并在该类中将AuthenticationManager定义为Bean
b. JSR-250注解：
* @RolesAllowed：
1. 标注在方法上，表示访问对应方法时所应该具有的角色
2. @RolesAllowed({"USER", "ADMIN"}) 该方法只要具有"USER", "ADMIN"任意一种权限就可以访问。
3. 这里可以省略前缀ROLE_，实际的权限是ROLE_ADMIN
* @PermitAll：
1. 表示允许所有的角色进行访问，也就是说不进行权限控制
* @DenyAll：
1. 是和PermitAll相反的，表示无论什么角色都不能访问
c. @Secured注解:
* @Secured：
1. 标注在方法上，表示访问对应方法时所应该具有的角色
2. 此处不能省略ROLE_前缀
d. 支持表达式注解：
* @PreAuthorize：
1. 在方法调用之前,基于表达式的计算结果来限制对方法的访问
2. 使用：
@PreAuthorize("#userId == authentication.principal.userId or hasAuthority(‘ADMIN’)")
void changePassword(@P("userId") long userId ){ }
这里表示在changePassword方法执行之前
判断方法参数userId的值是否等于principal中保存的当前用户的userId
或者当前用户是否具有ROLE_ADMIN权限，两种符合其一，就可以访问该方法。
* @PostAuthorize：
1. 允许方法调用,但是如果表达式计算结果为false,将抛出一个安全性异常
* @PostFilter：
1. 允许方法调用,但必须按照表达式来过滤方法的结果
* @PreFilter：
1. 允许方法调用,但必须在进入方法之前过滤输入值
2. 页面端：基于标签的权限控制
a. 导入相关jar包
spring-security-taglibs.jar
b. 在jsp页面导入taglib
<%@taglib uri="http://www.springframework.org/security/tags" prefix="security"%>
c. 标签：
* authentication标签：
1. 代表的是当前认证对象，可以获取当前认证对象信息，例如用户名。
2. 使用：
<security:authentication property="" htmlEscape="" scope="" var=""/>
属性：
property：只允许指定Authentication所拥有的属性
可以进行属性的级联获取，如“principle.username”，不允许直接通过方法进行调用
principle表示当前操作的对象
htmlEscape：表示是否需要将html进行转义。默认为true。
scope：与var属性一起使用，用于指定存放获取的结果的属性名的作用范围，默认我pageContext。
Jsp中拥有的作用范围都进行进行指定
var： 用于指定一个属性名，当获取到了authentication的相关信息后
会将其以var指定的属性名进行存放，默认是存放在pageConext中
* authorize标签：
1. 用于控制页面上某些标签是否可以显示
2. 使用：
<security:authorize access="" method="" url="" var="">
<!-包裹住需要访问控制的代码-->
</security:authorize>
属性：
access： 需要使用表达式来判断权限，当表达式的返回结果为true时表示拥有对应的权限
method：method属性是配合url属性一起使用的，表示用户应当具有指定url指定method访问的权限
method的默认值为GET，可选值为http请求的7种方法
url：url表示如果用户拥有访问指定url的权限即表示可以显示authorize标签包含的内容
var：用于指定将权限鉴定的结果存放在pageContext的哪个属性中
3. 注意事项：
* 在需要使用标签来控制访问权限时，在spring-security.xml配置中需要设置使用表达式
* 需要在access中使用表达式来控制权限
<security:http auto-config="true" use-expressions="true">
<!-- 配置具体的拦截的规则
pattern="请求路径的规则" access="访问系统的人，必须有ROLE_USER的角色" -->
<security:intercept-url pattern="/**" access="hasAnyRole(ROLE_USER,ROLE_ADMIN)"/>
...
</security:http>
* 如果不修改之前的use-expression和access，需要配置bean标签启用
<bean id="webSecurityExpressionHandler"
class=
"org.springframework.security.web.access.expression.DefaultWebSecurityExpressionHandler"/>
- 错误页面跳转
1. web.xml配置文件中配置错误跳转
* 使用标签error-page
<error-page>
<error-code>404</error-code>
<location>/xxxx.jsp</location>
<error-page>
- 通过AOP切面来记录操作日志
@Component
@Aspect
public class LogAop {
@Autowired
private HttpServletRequest request;
@Autowired
private ISysLogService sysLogService;
private Date startTime; // 访问时间
private Class executionClass;// 访问的类
private Method executionMethod; // 访问的方法
// 主要获取访问时间、访问的类、访问的方法
@Before("execution(* cn.mysilent.ssm.controller.*.*(..))")
public void doBefore(JoinPoint jp) throws NoSuchMethodException, SecurityException {
startTime = new Date(); // 访问时间
// 获取访问的类
executionClass = jp.getTarget().getClass();
// 获取访问的方法
String methodName = jp.getSignature().getName();// 获取访问的方法的名称
Object[] args = jp.getArgs();// 获取访问的方法的参数
if (args == null || args.length == 0) {// 无参数
executionMethod = executionClass.getMethod(methodName); // 只能获取无参数方法
} else {
// 有参数，就将args中所有元素遍历，获取对应的Class,装入到一个Class[]
Class[] classArgs = new Class[args.length];
for (int i = 0; i < args.length; i++) {
classArgs[i] = args[i].getClass();
}
executionMethod = executionClass.getMethod(methodName, classArgs);// 获取有参数方法
}
}
// 主要获取日志中其它信息，时长、ip、url...
@After("execution(* cn.mysilent.ssm.controller.*.*(..))")
public void doAfter(JoinPoint jp) throws Exception {
// 获取类上的@RequestMapping对象
if (executionClass != SysLogController.class) {
RequestMapping classAnnotation = (RequestMapping)
executionClass.getAnnotation(RequestMapping.class);
if (classAnnotation != null) {
// 获取方法上的@RequestMapping对象
RequestMapping methodAnnotation =
executionMethod.getAnnotation(RequestMapping.class);
if (methodAnnotation != null) {
String url = "";
// 它的值应该是类上的@RequestMapping的value+方法上的@RequestMapping的value
url = classAnnotation.value()[0] + methodAnnotation.value()[0];
SysLog sysLog = new SysLog();
// 获取访问时长
Long executionTime = new Date().getTime() - startTime.getTime();
// 将sysLog对象属性封装
sysLog.setExecutionTime(executionTime);
sysLog.setUrl(url);
// 获取ip
String ip = request.getRemoteAddr();
sysLog.setIp(ip);
// 可以通过securityContext获取，也可以从request.getSession中获取
SecurityContext context = SecurityContextHolder.getContext();
//request.getSession().getAttribute("SPRING_SECURITY_CONTEXT")
String username = ((User)
(context.getAuthentication().getPrincipal())).getUsername();
sysLog.setUsername(username);
sysLog.setMethod("[类名]" + executionClass.getName() + "[方法名]" +
executionMethod.getName());
sysLog.setVisitTime(startTime);
// 调用Service，调用dao将sysLog insert数据库
sysLogService.save(sysLog);
}
}
}
}
}
注意：
* 在获取注入的request对象时，需要在web.xml中配置一个监听器
* 配置RequestContextListener后，可以直接有spring注入HttpServletRequest
扫一扫
263
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
