SpringBoot高级整合 尚硅谷雷锋阳 学习笔记

SpringBoot高级整合 尚硅谷雷锋阳 学习笔记

Springboot与缓存

JSR107缓存规范

相信大家都能看得懂

使用JSR107需要导入下面的依赖包

Spring缓存抽象

代码实现

搭建基本环境

创建数据库

SET FOREIGN_KEY_CHECKS=0;

DROP TABLE IF EXISTS `department`;
CREATE TABLE `department` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `departmentName` VARCHAR(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `employee`;
CREATE TABLE `employee` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `lastName` VARCHAR(255) DEFAULT NULL,
  `email` VARCHAR(255) DEFAULT NULL,
  `gender` INT(2) DEFAULT NULL,
  `d_id` INT(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO employee(lastName,email,gender,d_id)VALUES('zhangsan','[email protected]',1,1);
INSERT INTO employee(lastName,email,gender,d_id)VALUES('lisi','[email protected]',0,2);

建两个bean实体类

package com.luyi.bean;

/**
 * @author 卢意
 * @create 2020-11-24 9:00
 */
public class Department {
	private Integer id;
	private String departmentName;


	public Department() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Department(Integer id, String departmentName) {
		super();
		this.id = id;
		this.departmentName = departmentName;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getDepartmentName() {
		return departmentName;
	}
	public void setDepartmentName(String departmentName) {
		this.departmentName = departmentName;
	}
	@Override
	public String toString() {
		return "Department [id=" + id + ", departmentName=" + departmentName + "]";
	}
}

package com.luyi.bean;

/**
 * @author 卢意
 * @create 2020-11-24 9:01
 */
public class Employee {
	private Integer id;
	private String lastName;
	private String email;
	private Integer gender; //性别 1男  0女
	private Integer dId;


	public Employee() {
		super();
	}


	public Employee(Integer id, String lastName, String email, Integer gender, Integer dId) {
		super();
		this.id = id;
		this.lastName = lastName;
		this.email = email;
		this.gender = gender;
		this.dId = dId;
	}

	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Integer getGender() {
		return gender;
	}
	public void setGender(Integer gender) {
		this.gender = gender;
	}
	public Integer getdId() {
		return dId;
	}
	public void setdId(Integer dId) {
		this.dId = dId;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", lastName=" + lastName + ", email=" + email + ", gender=" + gender + ", dId="
				+ dId + "]";
	}
}

application里添加Mybatis配置

spring.datasource.url=jdbc:mysql://localhost:3306/spring_cache?serverTimezone=GMT
spring.datasource.username=root
spring.datasource.password=123456
#Driver可不写，会根据连接自动添加
#spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

#开启驼峰命名规则
mybatis.configuration.map-underscore-to-camel-case=true
#开启日志
logging.level.com.luyi.mapper=debug

新建mapper接口

package com.luyi.mapper;

import com.luyi.bean.Employee;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

/**
 * @author 卢意
 * @create 2020-11-24 9:04
 */
public interface EmployeeMapper {
	@Select("SELECT * FROM employee WHERE id=#{id}")
	Employee getEmpById(Integer id);

	@Insert("INSERT INTO employee(lastName,email,gender,d_id)VALUES(#{lastName},#{email},#{gender},#{dId})")
	void insertEmployee(Employee employee);

	@Update("UPDATE employee SET lastName=#{lastName},email=#{email},gender=#{gender},d_id=#{dId} WHERE id=#{id}")
	void updateEmp(Employee employee);

	@Delete("DELETE FROM employee WHERE id=#{id}")
	void deleteEmpById(Integer id);

}

新建test类

package com.luyi;

import com.luyi.mapper.EmployeeMapper;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.security.RunAs;

@SpringBootTest
@RunWith(SpringRunner.class)
class SpringbootstudyApplicationTests {

	@Autowired
	EmployeeMapper employeeMapper;

	@Test
	void contextLoads() {
		employeeMapper.getEmpById(1);
	}

}

查找成功

新建Employeeservice

package com.luyi.service;

import com.luyi.bean.Employee;
import com.luyi.mapper.EmployeeMapper;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @author 卢意
 * @create 2020-11-24 9:10
 */
 @Service
public class EmployeeService {
	@Autowired
	EmployeeMapper employeeMapper;

	public Employee getEmp(Integer id){
		System.out.println("查询" + id + "号员工");
		Employee emp = employeeMapper.getEmpById(id);
		return emp;
	}
}

新建controller类

package com.luyi.controller;

import com.luyi.bean.Employee;
import com.luyi.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 卢意
 * @create 2020-11-24 9:12
 */
@RestController
public class EmployeeController {

	@Autowired
	EmployeeService employeeService;

	@GetMapping("/emp/{id}")
	public Employee getEmployee(@PathVariable("id") Integer id){
		Employee emp = employeeService.getEmp(id);
		return emp;
	}

}

启动项目

没加缓存时 每次访问都会调用数据库

体验缓存

主启动类加上开启缓存注解

service 放法加入缓存注解

缓存的key编写

先只用默认的注解进行测试

只查询了一次 就没有在调用数据库了

Cacheable运行流程

自动配置类导入了下面的缓存配置类

生效的缓存配置类

Cacheable其他属性

用配置类指定key


condition
第一个参数大于1 在进行缓存

unless 否定缓存 第一个参数等于2 就不缓存

sync异步模式 将返回值异步存在缓存中 不支持unless

Cacheput

既调用方法，又更新缓存
@CachePut与@Cacheable的区别
@Cacheable是先到缓存里查找有没有要查的数据，如果有就直接用缓存里的数据，不调用方法操作数据库，如果没有再调用方法操作数据库并把返回的数据保存到缓存里。（前置处理）（用于查询）
@CachePut是每次都先调用方法进行数据库操作，并把返回的数据保存到缓存里，如果缓存里已经有了就覆盖原来的数据。（后置处理）（用于修改）
运行时机：先调用目标方法，再将目标方法的返回结果保存到缓存中。（属性比@Cacheable少了一个sync，其他相同）
应用场景：修改了数据库的某个数据，同时更新缓存。
mapper里添加

@CachePut(value = "emp")
   public Employee updateEmp(Employee employee){
   	System.out.println("updateEmp：" + employee);
       employeeMapper.updateEmp(employee);
       return employee;
  }

EmployeeController类内添加

@GetMapping("/emp")
   public Employee update(Employee employee){
       Employee emp = employeeService.updateEmp(employee);
       return emp;
   }

CacheEvict 清除缓存

mapper添加方法

@CacheEvict(value = "emp", key = "#id")
public void deleteEmp(Integer id){
    System.out.println("deleteEmp：" + id);
    //数据库只有两个数据，这里就不删除了，只清理缓存中的数据
    //employeeMapper.deleteEmpById(id);
}

conroller类

@GetMapping("/delemp")
public String deleteEmp(Integer id){
    employeeService.deleteEmp(id);
    return "success";
}

key默认使用传参的值

Caching（三合一）

全局配置 value="emp"就可以不写了

Redis

redis环境搭建

启动redis

Redis环境搭建

pom 文件添加依赖

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>

配置redis

spring.redis.host=192.168.216.138 

springboot 自动配置redisTemplate
使用

Redis常见的五大数据类型
String（字符串）、List（列表）、Set（集合）、Hash（散列）、ZSet（有序集合）
stringRedisTemplate.opsForValue() String（字符串）
stringRedisTemplate.opsForList() List（列表）
stringRedisTemplate.opsForSet() Set（集合）
stringRedisTemplate.opsForHash() Hash（散列）
stringRedisTemplate.opsForZSet() ZSet（有序集合）
redisTemplate的方法和stringRedisTemplate是一样的，不同的是redisTemplate操作k-v都是对象的，而操作k-v都是字符串的

测试redisTemplate

@Test
public void test02(){
    Employee employee = employeeMapper.getEmpById(1);
    //如果保存对象，默认使用jdk系列化机制，系列化后的数据保存到redis中
    redisTemplate.opsForValue().set("emp01", employee);  //append是追加字符串的，set才是添加对象的，并且每次提交相同的key时，原来的value会被新的value覆盖
}

需要将Employee变成可序列化

默认的序列化器是jdk的

将数据以json的形式保存到redis：
自己将对象转为json（如使用gson）
修改redisTemplate默认的系列化（默认使用的是jdk的系列化器）我们想修改成json的序列化器

新建一个MyRedisConfig配置类

@Configuration
public class MyRedisConfig {

    @Bean
    public RedisTemplate<Object, Object> empRedisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        //设置默认的系列化器为Jackson2JsonRedisSerializer
        template.setDefaultSerializer(serializer);
        return template;
    }
}

//自定义RedisTemplate
@Autowired
RedisTemplate<Object, Object> empRedisTemplate;

@Test
public void test03(){
    Employee employee = employeeMapper.getEmpById(1);
    empRedisTemplate.opsForValue().set("emp01", employee);
}

自定义CacheManger

现在引入了Redis 默认的缓存配置 SimpleCacheConfiguration不生效了 因为他的触发条件是没有CacheManager的类才生效

RedisCacheConfiguration的启动顺序比SimpleCacheConfiguration高 提前判断生效 放入RedisCacheManager

自定义redisCachemanager

这个样子就相当于我们容器内有了CacheManager 就不会去注册上面的默认缓存 查出来的也是默认序列化为josn的数据


新建一个Department的操作 进行缓存查询 第一次走数据库查询成功 将缓存存入

第二次走缓存查询就有问题了 上面写着无法从Department的json对象转为Emloyee的反序列化

因为这里配了Employee的序列化对象

那就只能在写一个部门的Template对象和部门的缓存管理器

使用的时候需要指定CacheManager

多个CacheManager需要定义一个主键CacheManager(默认使用)

编码的方式使用redis缓存
指定缓存管理器

SpringBoot 与消息

https://blog.csdn.net/weixin_43691773/article/details/109295391

SpringBoot 与检索

https://blog.csdn.net/weixin_43691773/article/details/109442332

SpringBoot 与任务(异步,定时,邮件 任务)

https://blog.csdn.net/weixin_43691773/article/details/109472499

SpringBoot 与安全

https://editor.csdn.net/md/?articleId=109143604

SpringBoot 与开发热部署

SpringBoot 与监控管理

各端点测试

控制台会有映射信息

尝试访问监控信息 发现没有授权

修改配置文件 将管理安全模式给关闭

从新进入

各字段功能

远程关闭程序

定制端点

更改bean的访问路径和id 都是 mybean和/mybean

也可以单独设置路径

不让beans端点被访问 需要在配置文件加入

值开启beans端点



定义端口号

自定义Healtindicator

当前健康检查 只有一个diskpace健康状态

springboot自带很多组件的健康检查

引入redis依赖个配置 就可以进行redis的健康检查

自定义健康状态指示器