架构文摘
架构文摘

SpringBoot 整合Shiro实现动态权限加载更新+Session共享+单点登录

 来源： http://dwz.date/bRkG
 作者：Sans_

一.说明

Shiro是一个安全框架,项目中主要用它做认证,授权,加密,以及用户的会话管理,虽然Shiro没有SpringSecurity功能更丰富,但是它轻量,简单,在项目中通常业务需求Shiro也都能胜任.

二.项目环境

  • MyBatis-Plus版本: 3.1.0
  • SpringBoot版本:2.1.5
  • JDK版本:1.8
  • Shiro版本:1.4
  • Shiro-redis插件版本:3.1.0

数据表(SQL文件在项目中):数据库中测试号的密码进行了加密,密码皆为123456

数据表名     中文表名     备注说明  
sys_user     系统用户表     基础表  
sys_menu     权限表     基础表  
sys_role     角色表     基础表  
sys_role_menu     角色与权限关系表     中间表  
sys_user_role     用户与角色关系表     中间表  

Maven依赖如下：

    
            
                org.springframework.boot
                spring-boot-starter-web
            
            
                mysql
                mysql-connector-java
                runtime
            
            
            
                org.springframework.boot
                spring-boot-starter-aop
            
            
            
                org.projectlombok
                lombok
                true
            
            
            
                org.springframework.boot
                spring-boot-starter-data-redis-reactive
            
            
            
                com.baomidou
                mybatis-plus-boot-starter
                3.1.0
            
            
            
                com.alibaba
                druid
                1.1.6
            
            
            
                org.apache.shiro
                shiro-spring
                1.4.0
            
            
            
                org.crazycake
                shiro-redis
                3.1.0
            
            
            
                org.apache.commons
                commons-lang3
                3.5
            
    

配置如下:

    # 配置端口
    server:
      port: 8764
    spring:
      # 配置数据源
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/my_shiro?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false
        username: root
        password: root
        type: com.alibaba.druid.pool.DruidDataSource
      # Redis数据源
      redis:
        host: localhost
        port: 6379
        timeout: 6000
        password: 123456
        jedis:
          pool:
            max-active: 1000  # 连接池最大连接数（使用负值表示没有限制）
            max-wait: -1      # 连接池最大阻塞等待时间（使用负值表示没有限制）
            max-idle: 10      # 连接池中的最大空闲连接
            min-idle: 5       # 连接池中的最小空闲连接
    # mybatis-plus相关配置
    mybatis-plus:
      # xml扫描，多个目录用逗号或者分号分隔（告诉 Mapper 所对应的 XML 文件位置）
      mapper-locations: classpath:mapper/*.xml
      # 以下配置均有默认值,可以不设置
      global-config:
        db-config:
          #主键类型 AUTO:"数据库ID自增" INPUT:"用户输入ID",ID_WORKER:"全局唯一ID (数字类型唯一ID)", UUID:"全局唯一ID UUID";
          id-type: auto
          #字段策略 IGNORED:"忽略判断"  NOT_NULL:"非 NULL 判断")  NOT_EMPTY:"非空判断"
          field-strategy: NOT_EMPTY
          #数据库类型
          db-type: MYSQL
      configuration:
        # 是否开启自动驼峰命名规则映射:从数据库列名到Java属性驼峰命名的类似映射
        map-underscore-to-camel-case: true
        # 返回map时true:当查询数据为空时字段返回为null,false:不加这个查询数据为空时，字段将被隐藏
        call-setters-on-nulls: true
        # 这个配置会将执行的sql打印出来，在开发或测试的时候可以用
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

二.编写项目基础类

用户实体,Dao,Service等在这里省略,请参考源码

编写Exception类来处理Shiro权限拦截异常

    /**
     * @Description 自定义异常
     * @Author Sans
     * @CreateTime 2019/6/15 22:56
     */
    @ControllerAdvice
    public class MyShiroException {
        /**
         * 处理Shiro权限拦截异常
         * 如果返回JSON数据格式请加上 @ResponseBody注解
         * @Author Sans
         * @CreateTime 2019/6/15 13:35
         * @Return Map 返回结果集
         */
        @ResponseBody
        @ExceptionHandler(value = AuthorizationException.class)
        public Map defaultErrorHandler(){
            Map map = new HashMap<>();
            map.put("403","权限不足");
            return map;
        }
    }


创建SHA256Util加密工具


    /**
     * @Description Sha-256加密工具
     * @Author Sans
     * @CreateTime 2019/6/12 9:27
     */
    public class SHA256Util {
        /**  私有构造器 **/
        private SHA256Util(){};
        /**  加密算法 **/
        public final static String HASH_ALGORITHM_NAME = "SHA-256";
        /**  循环次数 **/
        public final static int HASH_ITERATIONS = 15;
        /**  执行加密-采用SHA256和盐值加密 **/
        public static String sha256(String password, String salt) {
            return new SimpleHash(HASH_ALGORITHM_NAME, password, salt, HASH_ITERATIONS).toString();
        }
    }



创建Spring工具


    /**
     * @Description Spring上下文工具类
     * @Author Sans
     * @CreateTime 2019/6/17 13:40
     */
    @Component
    public class SpringUtil implements ApplicationContextAware {
        private static ApplicationContext context;
        /**
         * Spring在bean初始化后会判断是不是ApplicationContextAware的子类
         * 如果该类是,setApplicationContext()方法,会将容器中ApplicationContext作为参数传入进去
         * @Author Sans
         * @CreateTime 2019/6/17 16:58
         */
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            context = applicationContext;
        }
        /**
         * 通过Name返回指定的Bean
         * @Author Sans
         * @CreateTime 2019/6/17 16:03
         */
        public static  T getBean(Class beanClass) {
            return context.getBean(beanClass);
        }
    }



创建Shiro工具


    /**
     * @Description Shiro工具类
     * @Author Sans
     * @CreateTime 2019/6/15 16:11
     */
    public class ShiroUtils {
    
        /** 私有构造器 **/
        private ShiroUtils(){}
    
        private static RedisSessionDAO redisSessionDAO = SpringUtil.getBean(RedisSessionDAO.class);
    
        /**
         * 获取当前用户Session
         * @Author Sans
         * @CreateTime 2019/6/17 17:03
         * @Return SysUserEntity 用户信息
         */
        public static Session getSession() {
            return SecurityUtils.getSubject().getSession();
        }
    
        /**
         * 用户登出
         * @Author Sans
         * @CreateTime 2019/6/17 17:23
         */
        public static void logout() {
            SecurityUtils.getSubject().logout();
        }
    
        /**
        * 获取当前用户信息
        * @Author Sans
        * @CreateTime 2019/6/17 17:03
        * @Return SysUserEntity 用户信息
        */
        public static SysUserEntity getUserInfo() {
          return (SysUserEntity) SecurityUtils.getSubject().getPrincipal();
        }
    
        /**
         * 删除用户缓存信息
         * @Author Sans
         * @CreateTime 2019/6/17 13:57
         * @Param  username  用户名称
         * @Param  isRemoveSession 是否删除Session
         * @Return void
         */
        public static void deleteCache(String username, boolean isRemoveSession){
            //从缓存中获取Session
            Session session = null;
            Collection sessions = redisSessionDAO.getActiveSessions();
            SysUserEntity sysUserEntity;
            Object attribute = null;
            for(Session sessionInfo : sessions){
                //遍历Session,找到该用户名称对应的Session
                attribute = sessionInfo.getAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY);
                if (attribute == null) {
                    continue;
                }
                sysUserEntity = (SysUserEntity) ((SimplePrincipalCollection) attribute).getPrimaryPrincipal();
                if (sysUserEntity == null) {
                    continue;
                }
                if (Objects.equals(sysUserEntity.getUsername(), username)) {
                    session=sessionInfo;
                    break;
                }
            }
            if (session == null||attribute == null) {
                return;
            }
            //删除session
            if (isRemoveSession) {
                redisSessionDAO.delete(session);
            }
            //删除Cache，在访问受限接口时会重新授权
            DefaultWebSecurityManager securityManager = (DefaultWebSecurityManager) SecurityUtils.getSecurityManager();
            Authenticator authc = securityManager.getAuthenticator();
            ((LogoutAware) authc).onLogout((SimplePrincipalCollection) attribute);
        }
    }



创建Shiro的SessionId生成器


    /**
     * @Description 自定义SessionId生成器
     * @Author Sans
     * @CreateTime 2019/6/11 11:48
     */
    public class ShiroSessionIdGenerator implements SessionIdGenerator {
        /**
         * 实现SessionId生成
         * @Author Sans
         * @CreateTime 2019/6/11 11:54
         */
        @Override
        public Serializable generateId(Session session) {
            Serializable sessionId = new JavaUuidSessionIdGenerator().generateId(session);
            return String.format("login_token_%s", sessionId);
        }
    }



三.编写Shiro核心类


创建Realm用于授权和认证


    /**
     * @Description Shiro权限匹配和账号密码匹配
     * @Author Sans
     * @CreateTime 2019/6/15 11:27
     */
    public class ShiroRealm extends AuthorizingRealm {
        @Autowired
        private SysUserService sysUserService;
        @Autowired
        private SysRoleService sysRoleService;
        @Autowired
        private SysMenuService sysMenuService;
        /**
         * 授权权限
         * 用户进行权限验证时候Shiro会去缓存中找,如果查不到数据,会执行这个方法去查权限,并放入缓存中
         * @Author Sans
         * @CreateTime 2019/6/12 11:44
         */
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
            SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
            SysUserEntity sysUserEntity = (SysUserEntity) principalCollection.getPrimaryPrincipal();
            //获取用户ID
            Long userId =sysUserEntity.getUserId();
            //这里可以进行授权和处理
            Set rolesSet = new HashSet<>();
            Set permsSet = new HashSet<>();
            //查询角色和权限(这里根据业务自行查询)
            List sysRoleEntityList = sysRoleService.selectSysRoleByUserId(userId);
            for (SysRoleEntity sysRoleEntity:sysRoleEntityList) {
                rolesSet.add(sysRoleEntity.getRoleName());
                List sysMenuEntityList = sysMenuService.selectSysMenuByRoleId(sysRoleEntity.getRoleId());
                for (SysMenuEntity sysMenuEntity :sysMenuEntityList) {
                    permsSet.add(sysMenuEntity.getPerms());
                }
            }
            //将查到的权限和角色分别传入authorizationInfo中
            authorizationInfo.setStringPermissions(permsSet);
            authorizationInfo.setRoles(rolesSet);
            return authorizationInfo;
        }
        
        /**
         * 身份认证
         * @Author Sans
         * @CreateTime 2019/6/12 12:36
         */
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
            //获取用户的输入的账号.
            String username = (String) authenticationToken.getPrincipal();
            //通过username从数据库中查找 User对象，如果找到进行验证
            //实际项目中,这里可以根据实际情况做缓存,如果不做,Shiro自己也是有时间间隔机制,2分钟内不会重复执行该方法
            SysUserEntity user = sysUserService.selectUserByName(username);
            //判断账号是否存在
            if (user == null) {
                throw new AuthenticationException();
            }
            //判断账号是否被冻结
            if (user.getState()==null||user.getState().equals("PROHIBIT")){
                throw new LockedAccountException();
            }
            //进行验证
            SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
                    user,                                  //用户名
                    user.getPassword(),                    //密码
                    ByteSource.Util.bytes(user.getSalt()), //设置盐值
                    getName()
            );
            //验证成功开始踢人(清除缓存和Session)
            ShiroUtils.deleteCache(username,true);
            return authenticationInfo;
        }
    }



创建SessionManager类


    /**
     * @Description 自定义获取Token
     * @Author Sans
     * @CreateTime 2019/6/13 8:34
     */
    public class ShiroSessionManager extends DefaultWebSessionManager {
        //定义常量
        private static final String AUTHORIZATION = "Authorization";
        private static final String REFERENCED_SESSION_ID_SOURCE = "Stateless request";
        //重写构造器
        public ShiroSessionManager() {
            super();
            this.setDeleteInvalidSessions(true);
        }
        /**
         * 重写方法实现从请求头获取Token便于接口统一
         * 每次请求进来,Shiro会去从请求头找Authorization这个key对应的Value(Token)
         * @Author Sans
         * @CreateTime 2019/6/13 8:47
         */
        @Override
        public Serializable getSessionId(ServletRequest request, ServletResponse response) {
            String token = WebUtils.toHttp(request).getHeader(AUTHORIZATION);
            //如果请求头中存在token 则从请求头中获取token
            if (!StringUtils.isEmpty(token)) {
                request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, REFERENCED_SESSION_ID_SOURCE);
                request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, token);
                request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
                return token;
            } else {
                // 这里禁用掉Cookie获取方式
                // 按默认规则从Cookie取Token
                // return super.getSessionId(request, response);
                return null;
            }
        }
    }
    


创建ShiroConfig配置类


    /**
     * @Description Shiro配置类
     * @Author Sans
     * @CreateTime 2019/6/10 17:42
     */
    @Configuration
    public class ShiroConfig {
    
        private final String CACHE_KEY = "shiro:cache:";
        private final String SESSION_KEY = "shiro:session:";
    
        //Redis配置
        @Value("${spring.redis.host}")
        private String host;
        @Value("${spring.redis.port}")
        private int port;
        @Value("${spring.redis.timeout}")
        private int timeout;
        @Value("${spring.redis.password}")
        private String password;
    
        /**
         * 开启Shiro-aop注解支持
         * @Attention 使用代理方式所以需要开启代码支持
         * @Author Sans
         * @CreateTime 2019/6/12 8:38
         */
        @Bean
        public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
            AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
            authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
            return authorizationAttributeSourceAdvisor;
        }
    
        /**
         * Shiro基础配置
         * @Author Sans
         * @CreateTime 2019/6/12 8:42
         */
        @Bean
        public ShiroFilterFactoryBean shiroFilterFactory(SecurityManager securityManager){
            ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
            shiroFilterFactoryBean.setSecurityManager(securityManager);
            Map filterChainDefinitionMap = new LinkedHashMap<>();
            // 注意过滤器配置顺序不能颠倒
            // 配置过滤:不会被拦截的链接
            filterChainDefinitionMap.put("/static/**", "anon");
            filterChainDefinitionMap.put("/userLogin/**", "anon");
            filterChainDefinitionMap.put("/**", "authc");
            // 配置shiro默认登录界面地址，前后端分离中登录界面跳转应由前端路由控制，后台仅返回json数据
            shiroFilterFactoryBean.setLoginUrl("/userLogin/unauth");
            shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
            return shiroFilterFactoryBean;
        }
    
        /**
         * 安全管理器
         * @Author Sans
         * @CreateTime 2019/6/12 10:34
         */
        @Bean
        public SecurityManager securityManager() {
            DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
            // 自定义Ssession管理
            securityManager.setSessionManager(sessionManager());
            // 自定义Cache实现
            securityManager.setCacheManager(cacheManager());
            // 自定义Realm验证
            securityManager.setRealm(shiroRealm());
            return securityManager;
        }
    
        /**
         * 身份验证器
         * @Author Sans
         * @CreateTime 2019/6/12 10:37
         */
        @Bean
        public ShiroRealm shiroRealm() {
            ShiroRealm shiroRealm = new ShiroRealm();
            shiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
            return shiroRealm;
        }
    
        /**
         * 凭证匹配器
         * 将密码校验交给Shiro的SimpleAuthenticationInfo进行处理,在这里做匹配配置
         * @Author Sans
         * @CreateTime 2019/6/12 10:48
         */
        @Bean
        public HashedCredentialsMatcher hashedCredentialsMatcher() {
            HashedCredentialsMatcher shaCredentialsMatcher = new HashedCredentialsMatcher();
            // 散列算法:这里使用SHA256算法;
            shaCredentialsMatcher.setHashAlgorithmName(SHA256Util.HASH_ALGORITHM_NAME);
            // 散列的次数，比如散列两次，相当于 md5(md5(""));
            shaCredentialsMatcher.setHashIterations(SHA256Util.HASH_ITERATIONS);
            return shaCredentialsMatcher;
        }
    
        /**
         * 配置Redis管理器
         * @Attention 使用的是shiro-redis开源插件
         * @Author Sans
         * @CreateTime 2019/6/12 11:06
         */
        @Bean
        public RedisManager redisManager() {
            RedisManager redisManager = new RedisManager();
            redisManager.setHost(host);
            redisManager.setPort(port);
            redisManager.setTimeout(timeout);
            redisManager.setPassword(password);
            return redisManager;
        }
    
        /**
         * 配置Cache管理器
         * 用于往Redis存储权限和角色标识
         * @Attention 使用的是shiro-redis开源插件
         * @Author Sans
         * @CreateTime 2019/6/12 12:37
         */
        @Bean
        public RedisCacheManager cacheManager() {
            RedisCacheManager redisCacheManager = new RedisCacheManager();
            redisCacheManager.setRedisManager(redisManager());
            redisCacheManager.setKeyPrefix(CACHE_KEY);
            // 配置缓存的话要求放在session里面的实体类必须有个id标识
            redisCacheManager.setPrincipalIdFieldName("userId");
            return redisCacheManager;
        }
    
        /**
         * SessionID生成器
         * @Author Sans
         * @CreateTime 2019/6/12 13:12
         */
        @Bean
        public ShiroSessionIdGenerator sessionIdGenerator(){
            return new ShiroSessionIdGenerator();
        }
    
        /**
         * 配置RedisSessionDAO
         * @Attention 使用的是shiro-redis开源插件
         * @Author Sans
         * @CreateTime 2019/6/12 13:44
         */
        @Bean
        public RedisSessionDAO redisSessionDAO() {
            RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
            redisSessionDAO.setRedisManager(redisManager());
            redisSessionDAO.setSessionIdGenerator(sessionIdGenerator());
            redisSessionDAO.setKeyPrefix(SESSION_KEY);
            redisSessionDAO.setExpire(timeout);
            return redisSessionDAO;
        }
    
        /**
         * 配置Session管理器
         * @Author Sans
         * @CreateTime 2019/6/12 14:25
         */
        @Bean
        public SessionManager sessionManager() {
            ShiroSessionManager shiroSessionManager = new ShiroSessionManager();
            shiroSessionManager.setSessionDAO(redisSessionDAO());
            return shiroSessionManager;
        }
    }



四.实现权限控制


Shiro可以用代码或者注解来控制权限,通常我们使用注解控制,不仅简单方便,而且更加灵活.Shiro注解一共有五个:






注解名称  
  说明  






RequiresAuthentication  
  使用该注解标注的类,方法等在访问时,当前Subject必须在当前session中已经过认证.  




RequiresGuest  
使用该注解标注的类,方法等在访问时,当前Subject可以是“gust”身份,不需要经过认证或者在原先的session中存在记录.  




RequiresUser  
验证用户是否被记忆,有两种含义:一种是成功登录的(subject.isAuthenticated()结果为true);另外一种是被记忆的(subject.isRemembered()结果为true).  




RequiresPermissions  
当前Subject需要拥有某些特定的权限时,才能执行被该注解标注的方法.如果没有权限,则方法不会执行还会抛出AuthorizationException异常.  




RequiresRoles  
当前Subject必须拥有所有指定的角色时,才能访问被该注解标注的方法.如果没有角色,则方法不会执行还会抛出AuthorizationException异常.  






  
一般情况下我们在项目中做权限控制,使用最多的是RequiresPermissions和RequiresRoles,允许存在多个角色和权限,默认逻辑是AND,也就是同时拥有这些才可以访问方法,可以在注解中以参数的形式设置成OR


    示例
    //拥有一个角色就可以访问
    @RequiresRoles(value={"ADMIN","USER"},logical = Logical.OR)
    //拥有所有权限才可以访问
    @RequiresPermissions(value={"sys:user:info","sys:role:info"},logical = Logical.AND)


使用顺序:Shiro注解是存在顺序的,当多个注解在一个方法上的时候,会逐个检查,知道全部通过为止,默认拦截顺序是:



RequiresRoles->RequiresPermissions->RequiresAuthentication->RequiresUser->RequiresGuest



    示例
    //拥有ADMIN角色同时还要有sys:role:info权限
    @RequiresRoles(value={"ADMIN")
    @RequiresPermissions("sys:role:info")



创建UserRoleController角色拦截测试类


    /**
     * @Description 角色测试
     * @Author Sans
     * @CreateTime 2019/6/19 11:38
     */
    @RestController
    @RequestMapping("/role")
    public class UserRoleController {
    
        @Autowired
        private SysUserService sysUserService;
        @Autowired
        private SysRoleService sysRoleService;
        @Autowired
        private SysMenuService sysMenuService;
        @Autowired
        private SysRoleMenuService sysRoleMenuService;
    
        /**
         * 管理员角色测试接口
         * @Author Sans
         * @CreateTime 2019/6/19 10:38
         * @Return Map 返回结果
         */
        @RequestMapping("/getAdminInfo")
        @RequiresRoles("ADMIN")
        public Map getAdminInfo(){
            Map map = new HashMap<>();
            map.put("code",200);
            map.put("msg","这里是只有管理员角色能访问的接口");
            return map;
        }
    
        /**
         * 用户角色测试接口
         * @Author Sans
         * @CreateTime 2019/6/19 10:38
         * @Return Map 返回结果
         */
        @RequestMapping("/getUserInfo")
        @RequiresRoles("USER")
        public Map getUserInfo(){
            Map map = new HashMap<>();
            map.put("code",200);
            map.put("msg","这里是只有用户角色能访问的接口");
            return map;
        }
    
        /**
         * 角色测试接口
         * @Author Sans
         * @CreateTime 2019/6/19 10:38
         * @Return Map 返回结果
         */
        @RequestMapping("/getRoleInfo")
        @RequiresRoles(value={"ADMIN","USER"},logical = Logical.OR)
        @RequiresUser
        public Map getRoleInfo(){
            Map map = new HashMap<>();
            map.put("code",200);
            map.put("msg","这里是只要有ADMIN或者USER角色能访问的接口");
            return map;
        }
    
        /**
         * 登出(测试登出)
         * @Author Sans
         * @CreateTime 2019/6/19 10:38
         * @Return Map 返回结果
         */
        @RequestMapping("/getLogout")
        @RequiresUser
        public Map getLogout(){
            ShiroUtils.logout();
            Map map = new HashMap<>();
            map.put("code",200);
            map.put("msg","登出");
            return map;
        }
    }


创建UserMenuController权限拦截测试类


    /**
     * @Description 权限测试
     * @Author Sans
     * @CreateTime 2019/6/19 11:38
     */
    @RestController
    @RequestMapping("/menu")
    public class UserMenuController {
    
        @Autowired
        private SysUserService sysUserService;
        @Autowired
        private SysRoleService sysRoleService;
        @Autowired
        private SysMenuService sysMenuService;
        @Autowired
        private SysRoleMenuService sysRoleMenuService;
        
        /**
         * 获取用户信息集合
         * @Author Sans
         * @CreateTime 2019/6/19 10:36
         * @Return Map 返回结果
         */
        @RequestMapping("/getUserInfoList")
        @RequiresPermissions("sys:user:info")
        public Map getUserInfoList(){
            Map map = new HashMap<>();
            List sysUserEntityList = sysUserService.list();
            map.put("sysUserEntityList",sysUserEntityList);
            return map;
        }
    
        /**
         * 获取角色信息集合
         * @Author Sans
         * @CreateTime 2019/6/19 10:37
         * @Return Map 返回结果
         */
        @RequestMapping("/getRoleInfoList")
        @RequiresPermissions("sys:role:info")
        public Map getRoleInfoList(){
            Map map = new HashMap<>();
            List sysRoleEntityList = sysRoleService.list();
            map.put("sysRoleEntityList",sysRoleEntityList);
            return map;
        }
    
        /**
         * 获取权限信息集合
         * @Author Sans
         * @CreateTime 2019/6/19 10:38
         * @Return Map 返回结果
         */
        @RequestMapping("/getMenuInfoList")
        @RequiresPermissions("sys:menu:info")
        public Map getMenuInfoList(){
            Map map = new HashMap<>();
            List sysMenuEntityList = sysMenuService.list();
            map.put("sysMenuEntityList",sysMenuEntityList);
            return map;
        }
    
        /**
         * 获取所有数据
         * @Author Sans
         * @CreateTime 2019/6/19 10:38
         * @Return Map 返回结果
         */
        @RequestMapping("/getInfoAll")
        @RequiresPermissions("sys:info:all")
        public Map getInfoAll(){
            Map map = new HashMap<>();
            List sysUserEntityList = sysUserService.list();
            map.put("sysUserEntityList",sysUserEntityList);
            List sysRoleEntityList = sysRoleService.list();
            map.put("sysRoleEntityList",sysRoleEntityList);
            List sysMenuEntityList = sysMenuService.list();
            map.put("sysMenuEntityList",sysMenuEntityList);
            return map;
        }
    
        /**
         * 添加管理员角色权限(测试动态权限更新)
         * @Author Sans
         * @CreateTime 2019/6/19 10:39
         * @Param  username 用户ID
         * @Return Map 返回结果
         */
        @RequestMapping("/addMenu")
        public Map addMenu(){
            //添加管理员角色权限
            SysRoleMenuEntity sysRoleMenuEntity = new SysRoleMenuEntity();
            sysRoleMenuEntity.setMenuId(4L);
            sysRoleMenuEntity.setRoleId(1L);
            sysRoleMenuService.save(sysRoleMenuEntity);
            //清除缓存
            String username = "admin";
            ShiroUtils.deleteCache(username,false);
            Map map = new HashMap<>();
            map.put("code",200);
            map.put("msg","权限添加成功");
            return map;
        }
    }



创建UserLoginController登录类


    /**
     * @Description 用户登录
     * @Author Sans
     * @CreateTime 2019/6/17 15:21
     */
    @RestController
    @RequestMapping("/userLogin")
    public class UserLoginController {
    
        /**
         * 登录
         * @Author Sans
         * @CreateTime 2019/6/20 9:21
         */
        @RequestMapping("/login")
        public Map login(@RequestBody SysUserEntity sysUserEntity){
            Map map = new HashMap<>();
            //进行身份验证
            try{
                //验证身份和登陆
                Subject subject = SecurityUtils.getSubject();
                UsernamePasswordToken token = new UsernamePasswordToken(sysUserEntity.getUsername(), sysUserEntity.getPassword());
                //验证成功进行登录操作
                subject.login(token);
            }catch (IncorrectCredentialsException e) {
                map.put("code",500);
                map.put("msg","用户不存在或者密码错误");
                return map;
            } catch (LockedAccountException e) {
                map.put("code",500);
                map.put("msg","登录失败，该用户已被冻结");
                return map;
            } catch (AuthenticationException e) {
                map.put("code",500);
                map.put("msg","该用户不存在");
                return map;
            } catch (Exception e) {
                map.put("code",500);
                map.put("msg","未知异常");
                return map;
            }
            map.put("code",0);
            map.put("msg","登录成功");
            map.put("token",ShiroUtils.getSession().getId().toString());
            return map;
        }
        /**
         * 未登录
         * @Author Sans
         * @CreateTime 2019/6/20 9:22
         */
        @RequestMapping("/unauth")
        public Map unauth(){
            Map map = new HashMap<>();
            map.put("code",500);
            map.put("msg","未登录");
            return map;
        }
        /**
         * 添加一个用户演示接口
         * 这里仅作为演示不加任何权限和重复查询校验
         * @Author Sans
         * @CreateTime 2020/1/6 9:22
         */
        @RequestMapping("/testAddUser")
        public Map testAddUser(){
            // 设置基础参数
            SysUserEntity sysUser = new SysUserEntity();
            sysUser.setUsername("user1");
            sysUser.setState("NORMAL");
            // 随机生成盐值
            String salt = RandomStringUtils.randomAlphanumeric(20);
            sysUser.setSalt(salt);
            // 进行加密
            String password ="123456";
            sysUser.setPassword(SHA256Util.sha256(password, sysUser.getSalt()));
            // 保存用户
            sysUserService.save(sysUser);
            // 保存角色
            SysUserRoleEntity sysUserRoleEntity = new SysUserRoleEntity();
            sysUserRoleEntity.setUserId(sysUser.getUserId()); // 保存用户完之后会把ID返回给用户实体
            sysUserRoleService.save(sysUserRoleEntity);
            // 返回结果
            Map map = new HashMap<>();
            map.put("code",0);
            map.put("msg","添加成功");
            return map;
        }
    }



  五.POSTMAN测试


登录成功后会返回TOKEN,因为是单点登录,再次登陆的话会返回新的TOKEN,之前Redis的TOKEN就会失效了




当第一次访问接口后我们可以看到缓存中已经有权限数据了,在次访问接口的时候,Shiro会直接去缓存中拿取权限,注意访问接口时候要设置请求头.




ADMIN这个号现在没有sys:info:all这个权限的,所以无法访问getInfoAll接口,我们要动态分配权限后,要清掉缓存,在访问接口时候,Shiro会去重新执行授权方法,之后再次把权限和角色数据放入缓存中




访问添加权限测试接口,因为是测试,我把增加权限的用户ADMIN写死在里面了,权限添加后,调用工具类清掉缓存,我们可以发现,Redis中已经没有缓存了




再次访问getInfoAll接口,因为缓存中没有数据,Shiro会重新授权查询权限,拦截通过 




六.项目源码


码云:  gitee.com/liselotte/s… 
GitHub:  github.com/xuyulong201… 


谢谢大家阅读,如果喜欢,请收藏点赞,多给些star,文章不足之处,也请给出宝贵意见.


推荐



学习资料分享


12 套 微服务、Spring Boot、Spring Cloud 核心技术资料，这是部分资料目录：


    

  • Spring Security 认证与授权
    • 

  • Spring Boot 项目实战（中小型互联网公司后台服务架构与运维架构）
    • 

  • Spring Boot 项目实战（企业权限管理项目））
    • 

  • Spring Cloud 微服务架构项目实战（分布式事务解决方案）
    • 

  • ...
    公众号后台回复arch028获取资料：：
    • 

























你可能感兴趣的:(java,springboot,shiro)






    

  • Java高级编程—I/O流（包括字节输入流、字节输出流、字符输出流、字符输入流、缓冲流、序列化流、反序列化流等，详解 附有代码＋案例）
蔚一
Java知识java开发语言算法intellij-idea

    文章目录二十七.I/O流27.1概述27.2分类27.3字节输出流27.3.1数据写入本地文件27.3.2换行、续写27.4字节输入流27.4.1读取数据到程序27.4.2循环读取27.4.3拷贝数据27.4.4一次读取多个27.6字符输入流27.6.1FileReader的使用27.7字符输出流27.8.缓冲流27.8.1字节缓冲流27.8.1.1拷贝文件(一)27.8.1.2拷贝文件(二)27
    

    • 

  • System.getProperty，System.getenv().get(),environment.getProperty区别
spum
java前端服务器

    启动类：@SpringBootApplicationpublicclassM2Application{publicstaticvoidmain(String[]args){System.setProperty("a.x","xx_xx");//如果放到run下面不会生效并且在后续System.getProperty("a.x")也是null//如果-D或者环境变量中也设置了，生效的还是这里Spri
    

    • 

  • IDEA全文搜索排除无用的文件夹
常敲代码手不生
IDEA学习与实践intellij-ideajavaintellijidea

    问题：最近在用到idea的全文搜索关键字功能时候，发现检索很慢，仔细一看发现除了从工程类的java文件检索之外，另外从很多日志文件里也进行了检索，比如工程运行生成的日志文件。导致卡死、搜索巨慢解法：为了提高检索速度，需要idea手动配置过滤掉多余的文件夹操作：file——projectstructure——modules——选择指定的文件夹——右键excluded
    

    • 

  • JavaWeb - Spring Boot - 请求参数
湫湫玺云台
后端JavaWebspringbootjava后端

    @RequestMapping从注解名称上我们可以看到，@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系。SpringMVC接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求。@RequestMapping标识一个类：设置映射请求的请求路径的初始信息@RequestMapping标识一个方法：设置映射请求请求路径的具体信息@Cont
    

    • 

  • Java中的System.getenv()和System.getProperty()
星辰鸿溟
JavaHadoopYarnHadoopHDFS

    System.getenv()和System.getProperty()是Java种常用的两种读取环境配置信息的方法，它们都是java.lang.System类的方法，用途有相似之处，但我们在实际使用中，需要更加注意二者的区别。1.System.getenv()System.getenv()读取的是当前系统环境的环境变量。要深入理解环境变量的本质，需要对系统父子进程关系有更加清晰的认识。一般来说，
    

    • 

  • 鸿蒙HarmonyOS应用开发之使用Node-API接口进行线程安全开发
OpenHarmony_小贾
移动开发HarmonyOSOpenHarmonyharmonyos安全华为移动开发物联网APP

    场景介绍napi_create_threadsafe_function是Node-API接口之一，用于创建一个线程安全的JavaScript函数。主要用于在多个线程之间共享和调用，而不会出现竞争条件或死锁。例如以下场景：异步计算：如果需要进行耗时的计算或IO操作，可以创建一个线程安全的函数，将计算或IO操作放在另一个线程中执行，避免阻塞主线程，提高程序的响应速度。数据共享：如果多个线程需要访问同一
    

    • 

  • 在Windows系统上以服务的形式部署SpringBoot项目
程序员小H

    背景由于项目需要是实现Office文档的在线预览，为了更好的预览效果使用MSOffice对（doc、docx、xls、xlsx、ppt、pptx、txt）转换为PDF文件进行预览，MSOffice不支持Linux，所以文档转换服务只能部署在Windows服务器上，需要将文档转换服务添加到windows服务中，以服务的放是运行，从而实现开机自启动。部署工具使用官方推荐的工具：winsw工具下载：ht
    

    • 

  • Java基础面试题整理50题（附部分答案）
阿舒带你学编程
javajava开发语言jvmspring架构

    1、说说&和&&的区别答：&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于if(str!=null&&!str.equals(“”))表达式，当str为null时，后面的表达式不会执行，
    

    • 

  • System.getenv()和System.getProperty() 的区别
一步一台阶
javagetenvgetPropertySystemVMarguments

    最近遇到一个需求，服务器实例需要获取当前的环境变量。经过查资料，发现环境变量可以在两个地方设置。一、在系统层面设置环境变量在系统层面设置环境变量，之前我们应该都操作过，以windows系统为例System.getenv()可以获取的在这里设置的变量。二、在java虚拟机层面设置环境变量个人理解，System.getProperty()可以获取在JVM层面的变量，有些变量在JVM启动后，就内置了，如
    

    • 

  • 春意融融：SpringBoot打造在线订餐服务
代码之光_1980
springbootmysql数据库

    1绪论1.1研究背景随着互联网技术的快速发展，网络时代的到来，网络信息也将会改变当今社会。各行各业在日常企业经营管理等方面也在慢慢的向规范化和网络化趋势汇合[13]。电子商务必将成为未来商务的主流，因此对于餐饮行业来说，建立一个网上订餐系统是必不可少的一种销售模式；由于现在人们的生活节奏越来越快，就餐时间过于集中，为了实现用户通过计算机平台进行订餐的功能[1]，开发了本网上订餐系统。近几年随着互联
    

    • 

  • Java集合中fail-fast和fail-safe机制详解
橡 皮 人
Java集合java集合的fail机制

    在使用集合时候，大家应该都遇到过或听过并发修改异常（ConcurrentModificationException），这其实是Java集合中的一种fail-fast机制，为了避免触发fail-fast机制，Java中还提供了一些采用fail-safe机制设计的集合类，本篇文章就系统的介绍一下这两种机制。一、fail-fast机制1.1什么是fail-fast机制简单的说，这就是系统设计的一种理念，
    

    • 

  • Node.js的学习与简单使用
学习Java的唐唐
前端技术学习javajsnodejs

    一、简介1、什么是Node.js简单的说Node.js就是运行在服务端的JavaScript。Node.js是一个事件驱动I/O服务端JavaScript环境，基于Google的V8引擎，V8引擎执行Javascript的速度非常快，性能非常好。2、Node.js有什么用如果你是一个前端程序员，你不懂得像PHP、Python或Ruby等动态编程语言，然后你想创建自己的服务，那么Node.js是一个
    

    • 

  • java xml转json数组_如何在Java中将XML转换为JSON数组？
weixin_39850143
javaxml转json数组

    JSON是轻量级的数据交换格式，JSON的格式类似于键值对。我们可以使用org.json.XML类将XML转换为JSON数组，这提供了一个静态方法XML.toJSONObject()来将XML转换为JSON数组。语法publicstaticJSONObjecttoJSONObject(java.lang.Stringstring)throwsJSONException在下面的示例中，将XML转换为
    

    • 

  • java编程题——八皇后问题
sdg_advance
java算法排序算法数据结构

    背景及问题介绍：八皇后问题（英文：Eightqueens），是由国际象棋棋手马克斯·贝瑟尔于1848年提出的问题，是回溯算法的典型案例。问题表述为：在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。如果经过±9
    

    • 

  • JAVA XML转JSON工具类
张志飞
xmljson

    packagecom.cm.util.xmlutl;importcom.alibaba.fastjson.JSONArray;importcom.alibaba.fastjson.JSONObject;importorg.apache.log4j.Logger;importorg.dom4j.*;importjava.io.File;importjava.io.FileInputStream;im
    

    • 

  • MQTT.js 简述
Wu Youlu
javascript开发语言ecmascript

    MQTT.js简述简介MQTT是一种轻量级的消息传输协议，常用于物联网（IoT）设备间的通信。mqtt.js是一个JavaScript库，支持在Node.js和浏览器中使用，用于通过MQTT协议与MQTTBroker进行通信。安装在Node.js中，可以通过以下命令安装：npminstallmqtt--save在浏览器中使用：基础概念Broker（代理）：处理客户端消息的中介服务，管理消息的发布和
    

    • 

  • java版本ERP管理系统源码 Spring Cloud alibaba Spring Boot MybatisPlus Redis VUE3 ElementUI 微服务
m0_66404702
javaspringbootredisERP管理系统源码

    在当今数字化浪潮的推动下，企业对于高效、稳定且易于扩展的管理系统需求日益增长。为了满足这一需求，我们精心打造了一款基于Java技术的鸿鹄ERP（EnterpriseResourcePlanning）管理系统。该系统充分利用了SpringCloudAlibaba、SpringBoot、MybatisPlus、Redis等先进技术栈，并结合前端框架VUE3和ElementUI，构建了一个功能丰富、性能
    

    • 

  • 程序员故事 - 一家奇葩的互联网公司（一）
liruiqiang05
程序人生

    由于自己放浪，大学毕业没多久就失业了。为了糊口，我在自学了JAVA的一些基础知识以后，抱着试一试的心态，投了几份简历。接下来便收到了一家公司的面试邀请，于是我稍作准备、欣然前往。去了之后，先是一面，正当我忐忑不安、担心是否能通过面试的时候，面试官来了一句：“我们这里欢迎小白，我们将为每一个有编程梦想的人提供平台，不怕你一无所知，就怕你自己不肯努力！只要你愿意付出，我们这里有足够资深的工程师带你，让
    

    • 

  • RSocket-JS 使用指南
郁俪晟Gertrude

    RSocket-JS使用指南rsocket-jsJavaScriptimplementationofRSocket项目地址:https://gitcode.com/gh_mirrors/rs/rsocket-js1.项目介绍RSocket-JS是一个实现了RSocket协议（版本1.0）的JavaScript库，专为在浏览器环境及Node.js中使用设计。该库允许开发者通过RSocket协议进行高
    

    • 

  • QMetry自动化框架：一站式功能测试解决方案
芮奕滢Kirby

    QMetry自动化框架：一站式功能测试解决方案qafQualityAutomationFrameworkforweb,mobileweb,mobilenativeandrestweb-serviceusingSelenium,webdrier,TestNGandJavaJersey项目地址:https://gitcode.com/gh_mirrors/qa/qaf项目介绍QMetry自动化框架（Q
    

    • 

  • Java好资源网址推荐
学习&实践爱好者
Java学习编程资料java开发语言

    Java好资源网址推荐Java官方教程https://docs.oracle.com/javase/tutorial/index.htmlJavaDocumentationhttps://docs.oracle.com/en/java/JavaSELicensingUserManualhttps://www.oracle.com/java/technologies/javase/licensing
    

    • 

  • 在 Linux 上部署javaWeb项目+图文详解_java web项目部署到linux服务器
2401_85154737
服务器linuxjava

    -f:force强制的意思，如果目标文件已经存在，不会询问直接覆盖-i:若目标已经存在，就会询问是否覆盖-u:若目标文件已经存在，且比目标文件新，才会更新#该命令可以把多个文件一次移动到一个文件夹中，但是最后的一个目标文件一要是“目录”。例如：mvfile1file2file3dir#把多个文件移动到dir目录中mvfile1file2#把file重命名为file26、rm命令该命令用于删除文件或
    

    • 

  • MySQL高级篇（SQL优化、索引优化、锁机制、主从复制）_mysql sql优化
2401_85154737
mysqlsql数据库

    3索引介绍3.1索引是什么MySQL官方对索引的定义为：索引（Index）是帮助MySQL高效获取数据的数据结构（索引的本质是数据结构，排序+查询两种功能）。索引的目的在于提高查询效率，可以类比字典。如果要查“mysql”这个单词，我们肯定需要定位到m字母，然后从下往下找到y字母，再找到剩下的sql。如果没有索引，那么你可能需要逐个逐个寻找，如果我想找到Java开头的单词呢？或者Oracle开头的
    

    • 

  • Java泛型中 T 与 T的区别和用法
Java大数据布道者

    T表示返回值是一个泛型，传递啥，就返回啥类型的数据，而单独的T就是表示限制你传递的参数类型，这个案例中，通过一个泛型的返回方式，获取每一个集合中的第一个数据，通过返回值T和T的两种方法实现一、T用法TT.png二、T用法T.pnggoldmei.png
    

    • 

  • 设计模式学习笔记（6）工厂方法
摆码王子

    本文实例代码：https://github.com/JamesZBL/java_design_patterns工厂方法（FactoryMethod)模式，又叫做虚拟构造（VirtualConstructor）模式或多态工厂(PolymorphicFactory）模式。工厂方法的特点是定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。实例这次以顾客点餐为例，
    

    • 

  • java xml 转json json 转 json对象
在下，杨江河
遇到的问题javaxmljson

    xml转json在Java中将XML转换为JSON是一个常见的需求，尤其是在处理Web服务或数据交换时。有多种库可以帮助你完成这项任务，但其中最流行和广泛使用的一个是org.json（虽然它本身不直接支持XML到JSON的转换，但可以通过解析XML然后构建JSON来实现）和com.fasterxml.jackson.dataformat.xml（Jackson库的一个扩展，可以直接从XML解析到J
    

    • 

  • Linux 如何创建进程函数与查看进程_linux java进程 查看热点函数
2401_85154737
javalinux开发语言

    进程创建函数进程就是pcb，意味着创建一个进程，就是创建一个pcbpid_tfork(void)–通过复制调用进程（父进程）创建一个新的进程（子进程）创建一个新的pcb，然后从父进程pcb中复制了很多数据过来复制的主要信息有内存指针，程序计数器，上下文数据。内存指针：子进程与父进程运行的代码其实是一样的–指向同一块物理内存中的数据及指令程序计数器/上下文数据：子进程被创建出来后，运行位置与父进程是
    

    • 

  • Python基础库-JSON库
度假的小鱼
Python基础jsonjavascript开发语言python

    活动地址：CSDN21天学习挑战赛文章目录1JSON介绍1.1json介绍1.2json特点1.3json文件的处理1.4json语法规则1.5json键1.6json文件的书写1.7读取json文件的方法(json.load)1.8操作json文件常见错误1JSON介绍JSON的全称是JavaScriptObjectNotation"，是JavaScript对象表示法，它是一种基于文本，独立于语
    

    • 

  • java日志级别
香辣奥利奥
框架java

    开发过程中或多或少我们会用到日志，一般有5个日志级别：DEBUG：程序调试bug时使用INFO：程序正常运行时使用WARNING：程序未按预期运行时使用，但并不是错误，如:用户登录密码错误ERROR：程序出错误时使用，如:IO操作失败Fatal：特别严重的问题，导致程序不能再继续运行时使用，如:磁盘空间为空，一般很少使用默认的是WARNING等级，当在WARNING或WARNING之上等级的才记录
    

    • 

  • java日志规范
dzl84394
日志javatomcat开发语言

    原则完整原则保证日志包含足够的信息，足够支持内部控制，定位故障，审计，合规要求有效性确保日志有效，可读，最低影响打印日志肯定损耗性能，但是要将损耗降到最低一、如何打印日志1、【禁止】禁止生产环境打印DEBUG日志，禁止打印SYSOUT.OUT日志代码审查sonar应该提醒去掉sout2、【禁止】禁止将文件转为base64等形式打印3、【禁止】禁止将业务字段作为日志字段如果日志内容是对象，json等
    

    • 

  • rust的指针作为函数返回值是直接传递，还是先销毁后创建？
wudixiaotie
返回值

     这是我自己想到的问题，结果去知呼提问，还没等别人回答， 我自己就想到方法实验了。。
fn main() {
let mut a = 34;
println!("a's addr:{:p}", &a);
let p = &mut a;
println!("p's addr:{:p}", &a
    

    • 

  • java编程思想 -- 数据的初始化
百合不是茶
java数据的初始化

     
1.使用构造器确保数据初始化
    
/*
*在ReckInitDemo类中创建Reck的对象
*/
public class ReckInitDemo {
public static void main(String[] args) {
//创建Reck对象
new Reck();
}
}
    

    • 

  • [航天与宇宙]为什么发射和回收航天器有档期
comsci

    
       地球的大气层中有一个时空屏蔽层,这个层次会不定时的出现,如果该时空屏蔽层出现,那么将导致外层空间进入的任何物体被摧毁,而从地面发射到太空的飞船也将被摧毁...
       所以,航天发射和飞船回收都需要等待这个时空屏蔽层消失之后,再进行
&
    

    • 

  • linux下批量替换文件内容
商人shang
linux替换

    1、网络上现成的资料
　　格式: sed -i "s/查找字段/替换字段/g" `grep 查找字段 -rl 路径`
　　linux sed 批量替换多个文件中的字符串
　　sed -i "s/oldstring/newstring/g" `grep oldstring -rl yourdir`
　　例如：替换/home下所有文件中的www.admi
    

    • 

  • 网页在线天气预报
oloz
天气预报

    网页在线调用天气预报
<%@ page language="java" contentType="text/html; charset=utf-8"
pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transit
    

    • 

  • SpringMVC和Struts2比较
杨白白
springMVC

    1. 入口
spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。
参见：http://blog.csdn.net/zs15932616453/article/details/8832343
2
    

    • 

  • refuse copy, lazy girl!
小桔子
copy

           妹妹坐船头啊啊啊啊！都打算一点点琢磨呢。文字编辑也写了基本功能了。。今天查资料，结果查到了人家写得完完整整的。我清楚的认识到：
1.那是我自己觉得写不出的高度
2.如果直接拿来用，很快就能解决问题
3.然后就是抄咩~~
4.肿么可以这样子，都不想写了今儿个，留着作参考吧！拒绝大抄特抄，慢慢一点点写！
  
    

    • 

  • apache与php整合
aichenglong
php apache web

    一  apache web服务器
1 apeche web服务器的安装
  1)下载Apache web服务器
  2)配置域名(如果需要使用要在DNS上注册)
  3)测试安装访问http://localhost/验证是否安装成功
2 apache管理
  1)service.msc进行图形化管理
  2)命令管理，配
    

    • 

  • Maven常用内置变量
AILIKES
maven

    Built-in properties
${basedir} represents the directory containing pom.xml
${version} equivalent to ${project.version} (deprecated: ${pom.version})
Pom/Project properties
Al
    

    • 

  • java的类和对象
百合不是茶
JAVA面向对象 类 对象

    java中的类：
 
  java是面向对象的语言，解决问题的核心就是将问题看成是一个类，使用类来解决
 
java使用 class 类名   来创建类 ，在Java中类名要求和构造方法，Java的文件名是一样的
 
创建一个A类：
class A{
}
 
java中的类：将某两个事物有联系的属性包装在一个类中，再通
    

    • 

  • JS控制页面输入框为只读
bijian1013
JavaScript

    在WEB应用开发当中，增、删除、改、查功能必不可少，为了减少以后维护的工作量，我们一般都只做一份页面，通过传入的参数控制其是新增、修改或者查看。而修改时需将待修改的信息从后台取到并显示出来，实际上就是查看的过程，唯一的区别是修改时，页面上所有的信息能修改，而查看页面上的信息不能修改。因此完全可以将其合并，但通过前端JS将查看页面的所有信息控制为只读，在信息量非常大时，就比较麻烦。
  
    

    • 

  • AngularJS与服务器交互
bijian1013
JavaScriptAngularJS$http

            对于AJAX应用（使用XMLHttpRequests）来说，向服务器发起请求的传统方式是：获取一个XMLHttpRequest对象的引用、发起请求、读取响应、检查状态码，最后处理服务端的响应。整个过程示例如下：
var xmlhttp = new XMLHttpRequest();
xmlhttp.onreadystatechange
    

    • 

  • [Maven学习笔记八]Maven常用插件应用
bit1129
maven

    常用插件及其用法位于：http://maven.apache.org/plugins/
 
1. Jetty server plugin
2. Dependency copy plugin
3. Surefire Test plugin
4. Uber jar plugin
 
 
 
 
 
1. Jetty Pl
    

    • 

  • 【Hive六】Hive用户自定义函数(UDF)
bit1129
自定义函数

    1. 什么是Hive UDF
Hive是基于Hadoop中的MapReduce，提供HQL查询的数据仓库。Hive是一个很开放的系统，很多内容都支持用户定制，包括：
文件格式：Text File，Sequence File
内存中的数据格式： Java Integer/String, Hadoop IntWritable/Text
用户提供的 map/reduce 脚本：不管什么
    

    • 

  • 杀掉nginx进程后丢失nginx.pid，如何重新启动nginx
ronin47
nginx 重启 pid丢失

    nginx进程被意外关闭，使用nginx -s reload重启时报如下错误：nginx: [error] open() “/var/run/nginx.pid” failed (2: No such file or directory)这是因为nginx进程被杀死后pid丢失了，下一次再开启nginx -s reload时无法启动解决办法：nginx -s reload 只是用来告诉运行中的ng
    

    • 

  • UI设计中我们为什么需要设计动效
brotherlamp
UIui教程ui视频ui资料ui自学

    随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。
但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。
一、加强体验舒适度
嗯，就是让用户更加爽更加爽的用你的产品。 
    

    • 

  • Spring中JdbcDaoSupport的DataSource注入问题
bylijinnan
javaspring

    参考以下两篇文章：
http://www.mkyong.com/spring/spring-jdbctemplate-jdbcdaosupport-examples/
http://stackoverflow.com/questions/4762229/spring-ldap-invoking-setter-methods-in-beans-configuration
Sprin
    

    • 

  • 数据库连接池的工作原理
chicony
数据库连接池

           随着信息技术的高速发展与广泛应用，数据库技术在信息技术领域中的位置越来越重要，尤其是网络应用和电子商务的迅速发展，都需要数据库技术支持动 态Web站点的运行，而传统的开发模式是：首先在主程序（如Servlet、Beans）中建立数据库连接；然后进行SQL操作，对数据库中的对象进行查 询、修改和删除等操作；最后断开数据库连接。使用这种开发模式，对
    

    • 

  • java 关键字
CrazyMizzz
java

    
关键字是事先定义的，有特别意义的标识符，有时又叫保留字。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。
Java中的关键字按功能主要可以分为以下几类：
   （1）访问修饰符
      public,private,protected
      p
    

    • 

  • Hive中的排序语法
daizj
排序hiveorder byDISTRIBUTE BYsort by

    Hive中的排序语法 2014.06.22 ORDER BY
hive中的ORDER BY语句和关系数据库中的sql语法相似。他会对查询结果做全局排序，这意味着所有的数据会传送到一个Reduce任务上，这样会导致在大数量的情况下，花费大量时间。
与数据库中 ORDER BY 的区别在于在hive.mapred.mode = strict模式下，必须指定 limit 否则执行会报错。
    

    • 

  • 单态设计模式
dcj3sjt126com
设计模式

      单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。 使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。
<?phpclass Example{    // 保存类实例在此属性中    private static&
    

    • 

  • svn locked
dcj3sjt126com
Lock

    post-commit hook failed (exit code 1) with output:
svn: E155004: Working copy 'D:\xx\xxx' locked
svn: E200031: sqlite: attempt to write a readonly database
svn: E200031: sqlite: attempt to write a 
    

    • 

  •  ARM寄存器学习
e200702084
数据结构C++cC#F#

    无论是学习哪一种处理器，首先需要明确的就是这种处理器的寄存器以及工作模式。
    ARM有37个寄存器，其中31个通用寄存器，6个状态寄存器。
1、不分组寄存器（R0-R7）
    不分组也就是说说，在所有的处理器模式下指的都时同一物理寄存器。在异常中断造成处理器模式切换时，由于不同的处理器模式使用一个名字相同的物理寄存器，就是
    

    • 

  • 常用编码资料
gengzg
编码

     List<UserInfo> list=GetUserS.GetUserList(11);
String json=JSON.toJSONString(list);
HashMap<Object,Object> hs=new HashMap<Object, Object>();
for(int i=0;i<10;i++)
{

    

    • 

  • 进程 vs. 线程
hongtoushizi
线程linux进程

    我们介绍了多进程和多线程，这是实现多任务最常用的两种方式。现在，我们来讨论一下这两种方式的优缺点。
首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。
如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。
如果用多线程实现
    

    • 

  • Linux定时Job：crontab -e 与 /etc/crontab 的区别
Josh_Persistence
linuxcrontab

    一、linux中的crotab中的指定的时间只有5个部分：* * * * *
分别表示：分钟，小时，日，月，星期，具体说来：
第一段 代表分钟 0—59
第二段 代表小时 0—23
第三段 代表日期 1—31
第四段 代表月份 1—12
第五段 代表星期几，0代表星期日 0—6
 
如：
*/1 * * * *   每分钟执行一次。
* 
    

    • 

  • KMP算法详解
hm4123660
数据结构C++算法字符串KMP

         字符串模式匹配我们相信大家都有遇过，然而我们也习惯用简单匹配法（即Brute-Force算法)，其基本思路就是一个个逐一对比下去，这也是我们大家熟知的方法，然而这种算法的效率并不高，但利于理解。
 
    假设主串s="ababcabcacbab",模式串为t="
    

    • 

  • 枚举类型的单例模式
zhb8015
单例模式

    E.编写一个包含单个元素的枚举类型[极推荐]。代码如下：
public enum MaYun {himself; //定义一个枚举的元素，就代表MaYun的一个实例private String anotherField;MaYun() {//MaYun诞生要做的事情//这个方法也可以去掉。将构造时候需要做的事情放在instance赋值的时候：/** himself = MaYun() {*
    

    • 

  • Kafka+Storm+HDFS
ssydxa219
storm

    cd /myhome/usr/stormbin/storm nimbus &amp;bin/storm supervisor &amp;bin/storm ui &amp;Kafka+Storm+HDFS整合实践kafka_2.9.2-0.8.1.1.tgzapache-storm-0.9.2-incubating.tar.gzKafka安装配置我们使用3台机器搭建Kafk
    

    • 

  • Java获取本地服务器的IP
中华好儿孙
javaWeb获取服务器ip地址

    
System.out.println("getRequestURL:"+request.getRequestURL());
System.out.println("getLocalAddr:"+request.getLocalAddr());
System.out.println("getLocalPort:&quo
    

    •