用shiro来作为系统的权限控制，它和spring的整合比较简单。思路是：
1. 首先用sping+struts2 做个最简单的登录
2. 引入shiro
一：简单的登录
1.login.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<html>
<title>
Login Page
</title>
<head>
<title>Login Page</title>
</head>
<body>
<s:form action="login" method="post">
<s:textfield name="user.id" label="UserId"/>
<s:password name="user.password" label="Password"/>
<s:submit value="Login"/>
</s:form>
</body>
</html>
2. home.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<html>
<head>
<title>Login Page</title>
</head>
<body>
Hello, <s:property value="user.id" />
</body>
</html>
3.web.xml
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
4.struts.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="default" extends="struts-default" namespace="/">
<action name="login" class="com.***.web.LoginAction">
<result name="success">/home.jsp</result>
<result name="input">/index.jsp</result>
</action>
<!-- Add your actions here -->
</package>
</struts>
5.LoginAction 把后面的带上来了，shiro判断这块可以去掉
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.rain.bo.User;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class LoginAction extends ActionSupport implements ModelDriven {
/*--------------------------------------------
| C O N S T A N T S |
============================================*/
private static final transient Logger log = LoggerFactory.getLogger(LoginAction.class);
/*--------------------------------------------
| I N S T A N C E V A R I A B L E S |
============================================*/
private User user;
/*--------------------------------------------
| C O N S T R U C T O R S |
============================================*/
/*--------------------------------------------
| A C C E S S O R S / M O D I F I E R S |
============================================*/
public void setUser(User user) {
this.user = user;
}
public User getUser() {
return user;
}
/*--------------------------------------------
| M E T H O D S |
============================================*/
@Override
public String execute() throws Exception {
Subject currentUser = SecurityUtils.getSubject();
if (!currentUser.isAuthenticated()) {
UsernamePasswordToken token = new UsernamePasswordToken(user.getId(), user.getPassword());
try {
currentUser.login(token);
} catch (UnknownAccountException uae) {
log.info("There is no user with username of " + token.getPrincipal());
return INPUT;
} catch (IncorrectCredentialsException ice) {
log.info("Password for account " + token.getPrincipal() + " was incorrect!");
return INPUT;
} catch (LockedAccountException lae) {
log.info("The account for username " + token.getPrincipal() + " is locked. " +
"Please contact your administrator to unlock it.");
return INPUT;
}
// ... catch more exceptions here (maybe custom ones specific to your application?
catch (AuthenticationException ae) {
//...
}
}
return SUCCESS;
}
@Override
public Object getModel() {
return user;
}
}
6. User.java
public class User {
private String id;
private String password;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
以上能正常的登录
二。引入shiro
1. web.xml 增加
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext-shiro.xml</param-value>
</context-param>
<filter>
<filter-name>shiroFilter</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
<init-param>
<param-name>targetFilterLifecycle</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>shiroFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
2.applicationContext-shiro.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">
<description>Shiro 配置</description>
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<property name="securityManager" ref="securityManager" />
<property name="loginUrl" value="/login.jsp" />
<property name="successUrl" value="/index.jsp" />
<property name="unauthorizedUrl" value="/login.do" />
<property name="filterChainDefinitions">
<value>
/login.jsp = anon
/login* = anon
/** = authc
</value>
</property>
</bean>
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<!--设置自定义realm-->
<!--<property name="realm" ref="monitorRealm" />-->
<property name="realm" ref="iniRealm" />
</bean>
<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />
<!-- 使用配置文件管理 -->
<bean id="iniRealm" class="org.apache.shiro.realm.text.IniRealm">
<property name="resourcePath" value="classpath:/shiro.ini" />
</bean>
<!--自定义Realm 继承自AuthorizingRealm-->
<bean id="monitorRealm" class="com.**.realm.MonitorRealm"></bean>
<!-- securityManager -->
<bean class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="staticMethod"
value="org.apache.shiro.SecurityUtils.setSecurityManager" />
<property name="arguments" ref="securityManager" />
</bean>
<!-- Enable Shiro Annotations for Spring-configured beans. Only run after -->
<!-- the lifecycleBeanProcessor has run: -->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor"/>
<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
<property name="securityManager" ref="securityManager"/>
</bean>
</beans>
MonitorRealm：自定义Realm，这里可以选择数据源是DB的、CAS的或者其它
iniRealm ： 使用ini配置文件来管理shiro的，demo时候或者系统不变的时候可以选择
3. MonitorRealm
import com.rain.bo.User;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.SimplePrincipalCollection;
import org.springframework.stereotype.Service;
@Service("monitorRealm")
public class MonitorRealm extends AuthorizingRealm {
/* @Autowired
UserService userService;
@Autowired
RoleService roleService;
@Autowired
LoginLogService loginLogService;*/
public MonitorRealm() {
super();
}
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
/*这里编写授权代码*/
return null;
}
@Override
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken authcToken) throws AuthenticationException {
/*这里编写认证代码*/
UsernamePasswordToken token = (UsernamePasswordToken) authcToken;
String userName = token.getUsername();
if( userName != null && !"".equals(userName) ){
// User user = accountManager.login(token.getUsername(),
// String.valueOf(token.getPassword()));
if(token.getUsername().equals("admin") && String.valueOf(token.getPassword()).equals("123"))
return new SimpleAuthenticationInfo(token.getUsername(), token.getPassword(), getName());
/* if( user != null )
return new SimpleAuthenticationInfo(
user.getId(),user.getPassword(), getName());*/
}
return null;
}
public void clearCachedAuthorizationInfo(String principal) {
SimplePrincipalCollection principals = new SimplePrincipalCollection(principal, getName());
clearCachedAuthorizationInfo(principals);
}
}
三：
可见引入shiro对原有系统的影响是超级轻微的，只是把原来对象（权限）的获得抛给了shiro来处理，至于获取对象之前和对象之后的流程操作基本上不用变
分享到：
相关推荐
shiro 登录管理和权限管理：将用户在页面输入的账号密码通过控制器到自定义realm里进行登录认证，如果查不到或者密码错误则抛出异常，控制器抓取异常反馈到登录页面，信息正确则跳转到菜单页面，通过点击菜单跳转到...
提供的资源“Shiro和Spring整合完全可运行”应该是一个包含完整配置和示例代码的项目。通过这个实例，你可以了解如何设置 Realm，定义权限和角色，以及如何在控制器和视图层实现登录、权限控制等功能。通过实际运行...
在IT行业中，Spring Shiro整合是一项常见的安全框架搭建技术，主要应用于Java Web开发。Spring MVC作为主流的MVC框架，负责处理HTTP请求和业务逻辑，MyBatis则为持久层框架，负责数据库交互，而Apache Shiro则是一个...
在本文中，我们将深入探讨Shiro与Spring整合的关键知识点，包括整合的目的、核心组件、配置过程以及实际应用。 **一、整合目的** Shiro是一款轻量级的安全框架，提供了认证、授权、会话管理和加密等核心功能。...
在本项目实例中，我们将深入探讨如何将Shiro与Spring框架整合，以实现更高效、灵活的安全控制。 1. **Shiro基础** Apache Shiro 提供了用户认证、权限授权、加密和会话管理四大核心功能。认证是指验证用户身份，...
手把手教你集成spring cloud + shiro微服务框架；用最少的工作量，改造基于shiro安全框架的微服务项目，实现spring cloud + shiro 框架集成。博客地址：...
在提供的压缩包"shiroSpring"中，我们可以看到以下关键文件： 1. `shiro-config.xml`: Shiro的配置文件，包含了SecurityManager、Realm和其他配置。 2. `spring-config.xml`: Spring的配置文件，用于加载Shiro配置...
《整合Shiro、Spring与SpringMVC：打造高效安全控制框架》 在现代Java Web开发中，安全性是不可或缺的一部分。Apache Shiro是一个强大且易用的Java安全框架，提供了认证、授权、加密和会话管理功能，使得开发者能够...
Spring 和 Apache Shiro 的整合是企业级应用中常见的安全框架集成方式，主要用于实现用户认证、授权和会话管理等功能。Spring 提供了强大的依赖注入和面向切面编程能力，而Shiro则以其轻量级、易用性在权限管理领域...
**Spring MVC 整合 Shiro 知识点详解** Spring MVC 是一款强大的MVC框架，用于构建企业级的Web应用程序，而Apache Shiro则是一款安全框架，负责处理身份验证、授权（权限控制）、会话管理和安全性相关的其他功能。...
Spring Shiro 整合入门教程 在Web应用开发中，安全是至关重要的一个环节。Spring框架作为Java领域最流行的框架之一，提供了丰富的功能，而Apache Shiro则是一款强大的安全管理框架，专注于身份验证、授权和会话管理...
Apache Shiro 和 Spring 的整合是企业级应用中常见的安全框架集成方式，这使得开发者能够利用 Shiro 强大的权限管理功能，同时享受 Spring 提供的依赖注入和事务管理等服务。下面将详细介绍这个整合过程中的关键知识...
将Shiro 整合到Spring 和 Spring MVC 中，可以实现统一的身份验证和授权管理，简化安全控制逻辑。 1. **Shiro 基本概念**： - **认证（Authentication）**：验证用户身份的过程，即确认用户是谁。 - **授权...
将Shiro与Spring整合，可以充分利用两者的优点，实现更高效、更灵活的安全管理。 在"shiro与spring整合工程源代码"中，我们可以看到以下几个关键的知识点： 1. **Shiro的核心组件**： - **Authentication（认证）...
本教程结合Spring框架，将深入讲解如何在实际项目中整合Shiro，以提升应用的安全性能。 1. **Shiro的基本概念** - **认证**：验证用户身份的过程，即确定用户是谁。 - **授权**：确认用户有权访问特定资源或执行...
在 Spring 框架中整合 Shiro，首先需要在 `pom.xml` 文件中添加 Shiro 的依赖。接着，在 `Web.xml` 中配置 Shiro 过滤器，使用 `DelegatingFilterProxy` 来代理 Shiro 的 Filter，确保 Shiro 能够访问 Spring 容器...
这个"spring整合shiro登录小例子"提供了一个简化的实例，展示了如何在 Spring 框架中集成 Shiro 进行用户登录验证和权限控制。下面我们将深入探讨相关的知识点。 **1. Spring 框架** Spring 是一个广泛使用的 Java ...
本文将深入探讨如何将Spring与Shiro进行整合，实现高效且安全的权限管理。 首先，让我们了解Spring框架。Spring以其依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）的...
《Shiro与Spring整合实战详解》 在Java Web开发领域，Apache Shiro和Spring框架的结合使用已经成为一种常见的安全解决方案。本示例项目"shiro+Spring的Demo"旨在展示如何将这两个强大的工具集整合，以实现高效、...