SpringBoot（二）
2024-05-26 21:48:50
模板引擎、数据源、安全框架部分
- 5、SpringBoot Web开发
- 5.1、静态资源
- 5.2、首页
- 5.3、Thymeleaf模板引擎
- 5.4、装配扩展SpringMVC
- 5.5、如何写网站
- 6、整合JDBC
- 7、整合Druid数据源
- 7.1、对druid数据源的相关信息测试
- 7.2、配置Druid数据源监控
- 7.3、配置 Druid web 监控 filter 过滤器
- 8、整合Mybatis
- 9、SpringSecurity（安全）
- 9.1、授权
- 9.2、认证
- 10、Shiro
- 10.1、什么是shiro
- 10.2、组成部分
- 10.3、Shiro架构（外部）
- 10.4、Shiro架构（内部）
- 10.5、快速入门
- 10.6、springboot与shiro的初步整合
- 10.7、实现登录拦截
- 10.8、实现用户认证
- 10.9、Mybatis整合Shiro
- 10.10、实现Shiro请求授权
- 10.11、Thymeleaf整合Shiro
- ==整合过去整合过来实在是令人头秃，感觉人要废了==
5、SpringBoot Web开发
需要解决的问题：
- 导入静态资源
- 首页的问题
- jsp，模板引擎Thymeleaf
- 装配扩展SpringMVC
- 增删改查
- 拦截器
- 国际化
5.1、静态资源
web对应的自动配置类：WebMvcAutoConfiguration
方式一：使用webjars的方式
去官网引入webjars的maven依赖
<dependency><groupId>org.webjars</groupId><artifactId>jquery</artifactId><version>3.4.1</version>
</dependency>
成功引入之后，启动服务后。访问路径为：localhost:8080/webjars/（我们的资源文件）
方式二：在resource目录下新建文件
ResourceProperties类的部分源码
即静态资源可以存放的位置为：
- 新建的public文件夹下
- 自带的static文件夹下
- 新建的resources文件夹下
- 根目录下的/**
外部访问的优先级：resources > static（默认） > public
5.2、首页
源码如图：
新建一个首页，文件命名为index.html，可以根据适当的需求，自行放在public、static、templates等目录的其中一个下。
访问路径为：localhost:8080
5.3、Thymeleaf模板引擎
对比JSP技术，它是将后端传过来的数据，绑定到对应的形式上，继而达到前端显示后端的数据。Thymeleaf也是将后端传回来的数据与前端的视图进行绑定，达到了与JSP类似的效果（JSP也是一种模板引擎）。Spring Boot推荐使用Thymeleaf模板引擎。
官方网址：https://www.thymeleaf.org
使用Thymeleaf需要导入对应的依赖
html页面可以引入相应相应的xmlns（xml name space）：xmlns:th=“http://www.thymeleaf.org”，防止看到报异常看着不舒服
Sping Boot文档中的启动器：
对应的pom文件
<dependency><groupId>org.thymeleaf</groupId><artifactId>thymeleaf-spring5</artifactId>
</dependency>
<dependency><groupId>org.thymeleaf.extras</groupId><artifactId>thymeleaf-extras-java8time</artifactId>
</dependency>
测试案例：
index的控制器类
package pers.mobian.controller;import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;@Controller
public class Index {@RequestMapping("/index")public String index(Model model) {model.addAttribute("msg", "hello SpringBoot");return "index";}
}
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<body>
<h1>首页</h1>
${msg}
<div th:text="${msg}"></div>
</body>
</html>
执行结果
总结：当我们访问首页的对应映射后，他会对数据进行封装，然后通过Thymeleaf模板引擎渲染到前端界面。并且前端的接收方式也要变成<div th:text="${msg}"></div>
Thymeleaf基本语法之：th:each、th:utext、th:text
@Controller
public class Index {@RequestMapping("/index")public String index(Model model) {model.addAttribute("msg","<h1>首页<h1>");model.addAttribute("users", Arrays.asList("mobian1","mobian2","mobian3"));return "index";}
}
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<body><div th:utext="${msg}"></div><div th:text="${msg}"></div><div th:each="user:${users}" th:text="${user}"></div>
</body>
</html>
测试结果：
5.4、装配扩展SpringMVC
测试代码：
package pers.mobian.config;import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;import java.util.Locale;//如果想要自定义一些功能，只需要重写这个组件，然后将它交给springboot，springboot就会帮我们自动装配
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {//ViewResolver 实现了视图解析器接口的类，我们就可以把它看做视图解析器@Beanpublic ViewResolver myViewResolver(){return new MyViewResolver();}//自定义了一个自己的视图解析器MyViewResolverpublic static class MyViewResolver implements ViewResolver{@Overridepublic View resolveViewName(String viewName, Locale locale) throws Exception {return null;}}
}
补充
package pers.mobian.config;import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;import java.util.Locale;//如果我们呢要扩展springmvc，官方建议我们这样去做
@Configuration
@EnableWebMvc //这个注解就是导入一个：DelegatingWebMvcConfiguration:从容器中获取所有的webmvcconfig(如果我们自定义了config类就不能添加这个注解)
public class MyMvcConfig implements WebMvcConfigurer {//视图跳转@Overridepublic void addViewControllers(ViewControllerRegistry registry) {//访问的url为/mobian，跳转的视图是test.jspregistry.addViewController("/mobian").setViewName("test");}
}
总结：在springboot中，有非常多的xxxConfiguration帮助我们进行扩展，只要看见这种类，那么它就会改变或者扩展了我们原来spring的功能
5.5、如何写网站
1、搞定前端： 明确页面的样子，方便数据的出现
2、设计数据库（数据库设计是难点）
3、前端能够使其能够自动运行，独立化工程
4、数据接口如何对接：json，对象all in one
5、前后端联调测试
前期准备工作：
- 有一套自己数据的后台模板：工作必要！x-amdin
- 前端界面：至少自己能够通过前端框架组合出一个网站的页面
- index
- about
- blog
- post
- user
- 让这个网站能够独立运行
花费一个月的时间去研究
6、整合JDBC
在进行该步操作时，创建的SpringBoot项目需要的依赖为：JDBC API 、MySQL Driver
导入成功后对应的依赖是
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope>
</dependency>
由于又是一个web项目，所以还需要添加web的启动器
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency>
整合案例步骤：
使用IDEA连接已存在的数据库表
新建application.yaml文件，配置数据库
spring:datasource:username: rootpassword:#注意要配置时区url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8#springboot默认配置的数据库连接使mysql 8.x(虽然我的数据库是5.5，但还是建议使用8.x的)#com.mysql.cj.jdbc.Driver mysql 8.x#com.mysql.jdbc.Driver mysql 5.xdriver-class-name: com.mysql.cj.jdbc.Driver新建一个控制器类JDBCController，处理JDBC的CRUD
package pers.mobian.controller;import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController;import java.util.List; import java.util.Map;@RestController public class JDBCController {/*** Spring Boot 默认提供数据源为org.springframework.jdbc.core.JdbcTemplate* JdbcTemplate 中会自己注入数据源，用于简化 JDBC操作* 还能避免一些常见的错误,使用起来也不用再自己来关闭数据库连接*/@AutowiredJdbcTemplate jdbcTemplate;//查找学生@RequestMapping("/selectUser")public List<Map<String, Object>> selectUser() {String sql = "select * from user";List<Map<String, Object>> mapList = jdbcTemplate.queryForList(sql);return mapList;}//新增学生@RequestMapping("/addUser")public String addUser() {String sql = "insert into mybatis.user(id,name,pwd) values (1,'小明','2222')";jdbcTemplate.update(sql);return "addUser ok";}//删除学生@RequestMapping("/deleteUser/{id}")public String deleteUser(@PathVariable("id") int id) {String sql = "delete from mybatis.user where id = ? ";jdbcTemplate.update(sql, id);return "deleteUser ok";}//修改学生@RequestMapping("/updateUser/{id}")public String updateUser(@PathVariable("id") int id) {String sql = "update mybatis.user set name=?,pwd=? where id=" + id;Object[] objects = new Object[2];objects[0] = "mobian";objects[1] = "88888";jdbcTemplate.update(sql, objects);return "updateUser ok";}}
补充：
在测试类中打印数据源的相关信息
package pers.mobian;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;@SpringBootTest
class Springboot04ApplicationTests {@AutowiredDataSource dataSource;@Testvoid contextLoads() throws SQLException {//查看默认的数据源System.out.println(dataSource.getClass());//获得数据库连接Connection connection = dataSource.getConnection();System.out.println(connection);//关闭数据库connection.close();}
}
测试结果：
//我们没有使用其他数据源，springboot就使用默认的数据源，且默认数据源是HikariDataSource
//HikariDataSource 号称 Java WEB 当前速度最快的数据源，相比于传统的 C3P0 、DBCP、Tomcat jdbc 等连接池更加优秀
class com.zaxxer.hikari.HikariDataSourceHikariProxyConnection@1375111241 wrapping com.mysql.cj.jdbc.ConnectionImpl@4eb9ae4d
数据源的所有默认配置类：DataSourceAutoConfiguration
7、整合Druid数据源
Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3P0、DBCP 等 DB 池的优点，同时加入了日志监控。
Druid 可以很好的监控 DB 池连接和 SQL 的执行情况，天生就是针对监控而生的 DB 连接池。
对应的maven依赖为，由于其日志是使用log4j，所以也需要引入日志对应的依赖
<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.20</version>
</dependency>
<dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version>
</dependency>
7.1、对druid数据源的相关信息测试
druid相关的参数
| 配置 | 缺省值 | 说明 |
|---|---|---|
| name | 配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分。如果没有配置，将会生成一个名字，格式是：“DataSource-”+System.identifyHashCode(this) | |
| url | 连接数据库的url，不同数据库不一样。例如：mysql：jdbc:mysql://10.20.153.104:3306/druid2 oracle：jdbc:oracle:thin:@10.20.149.85:1521:ocnauto | |
| username | 连接数据库的用户名 | |
| password | 连接数据库的密码。如果你不希望密码直接写在配置文件中，可以使用ConfigFilter | |
| driverClassName | 根据url自动识别 | 这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName |
| initialSize | 0 | 初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时 |
| maxActive | 8 | 最大连接池数量 |
| maxldle | 8 | 已经不再使用，配置了也没有效果 |
| minldle | 最想连接池数量 | |
| maxWait | 获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁 | |
| poolPreparedStatements | false | 是否缓存preparedStatement，也就是PSCache。PSCache对支持游戏的数据库性能提升巨大，比如说oracle。在mysql下建议关闭 |
| maxOpenPreparedStatements | -1 | 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatement自动出发修改为true。在druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如100 |
| validationQuery | 用来检测连接是否有效的sql，要求时一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileldle都不会起作用 | |
| validationQueryTimeout | 单位秒，检测连接是否有效的超长时间。底层调用jdbcStatement对象的void setQueryTimeout(int seconds)方法 | |
| testOnBorrow | true | 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能 |
| testOnReturn | false | 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能 |
| testWhileldle | false | 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效 |
| timeBetweenEvictionRunsMillis | 一分钟 | 有两个含义：1）Destroy线程会检测连接的间隔时间，如果连接空闲时间大于等于minEvictionRunsMillis则关闭物理连接 2）testWhileldle的判断依据，详情看testWhileldle属性说明 |
| numTestsPerEvictionRun | 不再使用，一个DruidDataSource只支持一个EvictionRun | |
| minEvictableldleTimeMillis | 30分钟 | 连接保持空闲而不被驱逐的最长时间 |
| connectionInitSqls | 物理连接初始化的时候执行的sql | |
| exceptionSorter | 根据dbType自动识别 | 当数据库抛出一些不可恢复的异常时，抛弃连接 |
| filters | 属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：监控统计用的filter：start日志用的filter：log4j 防御sql注入的filter：wall | |
| proxyFilters | 类型是List<com.alibaba.druid.filter.Filter>如果配置了filters和proxyFilters，是组合关系，而非替换关系 |
在springboot启动类的统计目录下新建一个配置配：
@Configuration
public class DruidConfig {/*将自定义的 Druid数据源添加到容器中，不再让 Spring Boot 自动创建绑定全局配置文件中的 druid 数据源属性到 com.alibaba.druid.pool.DruidDataSource从而让它们生效@ConfigurationProperties(prefix = "spring.datasource")：作用就是将 全局配置文件中前缀为 spring.datasource的属性值注入到 com.alibaba.druid.pool.DruidDataSource 的同名参数中*/@Bean@ConfigurationProperties(prefix = "spring.datasource")public DataSource druidDataSource() {return new DruidDataSource();}
}
测试类：
@SpringBootTest
class Springboot04ApplicationTests {@AutowiredDataSource dataSource;@Testvoid contextLoads() throws SQLException {//查看默认的数据源System.out.println(dataSource.getClass());//获得数据库连接Connection connection = dataSource.getConnection();System.out.println(connection);DruidDataSource druidDataSource = (DruidDataSource) dataSource;System.out.println("druidDataSource 数据源最大连接数：" + druidDataSource.getMaxActive());System.out.println("druidDataSource 数据源初始化连接数：" + druidDataSource.getInitialSize());//关闭数据库connection.close();}
}
测试结果：
class com.alibaba.druid.pool.DruidDataSource
2020-03-17 20:56:55.105 INFO 10448 --- [ main] com.alibaba.druid.pool.DruidDataSource : {dataSource-1} inited
com.mysql.cj.jdbc.ConnectionImpl@25ce435
druidDataSource 数据源最大连接数：8
druidDataSource 数据源初始化连接数：0
在yaml核心配置文件中进行相应设置后
spring:datasource:username: rootpassword:#?serverTimezone=UTC解决时区的报错url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8driver-class-name: com.mysql.cj.jdbc.Drivertype: com.alibaba.druid.pool.DruidDataSource#Spring Boot 默认是不注入这些属性值的，需要自己绑定#druid 数据源专有配置initialSize: 5minIdle: 5maxActive: 20maxWait: 60000timeBetweenEvictionRunsMillis: 60000minEvictableIdleTimeMillis: 300000validationQuery: SELECT 1 FROM DUALtestWhileIdle: truetestOnBorrow: falsetestOnReturn: falsepoolPreparedStatements: true#配置监控统计拦截的filters，stat:监控统计、log4j：日志记录、wall：防御sql注入#如果允许时报错 java.lang.ClassNotFoundException: org.apache.log4j.Priority#则导入 log4j 依赖即可，Maven 地址：https://mvnrepository.com/artifact/log4j/log4jfilters: stat,wall,log4jmaxPoolPreparedStatementPerConnectionSize: 20useGlobalDataSourceStat: trueconnectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
再次测试结果：
class com.alibaba.druid.pool.DruidDataSource
log4j:WARN No appenders could be found for logger (druid.sql.Connection).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
2020-03-17 20:59:36.003 INFO 1964 --- [ main] com.alibaba.druid.pool.DruidDataSource : {dataSource-1} inited
com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl@4cb00fa5
druidDataSource 数据源最大连接数：20
druidDataSource 数据源初始化连接数：5 //在配置文件中进行了修改
7.2、配置Druid数据源监控
Druid 数据源具有监控的功能，并提供了一个 web 界面方便用户查看，类似安装 路由器 时，人家也提供了一个默认的 web 页面
对应的配置类
package pers.mobian.config;import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;@Configuration
public class DruidConfig {/*将自定义的 Druid数据源添加到容器中，不再让 Spring Boot 自动创建绑定全局配置文件中的 druid 数据源属性到 com.alibaba.druid.pool.DruidDataSource从而让它们生效@ConfigurationProperties(prefix = "spring.datasource")：作用就是将 全局配置文件中前缀为 spring.datasource的属性值注入到 com.alibaba.druid.pool.DruidDataSource 的同名参数中*/@Bean@ConfigurationProperties(prefix = "spring.datasource")public DataSource druidDataSource() {return new DruidDataSource();}//配置 Druid 监控管理后台的Servlet；
//内置 Servlet 容器时没有web.xml文件，所以使用 Spring Boot 的注册 Servlet 方式@Beanpublic ServletRegistrationBean statViewServlet() {ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");// 这些参数可以在 com.alibaba.druid.support.http.StatViewServlet// 的父类 com.alibaba.druid.support.http.ResourceServlet 中找到Map<String, String> initParams = new HashMap<>();initParams.put("loginUsername", "admin"); //后台管理界面的登录账号initParams.put("loginPassword", "123456"); //后台管理界面的登录密码//后台允许谁可以访问//initParams.put("allow", "localhost")：表示只有本机可以访问//initParams.put("allow", "")：为空或者为null时，表示允许所有访问initParams.put("allow", "");//deny：Druid 后台拒绝谁访问//initParams.put("kuangshen", "192.168.1.20");表示禁止此ip访问//设置初始化参数bean.setInitParameters(initParams);return bean;}
}
在url中访问：http://localhost:8080/druid 它会自动跳转到http://localhost:8080/druid/login.html
在正确输入用户名和密码后，可以进入到其对应的后台。当用户进行了相关操作以后，其后台就会打印与其相关的信息。（此截图为我新开的一个界面，执行了相应的映射语句后，该监控后台打印出我的操作的sql语句）
7.3、配置 Druid web 监控 filter 过滤器
//配置 Druid 监控 之 web 监控的 filter
//WebStatFilter：用于配置Web和Druid数据源之间的管理关联监控统计
@Bean
public FilterRegistrationBean webStatFilter() {FilterRegistrationBean bean = new FilterRegistrationBean();bean.setFilter(new WebStatFilter());//exclusions：设置哪些请求进行过滤排除掉，从而不进行统计Map<String, String> initParams = new HashMap<>();initParams.put("exclusions", "*.js,*.css,/druid/*,/jdbc/*");bean.setInitParameters(initParams);//"/*" 表示过滤所有请求bean.setUrlPatterns(Arrays.asList("/*"));return bean;
}
8、整合Mybatis
在进行该步操作时，创建的SpringBoot项目需要的依赖是：JDBC API 、MySQL Driver
还需要引入springboot与mybatis相关联的依赖
<!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
<dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.1.1</version>
</dependency>
由于需要启动web服务，所以还需要引入web的启动器
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency>
为了代码方便引入lombok插件依赖
<dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><!--可以不需要引入版本及作用域--><version>1.18.8</version><scope>provided</scope>
</dependency>
整合案例步骤：
1、连接数据库
spring:datasource:username: rootpassword:#?serverTimezone=UTC解决时区的报错url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8driver-class-name: com.mysql.cj.jdbc.Driver#此处配置文件可以当作mybatis的配置类，可以配置实体类的别名，以及映射文件的位置
mybatis:type-aliases-package: pers.mobian.pojo #别名mapper-locations: mapper/*.xml #mapper类的位置，mybatis配置类中的绑定mapper语句
2、编写对应的实体类
package pers.mobian.pojo;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {private String name;private int id;private String pwd;
}
3、编写对应的接口类
package pers.mobian.mapper;import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import pers.mobian.pojo.User;import java.util.List;@Repository
@Mapper
public interface UserMapper {//查询所有的用户List<User> selectUser();//根据id查询用户User selectUserById(int id);//添加用户public int insertUser(User user);//删除用户public int deleteUser(int id);//修改用户public int updateUser(User user);
}
4、编写对应的接口的mapper类
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="pers.mobian.mapper.UserMapper"><select id="selectUser" parameterType="pers.mobian.pojo.User" resultType="pers.mobian.pojo.User">select * from mybatis.user</select><select id="selectUserById" resultType="pers.mobian.pojo.User">select * from mybatis.user where id=#{id}</select><insert id="insertUser" parameterType="pers.mobian.pojo.User">insert into mybatis.user (name,id,pwd) values (#{name},#{id},#{pwd})</insert><delete id="deleteUser" parameterType="int">delete from mybatis.user where id=#{id}</delete><update id="updateUser" parameterType="pers.mobian.pojo.User">update mybatis.user set name=#{name},id=#{id},pwd=#{pwd} where id=#{id}</update></mapper>
5、对应的控制器类
package pers.mobian.controller;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import pers.mobian.mapper.UserMapper;
import pers.mobian.pojo.User;import java.util.List;@RestController
public class UserTest {//自动装配UserMapper@Autowiredprivate UserMapper userMapper;@RequestMapping("/selectUser")public List<User> selectUserTest() {List<User> userList = userMapper.selectUser();for (User user : userList) {System.out.println(user);}return userList;}@RequestMapping("/selectUser/{id}")public User selectUserById(@PathVariable("id") int id) {User user = userMapper.selectUserById(id);System.out.println(user);return user;}@RequestMapping("/insertUser")public String insertUser() {userMapper.insertUser(new User("王二小", 1, "999"));return "insertUser ok";}@RequestMapping("/deleteUser/{id}")public String deleteUser(@PathVariable("id") int id) {userMapper.deleteUser(id);return "deleteUser ok";}@RequestMapping("/updateUser")public String updateUser(){userMapper.updateUser(new User("王三小",1,"jjjj"));return "updateUser ok";}
}
注意：接口类与其的对应的mapper类如果没有在同一目录下，则在yaml核心配置文件中需要进行相应的绑定。类似于曾经mybatis-config配置文件中定位资源文件。
9、SpringSecurity（安全）
基于AOP技术的安全
属于非功能性需求，但应在设计之初就考虑
Spring Security是针对Spring项目的安全框架，也是Spring Boot底层安全模块默认的技术选型，它可以实现强大的Web安全控制，对于安全控制，我们仅需要引入spring-boot-starter-security模块，进行少量的配置，即可实现强大的安全管理
需要记忆的几个类：
- WebSecurityConfigurerAdapter：自定义Security策略
- AuthenticationMangerBuilder：自定义认证策略
- @EnableWebSecurity：开启WebSecurity模式
Spring Security的两个主要目标是“认证”和“授权”（控制访问）
认证：Authentication
授权：Authorization
这是两个通用的概念，不仅仅在Spring Security中存在
9.1、授权
重写configure(HttpSecurity http)方法
http.xxx可以设置相应的权限规则
Spring Security拥有自己定制的登录界面，如果需要使用自己的，要进行相应的设置
还可以自己开启相关的操作，如：记住次此会话（cookie，默认保存两周）、注销功能、开启csrf防止网站被恶意攻击
9.2、认证
- 重写configure(AuthenticationManagerBuilder auth)方法
- aun.xx，可以读取数据库或者内存中的数据，用来判断用户的访问权限级别
- 对于密码， 需要使用到加密算法（如果不使用加密算法，代码被反编译能够看到最初的代码）
10、Shiro
10.1、什么是shiro
- Apache Shiro是一个java的安全（权限）框架
- Shiro可以非常容易地开发出足够好地应用，其不仅可以在JavaSEE环境，也可以使用在JavaEE环境中
- Shiro可以完成，认证，授权，加密，会话管理，Web集成，缓存等
- 官网：http://shiro.apache.org
10.2、组成部分
- Authentication：身份认证、登录，验证用户是不是拥有相应地身份
- Authorization：授权，即权限验证，验证某个已认证地用户是否拥有某个权限，即判断用户能否进行有关操作。如：验证某个用户是否拥有某个角色，或者细粒度的验证某个用户对某个资源是否具有某个权限
- Session Manger：会话管理，即用户登录后就是第一次会话，在内有退出之前，它的所有信息都在会话中；会话可以是普通的JavaSE环境，也可以是Web环境
- Cryptography：加密，保护数据的安全，如密码加密存储到数据库中，而不是明文存储
- Web Support：Web支持，可以非常容易集成到Web环境
- Caching：缓存，比如用户登录后，其用户信息，拥有的角色、权限不必每一次都去查看，这样可以提高效率
- Concurrency：Shiro支持多线程应用的并发验证，如，在一个线程中开启另一个线程，能把权限自动的传播过去
- Testing：提供测试支持
- Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问
- Remember Me：记住我，这是一个非常常见的功能，即一次登录后，下次再来就不需要登陆
10.3、Shiro架构（外部）
- subject：应用代码直接交互的对象是Subject，也就是说Shiro的对外API核心就是Subject，Subject代表了当前的用户，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是subject，如网络爬虫，机器人等，与Subject的所有交互都会委托给SecurityManager；Subject其实是一个门面，SecurityManageer才是实际的执行者
- SecurityManager：安全管理器，即多有与安全有关的操作都会与SecurityManager交互，并且它管理着所有的Subject，可以看出它是Shiro的核心，它负责与Shiro的其他组件进行交互，它相当于SpringMVC的DispatchServlet的角色
- Realm：Shiro从Realm获取安全数据（如用户，角色，权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较，来确定用户的身份是否合法；也需要从Realm得到用户相应的角色、权限，进行验证用户的操作是否能够进行，可以把Realm堪称DataSource
10.4、Shiro架构（内部）
- Subject：任何可以与应用交互的用户
- Security Manager：相当于SpringMVC中的DispatchServlet；是Shiro的心脏，所有具体的交互都通过Security Manager进行控制，它管理着所有的Subject，且负责进行认证，授权，会话，以及缓存管理。
- Authenticator：负责Subject认证，是一个扩展点，可以自定义实现；可以使用认证策略（Authentication Strategy），即什么情况下算用户认证通过了
- Authorizer：授权器，即访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的那些功能
- Realm：可以有一个或者多个的realm，可以认为是安全实体数据源，即用于获取安全实体的，可以用JDBC实现，也可以是内存实现等等，由用户提供；所以一般在应用中都需要实现自己的realm
- SessionManager：管理Session生命周期的组件，而Shiro并不仅仅可以用在Web环境，也可以用在普通的JavaSE环境中
- CacheManager：缓存控制器，来管理用户，角色，权限等缓存；因为这些数据基本上很少改变，放到缓存中后可以提高访问的性能
- Cryptography：密码模块，Shiro提高了一些常见的加密组件用于密码加密，解密等
10.5、快速入门
1、导入依赖
<!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-core -->
<dependency><groupId>org.apache.shiro</groupId><artifactId>shiro-core</artifactId><version>1.4.2</version>
</dependency>
<!-- configure logging -->
<dependency><groupId>org.slf4j</groupId><artifactId>jcl-over-slf4j</artifactId><version>1.7.21</version><scope>runtime</scope>
</dependency>
<dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId><version>1.7.21</version><scope>runtime</scope>
</dependency>
<dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version><scope>runtime</scope>
</dependency>
2、在resource目录下新建log4j.properties
log4j.rootLogger=INFO, stdoutlog4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n# General Apache libraries
log4j.logger.org.apache=WARN# Spring
log4j.logger.org.springframework=WARN# Default Shiro logging
log4j.logger.org.apache.shiro=INFO# Disable verbose logging
log4j.logger.org.apache.shiro.util.ThreadContext=WARN
log4j.logger.org.apache.shiro.cache.ehcache.EhCache=WARN
3、在resource目录下新建shiro.ini
[users]
# user 'root' with password 'secret' and the 'admin' role
root = secret, admin
# user 'guest' with the password 'guest' and the 'guest' role
guest = guest, guest
# user 'presidentskroob' with password '12345' ("That's the same combination on
# my luggage!!!" ;)), and role 'president'
presidentskroob = 12345, president
# user 'darkhelmet' with password 'ludicrousspeed' and roles 'darklord' and 'schwartz'
darkhelmet = ludicrousspeed, darklord, schwartz
# user 'lonestarr' with password 'vespa' and roles 'goodguy' and 'schwartz'
lonestarr = vespa, goodguy, schwartz# -----------------------------------------------------------------------------
# Roles with assigned permissions
#
# Each line conforms to the format defined in the
# org.apache.shiro.realm.text.TextConfigurationRealm#setRoleDefinitions JavaDoc
# -----------------------------------------------------------------------------
[roles]
# 'admin' role has all permissions, indicated by the wildcard '*'
admin = *
# The 'schwartz' role can do anything (*) with any lightsaber:
schwartz = lightsaber:*
# The 'goodguy' role is allowed to 'drive' (action) the winnebago (type) with
# license plate 'eagle5' (instance specific id)
goodguy = winnebago:drive:eagle5
4、新建一个快速的开始类Quickstart
/** Licensed to the Apache Software Foundation (ASF) under one* or more contributor license agreements. See the NOTICE file* distributed with this work for additional information* regarding copyright ownership. The ASF licenses this file* to you under the Apache License, Version 2.0 (the* "License"); you may not use this file except in compliance* with the License. You may obtain a copy of the License at** http://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing,* software distributed under the License is distributed on an* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY* KIND, either express or implied. See the License for the* specific language governing permissions and limitations* under the License.*/import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.Factory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;/*** Simple Quickstart application showing how to use Shiro's API.** @since 0.9 RC2*/
public class Quickstart {private static final transient Logger log = LoggerFactory.getLogger(Quickstart.class);public static void main(String[] args) {Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");SecurityManager securityManager = factory.getInstance();SecurityUtils.setSecurityManager(securityManager);// get the currently executing user://获得当前的用户对象SubjectSubject currentUser = SecurityUtils.getSubject();// Do some stuff with a Session (no need for a web or EJB container!!!)//通过当前的用户对象拿到SessionSession session = currentUser.getSession();session.setAttribute("someKey", "aValue");String value = (String) session.getAttribute("someKey");if (value.equals("aValue")) {log.info("Retrieved the correct value! [" + value + "]");}// let's login the current user so we can check against roles and permissions://判断当前用户是否被认证if (!currentUser.isAuthenticated()) {//Token：令牌，随机UsernamePasswordToken token = new UsernamePasswordToken("lonestarr", "vespa");token.setRememberMe(true);//设置记住我try {currentUser.login(token);//执行登录操作} catch (UnknownAccountException uae) {log.info("There is no user with username of " + token.getPrincipal());} catch (IncorrectCredentialsException ice) {log.info("Password for account " + token.getPrincipal() + " was incorrect!");} catch (LockedAccountException lae) {log.info("The account for username " + token.getPrincipal() + " is locked. " +"Please contact your administrator to unlock it.");}// ... catch more exceptions here (maybe custom ones specific to your application?catch (AuthenticationException ae) {//unexpected condition? error?}}//say who they are://print their identifying principal (in this case, a username):log.info("User [" + currentUser.getPrincipal() + "] logged in successfully.");//test a role:if (currentUser.hasRole("schwartz")) {log.info("May the Schwartz be with you!");} else {log.info("Hello, mere mortal.");}//test a typed permission (not instance-level)//粗粒度if (currentUser.isPermitted("lightsaber:wield")) {log.info("You may use a lightsaber ring. Use it wisely.");} else {log.info("Sorry, lightsaber rings are for schwartz masters only.");}//a (very powerful) Instance Level permission://细粒度if (currentUser.isPermitted("winnebago:drive:eagle5")) {log.info("You are permitted to 'drive' the winnebago with license plate (id) 'eagle5'. " +"Here are the keys - have fun!");} else {log.info("Sorry, you aren't allowed to drive the 'eagle5' winnebago!");}//all done - log out!//注销currentUser.logout();//结束System.exit(0);}
}
执行结果：
2020-03-18 15:43:58,561 INFO [org.apache.shiro.session.mgt.AbstractValidatingSessionManager] - Enabling session validation scheduler...
2020-03-18 15:43:59,783 INFO [Quickstart] - Retrieved the correct value! [aValue]
2020-03-18 15:43:59,787 INFO [Quickstart] - User [lonestarr] logged in successfully.
2020-03-18 15:43:59,787 INFO [Quickstart] - May the Schwartz be with you!
2020-03-18 15:43:59,788 INFO [Quickstart] - You may use a lightsaber ring. Use it wisely.
2020-03-18 15:43:59,788 INFO [Quickstart] - You are permitted to 'drive' the winnebago with license plate (id) 'eagle5'. Here are the keys - have fun!
核心要点：
Subject currentUser = SecurityUtils.getSubject();
Session session = currentUser.getSession();
currentUser.isAuthenticated()
currentUser.hasRole("schwartz")
currentUser.isPermitted("lightsaber:wield")
currentUser.logout();
currentUser.getPrincipal()
10.6、springboot与shiro的初步整合
1、新建一个带web依赖的springboot项目
2、引入外部依赖：shiro-spring与thymeleaf模板引擎需要的依赖
<dependency><groupId>org.apache.shiro</groupId><artifactId>shiro-spring</artifactId><version>1.4.2</version>
</dependency><dependency><groupId>org.thymeleaf</groupId><artifactId>thymeleaf-spring5</artifactId>
</dependency>
<dependency><groupId>org.thymeleaf.extras</groupId><artifactId>thymeleaf-extras-java8time</artifactId>
</dependency>
3、在配置包下新建UserRealm类
package pers.mobian.config;import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;public class UserRealm extends AuthorizingRealm {//授权@Overrideprotected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {System.out.println("执行了=> 授权doGetAuthorizationInfo");return null;}//认证@Overrideprotected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {System.out.println("执行了=> 认证doGetAuthenticationInfo");return null;}
}
4、在配置包下新建ShiroConfig类
package pers.mobian.config;import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class ShiroConfig {//创建ShiroFilterFactoryBean@Beanpublic ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("securityManager") DefaultSecurityManager defaultSecurityManager) {ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();//设置安全管理器bean.setSecurityManager(defaultSecurityManager);return bean;}//创建DefaultSecurityManager@Bean(name = "securityManager")public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("userRealm") UserRealm userRealm) {DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();//关联userRealmsecurityManager.setRealm(userRealm);return securityManager;}//创建realm对象， 需要自定义类@Beanpublic UserRealm userRealm() {return new UserRealm();}
}
5、新建控制器类IndexController
package pers.mobian.controller;import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;@Controller
public class IndexController {@RequestMapping({"/", "/index"})public String indexTest(Model model) {model.addAttribute("msg", "hello springboot-shiro");return "index";}@RequestMapping("/user/add")public String addTest(){return "/user/add";}@RequestMapping("/user/update")public String updateTest(){return "/user/update";}
}
6、在templates目录下编写html界面
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.w3.org/1999/xhtml">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<body>
<h1>首页</h1><p th:text="${msg}"></p><a th:href="@{/user/add}">add</a>|<a th:href="@{/user/update}">update</a>
</body>
</html>
7、在templates下新建user目录，并建立add.html和update.html
<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<body><h1>add</h1>
</body>
</html><!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<body><h1>update</h1>
</body>
</html>
8、测试结果
10.7、实现登录拦截
1、修改ShiroConfig类
package pers.mobian.config;import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import java.util.LinkedHashMap;
import java.util.Map;@Configuration
public class ShiroConfig {//创建ShiroFilterFactoryBean@Beanpublic ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("securityManager") DefaultSecurityManager defaultSecurityManager) {ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();//设置安全管理器bean.setSecurityManager(defaultSecurityManager);//添加shiro的内置过滤器/*anno：无需认证就可以访问authc：必须认证了才能通过user：必须拥有记住我这个功能才能使用perms：拥有对某个资源的权限才能访问role：拥有某个角色权限才能访问*/Map<String, String> filterMap = new LinkedHashMap<>();filterMap.put("/user/*","authc");bean.setFilterChainDefinitionMap(filterMap);//设置登录的请求bean.setLoginUrl("/toLogin");return bean;}//创建DefaultSecurityManager@Bean(name = "securityManager")public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("userRealm") UserRealm userRealm) {DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();//关联userRealmsecurityManager.setRealm(userRealm);return securityManager;}//创建realm对象， 需要自定义类@Beanpublic UserRealm userRealm() {return new UserRealm();}
}
2、新建一个登录界面
<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<body>
<form action=""><p>用户名：<input type="text" name="username"></p><p>密码：<input type="password" name="password"></p><p><input type="submit"></p>
</form>
</body>
</html>
3、添加对应的映射
@RequestMapping("/toLogin")
public String toLogin(){return "login";
}
测试点击对应的方法，会跳转到登录界面
10.8、实现用户认证
1、在控制器类中添加对应的代码
@RequestMapping("/login")
public String login(String username, String password, Model model) {Subject subject = SecurityUtils.getSubject();UsernamePasswordToken token = new UsernamePasswordToken(username, password);try {subject.login(token);return "index";} catch (UnknownAccountException e) {model.addAttribute("msg", "用户名错误");return "login";} catch (IncorrectCredentialsException e) {model.addAttribute("msg", "密码错误");return "login";}
}
2、修改UserRealm
package pers.mobian.config;import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;public class UserRealm extends AuthorizingRealm {//授权@Overrideprotected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {System.out.println("执行了=> 授权doGetAuthorizationInfo");return null;}//认证@Overrideprotected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {System.out.println("执行了=> 认证doGetAuthenticationInfo");//用户名，密码，来自于数据库中取出，此处伪造数据String name="root";String password = "123456";UsernamePasswordToken userToken = (UsernamePasswordToken) token;if(!userToken.getUsername().equals(name)){return null;//抛出异常 UnknownAccountException（控制器中定义的异常）}//密码认证，shiro自己内部操作return new SimpleAuthenticationInfo("",password,"");}
}
3、此时即可完成用户身份的校验
每次登录的时候，系统都会去通过控制器类然后跳转到UserRealm类，继而进行用户名和密码的判断。
10.9、Mybatis整合Shiro
1、引入对应的maven依赖
<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.20</version>
</dependency>
<dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version>
</dependency>
<dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.8</version>
</dependency>
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.16</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
<dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.1.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-spring -->
<dependency><groupId>org.apache.shiro</groupId><artifactId>shiro-spring</artifactId><version>1.4.2</version>
</dependency>
2、新建核心配置文件application.yaml，用来配置数据源（可以自行选择添加与否）并且配置mybatis信息
spring:datasource:username: rootpassword:#?serverTimezone=UTC解决时区的报错url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8driver-class-name: com.mysql.cj.jdbc.Drivertype: com.alibaba.druid.pool.DruidDataSource#Spring Boot 默认是不注入这些属性值的，需要自己绑定#druid 数据源专有配置initialSize: 5minIdle: 5maxActive: 20maxWait: 60000timeBetweenEvictionRunsMillis: 60000minEvictableIdleTimeMillis: 300000validationQuery: SELECT 1 FROM DUALtestWhileIdle: truetestOnBorrow: falsetestOnReturn: falsepoolPreparedStatements: true#配置监控统计拦截的filters，stat:监控统计、log4j：日志记录、wall：防御sql注入#如果允许时报错 java.lang.ClassNotFoundException: org.apache.log4j.Priority#则导入 log4j 依赖即可，Maven 地址：https://mvnrepository.com/artifact/log4j/log4jfilters: stat,wall,log4jmaxPoolPreparedStatementPerConnectionSize: 20useGlobalDataSourceStat: trueconnectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500mybatis:type-aliases-package: pers.mobian.pojomapper-locations: classpath:mapper/*.xml
3、新建实体类
package pers.mobian.pojo;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {private String name;private int id;private String pwd;
}
4、新建mapper的接口类
package pers.mobian.mapper;import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import pers.mobian.pojo.User;@Mapper
@Repository
public interface UserMapper {public User queryUserByName(String name);
}
5、新建mapper接口类的实体类
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="pers.mobian.mapper.UserMapper"><select id="queryUserByName" parameterType="String" resultType="User">select * from mybatis.user where name=#{name}</select>
</mapper>
6、编写对应的service层接口类
package pers.mobian.service;import pers.mobian.pojo.User;public interface UserService {public User queryUserByName(String name);
}
7、编写对应的service层接口类的实现类
package pers.mobian.service;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import pers.mobian.mapper.UserMapper;
import pers.mobian.pojo.User;@Service
public class UserServiceImpl implements UserService{@AutowiredUserMapper userMapper;@Overridepublic User queryUserByName(String name) {return userMapper.queryUserByName(name);}
}
8、控制器类代码不变
@RequestMapping("/login")
public String login(String username, String password, Model model) {Subject subject = SecurityUtils.getSubject();UsernamePasswordToken token = new UsernamePasswordToken(username, password);try {subject.login(token);return "index";} catch (UnknownAccountException e) {model.addAttribute("msg", "用户名错误");return "login";} catch (IncorrectCredentialsException e) {model.addAttribute("msg", "密码错误");return "login";}
}
9、ShiroConfig类不变
package pers.mobian.config;import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import java.util.LinkedHashMap;
import java.util.Map;@Configuration
public class ShiroConfig {//创建ShiroFilterFactoryBean@Beanpublic ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("securityManager") DefaultSecurityManager defaultSecurityManager) {ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();//设置安全管理器bean.setSecurityManager(defaultSecurityManager);//添加shiro的内置过滤器/*anno：无需认证就可以访问authc：必须认证了才能通过user：必须拥有记住我这个功能才能使用perms：拥有对某个资源的权限才能访问role：拥有某个角色权限才能访问*/Map<String, String> filterMap = new LinkedHashMap<>();filterMap.put("/user/*","authc");bean.setFilterChainDefinitionMap(filterMap);//设置登录的请求bean.setLoginUrl("/toLogin");return bean;}//创建DefaultSecurityManager@Bean(name = "securityManager")public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("userRealm") UserRealm userRealm) {DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();//关联userRealmsecurityManager.setRealm(userRealm);return securityManager;}//创建realm对象， 需要自定义类@Beanpublic UserRealm userRealm() {return new UserRealm();}
}
10、将UserRealm类中的模拟数据变成真实的数据库数据
package pers.mobian.config;import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;
import pers.mobian.pojo.User;
import pers.mobian.service.UserService;public class UserRealm extends AuthorizingRealm {@AutowiredUserService userService;//授权@Overrideprotected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {System.out.println("执行了=> 授权doGetAuthorizationInfo");return null;}//认证@Overrideprotected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {System.out.println("执行了=> 认证doGetAuthenticationInfo");UsernamePasswordToken userToken = (UsernamePasswordToken) token;//连接真实的数据库User user = userService.queryUserByName(userToken.getUsername());if(user == null) { //数据库中没有查询到该用户return null;}//md5加密：一串数字//md5盐值加密：一串数字加上用户名//密码认证，shiro自己操作return new SimpleAuthenticationInfo("",user.getPwd(),"");}
}
11、对应的目录结构是
12、测试代码即可完成安全验证
10.10、实现Shiro请求授权
type=Unauthorized,status=401
1、修改数据库的字段并且修改pojo类
2、修改ShiroConfig类
package pers.mobian.config;import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import java.util.LinkedHashMap;
import java.util.Map;@Configuration
public class ShiroConfig {//创建ShiroFilterFactoryBean@Beanpublic ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("securityManager") DefaultSecurityManager defaultSecurityManager) {ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();//设置安全管理器bean.setSecurityManager(defaultSecurityManager);//添加shiro的内置过滤器/*anno：无需认证就可以访问authc：必须认证了才能通过user：必须拥有记住我这个功能才能使用perms：拥有对某个资源的权限才能访问role：拥有某个角色权限才能访问*///拦截Map<String, String> filterMap = new LinkedHashMap<>();//授权,正常情况下，没有授权会跳转到未授权页面filterMap.put("/user/add","perms[user:add]");filterMap.put("/user/update","perms[user:update]");filterMap.put("/user/*","authc");bean.setFilterChainDefinitionMap(filterMap);//设置登录的请求bean.setLoginUrl("/toLogin");//未授权的页面bean.setUnauthorizedUrl("/unauthorized");return bean;}//创建DefaultSecurityManager@Bean(name = "securityManager")public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("userRealm") UserRealm userRealm) {DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();//关联userRealmsecurityManager.setRealm(userRealm);return securityManager;}//创建realm对象， 需要自定义类@Beanpublic UserRealm userRealm() {return new UserRealm();}
}
3、修改UserRealm类
package pers.mobian.config;import org.apache.catalina.security.SecurityUtil;
import org.apache.shiro.SecurityUtils;
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.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import pers.mobian.pojo.User;
import pers.mobian.service.UserService;public class UserRealm extends AuthorizingRealm {@AutowiredUserService userService;//授权@Overrideprotected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {System.out.println("执行了=> 授权doGetAuthorizationInfo");SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();info.addStringPermission("user:add");//拿到当前登录的这个对象Subject subject = SecurityUtils.getSubject();//拿到User对象User currentUser = (User) subject.getPrincipal();//设置当前用户的权限info.addStringPermission(currentUser.getPerms());return info;}//认证@Overrideprotected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {System.out.println("执行了=> 认证doGetAuthenticationInfo");UsernamePasswordToken userToken = (UsernamePasswordToken) token;//连接真实的数据库User user = userService.queryUserByName(userToken.getUsername());if(user == null) { //数据库中没有查询到该用户return null;}//md5加密：一串数字//md5盐值加密：一串数字加上用户名//密码认证，shiro自己操作return new SimpleAuthenticationInfo("user",user.getPwd(),"");}
}
此案例能够达到不同的用户对同一个页面拥有不同的权限
10.11、Thymeleaf整合Shiro
目的：将Shiro与前端的模板引擎Thymeleaf整合，达到不同权限不同显示的效果
1、修改index.html界面
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.w3.org/1999/xhtml"xmlns:shiro="http://www.thymeleaf.org/thymeleaf-extras-shiro">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<body>
<h1>首页</h1><div th:if="${session.loginUser==null}"><a th:href="@{/toLogin}">登录</a>
</div><p th:text="${msg}"></p><div shiro:hasPermission="user:add"><a th:href="@{/user/add}">add</a>
</div>
<div shiro:hasPermission="user:update"><a th:href="@{/user/update}">update</a>
</div></body>
</html>
2、将前端需要的session放在UserRealm类中
package pers.mobian.config;import org.apache.catalina.security.SecurityUtil;
import org.apache.shiro.SecurityUtils;
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.session.Session;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import pers.mobian.pojo.User;
import pers.mobian.service.UserService;public class UserRealm extends AuthorizingRealm {@AutowiredUserService userService;//授权@Overrideprotected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {System.out.println("执行了=> 授权doGetAuthorizationInfo");SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();info.addStringPermission("user:add");//拿到当前登录的这个对象Subject subject = SecurityUtils.getSubject();//拿到User对象User currentUser = (User) subject.getPrincipal();//设置当前用户的权限info.addStringPermission(currentUser.getPerms());return info;}//认证@Overrideprotected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {System.out.println("执行了=> 认证doGetAuthenticationInfo");UsernamePasswordToken userToken = (UsernamePasswordToken) token;//连接真实的数据库User user = userService.queryUserByName(userToken.getUsername());if(user == null) { //数据库中没有查询到该用户return null;}Subject currentSubject = SecurityUtils.getSubject();Session session = currentSubject.getSession();session.setAttribute("loginUser",user);//md5加密：一串数字//md5盐值加密：一串数字加上用户名//密码认证，shiro自己操作return new SimpleAuthenticationInfo("user",user.getPwd(),"");}
}
整合过去整合过来实在是令人头秃，感觉人要废了
SpringBoot（二）相关推荐
- spring-boot(二)
学习文章来自:http://www.ityouknow.com/spring-boot.html web开发 spring boot web开发非常的简单,其中包括常用的json输出.filters. ...
- SpringBoot 二维码生成base64并上传OSS
SpringBoot 二维码生成base64并上传OSS 基础环境 SpringBoot.Maven 代码实现 1.添加依赖 <!--二维码生成 --> <dependency> ...
- SpringBoot(二)——实现一个基本的小网站
文章目录 1. 新建一个SPringboot项目,构建web模块 2. 导入pojo 和 dao 的类 3. 导入静态资源 4. 所有页面增加头文件 5. 所有的资源链接修改格式为thymeleaf ...
- springboot二：过滤器、拦截器、静态资源访问
一:springboot中的过滤器 过滤器是什么? 它是基于Servlet 技术实现的, 简单的来说,过滤器就是起到过滤的作用,在web项目开发中帮我们过滤一些指定的 url做一些特殊的 处理. 过滤 ...
- springboot(二)自动化配置源码解析
@EnableAutoConfiguration 是开启自动配置的注解,在创建的 SpringBoot 项目中并不能直接看到此注解,它是由组合注解@SpringBootApplication 引入的. ...
- SpringBoot(二）——JPA
2019独角兽企业重金招聘Python工程师标准>>> 什么是JPA JPA是Java Persistence API的简称,中文名Java持久层API,是JDK 5.0注解或XML ...
- springboot(二)：web综合开发
为什么80%的码农都做不了架构师?>>> 上篇文章介绍了Spring boot初级教程:spring boot(一):入门篇,方便大家快速入门.了解实践Spring boot特 ...
- SpringBoot(二)：设置springboot同一接口程序启动入口
根据上一篇文章中搭建了一个springboot简单工程,在该工程中编写HelloWordController.java接口类,并在该类中写了一个main函数,做为该类的接口服务启动入口.此时如果新增多 ...
- SpringBoot(二): 使用Dokcer+SpringCloud+Consul+Fabio搭建微服务
SpringBoot: 2.1.1 SpringCloud: Greenwich.M3 Consul: consul:1.3.0 Fabio: fabiolb/fabio:1.5.5-go1.9.2 ...
- Java代码小demon（一）SpringBoot+二维码和条形码生成
1. 简介 原由 需要一个工具类,可以将数据存储在二维码中,通过扫一扫可以获取到信息,条形码不能接受中文字符 收藏和转载以及自己应用时拓展,具体实现和底层原理还不会,有时间我会去了解或者忘记 借鉴博客 ...
最新文章
- 【C++】多线程(链式、循环队列)实现生产者消费者模式
- JSON WEB TOKEN（JWT）的分析
- c语言用switch编写运输运费,求助。。关于用switch编写简易计算器
- Oracle MD5加密
- 【Error-Android Studio】clang++: error: no such file or directory
- 算法设计与分析——动态规划——最大字段和问题
- 给Eclipse插件的View加上菜单和工具条
- (转帖)美国人教你这样用Google，你真的会变特工
- R语言元胞自动机单车道代码_一维单车道交通流元胞自动机模型综述
- 教你一秒无插件下载B站/MOOC课视频
- 关于metasploit的一些架构目录
- 国际象棋渲染测试软件,国际象棋与Cinebench渲染
- jquery获取元素索引值index()
- 2022第九届生物发酵展（济南）3月召开，拓展生物发酵行业新机遇
- 班级日常工作管理系统
- 文件、目录管理（一）
- 编程猫Nemo基本代码块
- 蹄疾步稳，勇毅笃行，小白的大学四年
- 深入解析数据库透明加密技术
- 小视频源码炙手可热的秘密，短视频行业先驱者们给我们留下启示...
热门文章
- 三本学计算机没用吗,腾讯员工：我211学计算机都觉得写代码难，三本的人能写代码为啥考不上211...
- java证明角谷猜想_Java 代码界 3% 的王者？看我是如何解错这 5 道题的
- python按照日期筛选excel_用python判断Excel单元格格式为输出日期（日期字段位置不固定）的，按datetime格式输出日期（而非float）_python excle 日期列...
- java 子类 继承父类的注解,spring使用注解通过子类注入父类的私有变量
- maven配置项目根路径_Java的项目构建工具Maven的配置和使用教程
- storm发布jar包时报找不到主类_咖啡5元一大包，进口饼干10元3包…济南有个临期食品超市，快过期的食品你会买单吗...
- flutter 进度条_OkHttp 在 Flutter中的运用场景，Flutter语言连接网络的方法介绍
- hutool 读取扩展名文件_如何快速的搜索文件，Everything使用技巧
- jsp相关概念以及九大内置对象
- 威纶通触摸屏与仪表通讯_用博途建立西门子触摸屏和S7300PLC的通讯