spring boot 基础配置

最新推荐文章于 2021-07-06 14:17:03 发布

feifeiwuxian

最新推荐文章于 2021-07-06 14:17:03 发布

阅读量148

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/feifeiwuxian/article/details/108462131

版权

java 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

我直接先贴下项目代码吧

https://github.com/feifeiwuxian/my_spring_boot

一、创建简单的web工程

需求：可以在浏览器中访问http://localhost:8080/hello输出一串字符

实现步骤：

创建工程；
添加依赖（启动器依赖，spring-boot-starter-web）；
创建启动类；
创建处理器Controller；
测试

小结：

Spring Boot工程可以通过添加启动器依赖和创建启动引导类实现快速创建web工程。

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

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

    <groupId>com.wf</groupId>
    <artifactId>my_spring_boot</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--默认package打包方式 是jar-->

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.6</version>
        </dependency>

        <!--配置文件处理器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <!--不传递依赖-->
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--事务-->
        <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.47</version>
        </dependency>

        <!--整合mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>
        <!--通用mapper-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

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

        <!--打包-->
</dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

二、数据源的配置方案演进

2.1 通过 java代码的注解实现

目标：可以使用@Value获取配置文件配置项并结合@Bean注册组件到Spring

分析：

需求：使用Java代码配置数据库连接池，并可以在处理器中注入并使用

步骤：

添加依赖；
创建数据库；
创建数据库连接参数的配置文件jdbc.properties；
创建配置类；
改造处理器类注入数据源并使用

jdbcConfig类

//@Configuration
//@PropertySource("classpath:jdbc.properties")
//public class JdbcConfig {
//    @Value("${jdbc.url}")
//    String url;
//    @Value("${jdbc.driverClassName}")
//    String driverClassName;
//    @Value("${jdbc.username}")
//    String username;
//    @Value("${jdbc.password}")
//    String password;
//
//    @Bean
//    public DataSource dataSoruce() {
//        DruidDataSource dataSource = new DruidDataSource();
//        dataSource.setDriverClassName(driverClassName);
//        dataSource.setUrl(url);
//        dataSource.setUsername(username);
//        dataSource.setPassword(password);
//        return dataSource;
//    }
//}

//@Configuration
//@EnableConfigurationProperties(JdbcProperties.class)
//public class JdbcConfig {
//    @Bean
//    public DataSource dataSoruce(JdbcProperties jdbcProperties) {
//        DruidDataSource dataSource = new DruidDataSource();
//        dataSource.setDriverClassName(jdbcProperties.getDriverClassName());
//        dataSource.setUrl(jdbcProperties.getUrl());
//        dataSource.setUsername(jdbcProperties.getUsername());
//        dataSource.setPassword(jdbcProperties.getPassword());
//        return dataSource;
//    }
//}


//@Configuration
//public class JdbcConfig {
//    @Bean
//    @ConfigurationProperties(prefix = "jdbc")
//    public DataSource dataSoruce() {
//        DruidDataSource dataSource = new DruidDataSource();
//        return dataSource;
//    }
//}

2.2使用Spring Boot属性注入方式

目标：能够使用@ConfigurationProperties实现Spring Boot配置文件配置项读取和应用

分析：

需求：将配置文件中的配置项读取到一个对象中；

实现：可以使用Spring Boot提供的注解@ConfigurationProperties，该注解可以将Spring Boot的配置文件（默认必须为application.properties或application.yml）中的配置项读取到一个对象中。

实现步骤：

创建配置项类JdbcProperties类，在该类名上面添加@ConfigurationProperties；
将jdbc.properties修改名称为application.properties；
将JdbcProperties对象注入到JdbcConfig；
测试

上面用到的jdbcProperties

package com.wf.config;


import org.springframework.boot.context.properties.ConfigurationProperties;

//@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {
    private String url;
    private String driverClassName;
    private String username;
    private String password;

    public String getUrl() {
        return url;
    }

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

    public String getDriverClassName() {
        return driverClassName;
    }

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

    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;
    }

    @Override
    public String toString() {
        return "JdbcProperties{" +
                "url='" + url + '\'' +
                ", driverClassName='" + driverClassName + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

2.3 spring项目直接是配置的数据库连接池

默认带的有jdbc

通过yml或者yaml配置

贴一下yaml配置

jdbc:
  driverClassName: com.mysql.jdbc.Driver
  url: jdbc:mysql://127.0.0.1:3306/springboot_test
  username: root
  password: abc123456

#激活配置文件
spring:
  profiles:
    active: abc
#    active: abc,def
  mvc:
    view:
      prefix: /WEB-INF/
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/springboot_test
    username: root
    password: abc123456
  redis:
    host: localhost
    port: 6379

#tomcat端口修改
server:
  port: 8088
#日志级别
logging:
  level:
    com.wf: debug
    com.spring: info
mybatis:
  #配置实体类别名包路径
  type-aliases-package: com.wf.pojo
  #映射文件路径
#  mapper-locations: classpath:mappers/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

yml名称必须是application.yml 或.yaml

还需要创建Application启动引导类

可以通过一个插件JBLSpringBootAppGen生成

这里贴下Application的代码

package com.wf;


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

import java.util.ArrayList;

/**
 * spring,启动引导类
 */
@SpringBootApplication
// 扫描mabatis里mappter
//@MapperScan("com.wf.mapper")

// 改造为通用mapper // 要用tk开头的
@MapperScan("com.wf.mapper")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

这里也贴也其它代码

userMapper类

package com.wf.mapper;

import com.wf.pojo.User;
import org.springframework.stereotype.Repository;
import tk.mybatis.mapper.common.Mapper;

@Repository
public interface UserMapper extends Mapper<User> {
}

User类

package com.wf.pojo;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import tk.mybatis.mapper.annotation.KeySql;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;

// 在编译阶段会根据注解自动生成对应的方法； data包含get/set/hashCode/equals/toString等方法
@Data
//@Slf4j
@Table(name = "tb_user")
public class User {

    @Id // 主键
    @KeySql(useGeneratedKeys = true) // 主键回填
    private String id;

//    @Column(name = "abc")
    // user_name --> userName
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;

}

UserService类

package com.wf.service;


import com.wf.mapper.UserMapper;
import com.wf.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

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

    // 新增保存用户
    @Transactional // 事务配置
   public void saveUser(User user) {
       System.out.println("新增用户");
       // 选择性新增，如果属性为空，则该属性不会出现在insert语句
        userMapper.insertSelective(user);
        int i = 1/0;
   }
}

yml文件的一些使用方法

目标：可以将多个yml文件在application.yml文件中配置激活

分析：

yaml与properties配置文件除了展示形式不相同以外，其它功能和作用都是一样的；在项目中原路的读取方式不需要改变。

1）yml配置文件的特征：

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

2）多个yml配置文件；在spring boot中是被允许的。这些配置文件的名称必须为application-***.yml，并且这些配置文件必须要在application.yml配置文件中激活之后才可以使用。

3）如果properties和yml配置文件同时存在在spring boot项目中；那么这两类配置文件都有效。在两个配置文件中如果存在同名的配置项的话会以properties文件的为主。

四、Spring Boot整合-SpringMVC拦截器

MyInterceptor代码

package com.wf.interceptor;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Slf4j
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.debug("这是preHandle");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.debug("这是postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.debug("afterCompletion");
    }
}

如果想要查看或修改配置，举例查看spring web项目静态资源

spring boot自动装配的原理，跟进Application类中 SpringApplication.run方法，最终可找到下图，

五、lombok应用

目标：使用lombok的注解实现pojo类的简化

分析：

使用Spring Boot整合SSM工程；需要使用到数据库数据。

将数据库表数据导入到数据库中（springboot_test）；
编写数据库表对应的实体类；一般情况下需要编写get/set/toString等这些方法会耗时并且会让实体类看起来比较臃肿。可以使用lombok插件对实体类进行简化。

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

小结：

在Bean上使用： @Data ：自动提供getter和setter、hashCode、equals、toString等方法 @Getter：自动提供getter方法 @Setter：自动提供setter方法 @Slf4j：自动在bean中提供log变量，其实用的是slf4j的日志功能。

六、Spring boot整合-事务和连接池

目标：配置Spring Boot自带默认的hikari数据库连接池和使用@Transactional注解进行事务配置

分析：

事务配置
1. 添加事务相关的启动器依赖，mysql相关依赖；
2. 编写业务类UserService使用事务注解@Transactional
数据库连接池hikari配置

只需要在application配置文件中指定数据库相关参数

小结：

事务配置；只需要添加jdbc启动器依赖
数据库连接池使用默认的hikari，在配置文件中配置如下：

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/springboot_test
    username: root
    password: root

九、Spring Boot整合-Mybatis

目标：配置Mybatis在Spring Boot工程中的整合包，设置mybatis的实体类别名，输出执行sql语句配置项

分析：

添加启动器依赖；
配置Mybatis：实体类别名包，日志，映射文件等；
配置MapperScan

小结：

添加mybatis官方对于spring boot的一个启动器

十、Spring Boot整合-通用Mapper

目标：配置通用Mapper组件到Spring Boot项目中并使用Mapper接口

分析：

通用Mapper：可以实现自动拼接sql语句；所有的mapper都不需要编写任何方法也就是不用编写sql语句。可以提高开发效率。

添加启动器依赖；
改造UserMapper继承Mapper；
修改启动引导类Application中的Mapper扫描注解；
修改User实体类添加jpa注解；
改造UserService实现业务功能；

小结：

在启动引导类上面的mapper扫描注解一定要修改为通用mapper的扫描注解

十一、Spring Boot整合测试

目标：可以访问处理器对应路径将数据库中的数据根据id查询

分析：

改造HelloController，注入UserService利用其方法实现查询；
启动项目进行测试 http://localhost/user/用户id --> http://localhost/user/8

小结：

修改了HelloController：

package com.wf.controller;


import com.wf.pojo.User;
import com.wf.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;

@RestController
public class HelloController {
    @Autowired
    private DataSource dataSource;

    @Value("${feifei.url}")
    private String url;

    @Autowired
    private UserService userService;

    /**
     * 根据用户id查询用户
     * @param id
     * @return
     */
    @GetMapping("/user/{id}")
    public User queryById(@PathVariable Long id) {
        return userService.quryById(id);
    }
    @GetMapping("hello")
    public String hello(){
        System.out.println(url);
        System.out.println("DataSorce = " + dataSource);
        return "Hello Spring boot!";
    }
}

十二、Spring Boot整合-Junit

目标：在Spring Boot项目中使用Junit进行单元测试UserService的方法

分析：

添加启动器依赖spring-boot-starter-test；
编写测试类

小结：

UserServiceTest类

package com.wf.service;

import com.wf.pojo.User;
import org.junit.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 java.util.Date;

import static org.junit.Assert.*;

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

    @Autowired
    private UserService userService;


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

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

十三、Spring Boot整合-redis

目标：在Spring Boot项目中使用Junit测试RedisTemplate的使用

分析：

添加启动器依赖；spring-boot-starter-data-redis
配置application.yml中修改redis的连接参数；（redis需要启动）
编写测试类应用RedisTemplate操作redis中的5种数据类型（string/hash/list/set/sorted set）

小结：

RedisTest类

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

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void test(){
        //string 字符串
        //redisTemplate.opsForValue().set("str", "feifei");
        redisTemplate.boundValueOps("str").set("feifei");
        System.out.println("str = " + redisTemplate.opsForValue().get("str"));

        //hash 散列
        redisTemplate.boundHashOps("h_key").put("name", "feifei");
        redisTemplate.boundHashOps("h_key").put("age", 13);
        //获取所有域
        Set set = redisTemplate.boundHashOps("h_key").keys();
        System.out.println(" hash散列的所有域：" + set);
        //获取所有值
        List list = redisTemplate.boundHashOps("h_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 = redisTemplate.boundListOps("l_key").range(0, -1);
        System.out.println(" list列表中的所有元素：" + list);

        // set 集合
        redisTemplate.boundSetOps("s_key").add("a", "b", "c");
        set = redisTemplate.boundSetOps("s_key").members();
        System.out.println(" set集合中的所有元素：" + set);

        // sorted set 有序集合
        redisTemplate.boundZSetOps("z_key").add("a", 30);
        redisTemplate.boundZSetOps("z_key").add("b", 20);
        redisTemplate.boundZSetOps("z_key").add("c", 10);
        set = redisTemplate.boundZSetOps("z_key").range(0, -1);
        System.out.println(" zset有序集合中的所有元素：" + set);
    }
}

十四、Spring Boot项目部署

目标：将Spring Boot项目使用maven指令打成jar包并运行测试

分析：

需要添加打包组件将项目中的资源、配置、依赖包打到一个jar包中；可以使用maven的package；
注意，可以省略掉test步骤
部署：java -jar 包名

小结：

添加打包组件

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

部署运行