Spring Boot 框架基础

Spring Boot 框架基础 基础案例

pom.xml

    org.springframework.boot
    spring-boot-starter-parent
    2.6.4
     

web环境依赖

    org.springframework.boot
    spring-boot-starter-web

controller

@RestController
@RequestMapping("/demo")
public class DemoController {
    @RequestMapping("/handle01")
    public String handle01() {
        return "你好 springboot";
    }
}

测试

    org.springframework.boot
    spring-boot-starter-test
    test

@Autowired
private DemoController demoController;

@Test
void contextLoads() {
    System.out.println(demoController.handle01());
}

热部署

pom.xml

    org.springframework.boot
    spring-boot-devtools

使用IDEA工具热部署支持：

File => Settings => Build, Execution, Deployment => Compiler => 勾选 Build project automatically“Ctrl+Shift+Alt+/” 组合键打开 Registry 面板 => 勾选 compiler.automake.allow.when.app.running

热部署原理：

​ 在编译器上启动项目，改动代码，编译器会自动触发编译，替换掉原来的 class 文件，项目检测到有文件变更后会重启项目。

​ 当引入插件后，插件会监控 classpath 下文件的变化，当 classpath 有变化后，会触发重启。

​ 快速重启的原因：对类采用了两种加载机制，对于第三方的 jar 包采用 base-classloader 来加载，对于开发人员自己开发的代码使用 restart-classLoader 来加载，这里比停掉服务重启快得多，因为使用插件只重启开发人员编写的代码部分。

@Component
public class Devtools implements InitializingBean {

    @Override
    public void afterPropertiesSet() {
        // 在添加了 devtools 插件
        // 第三方 jar 包 使用 base-classloader 来加载
        // 自己开发的代码 使用 restart-classLoader 来加载

        // org.springframework.boot.devtools.restart.classloader.RestartClassLoader@472075a1
        System.out.println(Devtools.class.getClassLoader());

        // jdk.internal.loader.ClassLoaders$AppClassLoader@e73f9ac
        System.out.println(DispatcherServlet.class.getClassLoader());
    }
}

配置文件中属性注入 @Value

@Component
@Data
public class JdbcConfiguration {
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.driverClassName}")
    private String driverClassName;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
}

配置文件

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/bank
jdbc.username=root
jdbc.password=123

测试

@Autowired
private JdbcConfiguration jdbcConfiguration;

@Test
void JdbcValueConfigTest() {
    System.out.println(jdbcConfiguration);
}

结果

JdbcConfiguration(url=jdbc:mysql://127.0.0.1:3306/bank, driverClassName=com.mysql.jdbc.Driver, username=root, password=123)

@ConfigurationProperties

pom.xml

    org.springframework.boot
    spring-boot-configuration-processor
    true

定义需要被注入属性的实体类

@Component
@ConfigurationProperties(prefix = "person")
@Data
public class Person {
    private int id;
    private String name;
    private List hobbies1;
    private List hobbies2;
    private String[] family;
    private Map map1;
    private Map map2;
    private Pet pet;
}

@Component
@Data
public class Pet {
    private String name;
    private String type;
}

配置文件

application.properties

# 自定义属性注入到对应的实体中
person.id=1
person.name=应巅
person.hobbies1=吃饭,睡觉,打豆豆
person.hobbies2=睡觉,睡觉,睡觉
person.family=爸爸,妈妈,爷爷,奶奶
person.map1.extra1=1额外的信息1
person.map1.extra2=1额外的信息2
person.map2.extra1=2额外的信息1
person.map2.extra2=2额外的信息2
person.pet.type=猫
person.pet.name=旺财

application.yml

person:
  id: 2
  family: [爸爸,妈妈,爷爷,奶奶]
  name: 应巅
  hobbies1:
    睡觉,
    睡觉,
    睡觉
  hobbies2:
    - 吃饭
    - 睡觉
    - 打豆豆
  map1:
    extra1: 1额外的信息1
    extra2: 1额外的信息2
  map2: {extra1: 2额外的信息2, extra2: 2额外的信息2}
  pet:
    type: 猫
    name: 旺财

测试

@Autowired
private Person person;

@Test
void personConfigTest() {
    System.out.println(person);
}

结果

Person(id=1, name=应巅, hobbies1=[吃饭, 睡觉, 打豆豆], hobbies2=[睡觉, 睡觉, 睡觉], family=[爸爸, 妈妈, 爷爷, 奶奶], map1={extra1=1额外的信息1, extra2=1额外的信息2}, map2={extra1=2额外的信息1, extra2=2额外的信息2}, pet=Pet(name=旺财, type=猫))

日志框架

日志抽象层	日志实现层
JCL、SLF4J、jboos-logging	jul、log4j、log4j2、logback

springboot 默认使用 SLF4J 为日志抽象层，logback 为日志实现层。

日志使用

private Logger logger = LoggerFactory.getLogger(SpringBootDemoApplicationTests.class);

@Test
void logTest() {
    // 日志级别：trace < debug < info < warn < error
    // 日志默认使用：SLF4j + LogBack
    // spring boot 默认日志级别 为Info
    logger.trace("Trace 日志...");
    logger.debug("Debug 日志...");
    logger.info("Info 日志...");
    logger.warn("Warn 日志...");
    logger.error("Error 日志...");
}

配置文件

# 调整某个包下面的日志级别
logging.level.com.demo=trace
# 日志的输出格式
# 控制台
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
# 文件
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
# 文件路径 默认的日志文件名 spring.log
#logging.file.path=springLog
# 写入具体的文件
logging.file.name=log/log.log

缓存

pom.xml

    mysql
    mysql-connector-java
    runtime


    org.springframework.boot
    spring-boot-starter-data-jpa

application.properties

spring.datasource.url=jdbc:mysql:///bank?
spring.datasource.username=root
spring.datasource.password=123456
spring.jpa.show-sql=true

@Data
@Entity
@Table(name = "employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
    @Column(name = "last_name")
    private String lastName;
    @Column(name = "email")
    private String email;
    @Column(name = "gender")
    private Integer gender; //性别 1男 0女
    @Column(name = "d_id")
    private Integer dId;
}

// JPA实现简单CRUD
public interface EmployeeDao extends JpaRepository {}

@SpringBootApplication
@EnableCaching //开启基于注解的缓存
public class SpringBootDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootDemoApplication.class, args);
    }
}

添加缓存

@GetMapping("/emp/{id}")
// 添加缓存 cacheNames：缓存的名字 = value；
// key：默认参数的值 次数为id的值1；可以使用 SpEL 表达式
@Cacheable(cacheNames = {"emp"})
public Employee getEmp(@PathVariable("id") Integer id) {
    return employeeDao.findById(id).get();
}

更新缓存

 @GetMapping("/emp/update")
// 更新缓存
@CachePut(value = "emp", key = "#employee.id")
public Employee updateEmp(Employee employee) {
    employeeDao.save(employee);
    return employee;
}

删除缓存

@DeleteMapping("/emp/{id}")
// 删除缓存
// beforeInvocation:默认为 false，译为在方法调用之后删除缓存；设置为 true，译为在方法调用之前删除缓存
// 若方法出现异常，在方法调用之后清除缓存将不起作用。
@CacheEvict(value = "emp", key = "#id", beforeInvocation = true)
public void delEmp(@PathVariable("id") Integer id) {
    employeeDao.deleteById(id);
}

SpEL 表达式

@GetMapping("/SpELDemo/{id}")
@Cacheable(cacheNames = {"emp"}, key = "#root.method")
public Employee SpELDemo(@PathVariable("id") Integer id) {
    return employeeDao.findById(id).get();
}

SpEL 表达式	描述	值
#root.methodName	方法的名称	SpELDemo
#root.method	方法	public com.demo.pojo.Employee com.demo.controller.DemoController.SpELDemo(java.lang.Integer)
#root.args[0]	当前被调用的方法的参数列表	{id}的值
#iban、#a0、#p0	方法参数的名字，可以直接 #参数名，也可以使用 #p0 或 #a0 的形式，0 代表参数的索引	{id}的值
#result	方法执行后的返回值

基于redis 实现缓存

pom.xml

    org.springframework.boot
    spring-boot-starter-data-redis

spring.redis.database=1
spring.redis.host=127.0.0.1

需要实现 Serializable 接口

public class Employee implements Serializable {}

SpringBoot默认采用的是JDK的对象序列化方式。

自定义RedisCacheManager

使用 JSON 格式进行对象的序列化操作。

@Configuration
public class RedisConfig {

    // 自定义一个RedisTemplate
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        //设置redisTemplate模板API的序列化方式为json
        template.setDefaultSerializer(getJackson2JsonRedisSerializer());
        return template;
    }

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        // 分别创建String和JSON格式序列化对象，对缓存数据key和value进行转换
        RedisSerializer strSerializer = new StringRedisSerializer();
        // 定制缓存数据序列化方式及时效
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofDays(1))
                .serializeKeysWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(strSerializer))
                .serializevaluesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(getJackson2JsonRedisSerializer()))
                .disableCachingNullValues();
        return RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(config).build();
    }

    private Jackson2JsonRedisSerializer