SpringBoot学习笔记（十六：Shiro ）(1)，蚂蚁金服Java笔试

index

2、RBAC

========================================================================

RBAC 是基于角色的访问控制（Role-Based Access Control ）在 RBAC 中，权限与角色相关联，用户通过成为适当角色的成员而得到这些角色的权限。这就极大地简化了权限的管理。这样管理都是层级相互依赖的，权限赋予给角色，而把角色又赋予用户，这样的权限设计很清楚，管理起来很方便。

采用 Jpa 技术来自动生成基础表格，对应的实体如下：

用户信息：

@Entity

public class UserInfo implements Serializable {

@Id

@GeneratedValue

private Integer uid;

@Column(unique =true)

private String username;//帐号

private String name;//名称（昵称或者真实姓名，不同系统不同定义）

private String password; //密码;

private String salt;//加密密码的盐

private byte state;//用户状态,0:创建未认证（比如没有激活，没有输入验证码等等）–等待验证的用户 , 1:正常状态,2：用户被锁定.

@ManyToMany(fetch= FetchType.EAGER)//立即从数据库中进行加载数据;

@JoinTable(name = “SysUserRole”, joinColumns = { @JoinColumn(name = “uid”) }, inverseJoinColumns ={@JoinColumn(name = “roleId”) })

private List roleList;// 一个用户具有多个角色

// 省略 get set 方法

}

角色信息：

@Entity

public class SysRole {

@Id@GeneratedValue

private Integer id; // 编号

private String role; // 角色标识程序中判断使用,如"admin",这个是唯一的:

private String description; // 角色描述,UI界面显示使用

private Boolean available = Boolean.FALSE; // 是否可用,如果不可用将不会添加给用户

//角色 – 权限关系：多对多关系;

@ManyToMany(fetch= FetchType.EAGER)

@JoinTable(name=“SysRolePermission”,joinColumns={@JoinColumn(name=“roleId”)},inverseJoinColumns={@JoinColumn(name=“permissionId”)})

private List permissions;

// 用户 - 角色关系定义;

@ManyToMany

@JoinTable(name=“SysUserRole”,joinColumns={@JoinColumn(name=“roleId”)},inverseJoinColumns={@JoinColumn(name=“uid”)})

private List userInfos;// 一个角色对应多个用户

// 省略 get set 方法

}

权限信息：

@Entity

public class SysPermission implements Serializable {

@Id@GeneratedValue

private Integer id;//主键.

private String name;//名称.

@Column(columnDefinition=“enum(‘menu’,‘button’)”)

private String resourceType;//资源类型，[menu|button]

private String url;//资源路径.

private String permission; //权限字符串,menu例子：role:*，button例子：role:create,role:update,role:delete,role:view

private Long parentId; //父编号

private String parentIds; //父编号列表

private Boolean available = Boolean.FALSE;

@ManyToMany

@JoinTable(name=“SysRolePermission”,joinColumns={@JoinColumn(name=“permissionId”)},inverseJoinColumns={@JoinColumn(name=“roleId”)})

private List roles;

// 省略 get set 方法

}

根据以上的代码会自动生成 user_info（用户信息表）、sys_role（角色表）、sys_permission（权限表）、sys_user_role（用户角色表）、sys_role_permission（角色权限表）这五张表，为了方便测试我们给这五张表插入一些初始化数据：

INSERT INTO user_info (uid,username,name,password,salt,state) VALUES (‘1’, ‘admin’, ‘管理员’, ‘d3c59d25033dbf980d29554025c23a75’, ‘8d78869f470951332959580424d4bf4f’, 0);

INSERT INTO sys_permission (id,available,name,parent_id,parent_ids,permission,resource_type,url) VALUES (1,0,‘用户管理’,0,‘0/’,‘userInfo:view’,‘menu’,‘userInfo/userList’);

INSERT INTO sys_permission (id,available,name,parent_id,parent_ids,permission,resource_type,url) VALUES (2,0,‘用户添加’,1,‘0/1’,‘userInfo:add’,‘button’,‘userInfo/userAdd’);

INSERT INTO sys_permission (id,available,name,parent_id,parent_ids,permission,resource_type,url) VALUES (3,0,‘用户删除’,1,‘0/1’,‘userInfo:del’,‘button’,‘userInfo/userDel’);

INSERT INTO sys_role (id,available,description,role) VALUES (1,0,‘管理员’,‘admin’);

INSERT INTO sys_role (id,available,description,role) VALUES (2,0,‘VIP会员’,‘vip’);

INSERT INTO sys_role (id,available,description,role) VALUES (3,1,‘test’,‘test’);

INSERT INTO sys_role_permission VALUES (‘1’, ‘1’);

INSERT INTO sys_role_permission (permission_id,role_id) VALUES (1,1);

INSERT INTO sys_role_permission (permission_id,role_id) VALUES (2,1);

INSERT INTO sys_role_permission (permission_id,role_id) VALUES (3,2);

INSERT INTO sys_user_role (role_id,uid) VALUES (1,1);

3、Shiro 配置

---

首先要配置的是 ShiroConfig 类，Apache Shiro 核心通过 Filter 来实现，就好像 SpringMvc 通过 DispachServlet 来主控制一样。 既然是使用 Filter 一般也就能猜到，是通过 URL 规则来进行过滤和权限校验，所以我们需要定义一系列关于 URL 的规则和访问权限。

3.1、ShiroConfig

@Configuration

public class ShiroConfig {

@Bean

public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {

System.out.println(“ShiroConfiguration.shirFilter()”);

ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();

shiroFilterFactoryBean.setSecurityManager(securityManager);

//拦截器.

Map<String,String> filterChainDefinitionMap = new LinkedHashMap<String,String>();

// 配置不会被拦截的链接 顺序判断

filterChainDefinitionMap.put(“/static/**”, “anon”);

//配置退出 过滤器,其中的具体的退出代码Shiro已经替我们实现了

filterChainDefinitionMap.put(“/logout”, “logout”);

//过滤链定义，从上向下顺序执行，一般将/**放在最为下边 -->:这是一个坑呢，一不小心代码就不好使了;

//

filterChainDefinitionMap.put(“/**”, “authc”);

// 如果不设置默认会自动寻找Web工程根目录下的"/login.jsp"页面

shiroFilterFactoryBean.setLoginUrl(“/login”);

// 登录成功后要跳转的链接

shiroFilterFactoryBean.setSuccessUrl(“/index”);

//未授权界面;

shiroFilterFactoryBean.setUnauthorizedUrl(“/403”);

shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);

return shiroFilterFactoryBean;

}

@Bean

public MyShiroRealm myShiroRealm(){

MyShiroRealm myShiroRealm = new MyShiroRealm();

return myShiroRealm;

}

@Bean

public SecurityManager securityManager(){

DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

securityManager.setRealm(myShiroRealm());

return securityManager;

}

}

Filter Chain 定义说明：

• 1、一个URL可以配置多个 Filter，使用逗号分隔

• 2、当设置多个过滤器时，全部验证通过，才视为通过

• 3、部分过滤器可指定参数，如 perms，roles

Shiro 内置的 FilterChain:

| Filter Name | Class |

| — | — |

| anon | org.apache.shiro.web.filter.authc.AnonymousFilter |

| authc | org.apache.shiro.web.filter.authc.FormAuthenticationFilter |

| authcBasic | org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter |

| perms | org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter |

| port | org.apache.shiro.web.filter.authz.PortFilter |

| rest | org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter |

| roles | org.apache.shiro.web.filter.authz.RolesAuthorizationFilter |

| ssl | org.apache.shiro.web.filter.authz.SslFilter |

| user | org.apache.shiro.web.filter.authc.UserFilter |

• anon:所有 url 都都可以匿名访问

• authc: 需要认证才能进行访问

• user:配置记住我或认证通过可以访问

3.2、登录认证实现

在认证、授权内部实现机制中都有提到，最终处理都将交给Real进行处理。因为在 Shiro 中，最终是通过 Realm 来获取应用程序中的用户、角色及权限信息的。通常情况下，在 Realm 中会直接从我们的数据源中获取 Shiro 需要的验证信息。可以说，Realm 是专用于安全框架的 DAO. Shiro 的认证过程最终会交由 Realm 执行，这时会调用 Realm 的getAuthenticationInfo(token)方法。

该方法主要执行以下操作:

• 1、检查提交的进行认证的令牌信息

• 2、根据令牌信息从数据源(通常为数据库)中获取用户信息

• 3、对用户信息进行匹配验证。

• 4、验证通过将返回一个封装了用户信息的AuthenticationInfo实例。

• 5、验证失败则抛出AuthenticationException异常信息。

而在我们的应用程序中要做的就是自定义一个 Realm 类，继承AuthorizingRealm 抽象类，重载 doGetAuthenticationInfo()，重写获取用户信息的方法。

doGetAuthenticationInfo 的重写：

@Override

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)

throws AuthenticationException {

System.out.println(“MyShiroRealm.doGetAuthenticationInfo()”);

//获取用户的输入的账号.

String username = (String)token.getPrincipal();

System.out.println(token.getCredentials());

//通过username从数据库中查找 User对象，如果找到，没找到.

//实际项目中，这里可以根据实际情况做缓存，如果不做，Shiro自己也是有时间间隔机制，2分钟内不会重复执行该方法

UserInfo userInfo = userInfoService.findByUsername(username);

System.out.println(“----->>userInfo=”+userInfo);

if(userInfo == null){

return null;

}

SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(

userInfo, //用户名

userInfo.getPassword(), //密码

ByteSource.Util.bytes(userInfo.getCredentialsSalt()),//salt=username+salt

getName() //realm name

);

return authenticationInfo;

}

3.3、链接权限的实现

Shiro 的权限授权是通过继承AuthorizingRealm抽象类，重载doGetAuthorizationInfo();当访问到页面的时候，链接配置了相应的权限或者 Shiro 标签才会执行此方法否则不会执行，所以如果只是简单的身份认证没有权限的控制的话，那么这个方法可以不进行实现，直接返回 null 即可。在这个方法中主要是使用类：SimpleAuthorizationInfo进行角色的添加和权限的添加。

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

System.out.println(“权限配置–>MyShiroRealm.doGetAuthorizationInfo()”);

SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();

UserInfo userInfo = (UserInfo)principals.getPrimaryPrincipal();

for(SysRole role:userInfo.getRoleList()){

authorizationInfo.addRole(role.getRole());

for(SysPermission p:role.getPermissions()){

authorizationInfo.addStringPermission(p.getPermission());

}

}

return authorizationInfo;

}

当然也可以添加 set 集合：roles 是从数据库查询的当前用户的角色，stringPermissions 是从数据库查询的当前用户对应的权限：

authorizationInfo.setRoles(roles);

authorizationInfo.setStringPermissions(stringPermissions);

就是说如果在shiro配置文件中添加了filterChainDefinitionMap.put(“/add”, “perms[权限添加]”);就说明访问/add这个链接必须要有“权限添加”这个权限才可以访问，如果在shiro配置文件中添加了filterChainDefinitionMap.put(“/add”, “roles[100002]，perms[权限添加]”);就说明访问/add这个链接必须要有“权限添加”这个权限和具有“100002”这个角色才可以访问。

3.4、登录实现

登录过程其实只是处理异常的相关信息，具体的登录验证交给 Shiro 来处理：

@RequestMapping(“/login”)

public String login(HttpServletRequest request, Map<String, Object> map) throws Exception{

System.out.println(“HomeController.login()”);

// 登录失败从request中获取shiro处理的异常信息。

// shiroLoginFailure:就是shiro异常类的全类名.

String exception = (String) request.getAttribute(“shiroLoginFailure”);

System.out.println(“exception=” + exception);

String msg = “”;

if (exception != null) {

if (UnknownAccountException.class.getName().equals(exception)) {

System.out.println(“UnknownAccountException – > 账号不存在：”);

msg = “UnknownAccountException – > 账号不存在：”;

} else if (IncorrectCredentialsException.class.getName().equals(exception)) {

System.out.println(“IncorrectCredentialsException – > 密码不正确：”);

msg = “IncorrectCredentialsException – > 密码不正确：”;

} else if (“kaptchaValidateFailed”.equals(exception)) {

System.out.println(“kaptchaValidateFailed – > 验证码错误”);

msg = “kaptchaValidateFailed – > 验证码错误”;

} else {

msg = "else >> "+exception;

System.out.println(“else – >” + exception);

}

}

map.put(“msg”, msg);

// 此方法不处理登录成功,由shiro进行处理

return “/login”;

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）

最后

为什么我不完全主张自学？
①平台上的大牛基本上都有很多年的工作经验了，你有没有想过之前行业的门槛是什么样的，现在行业门槛是什么样的？以前企业对于程序员能力要求没有这么高，甚至十多年前你只要会写个“Hello World”，你都可以入门这个行业，所以以前要入门是完全可以入门的。
②现在也有一些优秀的年轻大牛，他们或许也是自学成才，但是他们一定是具备优秀的学习能力，优秀的自我管理能力（时间管理，静心坚持等方面）以及善于发现问题并总结问题。
如果说你认为你的目标十分明确，能做到第②点所说的几个点，以目前的市场来看，你才真正的适合去自学。

除此之外，对于绝大部分人来说，报班一定是最好的一种快速成长的方式。但是有个问题，现在市场上的培训机构质量参差不齐，如果你没有找准一个好的培训班，完全是浪费精力，时间以及金钱，这个需要自己去甄别选择。

我个人建议线上比线下的性价比更高，线下培训价格基本上没2W是下不来的，线上教育现在比较成熟了，此次疫情期间，学生基本上都感受过线上的学习模式。相比线下而言，线上的优势以我的了解主要是以下几个方面：
①价格：线上的价格基本上是线下的一半；
②老师：相对而言线上教育的师资力量比线下更强大也更加丰富，资源更好协调；
③时间：学习时间相对而言更自由，不用裸辞学习，适合边学边工作，降低生活压力；
④课程：从课程内容来说，确实要比线下讲的更加深入。

应该学哪些技术才能达到企业的要求？（下图总结）

这么高，甚至十多年前你只要会写个“Hello World”，你都可以入门这个行业，所以以前要入门是完全可以入门的。
②现在也有一些优秀的年轻大牛，他们或许也是自学成才，但是他们一定是具备优秀的学习能力，优秀的自我管理能力（时间管理，静心坚持等方面）以及善于发现问题并总结问题。
如果说你认为你的目标十分明确，能做到第②点所说的几个点，以目前的市场来看，你才真正的适合去自学。

除此之外，对于绝大部分人来说，报班一定是最好的一种快速成长的方式。但是有个问题，现在市场上的培训机构质量参差不齐，如果你没有找准一个好的培训班，完全是浪费精力，时间以及金钱，这个需要自己去甄别选择。

我个人建议线上比线下的性价比更高，线下培训价格基本上没2W是下不来的，线上教育现在比较成熟了，此次疫情期间，学生基本上都感受过线上的学习模式。相比线下而言，线上的优势以我的了解主要是以下几个方面：
①价格：线上的价格基本上是线下的一半；
②老师：相对而言线上教育的师资力量比线下更强大也更加丰富，资源更好协调；
③时间：学习时间相对而言更自由，不用裸辞学习，适合边学边工作，降低生活压力；
④课程：从课程内容来说，确实要比线下讲的更加深入。

应该学哪些技术才能达到企业的要求？（下图总结）

[外链图片转存中…(img-Y3aTBfOw-1711993356888)]

[外链图片转存中…(img-aFghUdhe-1711993356888)]