Spring Boot

1、Spring Boot是什么？有什么作用？
Spring Boot是一个便捷搭建基于spring工程的脚手架；作用是帮助开发人员快速搭建大型的spring 项目。简化工程的配置，依赖管理；实现开发人员把时间都集中在业务开发上。

2、如何使用Spring Boot搭建一个项目？
Spring Boot工程可以通过添加启动器依赖和创建启动引导类实现快速创建web工程。
1.创建工程，引入父依赖，指定spring boot版本2.1.5

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

2.添加启动器依赖，spring-boot-starter-web

   <!--修改Spring Boot项目的jdk版本-->
    <properties>
        <java.version>1.8</java.version>
    </properties>

        <!--这里是web项目，因此引入web启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

3.创建启动类

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

4.创建处理器Controller

@RestController
public class HelloController {

    @GetMapping("hello")
    public String hello() {
        return "Hello";
    }
}

3、Spring Boot如何配置一个数据库连接池？
1.在 pom.xml 文件中添加Druid连接池依赖

       <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.6</version>
        </dependency>

2.创建数据库连接参数的配置文件jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/test
jdbc.username=root
jdbc.password=123456

3.创建配置类

@Configuration
@PropertySource("classpath:jdbc.properties")
public class Jdbcconfig {
    @Value("${jdbc.driverClassName}")
    String driverClassName;
    @Value("${jdbc.url}")
    String url;
    @Value("${jdbc.username}")
    String username;
    @Value("${jdbc.password}")
    String password;

    @Bean
    public DataSource dataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driverClassName);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }
}

4、如何将配置文件中的配置项读取到一个对象中？
有两种方法
方法一：
1.将jdbc.properties修改名称为application.properties
2.使用@ConfigurationProperties编写配置项类将配置文件中的配置项设置到对象中

@Configuration
@PropertySource("classpath:application.properties")
public class JdbcProperties{
    
    String driverClassName;
    String url;
    String username;
    String password;

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

3.@EnableConfigurationProperties将JdbcProperties对象注入到JdbcConfig

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {

    @Bean
    public DataSource dataSource(JdbcProperties jdbcProperties) {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(jdbcProperties.getDriverClassName());
        druidDataSource.setUrl(jdbcProperties.getUrl());
        druidDataSource.setUsername(jdbcProperties.getUsername());
        druidDataSource.setPassword(jdbcProperties.getPassword());
        return druidDataSource;
    }
}

方法二：直接使用@ConfigurationProperties在方法上面使用

@Configuration
public class Jdbcconfig {

    @Bean
    // 声明要注入的属性前缀，Spring Boot会自动把相关属性通过set方法注入到DataSource中
    @ConfigurationProperties(prefix = "jdbc")
    public DataSource dataSource() {
        return new DruidDataSource();
    }
}

yml配置文件的特征：

树状层级结构展示配置项；
配置项之间如果有关系的话需要分行空两格；
配置项如果有值的话，那么需要在: 之后空一格再写配置项值；

5. 多个yml文件如何进行配置？
以application-**.yml命名；在application.yml中使用激活
这些配置文件即可。

spring:
  profiles:
    active: y1,*y2

6、Spring Boot项目的配置是怎样加载的？
在 META-INF\spring.factories文件中定义了很多自动配置类；可以根据在pom.xml文件中添加的启动器依赖自动配置组件

通过如下图流程可以去修改application配置文件，改变自动配置的组件默认参数

7、如何使用lombok的注解实现pojo类的简化？
lombok是一个插件工具类包；提供了一些注解@Data、@Getter等这些注解去简化实体类中的构造方法、get/set等方法的编写。
1.在IDEA中安装lombok插件；
2.添加lombok对应的依赖到项目pom.xml文件；

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

3.在实体类上加上@Data，就可以省去getter和setter等方法的编写，lombok插件会自动生成

8、Spring Boot如何修改服务端口和访问项目中的静态资源？
1.修改端口：修改application.yml配置文件，添加如下配置

#映射端口
server:
  port: 80

2.访问项目中的静态资源：创建classpath:/static/目录，将静态文件放置该目录下

9、如何使用Spring Boot配置自定义SpringMVC拦截器？
1编写拦截器类（实现HandlerInterceptor接口）

@Slf4j
public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.debug("这是MyInterceptor拦截器的preHandle方法");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.debug("这是MyInterceptor拦截器的postHandle方法");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.debug("这是MyInterceptor拦截器afterCompletion方法");
    }
}

2.编写配置类（实现WebMvcConfigurer接口）

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    /**
     * 将拦截器注册到spring ioc容器
     * @return myInterceptor
     */
    @Bean
    public MyInterceptor myInterceptor() {
        return new MyInterceptor();
    }

    /**
     * 重写该方法；往拦截器链添加自定义拦截器
     * @param registry 拦截器链
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 通过registry添加myInterceptor拦截器，并设置拦截器路径为 /*
        registry.addInterceptor(myInterceptor()).addPathPatterns("/*");
    }
}

10、SpringBoot如何整合事务和hikari连接池？
事务配置：
1.添加事务启动器依赖和MySQL依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>

2.编写业务类使用事务注解@Transactional

@Service
public class UserService {

    // 根据id查询
    public User queryById(Long id) {
        return new User();
    }

    @Transactional
    public void saveUser(User user) {
        System.out.println("add user...");
    }
}

数据库连接池hikari配置：
在application配置文件中指定数据库相关配置参数

Spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test
    username: root
    password: 123456

11、Spring Boot如何整合Mybatis?
1.添加启动器依赖；

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>

2.配置application.yml：

mybatis:
  # 实体类别名包路径
  type-aliases-package: com.september.pojo
  # 映射文件路径
  # mapper-locations: classpath:mappers/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

3.设置启动器类中的mapper扫描

@SpringBootApplication
// 扫描Mybatis所有业务的Mapper接口
@MapperScan("com.september.mapper")
public class Application {
    public static void main(String[] args) {
        // 启动代码
        SpringApplication.run(Application.class, args);
    }
}

12、Spring Boot如何整合通用Mapper？
通用Mapper：可以实现自动拼接sql语句；所有的mapper都不需要编写任何方法也就是不用编写sql语句。可以提高开发效率。
1.添加启动器依赖：

        <!-- 通用mapper -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>

2.Mapper类继承Mapper<T>接口：

public interface UserMapper extends Mapper<User> {    

}

3.把启动类上的@MapperScan注解修改为通用mapper中自带的：

4.在User实体类上加@Table注解

//在编译阶段会根据注解自动生成对应的方法：@Data包含get/set/hashCode/equals/toString等方法
@Data
@Table(name = "tb_user")
public class User {
    @Id
    //主键回填
    @KeySql(useGeneratedKeys = true)
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private Integer sex;
    private Date birthday;
    private String note;
    private Date created;
    private Date updated;
}

5.改造Service类实现业务功能

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    // 根据id查询
    public User queryById(Long id) {
        return userMapper.selectByPrimaryKey(id);
    }

    // 新增保存用户
    @Transactional
    public void saveUser(User user) {
        System.out.println("add user...");
        // 选择性新增；如果属性为空则该属性不会出现在insert语句上
        userMapper.insertSelective(user);
    }
}

13、Spring Boot如何整合通用Mapper？
1.添加启动器依赖spring-boot-starter-test：

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

2.编写测试类上面,必须要添加 @SpringBootTest 注解：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void queryById() {
        User user = userService.queryById(1L);
        System.out.println("user = " + user);
    }

    @Test
    public void saveUser() {
        User user = new User();
        user.setUserName("test");
        user.setName("test");
        user.setPassword("123456");
        user.setSex(1);
        user.setAge(20);
        user.setCreated(new Date());
        userService.saveUser(user);
    }
}

14、Spring Boot如何整合Redis?
1.添加启动器依赖；spring-boot-starter-data-redis

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

2.配置application.yml中redis的连接参数

  redis:
    host: 192.168.254.128
    port: 6379

3.编写测试类应用RedisTemplate操作redis

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void test() {
        //string字符串
        //redisTemplate.opsForValue().set("str","september");
        //System.out.println("str = " + redisTemplate.opsForValue().get("str"));
        redisTemplate.boundValueOps("str").set("september");
        System.out.println(redisTemplate.boundValueOps("str").get());
        //hash散列
        redisTemplate.boundHashOps("s_key").put("name", "9月");
        redisTemplate.boundHashOps("s_key").put("tuesday", 2);
        //获取所有的域
        Set set = redisTemplate.boundHashOps("s_key").keys();
        System.out.println("hash散列所有的域：" + set);
        //获取所有的值
        List list = redisTemplate.boundHashOps("s_key").values();
        System.out.println("hash散列所有的域值：" + list);
        //list列表
        redisTemplate.boundListOps("l_key").leftPush("c");
        redisTemplate.boundListOps("l_key").leftPush("b");
        redisTemplate.boundListOps("l_key").leftPush("a");
        //获取全部元素
        List l_key = redisTemplate.boundListOps("l_key").range(0, -1);
        System.out.println("列表的值：" + l_key);
        //set集合
        redisTemplate.boundSetOps("set_key").add("a", "b", "c");
        Set set_key = redisTemplate.boundSetOps("set_key").members();
        System.out.println("set集合中的所有元素：" + set_key);
        //sorted set有序集合
        redisTemplate.boundZSetOps("z_set").add("a", 30);
        redisTemplate.boundZSetOps("z_set").add("b", 20);
        redisTemplate.boundZSetOps("z_set").add("c", 10);
        Set z_set = redisTemplate.boundZSetOps("z_set").range(0, -1);
        System.out.println("zset有序集合中的所有元素：" + z_set);
    }
}

15、Spring Boot项目如何进行部署？
1.在pom文件添加打包插件将项目中的资源、配置、依赖包打成一个jar包

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

2.使用maven的package进行打包

3.部署运行：java -jar 包名