SpringBoot基础(二)
spring官网：https://spring.io/
https://mp.weixin.qq.com/mp/homepage?__biz=Mzg2NTAzMTExNg==&hid=1&sn=3247dca1433a891523d9e4176c90c499
该笔记记录的是SpringBoot2，更新的SpringBoot3版本需要参考最新官方文档
7、连接数据库
7.0 SpringData
对于数据访问层，无论是 SQL 还是 NoSQL，Spring Boot 底层都是采用 Spring Data 的方式进行统一处理。
SpringData官网：https://spring.io/projects/spring-data
数据库相关启动器：https://docs.spring.io/spring-boot/docs/2.2.5.RELEASE/reference/htmlsingle/#using-boot-starter
7.1 整合JDBC
创建一个springboot项目，引入JDBC相关依赖
自动生成的pom.xml依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</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.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
编写application.yml配置文件连接数据库
spring:
datasource:
username: root
password: 密码
#?serverTimezone=UTC用于解决时区报错
url: jdbc:mysql://localhost:3306/springboot?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
driver-class-name: com.mysql.cj.jdbc.Driver
springboot底层会处理这些配置内容。接下来可以直接使用jdbc
@SpringBootTest
public class SpringbootDataJdbcTest {
//注入数据源。配置文件完成后，底层会构造出dataSource对象
@Resource
DataSource dataSource;
@Test
public void contextLoads() throws SQLException{
//查看默认的数据源
System.out.println(dataSource.getClass());
//获取连接
Connection connection = dataSource.getConnection();
System.out.println(connection);
//关闭连接
connection.close();
}
}
注：项目创建后会生成一个总测试类，自己写的测试类要和这个总测试类处于同级目录
输出
由输出可以看到，默认配置的数据源是class com.zaxxer.hikari.HikariDataSource。
数据源的自动配置写在DataSourceAutoConfiguration类中，打开它的源码，源码中有一处默认数据源配置相关的内部类
@Configuration(
proxyBeanMethods = false
)
@Conditional({DataSourceAutoConfiguration.PooledDataSourceCondition.class})
@ConditionalOnMissingBean({DataSource.class, XADataSource.class})
@Import({Hikari.class, Tomcat.class, Dbcp2.class, OracleUcp.class, Generic.class, DataSourceJmxConfiguration.class})
protected static class PooledDataSourceConfiguration {
protected PooledDataSourceConfiguration() {
}
}
源码中通过@Import注解导入了Hikari.class，即前面打印的默认配置数据源。
可以在配置文件中设置spring.datasources.type的值来配置数据源类型（mysql、oracle…）。
JDBCTemplate
目的和MyBatis差不多，都是为了简化数据库相关的代码书写。JDBCTemplate也是springboot底层的一个默认配置。
相关配置类是JdbcTemplateConfiguration。
常用方法：
excute：执行sql语句update、batchUpdate：前者执行增删改语句，后者执行批处理相关语句query、queryForXXX：执行查询语句call：执行存储过程、函数相关的语句
使用例
编写一个Controller，注入 jdbcTemplate，编写测试方法进行访问测试.
@RestController
@RequestMapping("/jdbc")
public class JdbcController {
//使用默认配置的JdbcTemplate
@Autowired
JdbcTemplate jdbcTemplate;
//查
//List 中的一个 Map 对应数据库的一行数据
//Map 中的 key 对应数据库的字段名，value 对应数据库的字段值
@GetMapping("/list")
public List<Map<String,Object>> userList(){
String sql="select * from user";
List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
return maps;
}
//增
@GetMapping("/add")
public String addUser(){
String sql="insert into user(id,name,pwd) values(5,'田七',888888)";
jdbcTemplate.update(sql);
return "addOk";
}
//删
@GetMapping("/del/{id}")
public String delUser(@PathVariable("id")int id){
String sql="delete from user where id=?";
jdbcTemplate.update(sql,id);
return "deleteOk";
}
//改
@GetMapping("/update/{id}")
public String updateUser(@PathVariable("id")int id){
String sql="update user set name=?,pwd=? where id="+id;
//修改数据
Object[] objects = new Object[2];
objects[0]="XXXX";
objects[1]="999999";
jdbcTemplate.update(sql,objects);
return "updateOk";
}
}
测试
7.2 整合Druid
开源仓库：https://github.com/alibaba/druid
Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3P0、DBCP 等 DB 池的优点，同时加入了日志监控。Druid能够提供强大的监控和扩展功能。
com.alibaba.druid.pool.DruidDataSource 基本配置参数：https://github.com/alibaba/druid/wiki/DruidDataSource%E9%85%8D%E7%BD%AE%E5%B1%9E%E6%80%A7%E5%88%97%E8%A1%A8
添加依赖
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.8</version>
</dependency>
在配置文件中修改数据源类型
spring:
datasource:
username: root
password: 密码
url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
driver-class-name: com.mysql.cj.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource # 自定义数据源
利用之前写好的SpringbootDataJdbcTest测试类打印查看当前的默认数据源
根据官方提供的参数，在配置文件中进行设置。
spring:
datasource:
username: root
password: 密码
url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
driver-class-name: com.mysql.cj.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource # 自定义数据源
#以下属性Spring Boot 默认不注入，需要自己配置
#druid 数据源专有配置
initialSize: 5 #连接池初始化大小
minIdle: 5 #最小连接池数量
maxActive: 20 #最大连接数
maxWait: 60000 #最大等待时间
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: SELECT 1 FROM DUAL
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
poolPreparedStatements: true
#配置监控统计拦截的filters。stat:监控统计、log4j：日志记录、wall：防御sql注入
#如果允许时报错 java.lang.ClassNotFoundException: org.apache.log4j.Priority
#则导入 log4j 依赖即可
filters: stat,wall,log4j
maxPoolPreparedStatementPerConnectionSize: 20
useGlobalDataSourceStat: true
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
导入Log4j依赖
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
配置文件中写好的Druid参数需要手动绑定属性，再添加到容器中。
创建一个config.DruidConfig类进行绑定
@Configuration
public class DruidConfig {
/*
将自定义的 Druid数据源添加到容器中，不再让 Spring Boot 自动创建
绑定全局配置文件中的 druid 数据源属性到 com.alibaba.druid.pool.DruidDataSource从而让它们生效
@ConfigurationProperties(prefix = "spring.datasource")：将全局配置文件中
前缀为 spring.datasource的属性值匹配注入到 com.alibaba.druid.pool.DruidDataSource 的同名参数中
*/
@ConfigurationProperties(prefix="spring.datasource")
@Bean
public DataSource druidDataSource(){
return (DataSource) new DruidDataSource();
}
}
测试类
@SpringBootTest
public class SpringbootDataDruidTest {
@Autowired
DataSource dataSource;
@Test
public void contextLoads() throws SQLException{
System.out.println(dataSource.getClass());
Connection connection = dataSource.getConnection();
System.out.println(connection);
DruidDataSource druidDataSource=(DruidDataSource) dataSource;
System.out.println("druidDateSource 数据源的最大连接数："+druidDataSource.getMaxActive());
System.out.println("druidDateSource 数据源的初始化连接数："+druidDataSource.getInitialSize());
connection.close();
}
}
输出
配置Druid数据源监控
Druid 数据源具有监控的功能，并提供了一个 web 界面方便用户查看。
在DruidConfig类中添加以下方法来设置 Druid 的后台管理页面，如账号、密码。
@Bean
public 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("xxxxxx", "192.168.1.20");表示禁止此ip访问
//设置初始化参数
bean.setInitParameters(initParams);
return bean;
}
测试
配置Druidweb监控的过滤器(filter)
在DruidConfig类中添加以下方法来设置监控网页的过滤器
@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;
}
7.3 整合Mybatis
官方文档：http://mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/
Maven仓库地址：https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter/2.1.1
添加依赖
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.3</version>
</dependency>
配置文件中的数据库连接信息保持之前(7.2)的配置。(测试数据库能否连上)
使用例
创建实体类
package com.example.springboot04data.pojo;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
private int id;
private String name;
private String pwd;
}
创建mapper目录以及实体类对应的Mapper接口
@Mapper //表示本类是一个 MyBatis 的 Mapper
@Repository
public interface UserMapper {
//获取所有用户信息
List<User> getUsers();
//通过id获取用户
User getUser(int id);
//增
int addUser(User user);
//删
int deleteUser(int id);
//改
int updateUser(User user);
}
在resources目录下创建mybatis/mapper目录，编写对应的Mapper映射文件。
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.springboot04data.mapper.UserMapper">
<select id="getUsers" resultType="User">
select * from user
</select>
<select id="getUser" resultType="User" parameterType="int">
select * from user where id=#{id}
</select>
<insert id="addUser" parameterType="User">
insert into user(id,name,pwd) values(#{id},#{name},#{pwd})
</insert>
<delete id="deleteUser" parameterType="int">
delete from user where id=#{id}
</delete>
<update id="updateUser" parameterType="User">
update user set name=#{name}, pwd=#{pwd} where id=#{id}
</update>
</mapper>
在配置文件中添加以下配置以简化对象返回值的书写（否则resultType要写出完整对象名）
mybatis:
type-aliases-package: com.example.springboot04data.pojo
mapper-locations: classpath:mybatis/mapper/*.xml
编写UserController进行测试
@RestController
public class UserController {
@Autowired
UserMapper userMapper;
//查询所有用户
@GetMapping("/getUsers")
public List<User> getUsers(){
return userMapper.getUsers();
}
//通过id查询用户
@GetMapping("/getUser/{id}")
public User getUser(@PathVariable("id") int id){
return userMapper.getUser(id);
}
//增
public String addUser(User user){
userMapper.addUser(user);
return "addOk";
}
//删
public String deleteUser(int id){
userMapper.deleteUser(id);
return "delOk";
}
//改
public String updateUser(User user){
userMapper.updateUser(user);
return "updateOk";
}
}
测试
8、信息安全
目的：保护用户信息安全、后期系统维护
市面上可用的框架：Shiro、Spring Security
Spring Security是一个功能强大且高度可定制身份验证和访问控制的框架(基于Spring)。侧重于为Java应用程序提供身份验证和授权。与所有Spring项目一样，Spring安全性的真正强大之处在于它易于扩展以满足定制需求。
一般来说，Web 应用的安全性包括用户认证（Authentication）和用户权限（Authorization）两个部分。
在用户认证方面，Spring Security 框架支持主流的认证方式，包括 HTTP 基本认证、HTTP 表单验证、HTTP 摘要认证、OpenID 和 LDAP 等。在用户授权方面，Spring Security 提供了基于角色的访问控制和访问控制列表（Access Control List，ACL），可以对应用中的领域对象进行细粒度的控制。
8.1 spring Security
8.1.1 环境搭建
新建一个springboot项目，引入web、thymeleaf模块
导入静态资源
创建controller.RouterController实现页面跳转
@Controller
public class RouterController {
@RequestMapping({"/","/index"})
public String index(){
return "index";
}
@RequestMapping("toLogin")
public String toLogin(){
return "views/login";
}
@RequestMapping("/level1/{id}")
public String level1(@PathVariable("id") int id){
return "views/level1/"+id;
}
@RequestMapping("/level2/{id}")
public String level2(@PathVariable("id") int id){
return "views/level2/"+id;
}
@RequestMapping("/level3/{id}")
public String level3(@PathVariable("id") int id){
return "views/level3/"+id;
}
}
测试
8.1.2 认证和授权
导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
常见的相关类：
WebSecurityConfigurerAdapter: 自定义Security策略AuthenticationManagerBuilder: 自定义认证策略@EnableWebSecurity: 开启WebSecurity模式
认证(Authentication):
- 通过用户名、密码等凭据验证用户的身份。
- 身份验证通常通过用户名和密码完成，有时与身份验证因素结合使用。
授权(Authorization):
- 系统成功验证您的身份后，最终会授予您访问资源（如信息，文件，数据库，资金，位置，几乎任何内容）的完全权限(可以联想数据库的权限)。
编写SpringSecurity配置类
参考官网：https://spring.io/projects/spring-security
https://docs.spring.io/spring-security/reference/servlet/index.html
编写基础配置类config.SecurityConfig
@EnableWebSecurity //开启WebSecurity模式
public class SecurityConfig extends WebSecurityConfigurerAdapter {
//定制请求的授权规则
@Override
protected void configure(HttpSecurity http) throws Exception{
//首页允许所有人访问
// antMarcher先择相关的路径，hasRole设置授权角色
http.authorizeRequests()
.antMatchers("/").permitAll()
.antMatchers("/level1/**").hasRole("vip1")
.antMatchers("/level2/**").hasRole("vip2")
.antMatchers("/level3/**").hasRole("vip3");
}
}
测试发现只有首页能显示，其他页面由于权限无法进入
修改configure()方法，开启自动配置的登录功能
@EnableWebSecurity //开启WebSecurity模式
public class SecurityConfig extends WebSecurityConfigurerAdapter {
//定制请求的授权规则
@Override
protected void configure(HttpSecurity http) throws Exception{
// 开启自动配置的登录功能
// /login 请求来到登录页
// /login/error 重定向到这里表示登录失败
http.formLogin();
http.authorizeRequests()
.antMatchers("/").permitAll()
.antMatchers("/level1/**").hasRole("vip1")
.antMatchers("/level2/**").hasRole("vip2")
.antMatchers("/level3/**").hasRole("vip3");
}
}
重写configure(AuthenticationManagerBuilder auth) 方法，实现自定义认证规则
//定义认证规则
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
//这里在内存中定义。后续可以去数据库中去拿
auth.inMemoryAuthentication()
.withUser("alice").password("123456").roles("vip2","vip3")
.and()
.withUser("root").password("123456").roles("vip1","vip2","vip3")
.and()
.withUser("guest").password("123456").roles("vip1","vip2");
}
不过测试发现登录失败
前端传到后端的密码需要进行加密，修改之前的代码
//定义认证规则
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
//Spring security 5.0中新增了多种加密方式，也改变了密码的格式。
//将前端传过来的密码进行某种方式加密
//spring security 官方推荐的是使用bcrypt加密方式。
auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder())
.withUser("alice").password(new BCryptPasswordEncoder().encode("123456")).roles("vip2","vip3")
.and()
.withUser("root").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1","vip2","vip3")
.and()
.withUser("guest").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1","vip2");
}
8.1.3 权限控制和注销
在configure(HttpSecurity http)方法中开启自动配置的注销功能
//定制请求的授权规则
@Override
protected void configure(HttpSecurity http) throws Exception{
//......
//开启自动配置的注销的功能
// /logout 发出注销请求
http.logout();
}
在index.html中增加一个注销按钮以发送/logout请求
<a class="item" th:href="@{/logout}">
<i class="address card icon"></i> 注销
</a>
测试发现注销后会退到登录界面，为了实现注销后回到主页可以修改configure(HttpSecurity http)方法
//定制请求的授权规则
@Override
protected void configure(HttpSecurity http) throws Exception{
//......
//开启自动配置的注销的功能
// /logout 发出注销请求
http.logout().logoutSuccessUrl("/");
}
需求：希望没有登录时，主页右上角有登录按钮。登录后，主页右上角的按钮由用户名代替。另外，主页中只显示当前登录用户有权限点进去的链接。比如alice没有进入level1的权限，那level1这一块链接就不显示
这里需要使用thymeleaf中的另一些功能
导入依赖
<!-- https://mvnrepository.com/artifact/org.thymeleaf.extras/thymeleaf-extras-springsecurity4 -->
<dependency>
<groupId>org.thymeleaf.extras</groupId>
<artifactId>thymeleaf-extras-springsecurity5</artifactId>
</dependency>
修改前端页面index.html
给页面导入命名空间xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5"
修改导航栏，增加认证判断（其他页面会复用主页的导航栏代码）
<!--登录注销-->
<div class="right menu">
<!--如果未登录-->
<div sec:authorize="!isAuthenticated()">
<a class="item" th:href="@{/login}">
<i class="address card icon"></i> 登录
</a>
</div>
<!--如果已登录-->
<div sec:authorize="isAuthenticated()">
<a class="item">
<i class="address card icon"></i>
用户名：<span sec:authentication="principal.username"></span>
角色：<span sec:authentication="principal.authorities"></span>
</a>
</div>
<div sec:authorize="isAuthenticated()">
<a class="item" th:href="@{/logout}">
<i class="address card icon"></i> 注销
</a>
</div>
</div>
测试
注销后可能会出现404，是因为它默认防止csrf跨站请求伪造，因为会产生安全问题，可以将请求改为post表单提交，或者在spring security中关闭csrf功能；在 configure(HttpSecurity http)方法中增加 http.csrf().disable();进行配置
修改主页中的代码实现根据用户权限显示对应的链接
<!-- sec:authorize="hasRole('vip1')" -->
<div class="column" sec:authorize="hasRole('vip1')">
<div class="ui raised segment">
<div class="ui">
<div class="content">
<h5 class="content">Level 1</h5>
<hr>
<div><a th:href="@{/level1/1}"><i class="bullhorn icon"></i> Level-1-1</a></div>
<div><a th:href="@{/level1/2}"><i class="bullhorn icon"></i> Level-1-2</a></div>
<div><a th:href="@{/level1/3}"><i class="bullhorn icon"></i> Level-1-3</a></div>
</div>
</div>
</div>
</div>
<div class="column" sec:authorize="hasRole('vip2')">
<div class="ui raised segment">
<div class="ui">
<div class="content">
<h5 class="content">Level 2</h5>
<hr>
<div><a th:href="@{/level2/1}"><i class="bullhorn icon"></i> Level-2-1</a></div>
<div><a th:href="@{/level2/2}"><i class="bullhorn icon"></i> Level-2-2</a></div>
<div><a th:href="@{/level2/3}"><i class="bullhorn icon"></i> Level-2-3</a></div>
</div>
</div>
</div>
</div>
<div class="column" sec:authorize="hasRole('vip3')">
<div class="ui raised segment">
<div class="ui">
<div class="content">
<h5 class="content">Level 3</h5>
<hr>
<div><a th:href="@{/level3/1}"><i class="bullhorn icon"></i> Level-3-1</a></div>
<div><a th:href="@{/level3/2}"><i class="bullhorn icon"></i> Level-3-2</a></div>
<div><a th:href="@{/level3/3}"><i class="bullhorn icon"></i> Level-3-3</a></div>
</div>
</div>
</div>
</div>
8.1.4 记住我功能
需求：记住用户名密码，重开浏览器后可以快速登录
在configure(HttpSecurity http)方法中添加http.rememberMe();即可，具体实现可以读源码
//定制请求的授权规则
@Override
protected void configure(HttpSecurity http) throws Exception {
//......
//记住我
http.rememberMe();
}
测试登录时会出现记住我的选项
登录后，重开浏览器，再进入主页，发现会自动登录
注销后，springsecurity会自动删除cookie
8.1.5 定制登录页
前面的登录页面样式是spring security 默认的，下面要使用自定义样式
在configure(HttpSecurity http)方法中修改http.formLogin();，指定自己的登录页面
http.formLogin().loginPage("/toLogin");
在index.html中指向自定义的login请求
<a class="item" th:href="@{/toLogin}">
<i class="address card icon"></i> 登录
</a>
登录时需要将这些信息发送到哪里，也需要自己配置。
可以在login.html 配置提交请求及方式，方式必须为post
<div class="ui form">
<form th:action="@{/login}" method="post">
<div class="field">
<label>Username</label>
<div class="ui left icon input">
<input type="text" placeholder="Username" name="username">
<i class="user icon"></i>
</div>
</div>
<div class="field">
<label>Password</label>
<div class="ui left icon input">
<input type="password" name="password">
<i class="lock icon"></i>
</div>
</div>
<input type="submit" class="ui blue submit button"/>
</form>
</div>
请求提交后，还需要验证。可以查看formLogin()方法的源码。
配置接收登录的用户名和密码的参数
http.formLogin()
.usernameParameter("username")
.passwordParameter("password")
.loginPage("/toLogin")
.loginProcessingUrl("/login"); // 登陆表单提交请求
在登录页中增加记住我的多选框
<input type="checkbox" name="remember"> 记住我
后端验证处理
//定制记住我的参数！
http.rememberMe().rememberMeParameter("remember");
测试
SecurityConfig完整代码
@EnableWebSecurity //开启WebSecurity模式
public class SecurityConfig extends WebSecurityConfigurerAdapter {
//定制请求的授权规则
@Override
protected void configure(HttpSecurity http) throws Exception{
http.formLogin()
.usernameParameter("username")
.passwordParameter("password")
.loginPage("/toLogin")
.loginProcessingUrl("/login"); // 登陆表单提交请求
//首页允许所有人访问
http.authorizeRequests()
.antMatchers("/").permitAll()
.antMatchers("/level1/**").hasRole("vip1")
.antMatchers("/level2/**").hasRole("vip2")
.antMatchers("/level3/**").hasRole("vip3");
http.logout().logoutSuccessUrl("/");
http.rememberMe().rememberMeParameter("remember");
}
//定义认证规则
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
//Spring security 5.0中新增了多种加密方式，也改变了密码的格式。
//将前端传过来的密码进行某种方式加密
//spring security 官方推荐的是使用bcrypt加密方式。
auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder())
.withUser("alice").password(new BCryptPasswordEncoder().encode("123456")).roles("vip2","vip3")
.and()
.withUser("root").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1","vip2","vip3")
.and()
.withUser("guest").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1","vip2");
}
}
8.2 Shiro
官网：https://shiro.apache.org/
github地址：https://github.com/apache/shiro
Shiro是一个Apache的java安全框架(是个maven项目)，可以实现认证、授权、加密、会话管理、web集成、缓存等功能。
8.2.0 Shiro外部架构
subject: 代码的直接交互对象，即Shiro的对外API的核心是Subject类。Subject代表当前用户，与当前应用交互的任何要素都可以是Subject类，如网络爬虫，机器人等，与Subject类的所有交互都会委托给SecurityManager执行。SecurityManager: 安全管理器，所有安全相关的操作都会与SecurityManager交互，并且它管理着所有的Subject，是shiro的核心。它负责与Shiro的其他组件进行交互，相当于SpringMVC的DispatcherServletRealm: shiro通过Realm获取安全数据(用户、角色、权限)，SecurityManager负责验证用户身份，而验证对象需要通过Realm获取，用来判定当前输入的用户身份是否合法。另外，也需要通过Realm得到用户相应的角色、权限，来验证用户的操作是否能够执行。Realm类似于DataSource。
8.2.1 使用例
新建maven项目。
下载官方源码，将源码的\samples\quickstart文件内容复制到项目中。
依赖
<dependencies>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.9.0</version>
</dependency>
<!-- configure logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.7.21</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j-impl</artifactId>
<version>2.17.2</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>
main/java和main/resources下的内容复制源码即可
QuickStart源码
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);
// 获取当前的用户对象
Subject currentUser = SecurityUtils.getSubject();
// 通过当前用户获取session
Session session = currentUser.getSession();
session.setAttribute("someKey", "aValue");
String value = (String) session.getAttribute("someKey");
if (value.equals("aValue")) {
log.info("Retrieved the correct value! [" + value + "]");
}
// 判断当前用户是否通过认证
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.");
}
//检测权限(粗粒度)
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.");
}
//检测权限(细粒度)
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);
}
}
源码中会有一个shiro.ini文件，需要预先下载相关的插件
配置/resources/log4j.properties
log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %n %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 verbase logging
log4j.logger.org.apache.shiro.util.ThreadContext=WARN
log4j.logger.org.apache.shiro.cache.ehcache.EhCache=WARN
启动测试
8.2.2 springboot整合shiro
新建springboot项目，添加web、thymeleaf模块
新建\template\index.html首页
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>首页</h1>
<p th:text="${msg}"></p>
</body>
</html>
创建controller.MyController
@Controller
public class MyController {
@RequestMapping({"/","/index"})
public String toIndex(Model model){
model.addAttribute("msg","hello,Shiro");
return "index";
}
}
至此，初步搭建结束。
导入依赖
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring-boot-web-starter</artifactId>
</dependency>
编写config.UserRealm
//自定义UserRealm
public class UserRealm extends AuthorizingRealm {
//授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
System.out.println("执行了=>授权doGetAuthorizationInfo");
return null;
}
//认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
System.out.println("执行了=>授权doGetAuthenticationInfo");
return null;
}
}
编写配置类config.ShiroConfig
@Configuration
public class ShiroConfig {
// ShiroFilterFactoryBean
@Bean
public ShiroFilterFactoryBean getShiroFilterFactoryBean(
@Qualifier("defaultWebSecurityManager") DefaultWebSecurityManager securityManager){
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
//设置安全管理器
bean.setSecurityManager(securityManager);
return bean;
}
// DefaultWebSecurityManager
@Bean(name="defaultWebSecurityManager")
public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("userRealm") UserRealm userRealm){
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
//关联UserRealm
securityManager.setRealm(userRealm);
return securityManager;
}
// 创建realm对象
@Bean(name="userRealm")
public UserRealm userRealm(){
return new UserRealm();
}
}
新建前端页面templates/user/add.html和templates/user/update.html用于测试。
在MyController中添加相关方法
@RequestMapping("user/add")
public String add(){
return "user/add";
}
@RequestMapping("user/update")
public String update(){
return "user/update";
}
在index.html中添加相关跳转链接
<a th:href="@{/user/add}">add</a>
<a th:href="@{/user/update}">update</a>
实现登录拦截
修改ShiroConfig的内容
@Configuration
public class ShiroConfig {
// ShiroFilterFactoryBean
@Bean(name="shiroFilterFactoryBean")
public ShiroFilterFactoryBean getShiroFilterFactoryBean(
@Qualifier("defaultWebSecurityManager") DefaultWebSecurityManager securityManager){
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
//设置安全管理器
bean.setSecurityManager(securityManager);
//添加shiro的内容过滤器
/*
anon:无需认证就能访问
authc:必须认证才能访问
user:必须拥有 记住我功能 才能使用
perms:拥有对某个资源的权限才能访问
role:拥有某个角色的权限才能访问
*/
Map<String,String> filterMap=new LinkedHashMap<>();
filterMap.put("/user/add","authc");
filterMap.put("/user/update","authc");
bean.setFilterChainDefinitionMap(filterMap);
return bean;
}
//......
}
编写一个登录页面templates/login.html
<form th:action="@{/login}">
<p>用户名: <input type="text" name="username"></p>
<p>密码: <input type="text" name="password"></p>
<p><input type="submit"></p>
</form>
在MyController中添加相关方法
@RequestMapping("/toLogin")
public String toLogin() {
return "login";
}
在ShiroConfig的getShiroFilterFactoryBean()方法中设置登录的请求
@Bean(name="shiroFilterFactoryBean")
public ShiroFilterFactoryBean getShiroFilterFactoryBean(
@Qualifier("defaultWebSecurityManager") DefaultWebSecurityManager securityManager){
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
bean.setSecurityManager(securityManager);
Map<String,String> filterMap=new LinkedHashMap<>();
filterMap.put("/user/add","authc");
filterMap.put("/user/update","authc");
bean.setFilterChainDefinitionMap(filterMap);
//设置登录请求
bean.setLoginUrl("/toLogin");
return bean;
}
实现用户认证
在MyController中添加登录请求相关方法
@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";
}
}
修改login.html中的内容
<p th:text="${msg}" style="color:red"></p>
<form th:action="@{/login}">
<p>用户名: <input type="text" name="username"></p>
<p>密码: <input type="text" name="password"></p>
<p><input type="submit"></p>
</form>
在UserRealm中修改认证方法
//认证
@Override
protected 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; //用户名错误
}
//密码认证
return new SimpleAuthenticationInfo("",password,"");
}
整合Mybatis
导入依赖
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.12</version>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.3</version>
</dependency>
编写application.yml，进行如下配置
spring:
datasource:
username: root
password: 密码
url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
driver-class-name: com.mysql.cj.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource # 自定义数据源
#以下属性Spring Boot 默认不注入，需要自己配置
#druid 数据源专有配置
initialSize: 5 #连接池初始化大小
minIdle: 5 #最小连接池数量
maxActive: 20 #最大连接数
maxWait: 60000 #最大等待时间
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: SELECT 1 FROM DUAL
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
poolPreparedStatements: true
#配置监控统计拦截的filters。stat:监控统计、log4j：日志记录、wall：防御sql注入
#如果允许时报错 java.lang.ClassNotFoundException: org.apache.log4j.Priority
#则导入 log4j 依赖即可
filters: stat,wall,log4j
maxPoolPreparedStatementPerConnectionSize: 20
useGlobalDataSourceStat: true
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
在application.properties中配置mybatis相关选项
mybatis.type-aliases-package=com.infinite.shirosptingboot.pojo
mybatis.mapper-locations=classpath:mapper/*.xml
编写实体类pojo.User
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
private int id;
private String name;
private String pwd;
}
(下面的内容和7.3差不多)
编写mapper.UserMapper
@Repository
@Mapper
public interface UserMapper {
public User queryUserByName(String name);
}
编写resorces/mapper/UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.infinite.shirospringboot.mapper.UserMapper">
<select id="queryUserByName" parameterType="String" resultType="User">
select * from mybatis.user where name=#{name}
</select>
</mapper>
编写service.UserService接口
public interface UserService {
public User queryUserByName(String name);
}
实现这个接口
@Service
public class UserServiceImpl implements UserService{
@Autowired
UserMapper userMapper;
@Override
public User queryUserByName(String name) {
return userMapper.queryUserByName(name);
}
}
修改UserRealm的内容，使其连接数据库
//自定义UserRealm
public class UserRealm extends AuthorizingRealm {
@Autowired
UserService userService;
//授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
System.out.println("执行了=>授权doGetAuthorizationInfo");
return null;
}
//认证
@Override
protected 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; //UnknownAccountException
}
//密码认证
return new SimpleAuthenticationInfo("",user.getPwd(),"");
}
}
请求授权实现
(user表中增加了权限字段)
需求：如果没有进入一个网页的相关权限时，自动跳转到未授权提示页
在MyController中添加未授权时跳转的方法
@RequestMapping("/noauth")
@ResponseBody
public String unauthorized(){
return "未经授权无法访问此页面";
}
修改ShiroConfig中的内容
//修改前
filterMap.put("/user/add","authc");
filterMap.put("/user/update","authc");
//修改后
// 授权。没有权限会返回401
filterMap.put("/user/add","perms[user:add]");
filterMap.put("/user/update","perms[user:update]");
filterMap.put("/user/*","authc");
//增加未授权页面跳转语句
bean.setUnauthorizedUrl("/noauth");
修改UserRealm中的授权方法
//自定义UserRealm
public class UserRealm extends AuthorizingRealm {
@Autowired
UserService userService;
//授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
System.out.println("执行了=>授权doGetAuthorizationInfo");
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
info.addStringPermission("user:add"); //添加权限
//获取当前登录的用户对象
Subject subject= SecurityUtils.getSubject();
User currentUser = (User)subject.getPrincipal();
//设置当前用户的权限
info.addStringPermission(currentUser.getPerms());
return info;
}
//认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
//......
//密码认证。 这里第一个参数会修改
return new SimpleAuthenticationInfo(user,user.getPwd(),"");
}
}
整合thymeleaf
需求：登录后只显示可以进入的链接
导入依赖
<dependency>
<groupId>com.github.theborakompanioni</groupId>
<artifactId>thymeleaf-extras-shiro</artifactId>
<version>2.1.0</version>
</dependency>
在ShiroConfig中添加整合thymeleaf相关的方法
//整合shiro和thymeleaf
@Bean
public ShiroDialect getShiroDialect(){
return new ShiroDialect();
}
修改index.html内容
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org"
xmlns:shiro="http://www.thymeleaf.org/thymeleaf-extras-shiro">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>首页</h1>
<p th:text="${msg}"></p>
<hr>
<p>
<a th:href="@{/toLogin}">登录</a>
</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>
测试
下面配置一下session
修改UserRealm中的认证方法
//认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
System.out.println("执行了=>授权doGetAuthenticationInfo");
//从数据库获取信息
//......
Subject currentSubject = SecurityUtils.getSubject();
Session session = currentSubject.getSession();
session.setAttribute("loginUser",user);
//密码认证
return new SimpleAuthenticationInfo(user,user.getPwd(),"");
}
修改index.html中的登录链接
<div th:if="session.loginUser==null">
<a th:href="@{/toLogin}">登录</a>
</div>
<div th:if="session.loginUser!=null">
<p th:text="${user.getUsername()}"></p>
</div>
MyController的login()方法中，在try-catch的登录成功部分添加model.addAttribute("user",token);以向前端传输数据。
9、Swagger
前后端分离
后端时代：前端只用管理静态页面：html。 后端使用模板引擎，如jsp(主要部分)
前后端分离时代：
- 后端：后端控制层，服务层，数据访问层
- 前端：前端控制层，视图层
- 前后端未合并前，前端可以伪造后端数据，即json，测试时不用后端也能运行
前后端通过API、json交互。
前后端可以部署到不同的服务器上。
缺点：两个部分的人比较难做到及时协商。
解决方案：
- 先制定schema(提纲)，实时更新最新的API，降低集成的风险
- 前端测试后端接口：postman
- 后端提供接口，需要实时更新相关消息
Swagger：
- 目前比较流行的API框架
- RestFul API文档在线自动生成工具。API文档与API定义同步更新
- 可以在线测试API接口
- 支持多种程序语言（java、php…）
https://swagger.io/
在项目中使用swagger需要用到springfox
- swagger2
- ui
9.1 springboor集成Swagger
新建springboot项目
导入依赖
<!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>3.9.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.9.2</version>
</dependency>
编写一个hello测试(HelloController)springboot程序(代码不再写出)
配置swagger，创建config.SwaggerConfig
@Configuration
@EnableSwagger2 //开启swagger2
public class SwaggerConfig {
}
测试时可能因为空指针问题不能启动，可以在pom文件中将springboot改成2.5.1版本
不要使用3+版本的swagger，此版本下的swagger-ui源码下没有swagger-ui.html，导致后面测试时的查询路径返回404
测试，访问localhost:8080/swagger-ui.html
9.2 配置swagger
完善SwaggerConfig的内容
@Configuration
@EnableSwagger2 //开启swagger2
public class SwaggerConfig {
// 配置了Swagger的Docket的bean实例
@Bean
public Docket docket(){
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo());
}
//配置Swagger的信息
private ApiInfo apiInfo(){
//作者信息
Contact contact = new Contact("infinite", "http://xxx.com", "123456@qq.com");
return new ApiInfo(
"自建SwaggerAPI文档",
"This is a description",
"va.b",
"http://xxx.com",
contact,
"Apache2.0",
"http://www.apache.org/lisence/LISENCE-2.0",
new ArrayList()
);
}
}
Docket源码中有一个DocumentationType，进入这个类的源码可以了解具体定义，常量SWAGGER_2就写在其中
9.3 Swagger配置扫描接口
完善docket()方法
// 配置了Swagger的Docket的bean实例
@Bean
public Docket docket(){
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.select()
//RequestHandlerSelectors:配置要扫描接口的方式
//basePackage:指定要扫描的包
//any():全部扫描
//none(): 不扫描
//withClassAnnotation(): 扫描类上的注解，参数是一个注解的反射对象
//withMethodAnnotation:扫描方法上的注解
.apis(RequestHandlerSelectors.basePackage("com.infinite/springbootswagger.controller"))
//paths():扫描指定路径
.paths(PathSelectors.ant("/xxx/**"))
.build();
}
另外，可以在apiInfo()方法后面跟一个enable()方法来设置swagger是否启动。在多配置环境下(如测试版本、发行版本)可以使用。
// 配置了Swagger的Docket的bean实例
@Bean
public Docket docket(){
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.enable(false) //不启动swagger
.select()
.apis(RequestHandlerSelectors.basePackage("com.infinite/springbootswagger.controller"))
.build();
}
下面要设置多种配置环境
新建application-dev.properties代表测试环境
新建application-pro.properties代表发布环境
在application.properties中设置spring.profiles.active=dev来指向测试环境的配置文件
再次修改docket()方法
@Bean
public Docket docket(Environment environment){
//设置要显示的Swagger环境
Profiles profiles = Profiles.of("dev","test");
//通过environment.acceptsProfiles()判断当前是否在自己设定的环境中
boolean flag = environment.acceptsProfiles(profiles);
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.enable(flag)
.select()
.apis(RequestHandlerSelectors.basePackage("com.infinite/springbootswagger.controller"))
.build();
}
9.4 API文档的分组和接口注释
在docket()中的apiInfo()方法后跟一个groupName(分组名)方法以设置一个分组
配置多个Docket对象即可实现设置多个分组
@Configuration
@EnableSwagger2 //开启swagger2
public class SwaggerConfig {
@Bean
public Docket docket1(){
return new Docket(DocumentationType.SWAGGER_2).groupName("A");
}
@Bean
public Docket docket2(){
return new Docket(DocumentationType.SWAGGER_2).groupName("B");
}
@Bean
public Docket docket3(){
return new Docket(DocumentationType.SWAGGER_2).groupName("C");
}
//......
}
编写实体类pojo.User
@ApiModel("用户实体类") //swagger-ui.html会给出相关提示
public class User {
@ApiModelProperty("用户名") //swagger-ui.html会给出相关提示
public String username;
@ApiModelProperty("密码")
public String password;
}
在HelloController中调用这个实体类
@RestController
public class HelloController {
@RequestMapping(value="/hello")
public String hello(){
return "hello";
}
//返回值若存在实体类，它就会被扫描到swagger中
@PostMapping(value="/user")
public User user(){
return new User();
}
}
另外，在controller类的头上添加@ApiOperation("注释")可以呈现同样的注释效果
@RestController
public class HelloController {
//......
@ApiOperation("Hello控制类")
@GetMapping(value="/hello2")
public String hello2(String username){
return "hello, "+username;
}
}
小结
- 可以通过Swagger给一些比较难理解的属性或接口，增加注释信息易于阅读
- 接口文档实时更新
- 在线测试接口
- 项目发行前要关闭swagger
10、任务
10.1 异步任务
新建springboot项目，导入web模块
新建service.AsyncService
@Service
public class AsyncService {
public void hello(){
try{
Thread.sleep(3000);
}
catch(InterruptedException e){
e.printStackTrace();
}
System.out.println("数据正在处理......");
}
}
新建controller.AsyncController
@RestController
public class AsyncController {
@Autowired
AsyncService asyncService;
@RequestMapping("/hello")
public String hello(){
asyncService.hello(); //停3秒
return "OK";
}
}
到这一步，测试时若输入相关请求，浏览器会加载3秒后才跳转到相关页面，用户体验较差。
下面要实现加载和跳转两件事一同执行(即所谓的异步任务)，可以利用@Async注解
@Service
public class AsyncService {
@Async //告诉spring这是一个异步的方法
public void hello(){
try{
Thread.sleep(3000);
}
catch(InterruptedException e){
e.printStackTrace();
}
System.out.println("数据正在处理......");
}
}
还要在主程序类上添加@EnableAsync以开启异步任务功能
10.2 邮件任务
导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
</dependency>
相关的自动配置类MailSenderAutoConfiguration，配置类MailProperties
完善配置文件application.properties
spring.mail.username=邮箱
spring.mail.password=密码 #qq邮箱可以通过手机短信获取另一种更安全的口令
spring.mail.host=smtp.qq.com
# 开启加密验证
spring.mail.properties.mail.smtp.ssl.enable=true
发送一个简单邮件
@SpringBootTest
class SpringbootMailTest(){
@Autowired
JavaMailSenderImpl mailSender;
@Test
void contextLoads1(){
//一个简单的邮件
SimpleMailMessage mailMessage=new SimpleMailMessage();
mailMessage.setSubject("This is a title");
mailMessage.setText("xxxxxxxxxxxxxxxxxxxx");
mailMessage.setFrom("发送方邮箱");
mailMessage.setTo("接受方邮箱");
mailSender.send(mailMessage);
}
@Test
void contextLoads2(){
//一个复杂的邮件
MimeMailMessage mimeMessage = mailSender.createMimeMessage();
//组装
MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
helper.setSubject("This is a mime title");
helper.setText("<p style='color:red'>xxxxxxxxxxxxxxxxxxxx</p>",true);
//附件
helper.addAttachment("1.jpg",new File("file1"));
helper.addAttachment("2.jpg",new File("file2"));
mailMessage.setFrom("发送方邮箱");
mailMessage.setTo("接受方邮箱");
mailSender.send(mimeMessage);
}
}
10.3 定时任务
相关的接口TaskExecutor（执行任务）、TaskScheduler(调度任务)
给主启动类添加@EnableScheduling以开启定时任务功能
创建一个类service.ScheduledService
@Service
public class ScheduledService {
//在一个特定的时间内执行这个方法
//cron 表达式
// 秒 分 时 日 月 周几
/* 例
30 15 10 * * ? 每天10:15:30 执行一次
30 0/5 10,18 * * ? 每天10点和18点，每歌5分钟执行一次
0 15 10 ? * 1-6 每个月的周一到周六的10:15执行一次
*/
@Scheduled(cron="0/2 * * * * ?") //每2秒执行一次
public void hello(){
System.out.println("hello ,schedule test");
}
}
11、Redis
https://spring.io/projects/spring-data-redis
新建一个springboot项目，导入lombok、springbootdevtools、springConfigurationProcessor、springWeb这几个基础依赖，再导入一个SpringDataRedis(Access+Driver)依赖
注：springboot2.x后，原本使用的jedis被替换成了lettuce
jedis：采用直连方式，多线程操作的情况下不安全，若要避免，需要用到jedis pool连接池。更像BIO模式
lettuce：采用netty，实例可以在多个线程中进行共享，不存在线程不安全的情况，可以减少线程数据。更像NIO模式
源码
相关自动配置类RedisAutoConfiguration、配置类RedisProperties
@Configuration(
proxyBeanMethods = false
)
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
public RedisAutoConfiguration() {
}
@Bean
@ConditionalOnMissingBean(
name = {"redisTemplate"}
) //若自己实现了一个redisTemplate，则可以替换掉这个默认的模板
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
//默认的RedisTemplate没有过多的设置，redis对象都需要序列化
//两个类型都是object，后续使用时需要用到强制转换
RedisTemplate<Object, Object> template = new RedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
return new StringRedisTemplate(redisConnectionFactory);
}
}
11.1 使用例
依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
完善配置文件内容
#配置redis
spring.redis.host=127.0.0.1
spring.redis.port=6379
编写一个测试类
@SpringBootTest
class Springboot08RedisApplicationTests {
@Autowired
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
//redisTemplate 可以操作不同的数据类型
//opsForValue 操作字符串
//opsForList 操作list
//其他redis中的数据类型同理
//除了基本操作，还可以执行事务和基本的CRUD
// 获取redis的连接对象(不常用)
//RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//connection.flushDb();
//connection.flushAll();
redisTemplate.opsForValue().set("myKey","infinite");
System.out.println(redisTemplate.opsForValue().get("myKey"));
}
}
注：本地要先开启redis服务
11.2 自定义RedisTemplate
进入RedisTemplate源码，会发现有几个RedisSerializer属性，这些属性是RedisTemplate的序列化配置
public void afterPropertiesSet() {
super.afterPropertiesSet();
boolean defaultUsed = false;
if (this.defaultSerializer == null) {
// JdkSerializationRedisSerializer 表示默认选择jdk序列化
this.defaultSerializer = new JdkSerializationRedisSerializer(this.classLoader != null ? this.classLoader : this.getClass().getClassLoader());
}
//......
}
假如要实现用json序列化，可以自己实现一个RedisTemplate，内部具体实现可以参考RedisAutoConfiguration的源码
创建config.RedisConfig
@Configuration
public class RedisConfig {
@Bean
@ConditionalOnMissingBean(
name = {"redisTemplate"}
)
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
}
编写实体类pojo.User
@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class User {
private String name;
private int age;
}
编写测试方法
@Test
public void test() throws JsonProcessingException {
User user=new User("infinite",20);
//进行json序列化,redis中存入json字符串。推荐使用json传输数据
String jsonUser = new ObjectMapper().writeValueAsString(user);
redisTemplate.opsForValue().set("user",jsonUser);
System.out.println(redisTemplate.opsForValue().get("user"));
}
假如想要在redis中直接存入对象，则要将对象序列化，即User类要实现Serializable接口。
需求：自定义一个序列化方式
修改RedisConfig代码
//固定模板，完成后就不用再改动了
@Configuration
public class RedisConfig {
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
//为了开发使用方便，一般直接使用<String,Object>
RedisTemplate<String, Object> template = new RedisTemplate<String,Object>();
template.setConnectionFactory(factory);
//Json序列化配置
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
//String的序列化
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
//key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
//hash的key采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
//value采用jackson序列化方式
template.setValueSerializer(jackson2JsonRedisSerializer);
//hash的value采用jackson的序列化方式
template.setHashValueSerializer(jackson2JsonRedisSerializer);
return template;
}
}
为了防止命名冲突，测试类中的redisTemplate需要通过@Qualifier()注解进行标识
@Autowired
@Qualifier("redisTemplate")
private RedisTemplate<String,Object> redisTemplate;
实际开发中，为了提高代码复用性，可以将项目中redis的常见操作进行抽象集成，整合到自定义的RedisUtil工具类中(和之前写jdbc、mybatis同理)。哪个类需要redis操作时，通过@Autowired装配这个工具类即可
12、分布式(待完善)
分布式系统的定义：分布式系统时若干独立计算机的集合，这些计算机对于用户来说就像单个系统。
分布式系统中的计算机之间通过网络进行通信，目的是利用更多的机器，处理更多的数据
著有当单个结点的处理能力无法满足日益增长的计算、存储任务，且硬件提升的成本高、应用程序难以进一步优化的时候，才需要考虑分布式系统。
12.1 分布式（待完善）
前置内容
背景
https://dubbo.apache.org/zh/index.html
背景相关的内容可以查看https://dubbo.apache.org/zh/docsv2.7/user/preface/background/
RPC
RPC(Remote Procedure Call):远程过程调用，是一种进程间的通信方式，本质是一种思想而非规范。RPC允许程序调用另一个地址空间(通常是共享网络的另一台机器上)的过程或函数，而不是程序员显式编码这个远程调用的细节，即调用本地和调用远程两种方式的代码基本是相同的。
例：现有两台服务器A、B，一个应用部署在A上，A现在想要调用B服务器上应用提供的函数/方法，由于不再一个内存空间中，A不能直接进行调用，需要通过网络来表达调用的予以和传输调用的数据。
为什么要用到RPC？假设有一个业务，它无法在一个进程内(或一台计算机内)通过本地调用的方式完成，比如不同系统(组织)之间的通讯。由于计算能力需要横向扩展，需要在多台机器组成的集群上部署应用，RPC实现的就是要项调用本地的函数一样去调用远程的函数。
https://www.jianshu.com/p/2accc2840a1b
RPC的两个核心模块：通讯、序列化（方便数据传输）
Dubbo概念
Dubbo是一款高性能、轻量级的开源java RPC框架。它提供了三大核心功能：面向接口的远程方法调用、只能容错和负载均衡、服务自动注册和实现
https://dubbo.apache.org/zh/docs/concepts/service-discovery/
Provider(服务提供者): 向服务提供方暴露服务，服务提供者在启动时，向注册中心注册自己提供的服务。Consumer(服务消费者): 调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务。消费者从提供者的地址列表中，基于软负载均衡算法，选择一台提供者进行调用，如果调用失败就换一台。Registry(注册中心): 返回服务提供者的地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。Monitor(监控中心): 服务消费者和提供者，让内存中累计调用次数和调用时间，每分钟发送一次统计数据到监控中心
zookeeper
充当注册中心的一个开源项目
使用：
-
下载项目压缩包并解压
-
执行
bin/zkServer.cmd，发现闪退。可以在zkServer.cmd添加pause以排错
-
修改
conf/zoo.cfg配置文件(没有的话就复制同目录下的zoo_sample.cfg)，重新以管理员模式运行bin/zkServer.cmd,以及bin.zkCli.cmd
修改zoo.cfg中的dataDir、dataLogDirdataDir=C:\TOOLS\apache-zookeeper-3.8.0\data dataLogDir=C:\TOOLS\apache-zookeeper-3.8.0\log
可能出现的问题
1.ZooKeeper audit is disabled 修改zkServer.cmd ，call %JAVA%中添加
"-Dzookeeper.audit.enable=true"
客户端下测试
ls /：列出zookeeper根下保存的所有节点
create -e /indinite : 创建一个节点，后面如果跟一个值可以设置存放的内容
get /infinite: 获取/infinite节点的信息
安装dubbo-admin
这是一个springboot项目，作为监控管理后台，查看注册了哪些服务
去github上下载源码并解压
进入项目，解压lib中的jar包，修改dubbo-admin\src\main\resources\application.properties文件中指定的zookeeper地址(默认为本地)
dubbo.registry.address=zookeeper://127.0.0.1:2181
打包项目
C:\TOOLS\dubbo-admin-0.2.0>mvn clean package -D maven.test.skip=true
可能会打包失败，可以参考https://blog.csdn.net/qq_43612538/article/details/103548650
最终打包成dubbo-admin-0.0.1-SNAPSHOT.jar
先启动zookeeper的service端，再启动这个的jar包
12.2 分布式Dubbo+Zookeeper+SpringBoot
新建一个空项目
新建一个provider-server模块(spring)，进入这个模块，端口配置为server.port=8001
新建接口service.TicketService
public interface TicketService {
public String getTicket();
}
实现接口
public class TicketServiceImpl implements TicketService{
@Override
public String getTicket(){
return "infinite";
}
}
新建一个consumer-server模块(spring)，进入这个模块，端口配置为server.port=8002
创建service.UserService类
导入依赖(两个模块分别导入)
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
<version>3.0.7</version>
</dependency>
<dependency>
<groupId>com.github.sgroschupf</groupId>
<artifactId>zkclient</artifactId>
<version>0.1</version>
</dependency>
<!--引入zookeeper-->
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-framework</artifactId>
<version>4.0.1</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-recipes</artifactId>
<version>4.0.1</version>
</dependency>
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.4.13</version>
<!--排除slf4j-log4j12-->
<exclusions>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</exclusion>
</exclusions>
</dependency>
完善provider-server的配置文件
server.port=8001
#服务应用名
dubbo.application.name=provider-server
#注册中心地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
#哪些服务需要注册
dubbo.scan.base-packages=com.infinite.service
给TicketServiceImpl添加dubbo的@DubboService注解，启动时可以被扫描到并注册
@DubboService
public class TicketServiceImpl implements TicketService{
@Override
public String getTicket(){
return "infinite";
}
}
给主启动类添加@EnableDubbo注解
启动zookeeper的服务端，再启动provider-server，测试是否注册成功
完善consumer-server的配置
server.port=8002
# 消费者去哪里拿服务。需要暴露自己的名字
dubbo.application.name=consumer-server
# 注册中心的地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
在service目录下复制一份provider-server的TicketService接口。
完善UserService
@DubboService
public class UserService {
@DubboReference //引用，获取provider-server提供的类
TicketService ticketService; //同目录下复制了同一份接口，用于引用
public void butTicket(){
String ticket=ticketService.getTicket();
System.out.println("在注册中心拿到==>"+ticket);
}
}
编写测试
步骤
前提：开启zookeeper服务
- 提供者提供服务
- 导入依赖
- 配置注册中心的地址，以及服务发现名、要扫描的包
- 在想要被注册的服务上，增加一个注解
@DubboService
- 消费者如何消费
- 导入依赖
- 配置注册中心的地址，配置自己的服务名
- 从远程注入服务
@DubboReference
新建一个provider-server模块(spring)，进入这个模块，端口配置为server.port=8001
新建接口service.TicketService
public interface TicketService {
public String getTicket();
}
实现接口
public class TicketServiceImpl implements TicketService{
@Override
public String getTicket(){
return "infinite";
}
}
新建一个consumer-server模块(spring)，进入这个模块，端口配置为server.port=8002
创建service.UserService类
导入依赖(两个模块分别导入)
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
<version>3.0.7</version>
</dependency>
<dependency>
<groupId>com.github.sgroschupf</groupId>
<artifactId>zkclient</artifactId>
<version>0.1</version>
</dependency>
<!--引入zookeeper-->
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-framework</artifactId>
<version>4.0.1</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-recipes</artifactId>
<version>4.0.1</version>
</dependency>
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.4.13</version>
<!--排除slf4j-log4j12-->
<exclusions>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</exclusion>
</exclusions>
</dependency>
完善provider-server的配置文件
server.port=8001
#服务应用名
dubbo.application.name=provider-server
#注册中心地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
#哪些服务需要注册
dubbo.scan.base-packages=com.infinite.service
给TicketServiceImpl添加dubbo的@DubboService注解，启动时可以被扫描到并注册
@DubboService
public class TicketServiceImpl implements TicketService{
@Override
public String getTicket(){
return "infinite";
}
}
给主启动类添加@EnableDubbo注解
启动zookeeper的服务端，再启动provider-server，测试是否注册成功
完善consumer-server的配置
server.port=8002
# 消费者去哪里拿服务。需要暴露自己的名字
dubbo.application.name=consumer-server
# 注册中心的地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
在service目录下复制一份provider-server的TicketService接口。
完善UserService
@DubboService
public class UserService {
@DubboReference //引用，获取provider-server提供的类
TicketService ticketService; //同目录下复制了同一份接口，用于引用
public void butTicket(){
String ticket=ticketService.getTicket();
System.out.println("在注册中心拿到==>"+ticket);
}
}
编写测试
步骤
前提：开启zookeeper服务
- 提供者提供服务
- 导入依赖
- 配置注册中心的地址，以及服务发现名、要扫描的包
- 在想要被注册的服务上，增加一个注解
@DubboService
- 消费者如何消费
- 导入依赖
- 配置注册中心的地址，配置自己的服务名
- 从远程注入服务
@DubboReference
404
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
