ssm整合shiro通过自定义Realm实现认证登录、权限处理、自定义role拦截、MD5加密

最新推荐文章于 2023-07-06 21:30:39 发布
置顶 最新推荐文章于 2023-07-06 21:30:39 发布
阅读量1.1k 收藏 5
点赞数
分类专栏： java及javaweb ssm框架 文章标签： shiro
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IManiy/article/details/83010510
版权

整合后实现功能

1.登录认证
2.权限处理
3.自定义role拦截
4.md5加密

ssm整合shiro步骤

ssm框架整合链接：https://blog.csdn.net/IManiy/article/details/81393256
开发工具：IDEA
Demo框架：Spring+SpringMVC+Mybatis+Maven

先看看整合完成后的项目结构
在这里插入图片描述

新建一个maven项目

配置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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>top.maniy</groupId>
    <artifactId>shiro-ssm</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <junit.version>4.12</junit.version>
        <spring.version>4.1.3.RELEASE</spring.version>
        <mybatis.version>3.2.8</mybatis.version>
        <mybatis.spring.version>1.2.2</mybatis.spring.version>
        <mybatis.paginator.version>1.2.15</mybatis.paginator.version>
        <mysql.version>5.1.32</mysql.version>
        <slf4j.version>1.6.4</slf4j.version>
        <jackson.version>2.4.2</jackson.version>
        <druid.version>1.0.9</druid.version>
        <jstl.version>1.2</jstl.version>
        <servlet-api.version>2.5</servlet-api.version>
        <jsp-api.version>2.0</jsp-api.version>
        <commons-lang3.version>3.3.2</commons-lang3.version>
        <commons-io.version>1.3.2</commons-io.version>
        <commons-net.version>3.3</commons-net.version>
        <pagehelper.version>3.4.1</pagehelper.version>
        <shiro-spring>1.2.3</shiro-spring>
        <shiro-core>1.2.3</shiro-core>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>${mybatis.spring.version}</version>
        </dependency>
        <dependency>
            <groupId>com.github.miemiedev</groupId>
            <artifactId>mybatis-paginator</artifactId>
            <version>${mybatis.paginator.version}</version>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>${pagehelper.version}</version>
        </dependency>
        <!-- Apache工具组件 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${commons-lang3.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-io</artifactId>
            <version>${commons-io.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>${commons-net.version}</version>
        </dependency>
        <!-- Jackson Json处理工具包 -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- 日志处理 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- JSP相关 -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>${jstl.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>${servlet-api.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jsp-api</artifactId>
            <version>${jsp-api.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>${shiro-core}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>${shiro-spring}</version>
        </dependency>
    </dependencies>

</project>

进行SSM框架整合

通过project Structure新建webpp及其下面目录

在这里插入图片描述

新建项目结构文件夹及文件

在这里插入图片描述

sqlMapConfig.xml、spring-service、spring-dao、jdbc.properites与下面链接相同

ssm框架整合链接：https://blog.csdn.net/IManiy/article/details/81393256

spring-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:context="http://www.springframework.org/schema/context"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.0.xsd">

    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
        <property name="loginUrl" value="login.html"/>
        <property name="unauthorizedUrl" value="403.html" />
        <property name="filterChainDefinitions">
            <value>
                <!-- 这里顺序执行 anon不要认证 authc需要认证，一般情况下 /*放在最下面-->
                <!--加载静态资源 /js/** = anon-->

                /login.html = anon
                /subLogin = anon
                /testRole2=roles["admin"]
                /testRole3=rolesOr["admin","admin1"]
                /testPerms =perms[user:select]
                /testPerms1 =perms["user:select","user:update"]
                /* = authc
            </value>
        </property>
        <property name="filters">
            <util:map>
                <entry key="rolesOr" value-ref="rolesOrFilter"/>
            </util:map>


        </property>
    </bean>

    <bean class="top.maniy.demo.filter.RolesOrFilter" id="rolesOrFilter"/>
    <!--创建SecurityManager对象 -->
    <bean class="org.apache.shiro.web.mgt.DefaultWebSecurityManager" id="securityManager">
        <property name="realm" ref="realm"/>
    </bean>

    <!--自定义realm -->
    <bean class="top.maniy.demo.shiro.realm.CustomRealm" id="realm">
        <property name="credentialsMatcher" ref="credentialsMatcher" />
    </bean>
    <!--md5 加密-->
    <bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher" id="credentialsMatcher">
        <property name="hashAlgorithmName" value="md5" />
        <property name="hashIterations" value="1"/>

    </bean>

</beans>

springmvc.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:p="http://www.springframework.org/schema/p"
		xmlns:context="http://www.springframework.org/schema/context"
	    xmlns:aop="http://www.springframework.org/schema/aop"
	    xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
	<!-- 配置Controller扫描 -->
	<context:component-scan base-package="top.maniy.demo.controller" />
<!-- 配置注解驱动 -->
	<mvc:annotation-driven />
	
	<!-- 对静态资源放行 -->
	<!--<mvc:resources location="/css/" mapping="/css/**"/>
	<mvc:resources location="/js/" mapping="/js/**"/>
	<mvc:resources location="/fonts/" mapping="/fonts/**"/>-->
	<!-- 2.静态资源默认servlet配置 (1)加入对静态资源的处理：js,gif,png (2)允许使用"/"做整体映射 -->
	<mvc:resources mapping="/*" location="WEB-INF/" />



	<!-- 配置视图解析器 -->
	<bean	class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>

		<!-- 前缀 -->
		<property name="prefix" value="/WEB-INF/page/" />
		<!-- 后缀 -->
		<property name="suffix" value=".jsp" />
	</bean>


	<aop:config proxy-target-class="true"/>

	<!--Shiro配置-->
	<!--
        1.配置lifecycleBeanPostProcessor，可以在Spring IOC容器中调用shiro的生命周期方法.
    -->
	<bean class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />

	<!--
       2.开启Spring AOC Shiro注解支持
   -->
	<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
		<property name="securityManager" ref="securityManager"/>
	</bean>
</beans>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <welcome-file-list>
        <welcome-file>login.html</welcome-file>
    </welcome-file-list>

    <!--配置shiro-->
    <filter>
        <filter-name>shiroFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>shiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 配置spring -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/spring-*.xml</param-value>
    </context-param>

    <!-- 配置监听器加载spring -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 配置过滤器，解决post的乱码问题 -->
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>


    <!-- 配置SpringMVC -->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/springmvc.xml</param-value>
        </init-param>
        <!-- 配置springmvc什么时候启动，参数必须为整数 -->
        <!-- 如果为0或者大于0，则springMVC随着容器启动而启动 -->
        <!-- 如果小于0，则在第一次请求进来的时候启动 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <!-- 所有的请求都进入springMVC -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

自定义role拦截RolesOrFilter

/**
 * @author liuzonghua
 * @Package top.maniy.filter
 * @Description:自定义role拦截，定义：如果有一个权限存在就可以跳转
 * @date 2018/10/9 12:57
 */
public class RolesOrFilter extends AuthorizationFilter{

    protected boolean isAccessAllowed(ServletRequest servletRequest, ServletResponse servletResponse, Object o) throws Exception {
        Subject subject =getSubject(servletRequest,servletResponse);
        String[] roles =(String[])  o;
        if(roles ==null || roles.length == 0){
            return true;
        }
        for (String role:roles){
            if(subject.hasRole(role)){
                return  true;
            }
        }
        return false;
    }
}

UserMapper.java

public interface UserMapper {
    //查询根据username用户信息
    User getUserByUserName(String userName);
    //根据username查询角色
    List<String> queryRolesByUserName(String userName);
    //根据username查询权限
    List<String> queryPermissionByUserName(String userName);
}

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace ="top.maniy.demo.mapper.UserMapper">


	<select id="getUserByUserName" resultType="User">
		SELECT * FROM users WHERE username=#{username}
	</select>
	<select id="queryRolesByUserName" resultType="String">
		SELECT role_name FROM user_roles WHERE username=#{username}
	</select>
	<select id="queryPermissionByUserName" resultType="String">
		SELECT permission FROM roles_permissions WHERE role_name=#{role_name}
	</select>
</mapper>

自定义CustomRealm

public class CustomRealm extends AuthorizingRealm{

    @Autowired
    private UserMapper userMapper;
//    Map<String,String> userMap =new HashMap<String, String>(16);
//    {
//        userMap.put("maniy","993121f227e2cef658c392549708d60c");
//        super.setName("customRealm");
//    }
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        String userName = (String) principalCollection.getPrimaryPrincipal();
        Set<String> roles =getRolesByUserName(userName);

        Set<String> permissions = getPermissionByUserName(userName);
        SimpleAuthorizationInfo simpleAuthorizationInfo =new SimpleAuthorizationInfo();
        simpleAuthorizationInfo.setStringPermissions(permissions);
        simpleAuthorizationInfo.setRoles(roles);
        return simpleAuthorizationInfo;
    }

    private Set<String> getPermissionByUserName(String userName) {
        List<String> listR =userMapper.queryRolesByUserName(userName);
        List<String>listP=new ArrayList<String>();
        for(String str:listR){
             listP.addAll(userMapper.queryPermissionByUserName(str));
        }

        Set<String> sets =new HashSet<String>(listP);
//     Set<String> sets =new HashSet<String>();
//     sets.add("user:delete");
//     sets.add("user:add");
     return sets;
    }

    private Set<String> getRolesByUserName(String userName) {
        System.out.println("从数据库中获取授权数据");
        List<String> list =userMapper.queryRolesByUserName(userName);

        Set<String> sets=new HashSet<String>(list);
//        Set<String> sets =new HashSet<String>();
//        sets.add("admin");
//        sets.add("user");
        return sets;
    }

       protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken)
            throws AuthenticationException {
        //1.从主体传过来额认证信息中，获得用户名
        String userName = (String) authenticationToken.getPrincipal();
        //2.通过用户名到数据库中获取凭证
        String password = getPasswordByUserName(userName);
        if(password == null){
            return null;
        }
        SimpleAuthenticationInfo simpleAuthenticationInfo =new SimpleAuthenticationInfo
                (userName,password,"customRealm");
        //shiro需要知道用了什么盐，在去解析密码
        simpleAuthenticationInfo.setCredentialsSalt(ByteSource.Util.bytes(userName));

        return simpleAuthenticationInfo;
    }

    /**
     * 模拟数据库查询认证
     * @param username
     * @return
     */
    private String getPasswordByUserName(String username){
        //
        User user =userMapper.getUserByUserName(username);
        if(user!=null){
            System.out.println(user.getPassword());
            return user.getPassword();
        }else {
            return null;
        }
        //return userMap.get(username);
    }

    public static void main(String[] args) {
        //单一的是密码加密容易破解，这时候就需要 加盐
        Md5Hash md5Hash= new Md5Hash("1234567","Mark");
        System.out.println(md5Hash.toString());
    }
}

UserController

@Controller
public class UserController {
    @RequestMapping(value = "/subLogin" ,method = RequestMethod.POST,
    produces = "application/json;charset=utf-8")
    @ResponseBody
    public String subLogin(User user){
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token =new UsernamePasswordToken(user.getUsername(),
                user.getPassword());
        try {
            token.setRememberMe(user.isRememberMe());
            subject.login(token);
        } catch (AuthenticationException e) {
            return  e.getMessage();
        }
        if(subject.hasRole("admin")){
            if (subject.isPermitted("user:select")){
                return "权限为user:select";
            }
            return "有admin权限";
        }
        return "无admin权限";
    }

    /**
     * 通过注解配置授权
     * 用户角色必须具备admin权限才能访问
     * @return
     */
    @RequiresRoles("admin")
    //@RequiresPermissions("xxxx")
    @RequestMapping(value = "/testRole",method = RequestMethod.GET)
    @ResponseBody
    public String TestRole(){
        return "testRole success";
    }

    /**
     * 通过注解配置授权
     * 用户角色必须具备admin权限才能访问
     * @return
     */
    @RequiresRoles("admin1")
    @RequestMapping(value = "/testRole1",method = RequestMethod.GET)
    @ResponseBody
    public String TestRole1(){
        return "testRole1 success";
    }

    @RequestMapping(value = "/testRole2",method = RequestMethod.GET)
    @ResponseBody
    public String TestRole2(){
        return "testRole2 success";
    }
    @RequestMapping(value = "/testRole3",method = RequestMethod.GET)
    @ResponseBody
    public String TestRole3(){
        return "testRole3 success";
    }

    @RequestMapping(value = "/testPerms",method = RequestMethod.GET)
    @ResponseBody
    public String TestPerms(){
        return "testPerms success";
    }
    @RequestMapping(value = "/testPerms1",method = RequestMethod.GET)
    @ResponseBody
    public String TestPerms1(){
        return "testPerms1 success";
    }
}

login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</head>
<body>
<form action="subLogin" method="post">
    <input type="text" name="username" /><br>
    <input type="password" name="password"/><br>
    <input type="checkbox" name="rememberMe" />记住我
    <input type="submit" value="登录">
</form>
</body>
</html>

数据库

在这里插入图片描述

项目demo下载：https://download.csdn.net/download/imaniy/10713477

IManiy
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SSM整合shiro 实现用户角色权限管理
Aron的博客
01-21 2241
ps: 一.环境:SpringMvc+spring+Mybatis,前后端分离,只支持单台项目(未实现单点登入); 二.需对shiro原理流程,有基础的理解,以及用户权限需求的应用场景明了,能更好项目整合; 三.shiro的基本构成: 1.Subject (接口) : 主体(当前用户) 定义了认证授权的相关函数,通过SecurityManage 安全管理器进行授权按认证 2...
SSM+Shiro+Redis实现项目的权限管理
05-06
SSM+Shiro+Redis是Java Web开发中一种常见的权限管理解决方案，主要涉及Spring、Spring MVC、MyBatis三大框架与Apache Shiro安全框架及Redis缓存技术的整合。这个小Demo展示了如何在项目中实现高效且灵活的权限控制...
SSM+Apache shiro--自定义realm
weixin_30410999的博客
01-14 88
自定义reaml需继承AuthorizingRealm，并重写doGetAuthorizationInfo（用户获取授权信息）和doGetAuthenticationInfo（用户获取认证信息）两个方法。例如： import java.util.ArrayList; import java.util.HashSet; import java.util.Set; impor...
SSM整合Shiro___多认证Realm
qq_37432174的博客
07-17 437
实际开发中存在这样一种场景，同一个密码可能在MqSQL中存储，也可能在Oracle中存储，有可能MqSQL中使用的是MD5加密算法，而Oracle使用SHA1加密算法。这就需要有多个Realm以及认证策略的问题。 加入依赖 <dependencies> <!-- https://mvnrepository.com/artifact/org.springframework/sp...
Shiro 六 自定义realm检查用户角色权限
这天有点热的博客
05-07 598
整体目录： pom文件 <?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://...
shrio自定义realm，权限拦截
weixin_34347651的博客
01-15 65
2019独角兽企业重金招聘Python工程师标准>>> ...
maven+SSM+shiro简单的授权和认证
12-26
- 在Spring配置中添加Shiro的Realm，实现自定义的认证和授权逻辑。 - 使用Shiro过滤器，如`authc`（认证过滤器）和`perms`（权限过滤器），设置URL拦截规则。 - 配置Shiro的Session管理和缓存管理，提高性能。 - 在...
ssm shiro 整合
11-09
5. **Authorization（授权）**：Shiro通过Role（角色）和Permission（权限）进行授权，可以实现细粒度的权限控制。可以基于角色或权限进行访问控制，如URL拦截、方法级别的权限检查。 6. **Cryptography（加密）**...
Shiro整合SSM代码
11-27
Apache Shiro 和 Springmvc、...这个整合项目可以帮助开发者理解 Shiro 如何与 SSM 框架协同工作，以及如何实现基于角色和权限的认证和授权。通过学习和实践这个示例，开发者可以更好地掌握 Java Web 应用的安全控制。
学习 权限框架shiro 的ssm
11-22
以上就是关于"学习权限框架Shiro的SSM"的知识点介绍，通过整合Shiro与SSM，我们可以构建出一套完整的权限管理体系，实现对用户访问的精细控制。在实际项目中，Shiro的灵活性和易用性使得它成为许多开发者首选的安全...
Java基于ssm框架的shiro整合，带有md5加密
01-06
使用：1，更改数据库配置文件2，创建test表（User的数据结构）。。。工具：Java7+eclipse+maven。 基于ssm框架的shiro整合，带有md5加密，注释只针对于shiro，其中有搭建过程中参考的博客地址，如有不懂的请参考注释中给的地址
SSM整合Shiro 身份验证及密码加密简单实现
weixin_33805992的博客
07-13 311
1.导入maven的相关依赖 　　　　<!-- shiro --> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-all</artifactId> ...
Shiro整合SSM 实现认证、授权、会话管理、多Realm、记住我功能
qq_43962245的博客
01-23 382
Shiro整合SSM 实现认证、授权、会话管理、多Realm、记住我功能一、环境搭建1.1 pom.xml引入依赖1.2 SSM其他配置文件整合（省略）1.3 Shiro的基本配置1.3.1 web.xml配置shiro的代理filter1.3.2 applicatioContext.xml中配置ShiroFilter1.3.3 applicatioContext.xml中配置Web安全管理器1.4 单个Realm实现1.5 多Realm实现（常用）1.6 Shiro的会话管理1.7 记住我功能1.7.
SSM整合shiro
BUG专业户
08-05 1538
SSM整合shiro安全框架
SSM整合Shiro安全框架详解
yhl15736773842的博客
07-06 158
SSM整合Shiro安全框架详解
SSM 整合 Shiro 安全框架【快速入门】
最新发布
每日一记，每周一结。
07-06 627
更改web路径创建所需目录。
在SSM项目中如何使用shiro【详细教程】
m0_59420288的博客
12-05 559
Shiro是一个强大且易用的Java安全框架。在web项目中可以使用shiro进行登录Login的安全验证，下面跟大家分享一下在SSM项目中如何使用shiro：页面拦截，自定义realm，MD5加密登录验证（密码、角色验证）我用的依赖（ssm shiro），请参考 2.文件目录 包含shiro配置，自定义realm，安全管理器，保证实现了Shiro内部lifecycle函数的bean执行，shiro拦截器，shiro注解 （2）日志（log4j.properties） （3）Mybatis配置（mybat
SSM+shiro整合
JGnewbie的博客
09-14 402
startsWith方法测试此字符串从指定索引开始的子字符串是否以指定前缀开始。 比如：String s=“fp_name” if( s.startsWith(“fp_”)){ System.out.println(“返回一个ture”); }
ssm整合shiro
qq_59114219的博客
08-07 230
ssm整合shiro ssm整合shiro完成前后端分离
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值