SpringBoot笔记

第十章 SpringBoot

10.1 配置文件加载

springboot支持二种类型的配置文件
·    properties属性配置文件
·    yaml配置文件

配置文件必须放置在项目的类加载目录下, 并且名字必须是`application`
springboot项目在运行的时候会自动加载这些配置文件

10.2 多环境的配置切换

spring boot项目中允许使用多个YAML配置文件。
这些文件名称必须为application-***.yml，并且在application.yml中激活。

修改 application.yml 配置文件：

spring:
  profiles:
    active: dev  //通过dev/pro来指定生效的文件

如果properties和yml文件都存在，不存在spring.profiles.active设置，默认以properties优先。
如果设置了spring.profiles.active，并且有重叠属性，以active设置优先。

10.3 Spring Boot 自动配置

10.3.1 @SpringBootApplication注解

@SpringBootConfiguration  代表这个类就是一个配置类 , 本质上就是一个
@EnableAutoConfiguration  自动配置注解 , 添加了此注解会自动去读取spring.factories配置文件中的自动							   配置类
@ComponentScan  组件扫描, 默认扫描启动类所在包及子包下的类身上的注解

10.3.2 @ConfigurationProperties注解

@ConfigurationProperties  可以将一些配置属性批量注入到bean对象

eg: application.yml配置文件

spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.jdbc.driver
      url: jdbc:mysql:///springboot_01
      username: root
      password: root

DataSourceProperties.java

public class DataSourceProperties {
    private String driverClassName;
    private String url;
    private String username;
    private String password;
    // 省略getter和setter.....
}

方式一：@Value 单个注入

@Component //不可省哦
public class DataSourceProperties {
    @Value("${spring.jdbc.datasource.driverClassName}")
    private String driverClassName;
    @Value("${spring.jdbc.datasource.url}")
    private String url;
    @Value("${spring.jdbc.datasource.username}")
    private String username;
    @Value("${spring.jdbc.datasource.password}")
    private String password;
    // 省略getter和setter.....
}

方式二：@ConfigurationProperties 批量注入

@Component //不可省哦  和@EnableConfigurationProperties 二选一
//需要配置开启注解的使用  @EnableConfigurationProperties(DataSourceProperties2.class)
@ConfigurationProperties(prefix = "spring.jdbc.datasource")  
public class DataSourceProperties2 {
    private String driverClassName;
    private String url;
    private String username;
    private String password;
     // 省略getter和setter.....
}    

在类上通过@ConfigurationProperties注解声明该类要读取属性配置prefix="spring.jdbc.datasource" 读取yml文件中前缀为spring.jdbc.datasource的值。前缀和配置文件中的key必须要保持一致才可以注入成功

Spring Boot默认读取application.properties属性文件

10.3.3 条件配置注解

10.3.4 自动配置原理（简略）

加载spring.factories
读取自动配置类
	加载所有classpath:META-INF/spring.factories

10.4 注解没有找到路径

解决：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

10.5 Spring Boot常用启动器

10.5.1 SpringBoot整合MVC

  <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

10.5.2 静态资源目录

在springboot中有一个叫做ResourceProperties的类，里面就定义了静态资源的默认查找路径：
默认的静态资源路径为：
•	classpath:/META-INF/resources/
•	classpath:/resources/
•	classpath:/static/
•	classpath:/public/
修改资源位置：
spring:
  resources:
    static-locations: classpath:/webapp/

10.5.3 自定义拦截器

1.编写拦截器

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor拦截器的preHandle方法执行....");
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor拦截器的postHandle方法执行....");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor拦截器的afterCompletion方法执行....");
    }
}

2.注册拦截器

import com.atguigu.interceptor.MyInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Autowired
    private MyInterceptor myInterceptor ;
    /**
     * /**  拦截当前目录及子目录下的所有路径 /user/**   /user/findAll  /user/order/findAll
     * /*   拦截当前目录下的以及子路径   /user/*     /user/findAll
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor).addPathPatterns("/**");
    }
}

10.5.4 SpringBoot整合Spring Data JPA

添加Spring Data JPA的起步依赖

  <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- springBoot JPA的起步依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!-- MySQL连接驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- 配置使用redis启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
    </dependencies>

在application.yml中配置数据库和jpa的相关属性

logging:
  level:
    com.atguigu.dao: debug # 配置日志
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/springboot?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect  #不加这句则默认为myisam引擎
    database: mysql    #指定使用的数据厂商
    show-sql: true     #展示sql
    generate-ddl: true   #将创建表的sql打印到控制台里
    hibernate:
      ddl-auto: update
      naming_strategy: org.hibernate.cfg.ImprovedNamingStrategy
server:
  port: 18081

创建实体配置实体

import javax.persistence.*;

@Entity   //声明当前类是一个实体类，实体类都是需要与一张表进行映射
@Table(name = "user")
public class User{
    @Id//声明主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//主键生成策略 auto increment
    @Column(name = "id")
    private Long id;
    @Column(name = "username")   //如果不指定@Column注解，框架进行默认映射，字段与属性一致
    private String username;
    @Column(name = "password")
    private String password;
    @Column(name = "name",unique=true,nullable=false,length=8)
    private String name;
    //此处省略setter和getter方法... ...
    @Transient   //声明临时属性，不需要与表字段进行映射
    private String email;
}

编写UserRepository(mapper)

import org.springframework.data.jpa.repository.JpaRepository;
//JpaRepository<User,Integer>   第一个参数根据User找到对应的表，第二个主键类型
public interface UserDao extends JpaRepository<User,Integer> {
}

编写service类

import java.util.List;

public interface UserService {
    List<User> findUsers();
    User findUserById(Integer id);
    void saveUser(User user);
    void updateUser(User user);
    void deleteUserById(Integer id);
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;
    /**
     * 查询所有
     */
    @Override
    public List<User> findUsers() {
        return userDao.findAll();
    }
    /**
     * 根据id查询
     */
    @Override
    public User findUserById(Integer id) {
        return userDao.findById(id).get();
    }
    /**
     * 保存
     */
    @Override
    public void saveUser(User user) {
        userDao.save(user);
    }
    /**
     * 更新
     */
    @Override
    public void updateUser(User user) {
        userDao.save(user);
    }
    /**
     * 根据id删除
     */
    @Override
    public void deleteUserById(Integer id) {
        userDao.deleteById(id);
    }
}

10.5.4 SpringBoot整合TkMapper

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
    </parent>

    <dependencies>
        <!--单元测试启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!--通用mapper启动器依赖-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>
        <!--JDBC启动器依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--druid启动器依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--web启动器依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--spring boot actuator依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--编码工具包-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <!--热部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!--spring boot maven插件 , 可以将项目运行依赖的jar包打到我们的项目中-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

创建启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;  

@SpringBootApplication
@MapperScan(basePackages = "com.atguigu.dao")  //这里是tk的注解
@EnableTransactionManagement
//启动注解事务管理
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

编写application.yml

server:
  port: 10001
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///springboot
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource
mybatis:
  type-aliases-package: com.atguigu.pojo  //mybatis的参数类型和返回类型可以不用全类名，类名就行

实体类

@Entity
@Table(name = "tb_user")
public class User implements Serializable {
    private Integer id;
    private String name;
	agrs...
}

mapper接口

import com.atguigu.pojo.User;
import tk.mybatis.mapper.common.Mapper;   //tk的类
import java.util.List;
//注意mapper的包，要tk的
public interface UserMapper extends Mapper<User> {
}

业务层调用

@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;

@Override
@Transactional(readOnly = true ,propagation = Propagation.SUPPORTS)
    public List<User> findAll() {
        return userMapper.selectAll();
    }
}

测试：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper ;
    @Test
    public void findAll() {
        List<User> users = userMapper.selectAll();
        System.out.println(users);
    }
}

10.6 Spring Boot其他组件

10.6.1 SpringBoot Actuator组件

Spring Boot Actuator是SpringBoot自带的一个组件 , 可以帮助我们监控和管理Spring Boot应用，比如健康检查、审计、统计和HTTP追踪等。

引入SpringBoot Actuator起步依赖

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

配置SpringBoot Actuator参数

management:
  endpoints:
    web:
      exposure:
        include: '*'  # 对外暴露的访问入口 , 默认是/health和/info
      base-path: /monitor # 默认是actuator
  endpoint:
    health:
      show-details: ALWAYS	# 显示所有健康状态
  server:
    port: 9999

启动项目获取系统信息

如 : http://localhost:9999/monitor/health

10.6.2 SpringBoot Admin组件

Spring Boot Admin是一个开源社区项目，用于管理和监控SpringBoot应用程序。 应用程序作为Spring Boot Admin Client向Spring Boot Admin Server注册 , Client会定时向Server发送数据, Server使用友好的界面展示数据。

1 SpringBoot Admin服务端

创建项目springboot-admin-server

起步依赖

	<parent>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-server</artifactId>
            <version>2.2.0</version>
        </dependency>
    </dependencies>

application.yml

spring:
  application:
    name: admin-server
server:
  port: 8769

启动类

@SpringBootApplication
@EnableAdminServer   //开启管理服务
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

2 SpringBoot Admin客户端

起步依赖

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-client</artifactId>
    <version>2.2.0</version>
</dependency>

application.yml

server:
  port: 9999
spring:
  application:
    name: admin-client
  boot:
    admin:
      client:
        url: http://localhost:8769   # 指定注册地址 , Spring Boot Admin Server地址
management:
  endpoints:
    web:
      exposure:
        include: '*' 
  endpoint:
    health:
      show-details: ALWAYS

访问http://localhost:8769

10.7 Spring Boot项目打包部署

10.7.1 项目打包

1 在pom.xml中配置Spring Boot项目的maven插件

<build>
    <plugins>
        <!-- 打jar包时如果不配置该插件，打出来的jar包没有清单文件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

2 运行maven的打包命令 : package

3 打包之前我们需要跳过测试 , 如果不跳过测试那么我们编写的测试类都会被maven自动执行, 可能会出现错误,导致打包不成功

4 .jar.original 是普通jar包，不包含依赖

​ .jar 是可执行jar包，包含了pom中的所有依赖，可以直接用java -jar 命令执行

​ 如果是部署，就用.jar , 如果是给别的项目用，就要给.jar.original这个包

10.7.2 项目运行

打开命令行运行打出来的包；使用命令：java –jar 包全名
java -jar springboot_02-1.0-SNAPSHOT.jar

项目打包部署

10.7.1 项目打包

1 在pom.xml中配置Spring Boot项目的maven插件

<build>
    <plugins>
        <!-- 打jar包时如果不配置该插件，打出来的jar包没有清单文件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

2 运行maven的打包命令 : package

3 打包之前我们需要跳过测试 , 如果不跳过测试那么我们编写的测试类都会被maven自动执行, 可能会出现错误,导致打包不成功

4 .jar.original 是普通jar包，不包含依赖

​ .jar 是可执行jar包，包含了pom中的所有依赖，可以直接用java -jar 命令执行

​ 如果是部署，就用.jar , 如果是给别的项目用，就要给.jar.original这个包

10.7.2 项目运行

打开命令行运行打出来的包；使用命令：java –jar 包全名
java -jar springboot_02-1.0-SNAPSHOT.jar