springboot

说明

Spring Boot让我们的Spring应用变的更轻量化
我们不必像以前那样繁琐的构建项目、打包应用、部署到Tomcat等应用服务器中来运行我们的业务服务。
通过Spring Boot实现的服务，只需要依靠一个Java类，把它打包成jar，并通过java -jar命令就可以运行起来。
依赖说明

1. Maven  需求：3.5+
2. JDK 需求  8+
3. Spring Framework 5.3.7以上版本
4. Tomcat 9.0
5. Servlet版本 4.0  但是可以部署到Servlet到3.1+的容器中

快速入门

依赖文件

<!--springboot的父工程其中定义了常用的依赖，并且无依赖冲突-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
    </parent>

注意上方的parent必须加，其中定义了springboot官方支持的n多依赖，基本上常用的已经有了，所以接下来导入依赖的时候，绝大部分都可以不加版本号。

添加web依赖

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

添加上方的web依赖，其中间接依赖了spring-web，spring-webmvc，spring-core等spring和springmvc的包，并且集成了tomcat。

编写启动类.src-main-java-对应的包目录下

package xyz.shi;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class HelloApp {

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

@SpringBootApplication注解标识了HelloApp为启动类，也是Spring Boot的核心。

运行后发现下面的日志，tomcat端口为8080

如果想要修改端口号，可以在resources目录下新建application.properties，然后重写运行即可

1	server.port=8082

编写一个Http接口

创建HelloController类，内容如下

package xyz.shi.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("hello")
public class HelloController {

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

}

重启程序，使用postman或者直接在浏览器输入http://localhost:8082/hello/boot

单元测试

加入依赖

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

在src/test/java/xyz.shi 下，编写测试用例

package xyz.shi;

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import xyz.shi.controller.HelloController;

import static org.hamcrest.Matchers.equalTo;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
public class TestHelloController {

    private MockMvc mockMvc;

    @BeforeEach
    public void beforeEach() {
        mockMvc = MockMvcBuilders.standaloneSetup(new HelloController()).build();
    }

    @Test
    public void testHello() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/hello/boot")
                        .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(content().string(equalTo("hello spring boot")));
    }
}

对Controller进行单元测试，需要用到mock

测试类的包需要和启动类HelloApp的包一致

打包为jar运行

添加打包(maven构建springboot)插件

<build>
      <plugins>
          <plugin>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
      </plugins>
  </build>

打开idea中的project Structure，选中Artifacts，点击中间的加号（Project Settings->Artifacts->JAR->From modules with dependencies ），如下图所示：

开始打包，点击右侧的Maven Projects，打开LIfecycle，先点击clean，再点击package，生成target文件夹，里面有以项目名命名加版本号的jar文件，至此打包完成。

,IDEA会自动开始把项目所有需要的文件和依赖包到打包到一个jar里面，完成后左侧目录栏里的target文件下会出现两个神奇的文件

进入jar所在的文件夹，使用java -jar命令运行jar，项目就能启动

Administrator@WIN-20230710BAT MINGW64 /d/project/StudySpringBoot/target
$ java -jar StudySpringBoot-1.0-SNAPSHOT.jar

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/

测试，使用postman或者直接在浏览器输入http://localhost:8082/hello/boot
得到结果：hello spring boot
jar tvf XXX.jar 可以查看包的内容

工程结构

略，参考此内容

配置文件详解

整合MybatisPlus

依赖文件

<dependencies>
       <!--web依赖 -->
       <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>
       <!--mybatis -->
       <dependency>
           <groupId>com.baomidou</groupId>
           <artifactId>mybatis-plus-boot-starter</artifactId>
           <version>3.4.3</version>
       </dependency>
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
       </dependency>
       <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
       </dependency>

   </dependencies>

resources-application.properties 配置数据库信息

server.port=8082

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdb

实体类

package xyz.shi.pojo;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
@TableName("users")
@Data
public class User {
    private Integer id;
    private String name;
    private String password;
}

mapper

package xyz.shi.mapper;

import xyz.shi.pojo.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
public interface UserMapper extends BaseMapper<User> {
}

config扫描mapper

package xyz.shi.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan("xyz.shi.mapper")
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

service

package xyz.shi.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import xyz.shi.mapper.UserMapper;
import xyz.shi.pojo.User;
import java.util.List;

@Service
@Slf4j
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public List<User> findAll() {
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        List<User> users = userMapper.selectList(queryWrapper);
        return users;
    }

    //分页
    public List<User> findPage(Integer CurrentPage, Integer PageSize) {
        System.out.println(CurrentPage);
        System.out.println(PageSize);
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        Page page = new Page(CurrentPage, PageSize);
        Page<User> userPage = userMapper.selectPage(page, queryWrapper);
        log.info("total:{}", userPage.getTotal());
        log.info("pages:{}", userPage.getPages());
        return userPage.getRecords();
    }
}

resource-logback-spring.xml 加上日志文件配置

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <contextName>logback</contextName>
    <!-- 格式化输出：%date表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %msg：日志消息，%n是换行符-->
    <property name="LOG_PATTERN" value="%date{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" />
    <!-- 定义日志存储的路径，不要配置相对路径 -->
<!--    <property name="FILE_PATH" value="/Users/Adm/spring-log.%d{yyyy-MM-dd}.%i.log" />-->
    <property name="FILE_PATH" value="d:/log/spring-log.%d{yyyy-MM-dd}.%i.log" />
    <!-- 控制台输出日志 -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 日志级别过滤INFO以下 -->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFO</level>
        </filter>
        <encoder>
            <!-- 按照上面配置的LOG_PATTERN来打印日志 -->
            <pattern>${LOG_PATTERN}</pattern>
        </encoder>
    </appender>
    <!--每天生成一个日志文件，保存30天的日志文件。rollingFile用来切分文件的 -->
    <appender name="rollingFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${FILE_PATH}</fileNamePattern>
            <!-- keep 15 days' worth of history -->
            <maxHistory>30</maxHistory>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <!-- 日志文件的最大大小 -->
                <maxFileSize>2MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!-- 超出删除老文件 -->
            <totalSizeCap>1GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>${LOG_PATTERN}</pattern>
        </encoder>
    </appender>
    <!-- logger节点，可选节点，作用是指明具体的包或类的日志输出级别，
    以及要使用的<appender>（可以把<appender>理解为一个日志模板）。
    addtivity：非必写属性，是否向上级loger传递打印信息。默认是true-->
    <logger name="net.sh.rgface.serive" level="ERROR" />
    <!--项目的整体的日志打印级别为info-->
    <root level="INFO">
        <appender-ref ref="console" />
        <appender-ref ref="rollingFile" />
    </root>
</configuration>

UserController

package xyz.shi.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import xyz.shi.pojo.User;
import xyz.shi.service.UserService;
import java.util.List;

@RestController
@RequestMapping("user")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("findAll")
    public List<User> findAll() {
        return userService.findAll();
    }

    @GetMapping("findPage")
    public List<User> findPage(Integer CurrentPage, Integer PageSize) {
        return userService.findPage(CurrentPage, PageSize);
    }
}

启动后浏览器访问 http://localhost:8082/user/findPage?CurrentPage=1&PageSize=1

日志文件

最终源代码

总结

spring系列暂时告一段落，后面开展学习vue方面的知识并且结合springboot