Spring Boot + JPA + Spring Security 实现用户权限数据库管理

最新推荐文章于 2021-10-02 23:04:11 发布
最新推荐文章于 2021-10-02 23:04:11 发布
阅读量7.1k 收藏 16
点赞数 4
分类专栏： J 文章标签： spring security spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sunday2017/article/details/83690383
版权

 使用Spring Boot + JPA + SpringSecurity 实现用户权限数据库管理

开发工具    STS（Spring Tool Suite） spring boot 2.0.6

 添加依赖

 依赖pom.xml

<dependencies>
           <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-starter-data-jpa</artifactId>
           </dependency>
           <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-starter-jdbc</artifactId>
           </dependency>
           <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-starter-security</artifactId>
           </dependency>
           <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-starter-thymeleaf</artifactId>
           </dependency>
           <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-starter-web</artifactId>
           </dependency>
           <dependency>
                 <groupId>mysql</groupId>
                 <artifactId>mysql-connector-java</artifactId>
                 <scope>runtime</scope>
           </dependency>
           <dependency>
                 <groupId>org.springframework.security</groupId>
                 <artifactId>spring-security-test</artifactId>
                 <scope>test</scope>
           </dependency>
           <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-devtools</artifactId>
                 <optional>true</optional> <!-- 这个需要为 true 热部署才有效  当修改后台文件保存的时候  自动重启项目-->
           </dependency>
      </dependencies>

application.properties

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/dome2
spring.datasource.username=root
spring.datasource.password=123456
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update

在搭建使用spring security 的时候  我分成了两个大的步骤学习   、

第一步   【用户的登录】，

第二步 【 权限限制】。 

 

第一步    用户登录（验证帐号密码）

 数据设计

     用户（user）  、角色 （role） 、  权限（authority ）   用数据库存储权限 ，url 存储在权限表中，其中用户 、角色 多对多关系， 角色 、权限也是多对多关系

 

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` bigint(20) NOT NULL,
  `email` varchar(50) DEFAULT NULL,
  `enabled` bit(1) DEFAULT NULL,
  `firstname` varchar(50) DEFAULT NULL,
  `lastpasswordresetdate` datetime DEFAULT NULL,
  `lastname` varchar(50) DEFAULT NULL,
  `password` varchar(100) DEFAULT NULL,
  `username` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `UK_sb8bbouer5wak8vyiiy4pf2bx` (`username`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

INSERT INTO `user` VALUES (1,'admin@admin.com',b'1','admin',NULL,'admin','123','sjy'),(2,'enabled@user.com',b'1','user',NULL,'user','123','user'),(3,'disabled@user.com',b'0','user',NULL,'user','123','test');



DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(25) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

INSERT INTO `role` VALUES (1,'ROLE_ADMIN'),(2,'ROLE_USER'),(3,'ROLE_TEST');


DROP TABLE IF EXISTS `authority`;
CREATE TABLE `authority` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `pid` int(11) NOT NULL,
  `url` varchar(255) DEFAULT NULL,
  `description` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

INSERT INTO `authority` VALUES (1,'admin',0,'/index1','管理'),(2,'user',0,'/index2','用戶'),(3,'test',0,'/index3','測試');


DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role` (
  `user_id` bigint(20) NOT NULL,
  `role_id` bigint(20) NOT NULL,
  KEY `FKa68196081fvovjhkek5m97n3y` (`role_id`),
  KEY `FK859n2jvi8ivhui0rl0esws6o` (`user_id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;


INSERT INTO `user_role` VALUES (1,1),(2,2),(3,3),(1,2);

DROP TABLE IF EXISTS `role_auth`;
CREATE TABLE `role_auth` (
  `auth_id` bigint(20) NOT NULL,
  `role_id` bigint(20) NOT NULL,
  KEY `FKrcrl3r3y8xexlss4vuah9h5pj` (`role_id`),
  KEY `FKdclw9v91w4q8voap572llxar1` (`auth_id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;


INSERT INTO `role_auth` VALUES (1,1),(2,3),(2,3),(2,2),(3,3);

         使用的JPA 注解的方式创建的实体，以及添加实体之间的关系，

user用户表

package com.sjy.bean;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;


import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;


@Entity
@Table(name = "USER")
public class User implements UserDetails {

    /**
     *
     */
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "ID")
    private Long id;

    @Column(name = "USERNAME", length = 50, unique = true)
    private String username;

    @Column(name = "PASSWORD", length = 100)
    private String password;

    @Column(name = "FIRSTNAME", length = 50)
    private String firstname;

    @Column(name = "LASTNAME", length = 50)
    private String lastname;

    @Column(name = "EMAIL", length = 50)
    private Boolean enabled;

    @Column(name = "LASTPASSWORDRESETDATE")
    @Temporal(TemporalType.TIMESTAMP)
    private Date lastPasswordResetDate;

    //急加载 会查询role表
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(
            name = "USER_ROlE",
            joinColumns = {@JoinColumn(name = "USER_ID", referencedColumnName = "ID")},
            inverseJoinColumns = {@JoinColumn(name = "ROLE_ID", referencedColumnName = "ID")})
    private List<Role> roles;

   //属性的get set 方法略················
      //实现UserDetails 重写的方法  
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        // TODO Auto-generated method stub
        List<GrantedAuthority> auths = new ArrayList<>();
        List<Role> roles = this.getRoles();
        for (Role role : roles) {
            for(Authority aurh:role.getAuthoritys())
            auths.add(new SimpleGrantedAuthority(aurh.getName()));
        }
        return auths;
    }

    @Override
    public boolean isAccountNonExpired() {
        // TODO Auto-generated method stub
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        // TODO Auto-generated method stub
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        // TODO Auto-generated method stub
        return true;
    }

    @Override
    public boolean isEnabled() {
        // TODO Auto-generated method stub
        return true;
    }
}

role角色表、

package com.sjy.bean;

import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

import com.fasterxml.jackson.annotation.JsonIgnore;

@Entity
@Table(name = "role")
public class Role {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "ID")
    private Long id;
    @Column(length = 25)
    private String name;
     //懒加载 不会查询role表
    @ManyToMany(mappedBy = "roles",fetch = FetchType.LAZY)
    private List<User> users;
     //急加载 会查询role表
    @ManyToMany(mappedBy = "roles",fetch = FetchType.EAGER)
    private List<Authority> Authoritys;

   //get  set方法略·········
}

authority 权限表

package com.sjy.bean;

import javax.persistence.*;


import java.util.List;

@Entity
@Table(name = "AUTHORITY")
public class Authority {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)//主键自动生成
    @Column(name="ID")
    private Long id;
    
    private String name;
    
    private String url;
    
    private int pid;
    
    private String description;

    @ManyToMany(fetch = FetchType.LAZY)//懒加载   快速查询 不会查询role表  
    @JoinTable(
            name = "ROlE_Auth",
            joinColumns = {@JoinColumn(name = "auth_ID", referencedColumnName = "ID")},
            inverseJoinColumns = {@JoinColumn(name = "ROLE_ID", referencedColumnName = "ID")})
    private List<Role> roles;
    
       //get set 略················
}

dao接口

package com.sjy.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;

import com.sjy.bean.User;

public interface userdao extends JpaRepository<User, Long> {
    
    public User findByUsername(String name);
}

UserDetailsServiceImpl 

             此类 实现  UserDetailsService接口 重写LoadUserUsername方法。

首先在usernamePasswordAuthenticationFilter中来拦截登录请求，并调用AuthenticationManager。AuthenticationManager调用

Provider，provider调用userDetaisService来根据username获取真实的数据库信息。最终验证帐号密码的类是

org.springframework.security.authentication.dao.DaoAuthenticationProvider.。 

          注意的是这里只需要一个根据用户名查询出用户的方法即可，不需要通过用户名和密码去查询。

package com.sjy.security;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.support.MessageSourceAccessor;
import org.springframework.security.core.SpringSecurityMessageSource;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import com.sjy.bean.User;
import com.sjy.dao.userdao;


@Service
public class UserDetailsServiceImpl implements UserDetailsService  {
    Logger logger = LoggerFactory.getLogger(UserDetailsServiceImpl.class);

    @Autowired
    private userdao userdao;

    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException  {
        User user = userdao.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("用户不存在");
        }
        System.out.println(user.getAuthorities());
        return user;
    }

}

映射页面（spring MVC config  或者在controller层写映射页面）

package com.sjy.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer  {
     @Override
        public void addViewControllers(ViewControllerRegistry registry) {
            registry.addViewController("/login1").setViewName("login");
            registry.addViewController("/index1").setViewName("index1");
            registry.addViewController("/index2").setViewName("index2");
            registry.addViewController("/index3").setViewName("index3");
            registry.addViewController("/myerror").setViewName("myerror");
            
        }
}

配置Spring Security

package com.sjy.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;

import com.sjy.security.MyPasswordEncoder;
import com.sjy.security.UserDetailsServiceImpl;

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter  {
    @Bean
    UserDetailsService customUserService() {
        return new UserDetailsServiceImpl();
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
        .userDetailsService(customUserService()).passwordEncoder(new MyPasswordEncoder());
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
        .anyRequest().authenticated()
        .and().formLogin().loginPage("/login1")
        //设置默认登录成功跳转页面
        .defaultSuccessUrl("/main").failureUrl("/login1?error").permitAll()
        .and()
        .logout()
        //默认注销行为为logout，可以通过下面的方式来修改
        .logoutUrl("/custom-logout")
        //设置注销成功后跳转页面，默认是跳转到登录页面
        .logoutSuccessUrl("/login1")
        .permitAll()
        .and()
        .exceptionHandling()
        .accessDeniedPage("/myerror");//无权访问;
    }
}

MyPasswordEncoder

package com.sjy.security;
import  org.springframework.security.crypto.password.PasswordEncoder;
public class MyPasswordEncoder implements PasswordEncoder {
    @Override
    public String encode(CharSequence arg0) {
        return arg0.toString();
    }
    @Override
    public boolean matches(CharSequence arg0, String arg1) {
        return arg1.equals(arg0.toString());
    }
}

HomeController

package com.sjy.controller;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import com.sjy.bean.Role;
import com.sjy.bean.User;
import com.sjy.dao.authdao;

@Controller
public class HomeController {
    @Autowired
    private authdao authdao;
    
    @RequestMapping("/main")
    public String main(Model model) {
        User user =getUserDetails();
        Set set = new HashSet();
         List<Role> roles = user.getRoles();
         for (Role role : roles) {
             set.addAll(role.getAuthoritys());
        }System.out.println(set);
    model.addAttribute("authorities",set);
        
    return "index";
    }
    private  User getUserDetails() {
        SecurityContext ctx = SecurityContextHolder.getContext();   
        Authentication auth = ctx.getAuthentication();
        return (User)auth.getPrincipal();
    }
}

登录页面

login.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8"/>
    <title>登录</title>
    <style type="text/css">
        body {
            padding-top: 50px;
        }
        .starter-template {
            padding: 40px 15px;
            text-align: center;
        }
    </style>
</head>
<body>
<nav class="navbar navbar-inverse navbar-fixed-top">
    <div class="container">
        <div class="navbar-header">
            <a class="navbar-brand" href="#">Spring Security演示</a>
        </div>
        <div id="navbar" class="collapse navbar-collapse">
            <ul class="nav navbar-nav">
                <li><a th:href="@{/}">首页</a></li>
                <li><a th:href="@{http://www.baidu.com}">百度</a></li>
            </ul>
        </div>
    </div>
</nav>
<div class="container">
    <div class="starter-template">
        <p th:if="${param.logout}" class="bg-warning">已注销</p>
        <p th:if="${param.error}" class="bg-danger">有错误，请重试</p>
        <h2>使用账号密码登录</h2>
        <form  th:action="@{/login1}" method="post">
            <div class="form-group">
                <label for="username">账号</label>
                <input type="text"  name="username" value="sjy"  placeholder="账号"/>
            </div>
            <div class="form-group">
                <label for="password">密码</label>
                <input type="password" name="password"  placeholder="密码"/>
            </div>
            <input type="submit" value="登陆"/>
        </form>
        <form th:action="@{/custom-logout}" method="post">
        <input type="submit" value="退出">
        </form>
    </div>
</div>
</body>
</html>

index.html

<html >
<head>
    <meta charset="utf-8">
    <title>后台登陆页面</title>
</head>
<body >
<li th:each="authority:${authorities}"  class="tpl-left-nav-item">
<a th:href="${authority.url}"  th:text="${authority.description}"></a>
</li>
          <h3>那些好的东西都是你的勒</h3>
          <form th:action="@{/custom-logout}" method="post">
        <input type="submit" value="退出">
        </form>
</body>
</html>

myerror.html

<html>
<head>
<meta charset="utf-8">
<title>后台登陆页面</title>
</head>
<body>
      <h1>myerror.html</h1>
      <h3>無權訪問</h3>
      <form th:action="@{/custom-logout}" method="post">
           <input type="submit" value="退出">
      </form>
</body>
</html>

           

                                               ok  第一步的  完成登录验证

 

第二步   权限限制

获取所有权限

 

MyInvocationSecurityMetadataSourceService    在项目加载的时候， 获取所有的权限，

package com.sjy.security;


import java.util.ArrayList;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.access.SecurityConfig;
import org.springframework.security.web.FilterInvocation;
import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
import org.springframework.stereotype.Service;

import com.sjy.bean.Authority;
import com.sjy.dao.authdao;




@Service
public class MyInvocationSecurityMetadataSourceService implements
        FilterInvocationSecurityMetadataSource{

    @Autowired
    private authdao authdao;
    
    private HashMap<String , Collection<ConfigAttribute>> map=null;
    
    /*
     * 系统启动后，首次有用户访问，加载权限表中所有权限。以便拦截无权放访问的用户请求。
     *
     * wzh增加了注释描述。
     */
    public void loadResourceDefine(){
        map=new HashMap<>();
        Collection<ConfigAttribute> array;
        ConfigAttribute cfg;
        List<Authority> permissions=authdao.findAll();
        for(Authority permission:permissions){
            array = new ArrayList<>();
            cfg=new SecurityConfig(permission.getName());
            //此处只添加了权限的名字，其实还可以添加更多权限的信息，例如请求方法到ConfigAttribute的集合中去。
            array.add(cfg);
            //用权限的getUrl（）作为map的key，用ConfigAttribute的集合作为value
            map.put(permission.getUrl(), array);
        }
    }
    
    /*
     * 此方法是为了判定用户请求的url是否再权限表中，如果在权限表中，则返回给decide方法，
     * 用来判定用户是否有此权限。如果不在权限表中则放行。
     *
     * 方法的目的是：确定该请求是否需要进行访问权限的判断，对于需要判断权限的请求，返回resUrl，对于不需要
     * 进行权限判断的请求，返回Null
     */
     @Override
        public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {
            if(map ==null) loadResourceDefine();
            HttpServletRequest request = ((FilterInvocation) object).getHttpRequest();
            AntPathRequestMatcher matcher;
            String resUrl;
            for(Iterator<String> iter = map.keySet().iterator(); iter.hasNext(); ) {
                resUrl = iter.next();
                //当url里有？的时候  进行切割   
                if(resUrl.indexOf("?")>-1){
                    resUrl=resUrl.substring(0,resUrl.indexOf("?"));
                }
                matcher = new AntPathRequestMatcher(resUrl);
                if(matcher.matches(request)) {
                    return map.get(resUrl);
                }
            }
            return null; //
        }

        @Override
        public Collection<ConfigAttribute> getAllConfigAttributes() {
            return null;
        }

        @Override
        public boolean supports(Class<?> clazz) {
            return true;
        }
}

MyFilterSecurityInterceptor

package com.sjy.security;

import java.io.IOException;


import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.SecurityMetadataSource;
import org.springframework.security.access.intercept.AbstractSecurityInterceptor;
import org.springframework.security.access.intercept.InterceptorStatusToken;
import org.springframework.security.web.FilterInvocation;
import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;
import org.springframework.stereotype.Service;



@Service
public class MyFilterSecurityInterceptor extends AbstractSecurityInterceptor implements Filter{
    
    @Autowired
    private FilterInvocationSecurityMetadataSource securityMetadataSource;

    @Autowired
    public void setMyAccessDecisionManager(MyAccessDecisionManager myAccessDecisionManager) {
        super.setAccessDecisionManager(myAccessDecisionManager);
    }


    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

        FilterInvocation fi = new FilterInvocation(request, response, chain);
        invoke(fi);
    }

    public void invoke(FilterInvocation fi) throws IOException, ServletException {
        //fi里面有一个被拦截的url
        //里面调用MyInvocationSecurityMetadataSource的getAttributes(Object object)这个方法获取fi对应的所有权限
        //再调用MyAccessDecisionManager的decide方法来校验用户的权限是否足够
        InterceptorStatusToken token = super.beforeInvocation(fi);
        try {
            //执行下一个拦截器
            fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
        } finally {
            super.afterInvocation(token, null);
        }
    }


    @Override
    public void destroy() {

    }

    @Override
    public Class<?> getSecureObjectClass() {
        return FilterInvocation.class;

    }

    @Override
    public SecurityMetadataSource obtainSecurityMetadataSource() {
        return this.securityMetadataSource;
    }
}

MyAccessDecisionManager   权限的一个判断

package com.sjy.security;

import org.springframework.security.access.AccessDeniedException;
import java.util.Collection;
import java.util.Iterator;

import org.springframework.security.access.AccessDecisionManager;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.authentication.InsufficientAuthenticationException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.stereotype.Service;


@Service
public class MyAccessDecisionManager implements AccessDecisionManager{

    //decide 方法是判定是否拥有权限的决策方法
    //authentication是UserDetailsServiceImpl中循环添加到GrantedAuthority 对象中的权限信息集合
    //object包含客户端发起的请求的request信息，可转换为 HttpServletRequest request=((FilterInvocation) object)
    //.getHttpRequest();
    //configAttributes 为MyInvocationSecurityMetadataSource的getAttributes(Object object)这个方法返回的结果，
    //此方法是为了判定用户请求的Url 是否在权限表中，如果在权限表中，则返回decide方法，用来判定用户是否由此权限，如果不在权限表中则放行。

    @Override
    public void decide(
            Authentication authentication,
            Object object,
            Collection<ConfigAttribute> configAttributes)
                    throws AccessDeniedException, InsufficientAuthenticationException {

        if(null== configAttributes || configAttributes.size() <=0) {
            return;
            //说明请求的系统中不存在指定的URL，返回执行security配置文件中其他项目。
        }
        ConfigAttribute c;
        String needRole;
        for(Iterator<ConfigAttribute> iter = configAttributes.iterator(); iter.hasNext(); ) {
            c = iter.next();
            needRole = c.getAttribute();
            for(GrantedAuthority ga : authentication.getAuthorities()) {
                
                
                if(needRole.trim().equals(ga.getAuthority())) {
                    return;
                }
            }
        }
        throw new AccessDeniedException(" 没有权限访问！ ");
    }



    @Override
    public boolean supports(ConfigAttribute attribute) {
        return true;
    }

    @Override
    public boolean supports(Class<?> clazz) {
        return true;
    }


}

 

添加 页面    测试权限使用  index1.html index2.html index3.html

修改HomeController   获取所有的权限

package com.sjy.controller;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import com.sjy.bean.Role;
import com.sjy.bean.User;
import com.sjy.dao.authdao;

@Controller
public class HomeController {
    @Autowired
    private authdao authdao;
    
    @RequestMapping("/main")
    public String main(Model model) {
        /*User user =getUserDetails();
        Set set = new HashSet();
         List<Role> roles = user.getRoles();
         for (Role role : roles) {
             set.addAll(role.getAuthoritys());
        }System.out.println(set);*/
        
    model.addAttribute("authorities",authdao.findAll());
        
    return "index";
    }
    private  User getUserDetails() {
        SecurityContext ctx = SecurityContextHolder.getContext();   
        Authentication auth = ctx.getAuthentication();
        return (User)auth.getPrincipal();
    }
}

使用sjy用户登录  他有管理  用户 权限的  但是没有  测试的权限 

  获取的所有权限

当点击测试的时候就跳转到了  myerror.html

点击管理

点击用户

 

 

地址

https://gitee.com/shijingyangman/Spring-Security

借鉴  

https://blog.csdn.net/u012373815/article/details/54632176

https://blog.csdn.net/u012702547/article/details/54319508

 

感谢感谢

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------更新  ：  发现了问题   ：

1.当你登陆之后其实所有的接口都是可以请求的。 （）  在MyInvocationSecurityMetadataSourceService.java  getAttributes方法当你登陆之后  return null  是默认通过的    就是   只要是你数据库没有的接口权限都是给你默认通过的。   反映了    “防君子不妨小人”    将所有的controller的接口映射都放入了数据库。一些公用的接口给定一样的权限

------------------------------------------------------------------------------------------------------------------------------------------------------------------------

添加qq第三方登录功能2019/3

 

Sunday2017
关注
  • 4
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
java 项目通用数据权限设计
学海无涯,我用JAVA
05-15 1118
权限一般分为操作权限和数据权限操作权限: 菜单,页面,按钮数据权限: 能看到的数据,包括各种页面的数据范围这里不做扩展,其实这里仅仅是最简单的方式,即直接通过限制表达到对于业务表的数据过滤,那么其实我们还可以通过其他方式限制;通过字典组限制,那么exists内部在拼接之前可能需要二次处理;通过sql语句配置限定条件,那么我们需要拼接sql语句,甚至当sql语句中有变量,我们需要解析后,再拼接到sql片段中;
基于SpringBoot2+Jpa+SpringSecurity+redis+Vue的前后端分离系统
03-10
系统功能模块 用户管理 提供用户的相关配置 角色管理 角色菜单分配权限 权限管理 权限细化到接口 菜单管理 已实现动态路由，后端可配置化 系统日志 记录用户访问监控异常信息 系统缓存管理 将redis的操作可视化，提供对redis的基本操作 Sql监控 采用 druid 监控数据库访问性能 技术栈 基础框架：Spring Boot 2.1.0.RELEASE 持久层框架：Spring boot Jpa 安全框架：Spring Security 缓存框架：Redis 日志打印：logback+log4jdbc 接口文档 swagger2 其他：fastjson，aop，MapStruct等。 页面框架：Vue 前端源码：eladmin-qt 后端源码：eladmin
SpringBoot + SpringSecurity + JPA 实现用户角色权限登录认证
09-10
IDEA + SpringBoot + SpringSecurity + JPA 实现用户角色权限登录认证，security过滤请求资源，用户登录获取用户角色权限，过滤用户非法请求等
基于JPA实现的支持SpringSecurity的RBAC权限模型
ikun 的博客
10-02 749
Role-Based Access Control，基于角色的访问控制。 一个用户可具备多角色，一个角色可具备多权限。 ER图 User 省略Getter/Setter、省略UserDetails部分实现、省略equals和hashCode的重写。 @Entity public class SysUser implements UserDetails { @Id @GeneratedValue private long id; @Column(nullable = fals
【Spring Security】Spring Security+Spring Data Jpa逆向生成数据库表
讯开技术孵化器博客
05-01 561
Spring Security+Spring Data Jpa 环境快速搭建 我们还是继续我们之前的安全管理权限框架学习，我们这里使用到的技术有 Spring Security 和 Spring Data Jpa 强强联手，安全管理没有简单，只有更简单！之前篇幅中我们的用户数据都保存在内存中，虽然中途介绍了 JdbcUserDetailsManager，但是使用起来依然灵活性不便，所以今天我要采用一个更加灵活的定义方式。那就是我们自己来定义授权数据库的模型。为了操作简单，我这里引入 Spring Data
springboot+jpa+security用户权限
11-04
springboot+jpa+mysql+security的用户权限管理代码 。
spring boot jpa 实现拦截器
热门推荐
田培融的博客
06-19 1万+
我们项目重构加上了很多数据权限的东西，项目中使用了mybatis 和 jpa。经手的人多了就是这样。 mybatis 我们使用的是拦截器给sql动态拼接，现在jpa也需要这样做。 以下是jpa 拦截器的配置。 第一步： 实现 hibernate接口。重写方法 public class JpaInterceptor implements StatementInspector { @Ov...
spring boot jpa security
05-08
综合上述信息，我们可以创建一个Spring Boot应用，使用Spring Data JPA进行数据持久化，Spring Security负责应用的安全管理，达梦数据库作为后端数据存储，FreeMarker处理前端展示，最后通过Assembly插件将整个项目...
基于spring boot + JPA的进销存管理系统源码.zip
最新发布
10-04
1. 用户管理：包括用户注册、登录、权限控制等功能，可能使用Spring Security进行安全认证和授权。 2. 商品管理：涉及商品的添加、修改、删除以及查询，JPA的Repository接口可以方便地实现这些操作。 3. 供应商管理...
SpringBoot整合Shiro，实现从数据库加载权限、权限的动态更新、Session共享
01-28
SpringBoot整合Shiro，实现从数据库加载权限、权限的动态更新、Session共享
基于spring boot + vue 的宿舍管理系统源码.zip
05-23
这是一个基于Spring Boot和Vue.js构建的宿舍管理系统源代码项目，旨在提供一套完整的从前端到后端，再到数据库的解决方案。让我们深入探讨这个系统的各个组成部分及其关键知识点。 首先，Spring Boot是Java开发的一...
spring boot使用HandlerInterceptor实现系统权限管理
qq_36526703的博客
08-21 3618
背景 前端效果类似于下图： 父子级菜单分别对应不同的操作权限、访问路径等。 数据库建三张表： 1.operate 页面菜单配置表 id即为权限id，url为菜单对应页面地址，type控制菜单是否显示。 2.action 请求url配置表 action为对应操作请求的url，operate即为对应操作权限，log控制是否打印日志。 3.account用户表 保存用户信...
基于JPA的Spring Boot Security实战
实践求真知
10-20 473
一pom <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache...
spring boot 最佳实践（九）-- 数据访问权限
老螺丝的技术人生
12-13 1万+
数据权限访问安全性是一个比基于角色的规则更复杂的场景。 访问控制列表 (ACL Access Controller List)它是用来做细粒度权限控制所用的一种权限模型。对ACL最简单的描述就是两个业务员，每个人只能查看操作自己签的合同，而不能看到对方的合同信息。
SpringBoot+Spring Security + spring boot jpa 实现权限管理
weixin_44533475的博客
08-01 1332
一 建表 权限管理需实现5张表：用户表、角色表、用户角色对应表、权限表、权限角色对应表 用户表 CREATE TABLE platform_user ( id bigint(20) NOT NULL AUTO_INCREMENT, username varchar(50) NOT NULL, password varchar(100) NOT NULL, PRIMARY KEY (id) ) EN...
spring boot 第三步 mvc+jpa+spring security+themeleaf
百尺竿头
07-11 1063
1.spring mvc + jpa参考https://blog.csdn.net/jo7490/article/details/800729452.pom.xml引入依赖及application.xml配置如下:&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4...
Springboot整合SpringSecurity
我能在河边钓一整天的鱼
05-11 217
目录 什么是Spring Security 环境搭建 基于AOP思想配置Secutrity 基于WebSecurityConfigurerAdapter实现自定义权限控制策略 基于AuthenticationManagerBuilder实现自定义身份认证策略 什么是Spring Security 是一个功能强大且高度可定制的用户身份验证和访问权限控制框架。它实际上是保护基于spring的应用程序的标准。 在用户认证方面，Spring Security 框架支持主流的认证方式，..
implement the shipping REST APIs with spring boot + sping mvc + jpa/batis + mysql + jwt
05-23
Sure, here's an outline of how you can implement the shipping REST APIs using Spring Boot, Spring MVC, JPA/Batis, MySQL, and JWT: 1. Set up a Spring Boot project with the necessary dependencies for ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值