Spring Boot 学习

springboot

前言

发展历程：servlet——>struts——>springmvc——>springboot——>服务网格

约定大于配置

程序 = 数据结构 + 算法;

springboot：自动装配，开箱即用

all in one : 将一个应用中的应用服务都装在一个应用中，如ERP

微服务架构：把每个功能元素独立出来，需要哪个功能元素，把独立出来的功能元素动态组合

学习方法：碎片化学习

看源码

看官方文档

1：第一个springboot程序

1.1：步骤

1：用spring Initializr 创建项目

2：Group：com.kuang Artifact :项目名 Package：创建包

3：添加spring web 依赖

4：运行测试

1.2：新知识

1：新建包一定要在主程序的同级目录下

2：https://www.bootschool.net/ascii 修改banner图案

1.3：原理

pom.xml

• 在springboot项目中导入依赖不需要指定版本，因为在父工程org.springframework.boot中已经指定

• spring-boot-starter-xxx 是springboot的场景启动器；

• spring-boot-starter-web 帮我们导入了web模块正常运行所依赖的所有组件

• springboot把所有的功能场景都抽取出来，做成一个个starter启动器，我们需要什么样的功能导入响应的启动器即可

主程序

@springBootApplication

• @SpringBootApplication 标注是一个springboot的主配置类，springboot就该运行这个类下的main方法来启动springroot应用
• SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值
• 将这些值作为自动配置类导入容器 ， 自动配置类就生效 ， 帮我们进行自动配置工作；
• 整个J2EE的整体解决方案和自动配置都在springboot-autoconfigure的jar包中；
• 它会给容器中导入非常多的自动配置类 （xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件 ， 并配置好这些组件 ；
• 有了自动配置类 ， 免去了我们手动编写配置注入功能组件等的工作；

SpringApplication.run()

• 推断应用的类型是普通的类型还是Web项目
• 查看并加载所有可用初始化器，设置到initializers属性中
• 找出所有应用程序监听器，设置到listeners属性中
• 推断并设置main方法的定义类，找到运行的主类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W8Oz5BSO-1604802175079)(C:\Users\Justin Boy\Desktop\微信图片_20201018142939.jpg)]

配置文件

springboot官方推荐使用yaml配置

2：yaml

2.1：语法

1：yaml对空格的要求特别高

2：yaml用缩进来控制层级关系

3：yaml的语法

k: v             #:后面一定要加上一个空格

#yaml的对象，map形式
k: 
	a: 
	b: 
k: {
     a: v,b: v}

#yaml的数组形式
k: 
	-a
	-b
k: [a,b]

4：yaml可以给我们的实体类直接注入值

2.2：新知识

1：yaml的支持包

<dependency>
    <groupId>org.yamlgroupId>
    <artifactId>snakeyamlartifactId>
dependency>

2：@ConfigurationProperties(prefix = “”) 可以给实体类的属性绑定yaml配置文件里的注入值

3：springboot导入配置文件处理器的依赖

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-configuration-processorartifactId>
    <optional>trueoptional>
dependency>

4：@PropertiesSource：加载加载指定的配置文件

5：yaml文件占位符：${}

6：spring常用注解

• @Component pojo层注册bean
• @Repository Dao层注册bean
• @Service service层注册bean
• @Controller controller层注册bean
• @AutoWired 依赖注入
• @Resource 依赖注入
• @Qualifier 按指定bean的实例名称装配

7：@Value properties文件给pojo类注入值

8：松散绑定：yaml文件里的属性名为 last-name pojo类属性名可以是lastName (驼峰命名)

2.3：JSR303数据效验

1：可以验证用户输入的值是否具有合法性

2：用法：在类上加注释@Validated 在属性上加上相应的注释即可

2.4：多环境切换

properties

1：新建多个文件，用来指定多个环境版本

application-dev.properties 代表开发环境配置

application-test.properties 代表测试环境配置

2：然后通过spring.profiles.active=dev选择激活那种环境

yaml

1：不用建立多个文件，在同一个文件里可以用—来表示多个环境

server:
	port: 8080
spring:
	profiles:
	active: test             #通过spring.profiles.active来指定激活那种环境

---
server:
	port:8081
spring:
	profiles: dev             #通过spring.profiles来指定环境名称
	
---
server:
	port:8082
spring:
	profiles: test

2：如果没有指定激活环境，默认8080

2.5：配置文件加载优先级

1：外部配置文件的优先级更高

2：默认的配置文件加载位置的优先级是最低的

3：优先级高的配置文件会覆盖低的

3：自动装配原理

3.1：底层原理

• springboot启动会加载大量的自动配置类–spring.factories
• 看看默认的自动配置类spring.factories中有没有我们想要的功能
• 看看这个自动配置类配置了那些组件（只要我们要用的组件在其中，我们就不需要手动配置了）
• 给容器中自动配置类添加组件的时候，会从Properties类中获取某些属性，我们只需要在配置文件中指定这些属性的值即可
• xxxAutoConfiguration：自动配置类，给容器添加组件
• xxxProperties：封装了application.yaml中能配置的所有属性
• spring.factories 所有的自动装配文件集合

3.2：@Conditional

自动配置类必须满足一定条件才能生效，由@Conditional来指定条件（spring底层注解）

根据不同的条件进行判断，决定这个配置类是否生效

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iTxIINip-1604802175087)(C:\Users\Justin Boy\Desktop\微信图片_20201019113755.jpg)]

3.3：debug = true

配置文件中编写debug = true可以知道那些自动装配类生效了

• Positive matches:（生效的）

• Negative matches:（失效的，没有匹配成功的自动配置类）

• Unconditional classes: （没有条件的类）

3.4：路径

在配置文件中指定属性的值——>@Conditional根据条件判断——>满足条件，自动配置类生效(xxxAutoConfiguration)——>配置类给loc容器中添加各种组件——>组件的属性是从对应的properties中获取

• 一但这个配置类生效；这个配置类就会给容器中添加各种组件；
• 这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的；
• 所有在配置文件中能配置的属性都是在xxxxProperties类中封装着；
• 配置文件能配置什么就可以参照某个功能对应的这个属性类

4：springboot web开发

4.1：静态资源导入

1：webjars --以jar包的形式导入我们的静态资源

• 百度搜webjars，导入依赖
• 运行测试，localhost:8080/warjars/jar包文件路径

2：resources下的 public static resources 和 /** 下的静态资源可以自动扫描

• 优先级 resources>static>public

3：自定义静态资源路径

spring.resources.static-locations=classpath:/

一旦配置后，原来的自动装配就是失效

4.2：首页和图标定制

首页

1：在静态文件夹下新建index.html

2：template文件夹下的所有网页，只能通过controller来跳转

网站图标

1：关闭默认图标

#关闭默认图标
spring.mvc.favicon.enabled=false

2：在public文件夹下新建favicon.ico

3：运行测试，网站图标变成自己的图片

4.3：Thymeleaf模板引擎

使用步骤

1：导入依赖

<dependency>
	<groupId>org.thymeleafgroupId>
	<artifactId>thymeleaf-spring5artifactId>
dependency>
<dependency>
    <groupId>org.thymeleaf.extrasgroupId>
    <artifactId>thymeleaf-extras-java8timeartifactId>
dependency>

2：在template文件夹下新建html文件

3：添加约束

<html lang="en" xmlns:th="http://www.thymeleaf.org">

新知识

1：html文件里的所有元素都可以被thymeleaf替换接管，使用th:元素名

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uEWAasZt-1604802175095)(C:\Users\Justin Boy\Desktop\微信图片_20201019160726.jpg)]

2：语法

Simple expressions:（表达式语法）
  Variable Expressions:${...}
  Selection Variable Expressions: *{...}：选择表达式：和${}在功能上是一样；
  Message Expressions: #{...}：获取国际化内容
  Link URL Expressions: @{...}：定义URL；
  Fragment Expressions: ~{...}：片段引用表达式

Literals（字面量）
      Text literals: 'one text' , 'Another one!' ,…
      Number literals: 0 , 34 , 3.0 , 12.3 ,…
      Boolean literals: true , false
      Null literal: null
      Literal tokens: one , sometext , main ,…
      
Text operations:（文本操作）
    String concatenation: +
    Literal substitutions: |The name is ${name}|
    
Arithmetic operations:（数学运算）
    Binary operators: + , - , * , / , %
    Minus sign (unary operator): -
    
Boolean operations:（布尔运算）
    Binary operators: and , or
    Boolean negation (unary operator): ! , not
    
Comparisons and equality:（比较运算）
    Comparators: > , < , >= , <= ( gt , lt , ge , le )
    Equality operators: == , != ( eq , ne )
    
Conditional operators:条件运算（三元运算符）
    If-then: (if) ? (then)
    If-then-else: (if) ? (then) : (else)
    Default: (value) ?: (defaultvalue)
    
Special tokens:
    No-Operation: _

4.4：扩展springmvc

步骤

1：在类上加上@Configuration,标注是一个配置类，可以使用自定义类扩展mvc的功能

2：实现WebMvcConfigurer接口

3：重写接口里的方法

新知识

1：如果要自己定制一些功能，只要写这个组件，然后将它交给springboot，springboot会帮我们自动装配

2：springboot在实现自动装配组件的时候，会先看容器中有没有用户自己配置的(@Bean)，有就会用自己的，没有就会自动配置

3：配置类上加注解@EnableWebMvc会全面接管springmvc，所有的都得我们自己来配置(不推荐)

4.5：员工管理系统

4.5.1：首页实现

步骤

1：导入静态资源

2：用thymeleaf模板引擎修改导入的html文件

3：springmvc扩展 增加视图控制器addViewController （网址输入/或者/index.xml都会跳转到index的页面）

新知识

1：spring.thymeleaf.cache=false 关闭模板引擎的缓存

4.5.2：国际化

步骤

1：在resources下新建i18n国际化配置文件

2：建立文件login.properties,login_zh_CH.properties,login_en_US.properties，在里面设置需要国际化的值

3：用thymeleaf语法修改html界面

4：配置文件中设置路径：spring.message.basename=i18n.login

5：springmvc扩展 实现接口LocaleResolver，重写里面的方法

6：往spring容器里注入组件

新知识

1：StringUtils用于操作String对象

2：java split 根据给定的正则表达式拆分字符串

3：LocaleResolver接口专门用于国际化（区域解析器） --Locale类

4：国际化用#{} url用@{} 取值用${} 插入替换用~{}

5：themyleaf语法设置网址参数是在()里 --/index(l=‘en_US’)

4.5.3：登录实现

1；return跳转界面实现登录

2：用户名或者密码不正确加上提示信息

3：提示信息不能一直存在，没有写登录名或者密码，提示信息不能存在 ???

4：url映射，登录之后显示用户名和密码会暴露信息，把视图跳转dashboard和url/main.html进行绑定

5：要拦截/main.html请求，防止未登录就可以进主页面，所以需要增加一个拦截器

6：需要在实现WebMvcConfigurer的类中重写addInterceptors方法

4.5.4：展示员工

步骤

1：后端查询所有员工返回给前端

2：提取公共页面，实现代码复用，

3：点击高亮，传递参数进行判断

4：循环遍历出信息并展示

新知识

1：th:fragment=“lala” 复用的代码 th:replace="~{common::lala}" 代替的代码

2：前端传递参数直接在后面用()

3：thymeleaf判断 条件?结果:不满足条件的结果

4：thymeleaf循环遍历 th:each="${单个元素 : 后端传来数组}"

5：thymeleaf日期格式化 ${#dates.format(日期,格式化)}

4.5.5：增加员工

步骤

1：新增一个增加按钮，在controller层写相应的方法

2：新加一个增加页面，添加name属性，要与pojo类属性一一对应

3：下拉框循环遍历，传递值为th:value="${dept.getId()}" name=“department.id”

4：在controller层里写提交的方法

新知识

1：标签里一定要有name属性，必须要和pojo的属性一一对应

报错：Servlet.service() for servlet [dispatcherServlet] in context with path [] th

解决：EmployeeDao类没有加上departmentDao构造方法

教训：找不着bug的时候可以看看文件里灰色的变量

4.5.6：修改员工

步骤

1：为更新按钮添加href

2：新增加一个修改页面，显示要修改的信息

3：controller层添加更新和修改的方法

细节

1：button标签下没有href方法，只有a标签有 href方法button标签里会不生效（bug：点击按钮转不到页面）

2：Dao层添加数据时，id应当一致，否则会查询不出来（遇到问题，前端页面显示不出来）

3：前端传递参数方法

• 传递的参数不需要取值：@{/index(l=‘参数’)}
• 传递的参数需要取值：@{/index}+${update.getId()}

4：th:checked 检查条件来设置属性

5：th:selected 选中显示值

6：隐藏域：type=“hidden”,需要提取上一页中的某些信息，但在上一页中不能显示这些信息

4.5.7：404处理

1：直接在tempaltes文件夹下建error，新建404.html即可

4.5.8：整合mybatis

1：导入依赖

<dependency>
    <groupId>org.mybatis.spring.bootgroupId>
    <artifactId>mybatis-spring-boot-starterartifactId>
    <version>2.1.3version>
dependency>

2：配置文件中设置别名和mapper文件位置

mybatis:
  type-aliases-package: com.kuang.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml

3：mapper接口上加@Mapper声明是mybatis的一个mapper类,写接口

4：写mapper.xml文件

4.6：前端

1：模板：别人写好的，我们拿来修改 后台模板xadmin

2：框架：组件–Layui bootstrap sementic-ui

3：自己独立写出一个网站

5：数据源

5.1：JDBC

1：常见数据源：dbcp,c3p0,druld，hikari

2：hikari是最快的数据源

3：datasource.getClass()获取当前数据源

4：JdbcTemplate：spring将jdbc进行轻量级的封装，形成JdbcTemplate，依赖注入使用即可

5：delete from 是连在一起的 不能分开

6：query()方法不能只查询一个sql语句，queryForList()可以

7：insert update delete 方法都是用jdbcTemplate下的update方法实现的

5.2：druid连接池

步骤

1：导入依赖

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.2.1version>
dependency>

2：application.yaml里配置druid数据源

spring:
	datasource:
	type: com.alibaba.druid.pool.DruidDataSource

3：将自定义的Druid数据源注入到容器中，不在让sprngboot自动创建

@ConfigurationProperties(prefix = "spring.datasource")
@Bean
public DataSource druidDataSource(){
     
    return new DruidDataSource();
}

4：实现Druid后台监控功能

//后台监控
@Bean
public ServletRegistrationBean servletRegistrationBean(){
     
    //设置进入后台管理系统的路径
    ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(),"/druid/*");

    //后台需要登录  需要设置登录用户名  登录密码
    Map<String, String> initParameters = new HashMap<>();
    initParameters.put("loginUsername","admin");
    initParameters.put("loginPassword","1");
    //允许谁可以访问
    initParameters.put("allow","");

    //禁止谁访问   initParameters.put("名字","ip地址");
    //设置初始化参数  进到方法中看见需要传递参数是一个map  所以需要实例化一个map
    bean.setInitParameters(initParameters);
    return bean;
}

5：运行测试

新知识

1：druid最强大的功能是加入了日志监控

2：如果想要使用自定义的组件，那么就在方法上加上@ConfigurationProperties(prefx = “”)和@Bean，这样的话springboot相应的自动装配就不会生效，我们的组件就会生效

3：StatViewServlet用于展示druid的统计信息

4：/druid/*设置进入后台管理系统的路径

5：后台监控功能需要实现三样功能

• 实例化StatViewServlet，用html展示druid的监控信息，设置访问路径
• 通过setInitParameters设置初始化参数 ，包括登录用户名的密码
• 设置允许谁可以访问，谁不可以访问

6：后台登录系统的登录用户名和密码必须是：loginUsername,loginPassword

7：initParameters.put(“allow”,""); 允许谁可以访问

8：initParameters.put(“名字”,“ip地址”); 禁止谁访问

过滤器

//配置 Druid web监控的 filter过滤器
// WebStatFilter  用于配置Web和Druid数据源之间的管理关联监控统计
@Bean
public FilterRegistrationBean filterRegistrationBean(){
     
    FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<>();
    bean.setFilter(new WebStatFilter());

    HashMap<String, String> initParams = new HashMap<>();
    //exclusions     设置哪些请求需要过滤掉，从而不进行统计
    initParams.put("exclusions","*.js,*.css,/druid/*,/jdbc/*");

    bean.setInitParameters(initParams);

    return bean;
}

1：WebStatFilter 用于配置Web和Druid数据源之间的管理关联监控统计

2：exclusions 设置哪些请求需要过滤掉，从而不进行统计

3：也需要通过setInitparameters设置初始化参数

6：spring security

概念

是针对spring项目的安全框架，可以仅引入security依赖，配置少许，就可以实现强大的安全管理

目标

授权：限制某些roles不能进入一些网页，允许某些人可以进入网页

认证：授予某些具体账号权限可以进入网页

6.1：环境部署

步骤

1：导入spring-boot-starter-security依赖

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-securityartifactId>
dependency>

2：导入静态资源

3：编写controller层

4：在配置类中继承WebSecurityConfigurerAdapter接口

5：重写configure方法实现认证和授权功能

6：运行测试

新知识

1：HttpSecurity http 方法实现授权功能

2：http.formLogin(); 没有权限会默认重定向到/login页面 输入错误会转到/login?error

3：在类上加注解@EnableWebSecurity 开启WebSecurity模式

4：AuthenticationManagerBuilder 方法实现认证功能

5：我们的界面要想正常登录，需要对前端传来的密码进行加密，否则会报错(This is no PasswordEncoder mapped for the id “null”)，认为这样是不安全的

5：spring security 官方推荐 Bcrypt 的加密方式

看源码学习如何重写方法

6.2：注销

1：http.logout() 实现注销功能 会转到登录界面

2：http.logout().logoutSuccessUrl("/"); 注销后转到首页

6.3：权限控制

1：导入依赖 --thymyleaf 和 springsecurity 整合包

<dependency>
   <groupId>org.thymeleaf.extrasgroupId>
   <artifactId>thymeleaf-extras-springsecurity5artifactId>
   <version>3.0.4.RELEASEversion>
dependency>

2：加入命名空间

xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5"

3：sec:authorize="isAuthenticated() " 是否认证登录，来显示不同的页面

4：http.csrf().disable(); 关闭跨站请求伪造 ，会默认使用post请求 因为get请求不安全，会使注销后404

5：sec:authorize="" 满足条件后才会把页面显示给用户

6：sec:authentication="" 显示身份验证的属性

6.4：记住我功能

1：http.rememberMe(); 即可

2：实际上是放了一个cookies

3：默认存放两周

6.5：定制登录页

1：http.formLogin().loginPage("/tologin"); 没有权限默认转到/login loginPage定制到别的页面

2：http.formLogin().usernameParameter(“username”).passwordParameter(“password”) 接受前端传来的参数名

看源码的好处

1：方法全面

2：可以快速找到自己想要的方法，变量，解析

7：shiro

7.1：认识shiro

概念

是java的一个安全框架

学习网页：https://www.w3cschool.cn/shiro/co4m1if2.html

功能

1：Authentication 身份认证/登录

2：Authorization 授权

3：Session Management：会话管理

4：Cryptography：加密

5：Web Support：Web 支持

6：Caching：缓存

shiro外部框架

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9TNEXBhz-1604802175102)(C:\Users\Justin Boy\AppData\Roaming\Typora\typora-user-images\image-20201024102158835.png)]

1：SubJect：当前用户

2：SecurityManager：安全管理器，管理着所有用户

3：Realm：域，安全数据源

7.2：搭建基础环境

1：导入依赖：thymeleaf 两个 shiro四个 shiro整合spring的包1个

2：配置controller和html文件测试环境是否可以运行

3：新建配置类，需要做三样事情

• ShirlFilterFactoryBean
• DefaultWebSecurityManager
• 创建realm安全数据源

4：realm需要继承接口AuthorizingRealm，重写里的方法

5：新建html文件和controller测试环境

配置基础环境时遇见问题：找不到html 文件

解决：springboot项目一定要导入thymeleaf依赖

依赖

<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-springartifactId>
    <version>1.6.0version>
dependency>

<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-coreartifactId>
    <version>1.6.0version>
dependency>

<dependency>
    <groupId>org.slf4jgroupId>
    <artifactId>jcl-over-slf4jartifactId>
    <version>1.7.21version>
dependency>

<dependency>
    <groupId>org.slf4jgroupId>
    <artifactId>slf4j-log4j12artifactId>
    <version>1.7.21version>
dependency>
<dependency>
    <groupId>log4jgroupId>
    <artifactId>log4jartifactId>
    <version>1.2.17version>
dependency>

7.3：登录拦截

步骤

1：在shiroFiltrFactoryBean中设置过滤器，.setFilterChainDefinitionMap()

2：进源码，写网页路径的级别

3：：新建登录页面 login.html

新知识

1：访问级别

• anon：无需认证即可访问
• authc：必须认证了才可以访问
• user：必须拥有记住我功能才可以访问
• perms：必须拥有某个资源的权限才可以访问
• role：必须拥有某个角色权限才可以访问

2：设置的路径必须要是网页的路径，不能是展示的页面

3：filterChainDefinitionMap.put(“网址路径”,“级别”);

7.4：实现用户认证

Subject当前用户步骤

1：获取当前用户

Subject currentUser = SecurityUtils.getSubject();

2：获取令牌

UsernamePasswordToken token = new UsernamePasswordToken(username,password);

3：判断当前用户是否被认证

if (!currentUser.isAuthenticated()) {
	//获取令牌
	UsernamePasswordToken token = new UsernamePasswordToken();
	 //设置记住我
     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.");
     }
}

4：在Realm中设置用户名验证和密码认证

UsernamePasswordToken usertoken = (UsernamePasswordToken) token;

新知识

1：ctrl+alt+T 显示常用方法

2：principals：身份

3：credentials：证明 / 凭证,即只有主体知道的安全值，如密码 / 数字证书等。

4：密码认证shrio会帮我们做，通过返回一个SimpleAuthenticationInfo

5：shiro中密码也可以加密

• md5加密
• md5盐值加密 在mad5加密基础上，再加上一些字符

7.5：shiro整合mybatis

步骤

1：导入依赖：mysql启动，mybatis，druid数据源，lombok

2：写pojo层

3：写mapper层，也要在resources下新建mapper文件夹，写xml文件

4：在配置文件application.properties下配置别名，设置mapper xml文件路径

5：写service层，和service实现类，需要依赖注入mapper

6：在realm中设置为从数据库中取值，需要依赖注入service

7：运行测试

新知识

1：依赖注入时一定要在上方加上@Autowired（经常忘）

2：写mapper层接口时一定要在上方加上@Mapper以便扫描得到，和@Repository注入到spring容器中

3：写service层实现类时一定要在上方加上@Service,以便注册到bean

依赖支持

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
dependency>
<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.2.1version>
dependency>
<dependency>
    <groupId>log4jgroupId>
    <artifactId>log4jartifactId>
    <version>1.2.17version>
dependency>
<dependency>
    <groupId>org.mybatis.spring.bootgroupId>
    <artifactId>mybatis-spring-boot-starterartifactId>
    <version>2.1.0version>
dependency>
<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <version>1.18.16version>
dependency>

7.6：实现授权功能

步骤

1：在ShiroConfig中设置权限

filterChainDefinitionMap.put("/add","perms[user:add]");   //参数   权限

2：在realm中获取权限并授予权限

• 先new 一个对象 SimpleAuthorizationInfo
• 查看对象下的方法，有个addStringPermission();方法可以授予权限
• 授予权限前首先要获取权限，那么就要通过SecurityUtils获取当前用户
• 通过SecurityUtils.getPrincipal()可以获取user对象
• user.getAuthorize geter方法可以获取权限

1：There was an unexpected error (type=Unauthorized, status=401). 说明该用户没有授权

7.7：shiro整合thymeleaf

设置信息有则显示，没有就不显示

1：导入依赖

<dependency>
    <groupId>com.github.theborakompanionigroupId>
    <artifactId>thymeleaf-extras-shiroartifactId>
    <version>2.0.0version>
dependency>

2：添加命名空间

xmlns:shiro="http://www.pollix.at/thymeleaf/shiro"

3：用shiro:hasPermission="user:add"来判断什么时候会显示

4：在index.html中添加登录按钮，并要设置没登录时要显示，登陆后不显示

5：在realm认证方法中获取当前用户，获取session，设置值

6：用th:if="session.loginUser==null"判断登录什么时候显示

8：swagger

官网：https://swagger.io/

访问网址：localhost:8080/swagger-ui.html

前后端交互：api 应用程序接口，就是我们写的一个个controller请求

原因：是为了解决前后端分离，无法及时协商的问题

优点

• 全世界最流行的api框架
• Restful api 文档在线自动生成器，API文档和API定义同步更新
• 在线测试API

8.1：基础环境搭建

使用步骤

1：导入架包

<dependency>
    <groupId>io.springfoxgroupId>
    <artifactId>springfox-swagger2artifactId>
    <version>2.9.2version>
dependency>

<dependency>
    <groupId>io.springfoxgroupId>
    <artifactId>springfox-swagger-uiartifactId>
    <version>2.9.2version>
dependency>

2：新建config类，在类上加上标签@Configuration和@EnableSwagger2

3：运行测试

错误：打不开localhost:8080/swagger-ui.html网页，导入的依赖版本太高

8.2：配置swagger信息

步骤

1：配置swagger的实例bean Docket

2：看Docket源码，需要返回一个DocumentationType

3：再进DocumentationType源码，我们需要调用的是DocumentationType.SWAGGER_2

4：通过ApiInfo可以配置swagger网址首页的信息，进源码可以得到配置的信息

8.3：swagger指定扫描接口

1：Profiles of(String… profiles) 中的…代表可变参数

2：.api()表示可以指定扫描的接口

return new Docket(DocumentType.SWAGGER_2).
    select()
    .api(RequestHandlerSelectors.basepackage())
    .build();

• RequestHandlerSelectors.any() 扫描所有接口
• RequestHandlerSelectors.none() 所有接口都不扫描
• RequestHandlerSelectors.basePackage() 扫描包下的接口
• RequestHandlerSelectors.withMethodAnnotation(GetMapping.class) 扫描有方法上有此注解的接口
• RequestHandlerSelectors.withClassAnnotation(Controller.class) 扫描类上有@Controller注解的接口

3：paths()表示过滤什么路径，不扫描此路径下的接口

return new Docket(DocumentationType.SWAGGER_2)
                .enable(flag)
                .select()
                .paths(PathSelectors.ant("/kuang/**"))
                .build()

• PathSelectors.any() 任何请求都扫描
• PathSelectors.nono() 任何请求都不扫描
• PathSelectors.regex(final String pathRegex) 通过正则表达式控制
• PathSelectors.ant(final String antPattern) 扫描请求路径以/kuang开头的请求

4：Docket(DocumentationType.SWAGGER_2).enable(true) 是否开启swagger

5：Profiles.of() 设置要显示的环境

6：Environtment.acceptsProfiles(profiles) 判断当前环境是否在profiles环境中

7：接口就是我们写的一个个controller

8.4：分组和接口注释

1：.groupName("") 配置分组名字，需要多少个分组就需要实例化多少Docket

2：@ApiModel() 给生成的api文档加注释 用在pojo类上

3：@ApiModelProperty(“用户名”) 给pojo类中的属性加注释

4：@ApiOperation(“方法”) 给controller类的方法加注释

5：@ApiParam(“用户名”) 给controller类中方法的参数加注释

6：@Api("") 用在pojo类上

8.5：总结

swagger的功能

1：可以在线测试

2：可以加注释

3：接口文档可以实时更新

swagger在项目上线以后一定要关闭，不能让用户访问

9：任务

9.1：异步任务

概念：先给前端用户发送成功消息，后台再需要时间来处理

步骤：1：在调用方法上加上注解@Async，告诉spring这是一个异步处理的方法

​ 2：在springboot的启动类上加上注解@EnableAsync开启异步处理即可

9.2：邮件发送

步骤

1：导入依赖

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-mailartifactId>
dependency>

2：在springboot配置文件中配置邮件发送的信息

[email protected]
spring.mail.password=iwsfypevuunbjiii
#主机地址
spring.mail.host=smtp.qq.com
#qq需要开启开启加密验证
spring.mail.properties.mail.smtp.ssl.enable=true

3：依赖注入JavaMailSenderImpl mailSender

4：mailSender.send(message); 执行send方法，发现需要传入参数，进源码看需要一个MailMessage

5：实例化一个MailMessage，然后配置发送信息

6：运行测试

新知识

1：SimpleMailMessage 一个简单的邮件发送 MimeMessage 一个复杂的邮件发送

2： MimeMessageHelper helper = new MimeMessageHelper(mimeMessage,true); 帮助发送一个复杂的邮件，参数：1：MimeMessage 2：是否支持多文件发送

9.3：定时任务

步骤

1：在启动类上加注解@EnableScheduling 开启定时任务

2：在方法上加@Scheduled(cron = “”) 按照cron表达式的时间执行这个方法

3：cron表达式：秒 分 时 日 月 周

4：spring实现异步执行任务调度提供了两个接口

• TaskExecutor 任务执行器
• TaskScheduler 任务调度器

10：Dubbo和Zookeeper集成

分布式系统

概念：一群独立的计算机共同对外服务，但是对于用户来说，就像是一台计算机在提供服务一样，各个主机之间的通信和协调主要通过网络进行

分布式

在多台不同的服务器中部署不同的服务模块，通过远程过程调用对外提供服务

集群

在多台不同的服务器上部署相同的服务模块，通过负载均衡对外提供服务

通信的方式

1：http协议

2：RPC协议

RPC

远程过程调用,是进程间的通信方式。

两个核心模块：通信，序列化（为了方便我们的数据传输）

解决的两个问题

1：解决分布式系统中，服务器之间的调用问题

2：远程调用时，要能够像本地调用一样方便

Dubbo

是一款针对 java RPC的高性能框架

dubbo-admin：是一个监控管理后台，可以查看我们注册了那些服务，那些服务被消费了

负载均衡：把用户压力均衡的分给每一个服务器

1：导入依赖

<dependency>
   <groupId>org.apache.dubbogroupId>
   <artifactId>dubbo-spring-boot-starterartifactId>
   <version>2.7.3version>
dependency>



<dependency>
   <groupId>com.github.sgroschupfgroupId>
   <artifactId>zkclientartifactId>
   <version>0.1version>
dependency>


<dependency>
   <groupId>org.apache.curatorgroupId>
   <artifactId>curator-frameworkartifactId>
   <version>2.12.0version>
dependency>
<dependency>
   <groupId>org.apache.curatorgroupId>
   <artifactId>curator-recipesartifactId>
   <version>2.12.0version>
dependency>
<dependency>
   <groupId>org.apache.zookeepergroupId>
   <artifactId>zookeeperartifactId>
   <version>3.4.14version>
   
   <exclusions>
       <exclusion>
           <groupId>org.slf4jgroupId>
           <artifactId>slf4j-log4j12artifactId>
       exclusion>
   exclusions>
dependency>

常用html标签

<html>html> 之间的文本描述网页
<body>body> 之间的文本是可见的页面内容
<h1>-<h6>定义html标题
<p>标签定义html段落
<a>标签定义html链接
<img>标签定义html图像
<br />标签用于换行
html属性在开始标签里定义，比键值对的方式出现
<table>定义html的表格
<hr />标签在html页面里创建水平线
<q>用于引用  在旁边加上引号
<nav>定义导航链接的部分
<span>用来组合文档中的行内元素
<div>用来组合文档中的块级元素
<li>定义列表项目
<ul>有序列表
<ol>无序列表
<footer>定义页脚部分
<script>用来导入javaScript代码
<button>定义按钮
<label>为input元素定义标注
<input>用于获取用户信息
<form>定义供用户输入的html表单  会进行网址的跳转-？
<tr>定义表中的行
<th>定义表格中表头单元格
<td>定义一个表格单元格
<input>表单的文本输入框
    属性type:类型，checkbox复选框
    name：文本框的名字(要和pojo属性对应)  
    value：实际的值  placeholder:提示值  text：显示的值

11：总结

微服务架构问题

1：这么多服务器，客户端该如何去访问

2：这么多服务器，服务器之间该怎么通信

3：这么多服务器，该怎么治理

4：服务器挂了怎么半

因此，springcloud应运而生，是一种生态，要想使用springcloud，就必须要掌握springboot

解决方案

1：spring Cloud Netfix

• Api网关 zuul组件
• Feign HttpClient(Http的通信方式，同步并阻塞)
• 服务注册与发现 Eureka
• 熔断机制 Hystrix

2：spring Cloud Apache

• Api 没有组件
• Dubbo RPC的通信框架
• 服务注册与发现 zookeeper （Hadoop Hive）
• 熔断机制 没有

3：spring Cloud alibaba

4：服务网格 server mesh --> istio

以上四种方案都是为了解决这四种问题

• Api网关 -->服务路由
• http协议 ，RPC协议 -->异步调用
• 服务注册与发现 -->高可用
• 熔断机制 -->服务降级

2020.10.18(周六)——2020.10.26(周一)

这次学习中除了学习springboot以外，还夹杂了很多别的东西

• yaml
• thymeleaf
• spring security