SpringBoot学习-简单shiro权限控制

最新推荐文章于 2022-11-28 01:00:24 发布
最新推荐文章于 2022-11-28 01:00:24 发布
阅读量702 收藏
点赞数
分类专栏： 后端篇 集成篇 SpringBoot springboot学习 文章标签： shiro spring-boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zng_xp/article/details/78210451
版权

前面介绍了很多基础设置的搭建方法，现在在前面的基础上，我们利用shiro来实现简单的登录及权限控制（只是简单的shiro集成，更细颗粒的shiro权限控制方法可以自己去学习shiro相关功能实现）。
框架基础：前面搭建的基础框架SpringBoot+JPA+MySQL
第一步：maven引入Jar包

<!-- shiro权限控制框架 -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.3.2</version>
</dependency>

第二步：前端登录页设计及方法
这里写图片描述
登录页代码就不贴了，自己弄个简单的登录页测试一下就行
第三步：后端设计
这里写图片描述

Shiro配置类：

package com.example.demo.shiro;

import org.apache.shiro.authc.credential.CredentialsMatcher;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Created by John.Zhang on 2017/10/10.
 */
@Configuration
public class ShiroConfig {
    /**
     * ShiroFilterFactoryBean 处理拦截资源文件问题。
     * 注意：单独一个ShiroFilterFactoryBean配置是或报错的，以为在
     * 初始化ShiroFilterFactoryBean的时候需要注入：SecurityManager
     *
     * Filter Chain定义说明 1、一个URL可以配置多个Filter，使用逗号分隔 2、当设置多个过滤器时，全部验证通过，才视为通过
     * 3、部分过滤器可指定参数，如perms，roles
     *
     */
    @Bean
    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 必须设置 SecurityManager
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        // 如果不设置默认会自动寻找Web工程根目录下的"/login.jsp"页面
        shiroFilterFactoryBean.setLoginUrl("/");
        // 未授权界面;
//        shiroFilterFactoryBean.setUnauthorizedUrl("/403");
        // 拦截器.
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
        // 配置不会被拦截的链接 顺序判断
        filterChainDefinitionMap.put("/css/**", "anon");
        filterChainDefinitionMap.put("/img/**", "anon");
        filterChainDefinitionMap.put("/js/**", "anon");
        filterChainDefinitionMap.put("/login", "anon");
        // 配置退出过滤器,其中的具体的退出代码Shiro已经替我们实现了
        filterChainDefinitionMap.put("/logout", "logout");
        // <!-- 过滤链定义，从上向下顺序执行，一般将 /**放在最为下边 -->:这是一个坑呢，一不小心代码就不好使了;
        // <!-- authc:所有url都必须认证通过才可以访问; anon:所有url都都可以匿名访问-->
        filterChainDefinitionMap.put("/**", "authc");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        System.out.println("Shiro拦截器工厂类注入成功");
        return shiroFilterFactoryBean;
    }
    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 设置realm.
        securityManager.setRealm(myShiroRealm());
        return securityManager;
    }
    /**
     * 身份认证realm; 
     *
     * @return
     */
    @Bean
    public ShiroRealm myShiroRealm() {
        ShiroRealm myShiroRealm = new ShiroRealm();
        myShiroRealm.setCredentialsMatcher(credentialsMatcher());
        return myShiroRealm;
    }

    /**
     * 凭证匹配器（用于加密密码使用，如不需要可以去除相关信息）
     */
    @Bean
    public CredentialsMatcher credentialsMatcher(){
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher("MD5");
        credentialsMatcher.setHashIterations(2);
        return credentialsMatcher;
    }
}

自定义认证：

package com.example.demo.shiro;

import com.example.demo.entities.Permission;
import com.example.demo.entities.Role;
import com.example.demo.entities.User;
import com.example.demo.service.UserSevice;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.ArrayList;
import java.util.List;

public class ShiroRealm extends AuthorizingRealm {
    private Logger logger = LoggerFactory.getLogger(ShiroRealm.class);

    @Autowired
    private UserSevice userSevice;

    /**
     * 登录认证
     *
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        logger.info("验证当前Subject时获取到token为：" + token.toString());
        //查出是否有此用户
        User hasUser = userSevice.findByName(token.getUsername());
        if (hasUser != null) {

            if(hasUser.getIsLocked() != null && hasUser.getIsLocked().equals(User.IsLocked.LOCKED))
            {
                throw new LockedAccountException("用户已被锁定，无法登录");
            }

            List<Role> rlist = userSevice.findRolesByUid(hasUser.getId());//获取用户角色
            List<Permission> plist = userSevice.findPermissionsByUid(hasUser.getId());//获取用户权限

            List<String> roles = new ArrayList<>();
            List<String> permissions = new ArrayList<>();
            for(Role role : rlist){
                roles.add(role.getName());
            }
            for(Permission permission : plist){
                permissions.add(permission.getName());
            }
            hasUser.setRoleList(roles);
            hasUser.setPermissionList(permissions);
//            Session session = SecurityUtils.getSubject().getSession();
//            session.setAttribute("user", hasUser);//成功则放入session

            // 若存在，将此用户存放到登录认证info中，无需自己做密码对比，Shiro会为我们进行密码对比校验
            return new SimpleAuthenticationInfo(hasUser, hasUser.getPassword(),ByteSource.Util.bytes(hasUser.getSalt()), getName());
        }else {
            throw new UnknownAccountException("用户不存在");
        }
    }

    /**
     * 权限认证
     *
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        logger.info("##################执行Shiro权限认证##################");
        User user = (User) principalCollection.getPrimaryPrincipal();
//        //到数据库查是否有此对象
//        User user = null;// 实际项目中，这里可以根据实际情况做缓存，如果不做，Shiro自己也是有时间间隔机制，2分钟内不会重复执行该方法
//        user = userMapper.findByName(loginName);
        if (user != null) {
            //权限信息对象info,用来存放查出的用户的所有的角色（role）及权限（permission）
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
            //用户的角色集合
            info.addRoles(user.getRoleList());
            //用户的权限集合
            info.addStringPermissions(user.getPermissionList());
            return info;
        }
        // 返回null的话，就会导致任何用户访问被拦截的请求时，都会自动跳转到unauthorizedUrl指定的地址
        return null;
    }
}

用户实体类User:

package com.example.demo.entities;

import org.hibernate.annotations.GenericGenerator;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;

import javax.persistence.*;

import java.util.Date;
import java.util.List;
import java.util.Random;
import java.util.UUID;

import static javax.persistence.GenerationType.TABLE;
import static javax.persistence.TemporalType.TIMESTAMP;

@Entity
@Table(name = "tab_user")
public class User extends CommEntity{

    @Id
    @Column(name = "user_id")
    @GeneratedValue(strategy = TABLE, generator = "sequence_generator")
    @GenericGenerator(
            name = "sequence_generator",
            strategy = "org.hibernate.id.enhanced.TableGenerator",
            parameters = {
                    @org.hibernate.annotations.Parameter(name = "segment_value", value = "user"),
                    @org.hibernate.annotations.Parameter(name = "increment_size", value = "100"),
                    @org.hibernate.annotations.Parameter(name = "optimizer", value = "pooled")
            })
    private Long id;

    @Column(name = "user_name",nullable = false,unique = true)
    private String name;

    @Column(name = "password",nullable = false)
    private String password;

    @Column(name = "user_salt",nullable = false)
    private String salt = UUID.randomUUID().toString();

    @Column(name = "user_status")
    private Integer status = 1;

    @Column(name = "is_locked")
    private IsLocked isLocked = IsLocked.LOCKED;

    @Transient
    private List<String> roleList;

    @Transient
    private List<String> permissionList;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public List<String> getRoleList() {
        return roleList;
    }

    public void setRoleList(List<String> roleList) {
        this.roleList = roleList;
    }

    public List<String> getPermissionList() {
        return permissionList;
    }

    public void setPermissionList(List<String> permissionList) {
        this.permissionList = permissionList;
    }

    public String getSalt() {
        return salt;
    }

    public void setSalt(String salt) {
        this.salt = salt;
    }

    public IsLocked getIsLocked() {
        return isLocked;
    }

    public void setIsLocked(IsLocked isLocked) {
        this.isLocked = isLocked;
    }

    public static enum IsLocked{
        LOCKED("锁定"),UNLOCKED("正常");

        IsLocked(String type){
            this.type = type;
        }

        private String type;

        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }

        public static IsLocked getValue(Integer i){
            switch (i){
                case 0:
                    return LOCKED;
                case 1:
                    return UNLOCKED;
                default:
                    return null;
            }
        }
    }
}

角色实体类Role：

package com.example.demo.entities;

import org.hibernate.annotations.GenericGenerator;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;

import javax.persistence.*;

import java.util.Date;
import java.util.List;

import static javax.persistence.GenerationType.TABLE;
import static javax.persistence.TemporalType.TIMESTAMP;

/**
 * Created by John.Zhang on 2017/10/11.
 */
@Entity
@Table(name = "tab_sys_role")
public class Role extends CommEntity{

    @Id
    @Column(name = "role_id")
    @GeneratedValue(strategy = TABLE, generator = "sequence_generator")
    @GenericGenerator(
            name = "sequence_generator",
            strategy = "org.hibernate.id.enhanced.TableGenerator",
            parameters = {
                    @org.hibernate.annotations.Parameter(name = "segment_value", value = "role"),
                    @org.hibernate.annotations.Parameter(name = "increment_size", value = "1"),
                    @org.hibernate.annotations.Parameter(name = "optimizer", value = "pooled")
            })
    private Long id;

    @Column(name = "role_name",unique = true,nullable = false)
    private String name;

    @Column(name = "role_type",nullable = false)
    private Short type;

    @Transient
    private List<Permission> permissionList;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Short getType() {
        return type;
    }

    public void setType(Short type) {
        this.type = type;
    }

    public List<Permission> getPermissionList() {
        return permissionList;
    }

    public void setPermissionList(List<Permission> permissionList) {
        this.permissionList = permissionList;
    }
}

用户角色映射类UserRole：

package com.example.demo.entities;

import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;

import static javax.persistence.GenerationType.TABLE;

/**
 * Created by John.Zhang on 2017/10/11.
 */
@Entity
@Table(name = "tab_user_role")
public class UserRole extends CommEntity{

    @Id
    @Column(name = "user_role_id")
    @GeneratedValue(strategy = TABLE, generator = "sequence_generator")
    @GenericGenerator(
            name = "sequence_generator",
            strategy = "org.hibernate.id.enhanced.TableGenerator",
            parameters = {
                    @org.hibernate.annotations.Parameter(name = "segment_value", value = "user_role"),
                    @org.hibernate.annotations.Parameter(name = "increment_size", value = "1"),
                    @org.hibernate.annotations.Parameter(name = "optimizer", value = "pooled")
            })
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id")
    private User user;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "role_id")
    private Role role;

    @Column(name = "note")
    private String note;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public Role getRole() {
        return role;
    }

    public void setRole(Role role) {
        this.role = role;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }
}

权限基础类Permission:

package com.example.demo.entities;

import org.hibernate.annotations.GenericGenerator;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;

import javax.persistence.*;

import java.util.Date;

import static javax.persistence.GenerationType.TABLE;
import static javax.persistence.TemporalType.TIMESTAMP;

/**
 * Created by John.Zhang on 2017/10/11.
 */
@Entity
@Table(name = "tab_sys_permission")
public class Permission extends CommEntity{
    @Id
    @Column(name = "permission_id")
    @GeneratedValue(strategy = TABLE, generator = "sequence_generator")
    @GenericGenerator(
            name = "sequence_generator",
            strategy = "org.hibernate.id.enhanced.TableGenerator",
            parameters = {
                    @org.hibernate.annotations.Parameter(name = "segment_value", value = "permission"),
                    @org.hibernate.annotations.Parameter(name = "increment_size", value = "1"),
                    @org.hibernate.annotations.Parameter(name = "optimizer", value = "pooled")
            })
    private Long id;

    @Column(name = "permission_name",unique = true,nullable = false)
    private String name;

    @Column(name = "permission_url")
    private String url;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }
}

角色权限映射类RolePermission：

package com.example.demo.entities;

import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;

import static javax.persistence.GenerationType.TABLE;

/**
 * Created by John.Zhang on 2017/10/11.
 */
@Entity
@Table(name = "tab_role_permission")
public class RolePermission extends CommEntity{
    @Id
    @Column(name = "role_permission_id")
    @GeneratedValue(strategy = TABLE, generator = "sequence_generator")
    @GenericGenerator(
            name = "sequence_generator",
            strategy = "org.hibernate.id.enhanced.TableGenerator",
            parameters = {
                    @org.hibernate.annotations.Parameter(name = "segment_value", value = "role_permission"),
                    @org.hibernate.annotations.Parameter(name = "increment_size", value = "1"),
                    @org.hibernate.annotations.Parameter(name = "optimizer", value = "pooled")
            })
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "role_id")
    private Role role;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "permission_id")
    private Permission permission;

    @Column(name = "note")
    private String note;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Role getRole() {
        return role;
    }

    public void setRole(Role role) {
        this.role = role;
    }

    public Permission getPermission() {
        return permission;
    }

    public void setPermission(Permission permission) {
        this.permission = permission;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }
}

公用实体类CommEntity：

package com.example.demo.entities;

import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;

import javax.persistence.Column;
import javax.persistence.Temporal;
import java.util.Date;

import static javax.persistence.TemporalType.TIMESTAMP;

/**
 * Created by John.Zhang on 2017/10/11.
 */
public class CommEntity {
    @CreatedDate
    @Temporal(TIMESTAMP)
    @Column(name = "create_time")
    private Date createTime = new Date();

    @LastModifiedDate
    @Temporal(TIMESTAMP)
    @Column(name = "modified_date")
    private Date modifiedDate;

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getModifiedDate() {
        return modifiedDate;
    }

    public void setModifiedDate(Date modifiedDate) {
        this.modifiedDate = modifiedDate;
    }
}

登录Controller :

package com.example.demo.controller;

import com.example.demo.entities.User;
import com.example.demo.entities.UserToken;
import com.example.demo.service.UserSevice;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;

/**
 * Created by John.Zhang on 2017/10/9.
 */
@RestController
public class LoginController {

    @Autowired
    private UserSevice userSevice;

    @PostMapping(value = "login")
    public HashMap<String,Object> login(@RequestBody UserToken userToken){
        return userSevice.login(userToken);
    }

    @PostMapping(value = "getLoginUser")
    public User getLoginUser(){
        return userSevice.getLoginUser();
    }
}

路径跳转Controller ：

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * Created by John.Zhang on 2017/10/9.
 */
@Controller
public class PathController {

    private String LoginPath = "Login";
    private String IndexPath = "index";

    @RequestMapping(value = "/")
    public String loginInit(){
        return LoginPath;
    }

    @RequestMapping(value = "index")
    public String toIndex(){
        return IndexPath;
    }
}

方法实现类（接口类不贴了，自动生成就行）：

package com.example.demo.service.impl;

import com.example.demo.entities.*;
import com.example.demo.repository.*;
import com.example.demo.service.UserSevice;
import com.example.demo.utils.DataTransUtil;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.LockedAccountException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * Created by John.Zhang on 2017/10/9.
 */
@Service
public class UserSeviceImpl implements UserSevice{

    @Autowired
    private UserRepository userRepository;
    @Autowired
    private UserRoleRepository userRoleRepository;
    @Autowired
    private RolePermissionRepository rolePermissionRepository;
    @Autowired
    private RoleRepository roleRepository;
    @Autowired
    private PermissionRepository permissionRepository;


    @Override
    public HashMap<String, Object> login(UserToken userToken) {

        UsernamePasswordToken token = new UsernamePasswordToken(userToken.getUsername(), userToken.getPassword());

        try {
            SecurityUtils.getSubject().login(token);
        }catch (UnknownAccountException e){
            return DataTransUtil.returnData(0,"用户名不存在");
        }catch (IncorrectCredentialsException e) {
            return DataTransUtil.returnData(0, "密码错误");
        }catch (LockedAccountException e){
            return DataTransUtil.returnData(0,"用户已被锁定，无法登录");
        }catch (Exception e){
            return DataTransUtil.returnData(0,"其他错误");
        }

        return DataTransUtil.returnData();
    }

    @Override
    public User findByName(String username) {
        return userRepository.findByName(username);
    }

    @Override
    public User getLoginUser() {
        return (User)SecurityUtils.getSubject().getPrincipal();
    }

    @Override
    public List<Role> findRolesByUid(Long id) {
        List<UserRole> userRoleList = userRoleRepository.findRolesByUid(id);
        List<Role> roleList = new ArrayList<>();
        for(UserRole userRole : userRoleList){
            roleList.add(userRole.getRole());
        }
        return roleList;
    }

    @Override
    public List<Permission> findPermissionsByUid(Long id) {
        List<UserRole> userRoleList = userRoleRepository.findRolesByUid(id);
        List<Long> roleIds = new ArrayList<>();
        for(UserRole userRole : userRoleList){
            roleIds.add(userRole.getRole().getId());
        }

        List<RolePermission> rolePermissionList = rolePermissionRepository.findPermissionsByUid(roleIds);
        List<Permission> permissionList = new ArrayList<>();
        for(RolePermission rolePermission : rolePermissionList){
            if(!permissionList.contains(rolePermission.getPermission())){
                permissionList.add(rolePermission.getPermission());
            }
        }
        return permissionList;
    }
}

Dao层（详细代码不贴了，自己定义就行）：
这里写图片描述

工具类：

package com.example.demo.utils;

import org.springframework.util.StringUtils;

import java.util.HashMap;

/**
 * Created by lean on 2017/9/18.
 */
public class DataTransUtil {

    private static Integer defaultCode = 1;
    private static String defaultMessage = "succesful";

    public static HashMap<String,Object> returnData(Integer code,String message,Object data){
        HashMap<String,Object> map = new HashMap<>();

        if(null != code){
            map.put("code",code);
        }else{
            map.put("code",defaultCode);
        }
        if(!StringUtils.isEmpty(message)){
            map.put("message",message);
        }else{
            map.put("message",defaultMessage);
        }
        map.put("data",data);

        return map;
    }

    public static HashMap<String,Object> returnData(Object data){
        return returnData(null,null,data);
    }

    public static HashMap<String,Object> returnData(){
        return returnData(null,null,null);
    }

    public static HashMap<String,Object> returnData(Integer code,String message){
        return returnData(code,message,null);
    }

}

从 getLoginUser 接口方法获得登录用户信息展示：
这里写图片描述

附加-密码加密方法：

package com.example.demo;

import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.crypto.hash.SimpleHash;
import org.apache.shiro.util.ByteSource;

/**
 * Created by John.Zhang on 2017/10/11.
 */
public class Test {
    public static void main(String[] args) {
        String newPassword = new SimpleHash(
                "MD5",           //加密算法
                "123",      //密码
                ByteSource.Util.bytes("10086"),  //salt盐   username + salt
                2   //迭代次数
        ).toHex();
        System.out.print(newPassword);
    }
}
ZNG_XP
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot-vue-shiro-权限整合
01-06
springboot+vue+shiro 前后盾分离，权限整合，vue路由配置解析，有sql语句，shiro 权限验证。
springboot 简单集成 spring security（二）权限控制
aimeng555的博客
05-10 1484
简介 上一篇我们实现了springboot简单的集成了spring security，实现了在用户想要实现某一操作时需要进行登陆认证，但是在登陆后用户能够进行所有想要的操作，这并不是我们想要的，我们需要的是当用户访问后，用户能够操作的是我们能够控制他能够操作接口。这里我们就需要进行权限的控制。
Maven项目下的shiro配置一
lei_1994的博客
06-03 1万+
一、认识Shiro 二、代码结构 1、代码目录： 2、pom.xml所有的依赖： &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.o...
springboot整合SpringSecurity并实现简单权限控制
听钱塘信来的博客
11-28 6503
springboot整合SpringSecurity并实现简单权限控制
spring boot注解实现权限控制
大圣即大盗
12-25 3686
1、自定义注解 Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface RoleCheck { String[] roles() default {}; } 2、注解的实现 @Service public class RoleCheckInterceptor ...
springboot实现简单自定义权限控制
泉眼和溪流的关系，大概是泉眼会被溪流一点一滴的占据
07-10 2087
框架选择 权限控制是管理系统必不可少的模块，当前成熟的权限控制框架有Shiro，spring security等，利用框架开发的好处就是简洁方便快捷。 本文权限思路——注解方式 本文实现权限的方式是没有使用框架，而是通过自定义注解方式实现简单的权限管理控制。 关于表设计 一般权限表的设计都可以通过5张表来实现，用户表，角色表，权限表，用户角色关系表，角色权限关系表，其中用户与角色是多对多关系，角色与权限也是多对多关系，下图是实现思路举例，具体要根据各自业务逻辑灵活设计。 本文思路是通过自定义注解进行权限控制
SpringBoot-Shiro-Vue:提供一套基于Spring Boot-Shiro-Vue的权限管理思路.前后端都加以控制,做到按钮接口级别的权限
05-11
提供一套基于SpringBoot-shiro-vue的权限管理思路. 前后端都加以控制,做到按钮/接口级别的权限 DEMO admin/123456 管理员身份登录,可以新增用户,角色. 角色可以分配权限 控制菜单是否显示,新增/删除按钮是否显示 ...
springboot-shiro-demo_mybatisplus_DEMO_shiro权限管理_
10-02
实现shiro权限管理，mysql
Springboot和bootstrap实现shiro权限控制配置过程
08-19
主要介绍了Springboot和bootstrap实现shiro权限控制,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springboot-2.0-shiro.rar
07-13
springboot与shiroShiro是Apache旗下的一个开源项目，它是一个非常易用的安全框架，提供了包括认证、授权、加密、会话管理等功能，与Spring Security一样属基于权限的安全框架，但是与Spring Security 相比，Shiro...
探索 Hibernate 新 TableGenerator 机制
技术之家
03-26 1356
探索 Hibernate 新 TableGenerator 机制 Hibernate 从 3.2.3 之后引入了两个新的主键生成器 TableGenerator 和 SequenceStyleGenerator。为了保持与旧版本的兼容，这两个新主键生成器在默认情况下不会被启用，而不启用新 TableGenerator 的 Hibernate 在提供 JPA 的 @TableGen
SpringBoot权限控制，实现CRUD
qq_35125495的博客
04-16 1734
转自https://www.cnblogs.com/xuwujing/p/8260935.html SpringBoot介绍 Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。 简单的来说就是，只需几个jar和一些简单的配置，就可以快速开发项目。 假如...
小白的springboot之旅(十一) - springboot之用户权限管理（一）
热门推荐
shanjingyuan的专栏
05-31 6万+
关键词：springboot，jpa，spring security，mysql通常我们的网站都有权限控制，就像一个公司有产品、开发、运维之分，各自负责各自的业务，相互独立，有相互协作，共同完成一个任务。拥有不同权限的用户查看不同的页面，进行不同的操作。这篇来简单的说一下使用springboot+jpa+springsecurity实现简单的用户权限管理。角色和用户的关系通过数据库配置控制。角色可...
SpringBoot中使用Spring Security实现权限控制
椭圆的博客
07-21 2万+
Spring Security，这是一个专门针对基于Spring的项目的安全框架，它主要是利用了AOP来实现的。以前在Spring框架中使用Spring Security需要我们进行大量的XML配置，但是，Spring Boot针对Spring Security也提供了自动配置的功能，这些默认的自动配置极大的简化了我们的开发工作，我们今天就来看看这个吧。创建Project并添加相关依赖数据库使用My
Spring Boot + Security + Mybatis 简单权限控制（入门 + 记录篇）
温故而知新，可以为师矣。
08-22 9150
Spring Boot Security 权限 这两天研究了一下权限管理框架。。 查阅资料的过程中，JAVA中常用的安全框架有Shiro和Spring Security。Shiro比Spring Security学习起来更加简单，功能够用。而这两天的学习中，就我自己的体会而言，学习Spring Security还是有一定难度的。虽然它的扩展性非常的好，我们可以重载它默认的类，重写方法...
SpringBoot 做系统的权限管理——
yangjunzhuce的博客
03-01 8828
参考：https://www.cnblogs.com/zhaojiatao/p/8482998.html 参考:https://blog.csdn.net/likeyjs/article/details/80525042 再次感谢两位很牛的大牛！！！
Spring Boot 优雅的配置拦截器，实现权限管理
延宝小白马的博客
04-07 5167
其实spring boot拦截器的配置方式和springMVC差不多，只有一些小的改变需要注意下就ok了。下面主要介绍两种常用的拦截器： 一、基于URL实现的拦截器： 关键代码：path.matches(Const.NO_INTERCEPTOR_PATH 就是基于正则匹配的url。 二、基于注解的拦截器 ①创建注解： ②创建拦截器： 三、把拦截器...
基于SpringBoot+SpringSecurity实现简单的权限控制
xiongminming的博客
08-22 1536
前言 权限控制主要就是保证两方面的功能，1.验证:验证就是认证用户身份，一般采用用户名+密码的方式；2.鉴权:确认用户身份和权限，以便能够访问受保护的资源。 话不多说，直接上代码: 1.在pom文件中新增SpringSecurity依赖包，代码如下: <dependency> <groupId>org.springframework.boot&l...
springboot shiro 权限控制
最新发布
05-26
Spring Boot集成Shiro进行权限控制的步骤如下： 1. 引入Shiro和Spring Boot相关依赖。 2. 配置Shiro相关的Bean，包括Realm、SecurityManager和Filter等。 3. 配置Shiro的拦截器，即设置需要拦截的URL和对应的权限...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值