authc过滤器 shiro_Shiro的web下的使用

最新推荐文章于 2022-08-29 10:18:32 发布
最新推荐文章于 2022-08-29 10:18:32 发布
阅读量95 收藏
点赞数
文章标签： authc过滤器 shiro
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39844549/article/details/111621668
版权

在前面我们一起使用了iniRealm和JdbcRealm的使用，接下来我们将在web下使用自定义的Realm。

步骤一：导入jar包 
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
      <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-core</artifactId>
          <version>1.3.2</version>
      </dependency>
      <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-web</artifactId>
          <version>1.3.2</version>
      </dependency>
      <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.30</version>
      </dependency>
      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
          <version>1.1.15</version>
      </dependency>
      <dependency>
          <groupId>jstl</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</version>
      </dependency>
      <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>3.1.0</version>
      </dependency>
      <dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
          <version>1.16.0</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jdbc</artifactId>
          <version>4.3.18.RELEASE</version>
      </dependency>
步骤二：配置shiro.ini文件 
[main]
realm=com.zmz.shiro.MyShiro

securityManager.realm=$realm
/#配置过滤器
authc=org.apache.shiro.web.filter.authc.FormAuthenticationFilter
/#定义login的路径
authc.loginUrl=/login.jsp

[urls]
/#定义那些可以使用 任意
/login.jsp=anon
/#只有authc可以进入
/main.jsp=authc
/#角色为manager可使用
/manager.jsp=authc,roles[manager]
/guest.jsp=authc,roles[guest]
/#权限为select 可使用
/select.jsp=perms[select]
/delete.jsp=perms[delete]
步骤三：编写maven的代码
entity层，这里使用easycode反向生成 
//User类

@Data
public class User implements Serializable {
    private static final long serialVersionUID = 530207062682414506L;
    
    private Integer uid;
    
    private String username;
    
    private String password;
    
    private String tel;
    
    private String addr;

    private Set<Role> roles;
}
//role 角色类
@Data
public class Role implements Serializable {
    private static final long serialVersionUID = -24879821050530425L;
    
    private Integer rid;
    
    private String rname;
    
    private String rdesc;

    private Set<Permission> permissions;

}
// permission 权限类
@Data
public class Permission implements Serializable {
    private static final long serialVersionUID = 386621187080762599L;
    
    private Integer pid;
    
    private String pname;
    
    private String pdesc;
    
}
controller层 
package com.zmz.controller;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(urlPatterns = "/login")
public class UserServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        IniSecurityManagerFactory factory = new IniSecurityManagerFactory();
        SecurityManager securityManager = factory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);
        Subject subject = SecurityUtils.getSubject();
        //创建令牌
        UsernamePasswordToken token = new UsernamePasswordToken(username,password);
        //登入
        try {
            subject.login(token);
            request.getRequestDispatcher("hello.jsp").forward(request,response);
        } catch (AuthenticationException e) {
            e.printStackTrace();
            response.sendRedirect("login.jsp");
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }
}
service层 
package com.zmz.service;

import com.zmz.entity.Permission;
import com.zmz.entity.Role;
import com.zmz.entity.User;

import java.util.List;

public interface UserService {
    //通过账号密码进行查询
    User getloginByUsername(String username,String password);
    //通过用户名进行角色的查询
    List<Role> getAllRolesByUsernam(String username);
    //通过用户名进行权限的查询
    List<Permission> getAllPermissionByUsername(String username);
}
service对应的impl层 
package com.zmz.service.impl;

import com.zmz.dao.UserDao;
import com.zmz.dao.impl.UserDaoImpl;
import com.zmz.entity.Permission;
import com.zmz.entity.Role;
import com.zmz.entity.User;
import com.zmz.service.UserService;

import java.util.List;

public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImpl();
    @Override
    public User getloginByUsername(String username,String password) {
        User user = userDao.getLoginByUsername(username,password);
        return user;
    }

    @Override
    public List<Role> getAllRolesByUsernam(String username) {
        List<Role> roles = userDao.getAllRolesByUsername(username);
        return roles;
    }

    @Override
    public List<Permission> getAllPermissionByUsername(String username) {
        List<Permission> permissions = userDao.getAllPermissionByUsername(username);
        return permissions;
    }
}
dao层 
package com.zmz.dao;

import com.zmz.entity.Permission;
import com.zmz.entity.Role;
import com.zmz.entity.User;

import java.util.List;

public interface UserDao {
    //通过username进行登入校验
    User getLoginByUsername(String username,String password);
    //通过username进行角色的查询
    List<Role> getAllRolesByUsername(String username);
    //通过username进行权限的查询
    List<Permission> getAllPermissionByUsername(String username);
}
dao对应的impl层 
package com.zmz.dao.impl;

import com.zmz.dao.UserDao;
import com.zmz.entity.Permission;
import com.zmz.entity.Role;
import com.zmz.entity.User;
import com.zmz.utils.DruidUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class UserDaoImpl implements UserDao {
    private Connection conn = null;
    private PreparedStatement pdst = null;
    private ResultSet rs = null;


    @Override
    public User getLoginByUsername(String username,String password) {
        conn = DruidUtil.getConnection();
        User user = null;

        try {
            //创建sql语句
            String sql = "select * from user where username=? and password = ?";
            pdst =  conn.prepareStatement(sql);
            //添加数据
            pdst.setString(1,username);
            pdst.setString(2,password);
            rs = pdst.executeQuery();
            while(rs.next()){
                user = new User();
                user.setUid(rs.getInt("uid"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setAddr(rs.getString("addr"));
                user.setTel(rs.getString("tel"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            DruidUtil.closeAll(conn,pdst,rs);
        }
        return user;
    }

    @Override
    public List<Role> getAllRolesByUsername(String username) {
        conn = DruidUtil.getConnection();
        List<Role> list = new ArrayList<Role>();

        try {
            String sql = "select r.rid,r.rname,r.rdescn" +
                    "from user un" +
                    "inner join user_role ur on u.uid = ur.uidn" +
                    "inner join role r on ur.rid = r.ridn" +
                    "where u.username = ?";
            pdst =  conn.prepareStatement(sql);
            pdst.setString(1,username);
            rs = pdst.executeQuery();
            Role role = new Role();
            while(rs.next()){
                role.setRid(rs.getInt("rid"));
                role.setRname(rs.getString("rname"));
                role.setRdesc(rs.getString("rdesc"));
                list.add(role);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            DruidUtil.closeAll(conn,pdst,rs);
        }
        return list;
    }

    @Override
    public List<Permission> getAllPermissionByUsername(String username) {
        conn = DruidUtil.getConnection();
        List<Permission> list = new ArrayList<>();
        try {
            String sql = "select p.pid,p.pname,p.pdescn" +
                    "from user un" +
                    "inner join user_role ur on u.uid = ur.uidn" +
                    "inner join role r on ur.rid = r.ridn" +
                    "inner join role_perms rp on r.rid = rp.ridn" +
                    "inner join permission p on rp.pid = p.pidn" +
                    "where u.username = ?";
            pdst = conn.prepareStatement(sql);
            pdst.setString(1,username);
            rs = pdst.executeQuery();
            Permission pn = null;
            while(rs.next()){
                pn = new Permission();
                pn.setPid(rs.getInt("pid"));
                pn.setPname(rs.getString("pname"));
                pn.setPdesc(rs.getString("pdesc"));
                list.add(pn);
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            DruidUtil.closeAll(conn,pdst,rs);
        }
        return list;
    }
}
utils工具层 
import java.io.IOException;
import java.util.Properties;
//读取db.properties
public class Env extends Properties {

    private static Env env = null;

    private Env(){
        try {
            load(getClass().getResourceAsStream("/db.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Env getInstance(){
        if (env == null){
            env = new Env();
        }
        return env;
    }
}
数据连接池 
package com.zmz.utils;

import com.alibaba.druid.pool.DruidDataSource;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class DruidUtil {
    private static final String ENV_DRIVER = Env.getInstance().getProperty("driver");
    private static final String ENV_URL = Env.getInstance().getProperty("url");
    private static final String ENV_USER = Env.getInstance().getProperty("user");
    private static final String ENV_PASSWORD = Env.getInstance().getProperty("password");

    /**
     * 创建连接
     *
     * @return
     */
    public static Connection getConnection() {
        Connection conn = null;

        try {
            //数据源的连接
            DruidDataSource dataSource = new DruidDataSource();
            dataSource.setDriverClassName(ENV_DRIVER);
            dataSource.setUrl(ENV_URL);
            dataSource.setUsername(ENV_USER);
            dataSource.setPassword(ENV_PASSWORD);
            conn = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }

    /**
     * 清除资源
     *
     * @param conn
     * @param pdst
     * @param rs
     */
    public static void closeAll(Connection conn, PreparedStatement pdst, ResultSet rs) {
        try {
            if (rs != null) {
                rs.close();
            }
            if (pdst != null) {
                pdst.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
db.properties配置 
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/rbac?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
user=root
password=123456
自定义域 
package com.zmz.shiro;

import com.zmz.entity.Permission;
import com.zmz.entity.Role;
import com.zmz.entity.User;
import com.zmz.service.UserService;
import com.zmz.service.impl.UserServiceImpl;
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 java.util.List;

public class MyShiro extends AuthorizingRealm {
    private UserService userService = new UserServiceImpl();
    /**
     * 角色和权限的验证
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //获取用户名
        String username = getAvailablePrincipal(principalCollection).toString();
        //获取角色
        List<Role> roles = userService.getAllRolesByUsernam(username);
        for (Role role : roles) {
            //添加角色
            info.addRole(role.getRname());
        }
        //获取权限
        List<Permission> permissions = userService.getAllPermissionByUsername(username);
        for (Permission permission : permissions) {
            //添加权限
            info.addStringPermission(permission.getPname());
        }
        return info;
    }

    /**
     * 用户登入的验证
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        AuthenticationInfo info = null;
        //将令牌转换成usernamePasswordtoken
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        //获取账号和密码
        String username = token.getUsername();
        char[] str = token.getPassword();
        String password = new String(str);
        //进行用户判断
        User user = userService.getloginByUsername(username, password);
        if (user != null && user.getUid()!= 0){
            System.out.println(getName());
            info = new SimpleAuthenticationInfo(username,password,getName());
        }
        return info;
    }
}

前端就简单的写一个表单就可以了这里随意发挥，这里就附图吧，估计看代码都烦了

2e7217a984f462814618e67bc31d5714.png
login.jsp
简单的前端shiro标签

4ffe23ac9ed98bdaa7ff19b7091fa5c7.png
结果验证

27a1584b697db35a72ce57c5afa7d7a9.png
weixin_39844549
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
shiro_springboot
10-04
4. **过滤器配置**：配置 Shiro 过滤器，如 `authc` 过滤器用于处理登录请求，`perms` 过滤器用于权限控制。 5. **Spring Boot 配置**：在 `WebSecurityConfigurerAdapter` 的子类中，将 Shiro 的过滤器链注册到 ...
Shiro的authc过滤器的执行流程
likunpeng6656201的博客
07-30 3237
1.先执行isAccessAllowed()，通过subject.isAuthenticated()判断当前session中的subject是否已经登陆过。如果在当前session即会话中已经登陆过，返回true，authc过滤器放行请求到loginUrl。 问题? 这里会有一个问题，如果我登陆成功后，再次访问loginUrl，会执行isAccessAllowed()并返回true放行，那么我访问...
Shiro进行权限认证
零度的博客
09-12 1174
背景介绍 Apache Shiro是Java的一个安全框架。目前，使用Apache Shiro的人越来越多，因为它相当简单，对比Spring Security，可能没有Spring Security做的功能强大，但是在实际工作时可能并不需要那么复杂的东西，所以使用小而简单的Shiro就足够了。 知识剖析 1.常用的几个概念 Subject 主体，代表了当前“用户”，这个用户不一定是一个具体的人，与...
shiro进行登录认证和授权
shenhy95的博客
04-15 6494
1.Shiro核心架构 三个常用过滤器 anno：不需要任何权限即可访问资源 authc：需要登录的权限才可以访问资源 perms：需要指定的权限才能访问目标资源
Shiro | 实现权限验证完整版
冯文议技术博客
10-22 7952
写在前面的话 提及权限，就会想到安全，是一个十分棘手的话题。这里只是作为学校Shiro的一个记录，而不是，权限就应该这样设计之类的。 Shiro框架 1、Shiro是基于Apache开源的强大灵活的开源安全框架。 2、Shiro提供了 认证，授权，企业会话管理、安全加密、缓存管理。 3、Shiro与Security对比 4、Shiro整体架构 5、特性 6、认证流程 认证 当我们理解Shi...
shiro会话管理
m12120426的博客
08-29 426
shiro的会话管理具备Tomcat的会话管理的一切功能，同时相较于Tomcat的session，shiro提供了对于分布式session的管理。
shiro-demo_DEMO_shiro_shriodemo_shiro框架demo_shiro前后端分离_
10-04
- **Filters**：Shiro 提供了一系列过滤器，如 `authc`（认证过滤器）、`perms`（权限过滤器）等，用于拦截请求并执行相应的安全逻辑。 **4. 示例项目中的关键组件** - **Web 应用**：可能使用 Spring Boot 集成 ...
boot_shiro_demo.zip
01-01
- **过滤器链配置**：设置Shiro的过滤器链，例如 `authc`（认证过滤器）、`perms`（权限过滤器）等，定义哪些URL需要登录后访问，哪些需要特定权限才能访问。 - **Shiro标签使用**：在Thymeleaf或JSP视图中，可以...
springboot_shiro_jwt.zip
04-08
3. 在SpringBoot的配置类中，配置Shiro的WebFilter，设置过滤器链，比如anon（匿名访问）、authc（认证过滤器），并指定对应的URL规则。 4. 使用Shiro的RememberMe服务，可以实现用户下次访问时的自动登录功能。 5. ...
shiro_demo.rar
01-06
4. Filter：Shiro的过滤器链是实现Web安全的关键，如authc（认证）、perms（权限）、roles（角色）等过滤器，它们根据配置拦截特定的URL，并执行相应的安全逻辑。 四、实践示例 以一个简单的登录为例，当用户提交...
Shiro （三）之授权加注解式权限
cao_2000的博客
01-04 858
重点： 1.添加角色和权限的授权方法   //根据username查询该用户的所有角色，用于角色验证   Set&lt;String&gt; findRoles(String username); 代码分享： select r.roleid from t_shiro_user u,t_shiro_role r , t_shiro_user_role ur where u.userid=...
【Shiro权限管理】14.Shiro授权
程序猿之洞
12-02 1617
注：该系列所有测试均在之前创建的Shiro3的Web工程的基础上。 我们之前讲解了Realm认证和认证器策略等知识，下面来讲解Shiro中比较重要的知识：授权。 对于授权，也叫访问控制，即在应用中控制谁访问哪些资源(如访问页面/编辑数据/页面操作等)。 一、授权的几个重要概念 在授权中需要了解几个关键对象：主体(Subject)、资源(Resource)、权限(Permission)、
authc过滤器 shiro_shiro笔记 【四】
weixin_39690391的博客
11-20 313
shiro笔记 【三】public class MyIniWebEnvironment extends IniWebEnvironment { @Override protected FilterChainResolver createFilterChainResolver() { //在此处扩展自己的FilterChainResolver return s...
Shiro笔记五：Shiro内置Filter过滤器
公子&小白的博客
05-10 1685
Shiro笔记五：Shiro内置Filter过滤器 shiro内置的过滤器 核心过滤器类：DefaultFilter，配置哪个路径对应哪个拦截器进行处理。 authc：org.apache.shiro.web.filter.authc.FormAuthenticationFilter 需要认证登录才能访问 user：org.apache.shiro.web.filter.authc.UserFilter 用户拦截器，表示必须存在用户。 anon：org.apache.shiro.web.f
shiro授权和认证（一）
weixin_46403305的博客
10-28 493
shiro是什么 shiro一个授权和认证的这样一个框架 简单的给你说、就是以前咋们认证和授权的所有代码、shiro都给咋们写好了、而且封装好了、我们只需要按照这个框架提供的API来简单的集成到咋们的项目中就可以了 1、shiro能干什么 认证、授权、Cache的管理、Session的管理、rememberMe功能的实现、登陆、退出… 2、shiro的整体架构是什么 3、shiro的第一个helloworld程序 3.1、导包 <!--导入shiro的包--> <de
apache shiro jar包_只需要6个步骤，springboot集成shiro，并完成登录
weixin_39644139的博客
11-22 635
小Hub领读：导入jar包，配置yml参数，编写ShiroConfig定义DefaultWebSecurityManager，重写Realm，编写controller，编写页面，一气呵成。搞定，是个高手~上面一篇文章中，我们已经知道了shiro的认证与授权过程，这也是shiro里面最核心常用的基础功能。现在我们把shiro集成到我们的项目中，开始搭建一个有认证和权限体系的项目，比如用户中心需要登录...
Apache Shiro入门：过滤器详解与使用
2. authc: 表单认证过滤器 - `org.apache.shiro.web.filter.authc.FormAuthenticationFilter`，处理基于表单的用户登录。 3. authcBasic: HTTP基本认证过滤器 - `org.apache.shiro.web.filter.authc....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值