Shiro简介与入门

Shiro简介与入门
Apache Shiro是一个强大且易用的Java安全框架,有身份验证、授权、密码学和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。
Spring security 重量级安全框架
Apache Shiro轻量级安全框架
i. 导入jar

org.apache.shiro shiro-core 1.4.0 commons-logging commons-logging 1.2 junit junit 4.12

ii. 准备资源
资源我们可以到shiro的源码文件中拷备:
/shiro-root-1.4.0-RC2/samples/quickstart/src/main/resources
shiro.ini
log4j.properties
注：users下面代表的登录的用户(用户名=密码)
shiro.ini文件(对拷备过来的数据进行了解释)：

#-----------------------------------------------------------------------------
 所有的用户与对应的用户密码 ，用户的角色
 -----------------------------------------------------------------------------
[users] root用户有一个密码是secret，他的角色是admin
root = secret, admin
guest = guest, guest
presidentskroob = 12345, president
 darkhelmet用户有一个密码是ludicrousspeed，他的角色是darklord, schwartz
darkhelmet = ludicrousspeed, darklord, schwartz
lonestarr = vespa, goodguy, schwartz

-----------------------------------------------------------------------------
#所有的用户的角色
#-----------------------------------------------------------------------------
[roles]
#admin这个角色有所有权限功能
admin = *
#schwartz这个角色可以操作所有的lightsaber权限功能
schwartz = lightsaber:*
#goodguy这个角色可以操作winnebago下面的drive权限的一个eagle5资源
goodguy = winnebago:drive:eagle5
iii.	总结
通过SecurityManger获取Suject :
SecurityUtils.setSecurityManager(securityManager);
Subject currentUser = SecurityUtils.getSubject();
通过Subject来做事情：
获取Session-存值和获取值 Suject.getSession session.setAttribute session.getAttribute
认证（登录）:
判断是否登录Suject.isAuthenticated()
如果没有登录，通过用户名和密码创建UsernamePasswordToken
调用subject.login(UsernamePasswordToken)来进行登录判断
登陆成功: 返回principal给当前用户
登陆失败: 抛出异常
授权
判断是否具有某个角色subject .hasRole
判断是否有权限subject .isPrermited(resource:操作)
自定义Realm
i.	准备工作
自定义Realm一般直接继承AuthorizingRealm接口即可(里面包含身份认证与授权两个方法)

```java
/**
 * 自定义一个Realm
 */
public class MyRealm extends AuthorizingRealm {

    //获取到这个Realm的名称(随便取)
    @Override
    public String getName() {
        return "MyRealm";
    }

    //进行授权判断（权限）
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    //进行身份认证(登录)
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
           return null;
    }


}
ii.	身份认证(登录)
身份认证的代码
/**
 * 自定义一个Realm
 */
public class MyRealm extends AuthorizingRealm {

    //获取到这个Realm的名称(随便取)
    @Override
    public String getName() {
        return "MyRealm";
    }

    //进行授权的认证
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    //进行登录的认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //明显的知道：这个authenticationToken就是UsernamePasswordtoken
        UsernamePasswordToken token = (UsernamePasswordToken)authenticationToken;
        String username = token.getUsername(); //拿到用户名(注:这个用户名是传过来的)
        //这里根据用户名去获取密码(如果没有获取到，相当于这个用户不存在，就返回null值)
        String password = getByName(username);
        if(password==null){
            return null;
        }
        //创建一个简单的身份信息(把用户名与密码放进去-注：它会自动的比较获取的密码与你传过来的密码)
        SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(username,password,getName());
        return authenticationInfo;
    }

//模拟从数据库中获取信息
    private String getByName(String username) {
        if("admin".equals(username)){
            return "123456";
        }else if("guest".equals(username)){
            return "abcd";
        }
        return null;
    }
}
iii.	授权(权限)认证
授权认证的代码`
public class MyRealm extends AuthorizingRealm {

    //获取到这个Realm的名称(随便取)
    @Override
    public String getName() {
        return "MyRealm";
    }

    //进行授权的认证
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //拿到认证的主要信息(用户名)
        String username = (String) principalCollection.getPrimaryPrincipal();
        //模拟根据用户名拿到角色信息与权限信息
        Set<String> roles = getRolesByUsername(username);
        Set<String> permissions = getPermissionsByUsername(username);
        //拿到验证信息对象
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        //设置用户的角色
        authorizationInfo.setRoles(roles);
        //设置用户的权限
        authorizationInfo.setStringPermissions(permissions);
        return authorizationInfo;
    }

    //模拟根据用户名拿到角色的功能
    private Set<String> getRolesByUsername(String username) {
        Set<String> roles = new HashSet<>();
        roles.add("admin");
        roles.add("it");
        return roles;
    }
    //模拟根据用户名拿到权限的功能
    private Set<String> getPermissionsByUsername(String username) {
        Set<String> permissions = new HashSet<>();
        permissions.add("employee.*");
        permissions.add("department.save");
        return permissions;
    }
   
}
密码加密功能
i.	Shiro中密码加密
/**
 * algorithmName:加密算法(md5,sha)
 *  source:原始密码
 *  salt,加盐
 *  hashIterations:遍历次数
 */
SimpleHash simpleHash = new SimpleHash("MD5","admin","itsource",10);
System.out.println(simpleHash);
ii.	测试时让自定义Reaml加上算法
@Test
     public void testMyRealm() throws Exception{
         //创建自己定义的Realm
         MyRealm myRealm = new MyRealm();
        //把Realm放到securityManager中去
         DefaultSecurityManager securityManager = new DefaultSecurityManager();
         securityManager.setRealm(myRealm);
         //把权限管理器放到相应的环境中(我们可以在项目任何位置拿到)
         SecurityUtils.setSecurityManager(securityManager);

         //设置咱们Realm的密码匹配器(我们的密码要怎么处理)
         HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
         matcher.setHashAlgorithmName("md5"); //匹配器使用MD5的算法
         matcher.setHashIterations(10);//加密算法要迭代多少次
         myRealm.setCredentialsMatcher(matcher);

         //拿到当前用户(Subject就是当前用户,游客)
         Subject currentUser = SecurityUtils.getSubject();
         //准备登录的令牌(准备用户名与密码) -> 这里的密码进行了加密
         UsernamePasswordToken token = new UsernamePasswordToken("admin","123456");

         try {
             //根据令牌进行功能登录(当前用户进行登录)
             currentUser.login(token);
             System.out.println("登录成功啦。。。。");
         } catch (UnknownAccountException e) {
             System.out.println("这个账号不存在!" + token.getPrincipal());
             e.printStackTrace();
         } catch (IncorrectCredentialsException ice) {
             System.out.println("这个密码不存在!" + token.getPrincipal());
             ice.printStackTrace();
         }catch (AuthenticationException e){
             System.out.println("i don't k");
         }
     }
iii.	自定义Reaml加上盐值
//进行登录的认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    //明显的知道：这个authenticationToken就是UsernamePasswordtoken
    UsernamePasswordToken token = (UsernamePasswordToken)authenticationToken;
    String username = token.getUsername(); //拿到用户名(注:这个用户名是传过来的)

    //这里根据用户名去获取密码(如果没有获取到，相当于这个用户不存在，就返回陪我)
    String password = getByName(username);
    if(password==null){
        return null;
    }
    //在这里加盐值需一个ByteSource对象，而Shiro提供了一个ByteSource对象给咱们
    ByteSource salt = ByteSource.Util.bytes("itsource");
    //创建一个简单的身份信息(把用户名与密码放进去-注：它会自动的比较获取的密码与你传过来的密码)
    SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(username,password,salt,getName());
    return authenticationInfo;
}

private String getByName(String username) {
    if("admin".equals(username)){
        // 4a95737b032e98a50c056c41f2fa9ec6: 123456 迭代10次不加盐的结果
        // 831d092d59f6e305ebcfa77e05135eac: 123456 迭代10次加盐(itsource)的结果
        return "831d092d59f6e305ebcfa77e05135eac"; //修改为加密加盐后的数据
    }else if("guest".equals(username)){
        return "abcd";
    }
    return null;
}
Shiro集成Spring
i.	准备Spring-web项目
拷备咱们的SSJ集成项目/直接在当前配置中完成

ii.	集成
1）导入shiro-all-1.3.2.ja(现升级到1.4.0)r
参考官方demo做示例:

<!-- shiro的支持包 -->
<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-all</artifactId>
  <version>1.4.0</version>
  <type>pom</type>
</dependency>
<!-- shiro与Spring的集成包 -->
<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-spring</artifactId>
  <version>1.4.0</version>
</dependency>
2）拷贝shiroFilter配置到web.xml

<!-- Spring与shiro集成:需要定义一个shiro过滤器(这是一个代理过滤器，它会到spring的配置中找一个名称相同的真实过滤器) -->
<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>
3）拷贝shiro Spring配置文件并集成到Spring
applicationContext.xml 改名为applicationContext-shiro.xml并在applicationContext.xml中导入

4）修改配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="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-3.0.xsd">


    <!-- 1.配置apache的管理器 -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <!-- 配置一个realm，到数据库中获取权限数据 -->
        <property name="realm" ref="jpaRealm"/>
    </bean>


    <!-- 2.我们可以自定义一个realm【暂时未实现功能】这个必需实现org.apache.shiro.realm.Realm接口 -->
    <bean id="jpaRealm" class="cn.itsource.yxb.shiro.realm.JpaRealm">
    </bean>

    <!-- 3.lifecycleBeanPostProcessor：可以自动调用在Spring Ioc窗口中 Shiro bean的生成周期方法 -->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
    <!-- 4.启动ioc容器中使用 shiro的注解，但是必需配置在Spring Ioc容器中Shiro bean的生成周期方法 -->
    <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>

    <!-- 5.shiro的真实过滤器(注：这个名称必需和web.xml的代表过滤器【DelegatingFilterProxy】名称一样) -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
        <!-- 登录的url,如果没有登录，你访问的路径会跳到这个页面 -->
        <property name="loginUrl" value="/s/login.jsp"/>
        <!-- 登录成功的url,如果登录成功，会跳转到这个页面 -->
        <property name="successUrl" value="/s/main.jsp"/>
        <!-- 没有权限时跳转到这个位置 -->
        <property name="unauthorizedUrl" value="/s/unauthorized.jsp"/>
        <!--
            配置哪些资源被保护，哪些资源需要权限
            anon：不需要登录也可以访问相应的权限
            authc：需要权限才能访问
              /** ：所有文件及其子文件
        -->
        <property name="filterChainDefinitions">
            <value>
                /s/login.jsp = anon
                /** = authc
            </value>
        </property>
    </bean>

</beans>

```java
SecurityManager：权限的核心管理对象
IniSecurityManagerFactory:读取到shiro.ini文件，并创建SecurityManagerFactory工厂对象
getInstance()：工厂对象创建一个核心管理对象的实例
SecurityUtils.setSecurityManager(securityManager);
将securityManager对象放入到shiro环境中
SecurityUtils.getSubject();获取到当前用户
isAuthenticated()：判断当前用户是否登录认证
UsernamePasswordToken(final String username, final String password)：
创建登录令牌对象 传入账号和密码
login(AuthenticationToken token)：登录
logout()：登出注销
hasRole(String roleIdentifier);判断当前用户是否有这个角色
isPermitted(String permission);判断当前用户是否有这个权限
AuthorizingRealm是一个抽象类 抽象类里的方法必须被覆写