Shiro

最新推荐文章于 2023-04-03 08:43:52 发布
最新推荐文章于 2023-04-03 08:43:52 发布
阅读量92 收藏
点赞数
分类专栏： 编程学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WiseboyZZQ/article/details/119299968
版权

ShiroConfig

package com.ccb.web.configs;

//shiro
import com.ccb.web.shiro.*;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.shiro.cache.ehcache.EhCacheManager;
import org.apache.shiro.codec.Base64;
import org.apache.shiro.session.SessionListener;
import org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator;
import org.apache.shiro.session.mgt.eis.SessionDAO;
import org.apache.shiro.session.mgt.eis.SessionIdGenerator;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.web.filter.authc.FormAuthenticationFilter;
import org.apache.shiro.web.mgt.CookieRememberMeManager;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
//spring
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.MethodInvokingFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;
//java
import javax.servlet.Filter;
import java.io.Serializable;
import java.util.*;

/**
 * Shiro配置
 * <p>
 * 大部分参数都是在这里直接修改
 *
 * @author zhuyongsheng
 * @date 2019/8/13
 */
@Configuration
public class ShiroConfig {

    /**
     * ShiroFilterFactoryBean 处理拦截资源文件问题。
     * 注意：初始化ShiroFilterFactoryBean的时候需要注入：SecurityManager
     * Web应用中,Shiro可控制的Web请求必须经过Shiro主过滤器的拦截
     *
     * @return org.apache.shiro.spring.web.ShiroFilterFactoryBean
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean(name = "shirFilter")
    public ShiroFilterFactoryBean shiroFilterFactoryBean(@Qualifier("securityManager") SecurityManager securityManager) {

        //定义返回对象
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();

        //必须设置 SecurityManager,Shiro的核心安全接口
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        //这里的/login是后台的接口名,非页面，如果不设置默认会自动寻找Web工程根目录下的"/login.jsp"页面
        shiroFilterFactoryBean.setLoginUrl("/sessionInvalid");
        //这里的/index是后台的接口名,非页面,登录成功后要跳转的链接
        shiroFilterFactoryBean.setSuccessUrl("/");
        //未授权界面,该配置无效，并不会进行页面跳转
        shiroFilterFactoryBean.setUnauthorizedUrl("/sessionInvalid");

        //限制同一帐号同时在线的个数
        LinkedHashMap<String, Filter> filtersMap = new LinkedHashMap<>();
        filtersMap.put("kickout", kickoutSessionControlFilter());
        shiroFilterFactoryBean.setFilters(filtersMap);

        // 配置访问权限 必须是LinkedHashMap，因为它必须保证有序
        // 过滤链定义，从上向下顺序执行，一般将 /**放在最为下边 一定要注意顺序,否则就不好使了
        LinkedHashMap<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        //logout是shiro提供的过滤器
        filterChainDefinitionMap.put("/logout", "logout");
        //配置不登录可以访问的资源，anon 表示资源都可以匿名访问
        filterChainDefinitionMap.put("/swagger-ui.html", "anon");
        filterChainDefinitionMap.put("/webjars/**", "anon");
        filterChainDefinitionMap.put("/swagger-resources/**", "anon");
        filterChainDefinitionMap.put("/v2/**", "anon");
        filterChainDefinitionMap.put("/u/**", "anon");
        filterChainDefinitionMap.put("/swagger/**", "anon");
        filterChainDefinitionMap.put("/doc.html", "anon");
        filterChainDefinitionMap.put("/simpleBillRepertory/getShareStockUrl", "anon");
        filterChainDefinitionMap.put("/alicheck", "anon");
        filterChainDefinitionMap.put("/api-docs/**", "anon");
        //此时访问/userInfo/del需要del权限,在自定义Realm中为用户授权。
        //filterChainDefinitionMap.put("/userInfo/del", "perms[\"userInfo:del\"]");

        //其他资源都需要认证  authc 表示需要认证才能进行访问
        filterChainDefinitionMap.put("/**", "kickout,authc");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);

        return shiroFilterFactoryBean;
    }

    /**
     * 身份认证realm
     *
     * @return com.ccb.web.shiro.ShiroRealm
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean
    public ShiroRealm shiroRealm() {
        ShiroRealm shiroRealm = new ShiroRealm();
        shiroRealm.setCachingEnabled(true);
        //启用身份验证缓存，即缓存AuthenticationInfo信息，默认false
        shiroRealm.setAuthenticationCachingEnabled(true);
        //缓存AuthenticationInfo信息的缓存名称 在ehcache-shiro.xml中有对应缓存的配置
        shiroRealm.setAuthenticationCacheName("authenticationCache");
        //启用授权缓存，即缓存AuthorizationInfo信息，默认false
        shiroRealm.setAuthorizationCachingEnabled(true);
        //缓存AuthorizationInfo信息的缓存名称  在ehcache-shiro.xml中有对应缓存的配置
        shiroRealm.setAuthorizationCacheName("authorizationCache");
        return shiroRealm;
    }

    /**
     * cookie管理对象;记住我功能,rememberMe管理器
     *
     * @return org.apache.shiro.web.mgt.CookieRememberMeManager
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean
    public CookieRememberMeManager cookieRememberMeManager() {
        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        cookieRememberMeManager.setCookie(simpleCookie());
        //rememberMe cookie加密的密钥 建议每个项目都不一样 默认AES算法 密钥长度(128 256 512 位)
        cookieRememberMeManager.setCipherKey(Base64.decode("4AvVhmFLUs0KTA3Kprsdag=="));
        return cookieRememberMeManager;
    }

    /**
     * shiro缓存管理器
     *
     * @return org.apache.shiro.cache.ehcache.EhCacheManager
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean
    public EhCacheManager ehCacheManager() {
        EhCacheManager cacheManager = new EhCacheManager();
        cacheManager.setCacheManagerConfigFile("classpath:ehcache-shiro.xml");
        return cacheManager;
    }

    /**
     * redisTemplate 配置
     *
     * @param redisConnectionFactory
     * @return
     */
    @Bean("csRedisTemplate")
    public RedisTemplate<String, Serializable> csRedisTemplate(LettuceConnectionFactory redisConnectionFactory) {
        ObjectMapper om = new ObjectMapper();

        // 4.设置可见度
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 5.启动默认的类型
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        //解决实体缺少 set get 方法
        om.configure(MapperFeature.USE_GETTERS_AS_SETTERS, false);
        //截取实体缺少的属性
        om.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        RedisTemplate<String, Serializable> template = new RedisTemplate<>();
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer(om));
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setDefaultSerializer(new GenericJackson2JsonRedisSerializer(om));
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean("csRedisUtil")
    public CsRedisUtil csRedisUtil(@Qualifier("csRedisTemplate") RedisTemplate<String, Serializable> redisTemplate) {
        CsRedisUtil redisUtil = new CsRedisUtil();
        redisUtil.setRedisTemplate(redisTemplate);
        return redisUtil;
    }


    /**
     * 配置会话管理器，设定会话超时及保存
     *
     * @return org.apache.shiro.session.mgt.SessionManager
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean("shiroSessionManager")
    public ShiroSessionManager shiroSessionManager() {

        ShiroSessionManager sessionManager = new ShiroSessionManager();
        Collection<SessionListener> listeners = new ArrayList<>();
        //配置监听
        listeners.add(shiroSessionListener());
        sessionManager.setSessionListeners(listeners);
        sessionManager.setSessionIdCookie(sessionIdCookie());
        sessionManager.setSessionDAO(redisSessionDAO());
        sessionManager.setCacheManager(ehCacheManager());

        //全局会话超时时间（单位毫秒）
        sessionManager.setGlobalSessionTimeout(60 * 1000 * 60);
        //是否开启删除无效的session对象  默认为true
        sessionManager.setDeleteInvalidSessions(true);
        //是否开启定时调度器进行检测过期session 默认为true
        sessionManager.setSessionValidationSchedulerEnabled(true);
        //设置session失效的扫描时间, 清理用户直接关闭浏览器造成的孤立会话
        //设置该属性 就不需要设置 ExecutorServiceSessionValidationScheduler 底层也是默认自动调用ExecutorServiceSessionValidationScheduler
        sessionManager.setSessionValidationInterval(60 * 1000 * 10);
        sessionManager.setSessionFactory(shiroSessionFactory());

        //取消url 后面的 JSESSIONID
        sessionManager.setSessionIdUrlRewritingEnabled(false);

        return sessionManager;

    }

    /**
     * 配置核心安全事务管理器
     *
     * @return org.apache.shiro.mgt.SecurityManager
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean(name = "securityManager")
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        //设置自定义realm.
        securityManager.setRealm(shiroRealm());
        //配置记住我
        securityManager.setRememberMeManager(cookieRememberMeManager());
        //配置缓存管理器
        securityManager.setCacheManager(ehCacheManager());
        //配置session管理器
        securityManager.setSessionManager(shiroSessionManager());
        return securityManager;
    }

    /**
     * FormAuthenticationFilter 过滤器 过滤记住我
     *
     * @return org.apache.shiro.web.filter.authc.FormAuthenticationFilter
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean
    public FormAuthenticationFilter formAuthenticationFilter() {
        FormAuthenticationFilter formAuthenticationFilter = new FormAuthenticationFilter();
        //对应前端的checkbox的name = rememberMe
        formAuthenticationFilter.setRememberMeParam("rememberMe");
        return formAuthenticationFilter;
    }

    /**
     * 并发登录控制
     *
     * @return com.ccb.web.shiro.KickoutSessionControlFilter
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean
    public KickoutSessionControlFilter kickoutSessionControlFilter() {
        KickoutSessionControlFilter kickoutSessionControlFilter = new KickoutSessionControlFilter();
        //使用cacheManager获取相应的cache来缓存用户登录的会话；用于保存用户—会话之间的关系的；
        kickoutSessionControlFilter.setCacheManager(ehCacheManager());
        //是否踢出后来登录的，默认是false；即后者登录的用户踢出前者登录的用户；
        kickoutSessionControlFilter.setKickoutAfter(false);
        //同一个用户最大的会话数，默认1；比如2的意思是同一个用户允许最多同时两个人登录；
        kickoutSessionControlFilter.setMaxSession(1);
        //被踢出后重定向到的地址；
        kickoutSessionControlFilter.setKickoutUrl("/login?kickout=1");
        return kickoutSessionControlFilter;
    }

    /**
     * 配置Shiro生命周期处理器
     *
     * @return org.apache.shiro.spring.LifecycleBeanPostProcessor
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean(name = "lifecycleBeanPostProcessor")
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }



    /**
     * shiro缓存管理器
     *
     * @return com.ccb.web.shiro.RedisCacheManager
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean
    public RedisCacheManager redisCacheManager() {
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        //redis中针对不同用户缓存
        redisCacheManager.setPrincipalIdFieldName("username");
        //用户权限信息缓存时间
        redisCacheManager.setExpire(60 * 1000 * 60);
        return redisCacheManager;
    }

    /**
     * redis 替代默认缓存
     *
     * @return com.ccb.web.shiro.RedisSessionDAO
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean
    public RedisSessionDAO redisSessionDAO() {
        RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
        redisSessionDAO.setExpire(60 * 60);
        return redisSessionDAO;
    }

    /**
     * SessionDAO的作用是为Session提供CRUD并进行持久化的一个shiro组件
     *
     * @return org.apache.shiro.session.mgt.eis.SessionDAO
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean
    public SessionDAO sessionDAO() {
        RedisSessionDAO redisSessionDAO = redisSessionDAO();
        //使用ehCacheManager
        redisSessionDAO.setCacheManager(ehCacheManager());
        //设置session缓存的名字 默认为 shiro-activeSessionCache
        redisSessionDAO.setActiveSessionsCacheName("shiro-activeSessionCache");
        //sessionId生成器
        redisSessionDAO.setSessionIdGenerator(sessionIdGenerator());
        return redisSessionDAO;
    }

    /**
     * 配置保存sessionId的cookie
     * 注意：这里的cookie 不是上面的记住我 cookie 记住我需要一个cookie session管理 也需要自己的cookie
     *
     * @return org.apache.shiro.web.servlet.SimpleCookie
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean("sessionIdCookie")
    public SimpleCookie sessionIdCookie() {
        //这个参数是cookie的名称
        SimpleCookie simpleCookie = new SimpleCookie("sid");
        simpleCookie.setHttpOnly(true);
        simpleCookie.setPath("/");
        //maxAge=-1表示浏览器关闭时失效此Cookie
        simpleCookie.setMaxAge(-1);
        return simpleCookie;
    }

    /**
     * 配置会话ID生成器
     *
     * @return org.apache.shiro.session.mgt.eis.SessionIdGenerator
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean
    public SessionIdGenerator sessionIdGenerator() {
        return new JavaUuidSessionIdGenerator();
    }



    /**
     * session工厂
     *
     * @return com.ccb.web.shiro.ShiroSessionFactory
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean("sessionFactory")
    public ShiroSessionFactory shiroSessionFactory() {
        ShiroSessionFactory sessionFactory = new ShiroSessionFactory();
        return sessionFactory;
    }

    /**
     * 配置session监听
     *
     * @return com.ccb.web.shiro.ShiroSessionListener
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean("sessionListener")
    public ShiroSessionListener shiroSessionListener() {
        ShiroSessionListener sessionListener = new ShiroSessionListener();
        return sessionListener;
    }

    /**
     * cookie对象;会话Cookie模板 ,默认为: JSESSIONID 问题: 与SERVLET容器名冲突,重新定义为sid或rememberMe
     *
     * @return org.apache.shiro.web.servlet.SimpleCookie
     * @author zhuyongsheng
     * @date 2019/8/15
     */
    @Bean
    public SimpleCookie simpleCookie() {
        //这个参数是cookie的名称，对应前端的checkbox的name = rememberMe
        SimpleCookie simpleCookie = new SimpleCookie("rememberMe");
        /*
         * 设为true后，只能通过http访问，javascript无法访问
         * 防止xss读取cookie
         */
        simpleCookie.setHttpOnly(true);
        simpleCookie.setPath("/");
        //<!-- 记住我cookie生效时间30天 ,单位秒;-->
        simpleCookie.setMaxAge(2592000);
        return simpleCookie;
    }

    /**
     * 解决： 无权限页面不跳转
     *
     * @return org.springframework.web.servlet.handler.SimpleMappingExceptionResolver
     * @author zhuyongsheng
     * @date 2019/8/15
     * @apiNote shiroFilterFactoryBean.setUnauthorizedUrl(" / unauthorized ") 无效
     * shiro的源代码ShiroFilterFactoryBean.Java定义的filter必须满足filter instanceof AuthorizationFilter，
     * 只有perms，roles，ssl，rest，port才是属于AuthorizationFilter，而anon，authcBasic，auchc，user是AuthenticationFilter，
     * 所以unauthorizedUrl设置后页面不跳转 Shiro注解模式下，登录失败与没有权限都是通过抛出异常。
     * 并且默认并没有去处理或者捕获这些异常。在SpringMVC下需要配置捕获相应异常来通知用户信息
     */
    @Bean
    public SimpleMappingExceptionResolver simpleMappingExceptionResolver() {
        SimpleMappingExceptionResolver simpleMappingExceptionResolver = new SimpleMappingExceptionResolver();
        Properties properties = new Properties();
        //这里的 /unauthorized 是页面，不是访问的路径
        properties.setProperty("org.apache.shiro.authz.UnauthorizedException", "/unauthorized");
        properties.setProperty("org.apache.shiro.authz.UnauthenticatedException", "/unauthorized");
        simpleMappingExceptionResolver.setExceptionMappings(properties);
        return simpleMappingExceptionResolver;
    }



    /**
     * 让某个实例的某个方法的返回值注入为Bean的实例
     * Spring静态注入
     *
     * @return
     */
    @Bean
    public MethodInvokingFactoryBean getMethodInvokingFactoryBean() {
        MethodInvokingFactoryBean factoryBean = new MethodInvokingFactoryBean();
        factoryBean.setStaticMethod("org.apache.shiro.SecurityUtils.setSecurityManager");
        factoryBean.setArguments(new Object[]{securityManager()});
        return factoryBean;
    }

}

Md5加密

Method.1

import org.apache.commons.codec.digest.DigestUtils;

public static void main(String[] args) {
	        /**
	         * 第一种方法
	         */
	        //对字符串进行md5加密
	        String md5Hex = DigestUtils.md5Hex("123456");
	        //对字符串添加盐值加密
	        String md5Hex1 = DigestUtils.md5Hex("123456" + UUID.randomUUID().toString().substring(0, 4));
	        //散列1024次循环加密
	        for (int i = 0; i < 1024; i++) {
	             md5Hex1 = DigestUtils.md5Hex(md5Hex1);
	        }
	        System.out.println(md5Hex1);
        }

Method.2

import org.apache.shiro.crypto.hash.Md5Hash;
  
  public static void main(String[] args) {
         /* 
         *第二种方法
         */
        Md5Hash md5Hash = new Md5Hash("123456", UUID.randomUUID().toString().substring(0, 4), 1024);
        System.out.println(md5Hash);
    }

``

WiseboyZZQ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Shiro学习（3）shiroConfig配置类
m0_67403240的博客
08-24 1893
配置原理：对SecurityManager来说他管理了所有的Realm，通过这些代码获取了Realm管理信息。注意SecurityManager导包，是shiro的SecurityManager。可以直接创建CustonRealm这个对象，也可以通过Realm创建。在web程序中，shiro进行权限控制是通过一组过滤器集合进行的操作。3、通用配置（跳转登录页面，为授权跳转的页面）4、开启对shiro注解的支持。3、配置shiro过滤器工厂。
Shiro的配置及使用
qq_45733154的博客
10-21 2821
Shiro,Springboot整合Shiro,Shiro实现登录拦截，Shiro实现用户认证，用户授权，Shiro整合Thymeleaf
Shiro安全框架详解及springboot使用示例
weixin_46822367的博客
12-28 2822
目录一、认识Shiro1、什么是Shiro？2、有哪些功能？3、Shiro架构（外部）4、Shiro架构（内部） 一、认识Shiro 1、什么是Shiro？ Apache Shiro 是一个Java 的安全（权限）框架。 Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE环境，也可以用在JavaEE环 境。 Shiro可以完成，认证，授权，加密，会话管理，Web集成，缓存等。 2、有哪些功能？ Authentication：身份认证、登录，验证用户是不是拥有相应的身份； Aut
Shiro入门以及Shiro与web整合
m0_67401417的博客
08-24 284
Apache shiro是一个强大,易用的java安全框架执行身份认证,授权,密码和会话管理。
shiro1.5.3
05-11
Apache Shiro 是一个强大且易用的Java安全框架，提供了认证、授权、加密和会话管理功能，可以非常轻松地开发出足够安全的应用。你提到的 "shiro1.5.3" 是Shiro框架的一个特定版本，包含了该版本的所有核心组件和相关...
shiro1.6版本
09-07
Apache Shiro 是一个强大且易用的Java安全框架，提供了身份验证、授权、加密和会话管理功能，简化了企业级应用的安全实现。在本文中，我们将深入探讨Apache Shiro 1.6版本的重要更新，以及它如何修复了一个绕过认证...
shiro1.7.1.zip
04-12
在使用Shiro 1.7.1时，开发者可以根据具体需求选择合适的模块进行集成，例如，Web应用可能会主要依赖`shiro-core`、`shiro-web`和`shiro-spring`，而需要进行复杂加密操作的应用可能需要`shiro-crypto-hash`和`shiro...
shiro
04-30
Apache Shiro 是一个强大且易用的 Java 安全框架，提供身份认证、授权、会话管理和加密等核心功能。这个框架旨在简化企业级应用的安全实施，让开发者能够更专注于业务逻辑，而不是复杂的安全实现。从给定的标签"源码...
shiro_tool.zip
11-18
Apache Shiro 是一个强大且易用的Java安全框架，提供了认证、授权、加密和会话管理功能，可以非常轻松地开发出足够安全的应用。在"shiro_tool.zip"这个压缩包中，我们可以推测可能包含了一些关于Shiro使用的工具类、...
springboot整合shiro
akego的博客
10-27 1404
Subject(用户):当前的操作用户 获取当前用户Subject currentUser = SecurityUtils.getSubject()SecurityManager（安全管理器）:Shiro的核心,负责与其他组件进行交互,实现 subject 委托的各种功能。Realms（数据源） :Realm会查找相关数据源,充当与安全管理间的桥梁,经过Realm找到数据源进行认证,授权等操作。数据库5张表：用户表 角色表 权限表 用户与角色的中间表 角色与权限的中间表。
切面（@Aspect）和事务（@Transactional）莫名失效：`is not eligible for getting processed by all BeanPostProcesso
taoyalong的博客
12-02 1368
切面（@Aspect）和事务（@Transactional）莫名失效：`is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)`
记一下Shiro重构之ShiroConfig配置文件
m0_60721514的博客
04-29 479
ShiroConfig 所有的shiro配置都在这里面配就行了，你要是喜欢xml啥的就自己对应改下 package com.ccb.web.configs; //shiro import com.ccb.web.shiro.*; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jac
Shiro主配置文件分析
最新发布
weixin_73756660的博客
04-03 93
Shiro主配置文件分析
Spring-shiro-Boot-1 整合shiro的配置文件1-ShiroConfig
良之才的专栏
03-04 1203
shiro是纯java的权限管理框架，可以处理认证、权限、加密等标准需求。 shiro的思路就是给控制处理。封装处理的其实很不错，使用起来很方便。 但是，使用shiro得了解一些它的基本特点。 ======================================= 一、shiro权限模型 （1）配置之前，需要知道基本的权限控制概念。这里使用数据库模型控制。【用户-角色-权限】 （2）权限表--sys_permission （3）角色表-sys_role （4）角色...
shiro在web.xml里配置的shiroFilter
你就像甜甜的益达
01-01 1607
文章目录在ssm整合shiro的时候配置的shiroFilter如果不一致:配置参数总结所以需要将filter-name的名称跟spring配置文件里的ShiroFilterFactoryBean的bean名称保持一致 在ssm整合shiro的时候配置的shiroFilter 一般web.xml配置文件里面写: <!--shiro过滤器--> <filter> &lt...
Spring Boot logback日志配置
qq_25293281的博客
08-07 328
Spring Boot logback日志配置[转]  Posted on 2018-01-03 Spring Boot在所有内部日志中使用Commons Logging，但是默认配置也提供了对常用日志的支持，如：Java Util Logging，Log4J, Log4J2和Logback。每种Logger都可以通过配置使用控制台或者文件输出日志内容。 SLF4J —— Simple Lo...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值