驴のSpringBoot学习笔记

部分资料来自于黑马程序员

1.SpringBoot入门

1.1在idea创建SpringBoot

如图所示在项目中创建新的模块，模块选择Spring Init ,特别提醒注意自己的SDK版本号（我是jdk8），然后正常的起名字，type选择maven，java版本选择你的版本（我是8）然后next

这里勾选Web，上方的springboot默认就好

1.2尝试创建一个开发控制器

创建java文件（SB是springBoot缩写）

尝试写一段代码

@RestController
@RequestMapping("/books")
public class SB {
    @GetMapping
    public String get(){


        System.out.println("hello world");
        return "hello world";
    }
}

1.3运行

可能出现的错误：

无效的发行版：

[^此图来自csdn：https://blog.csdn.net/booker009/article/details/129648180]:

意味着你idea中的java版本设置与springboot不一致，需要做两步：

1.Project Structure Modules/Project选择你的项目（以及父级项目，如果有的话）->选择8（你的jdk版本），如图

2.Setting： 2.查找java compiler->Target bytecode version

再次运行就好了

另外如果报错说你的8080接口被占用，可以在application.properties中重新配置TomCat端口

//输入以下代码
server.port:你想要的端口号

成功：

然后在浏览器的地址栏里输入：

localhost/books

即可访问刚刚编写的控制器

2.入门案例

注意，此案例是建立在已经学习过javaweb等相关知识的案例

1.创建新模组并初步创建项目相关目录

如下

其中：

config：用于放置一些项目中自己配制的MP配置

dao：Mapper文件（javaweb知识）

domain： 实体类

resources&test：均为自动生成，test中我自建了一个test类用来初步测试代码功能

2.pom.xml手动配置

<!--由于mybatis-plus（国人开发，功能强大！）， druid ，lombook在springboot中并没有默认配置，所以需要手动导入-->
<dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.8</version>
        </dependency>

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

jar包功能用到时会讲

3.application.yml配置

#数据库链接基本配置
server:
  port: 80
spring:
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql:///db2
      username: root
      password: 123456
#主要配置链接数据库名还有自增属性
mybatis-plus:
  global-config:
    db-config:   #因为MP是根据你的实体类名寻找数据库表，不设置的话名称不一致会找不到
      #例如：数据库表名：tb_stu 实体类：stu 这样就会不识别，可以在这里写 db-config: tb_
      id-type: auto #此处设置id为自增，不然会和MP冲突
#开启MP日志
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

4.domain目录

本案例调用的是本地的账号密码数据库

实体类用来作为数据库内容的封装，其中的属性名要和数据库的列名一致，不一致可以通过注解单独绑定名称：

@Column(name = "release_status")

@Data:来自lombok包，可以自动给导入的类中添加getter，setter等方法，简化开发

@TableName:用于指定链接哪个数据库,如果实体类名和数据库表名一致可以不写（存疑）

代码：

@Data//来自lombok  自动为实体类添加getter,setter,toString等方法
@TableName("users")

public class Users {
    private Integer id;
    private String username;
    private String password;
}

5.dao目录

该目录中的mapper接口用于实现代码与数据库之间的交互，底层是sql语句的掉调用

@Repository: Repository它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean,使之能够被扫描

@Mapper：用来标识这是Mapper类

extends BaseMapper：BaseMapper来自MP，里面定义了很多现成的方法，可以不用自己写sql语句了（国产就是牛逼）

<>中放实体类，这样从数据库读到的数据会默认封装成实体类

6.Application自带的启动器

注解：@SpringBootApplication

7.test目录

系统自带的我先不讲，说一说自己配的（其实都一样，只不过是照着葫芦画瓢）

@SpringBootTest：用来表示这是springboot测试类，这样才能被扫描到

@Autowired：自动导入，如果这地方报错，就说明前面Mapper没加注解

@Autowired
private UserMapper userMapper;

这个userMapper对象可以调用很多数据库操作方法

讲一下test的规则，只要加上@Test就说明这是测试方法，测试方法只是单纯测试方法中的代码逻辑和输出是否报错，是否符合我们所期待的输出，所以测试方法是不需要返回值和参数的

额外说一下分页操作：

//分页操作
    @Test
    void getPage(){
        IPage page = new Page(1, 5);

        //直接这样写是不对的,因为MP中的拦截器没有配置
        userMapper.selectPage(page,null);
    }

拦截器在config中配置

8.config配置

/**
 * @Author 林峰
 * @Date
 * @Version 1.0
 */
//用来放MP的某些配置

@Configuration//注释成配置类
public class MPConfig {
    @Bean
    //配置Bean才能被扫描到
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        //两件事：1.把拦截器配置出来 2.return出去
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();//拦截器的壳
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return interceptor;
    }
}

这样我们的分页操作就可以用了

9.关于条件查询操作

MP下的条件查询需要配置条件构造器，然后把构造器放在查询语句中，在后台sql语句上会自动加上构造器中的条件

一些构造器条件：

queryWrapper.eq(Employee::getUsername,employee.getUsername());

两个参数，第一个参数是数据库的列名，第二个参数是查询条件（两个参数合起来，就是sql语句中的where）

需要特别注意的是：如果查询条件的值设置为null，则null会被识别为字符串，要避免这种情况发生，需要要在设置查询条件时就加入判断例如

lqw1.like(tiaojian != null,Users::getUsername,tiaojian);

若为true则拼接条件，false则不拼接

10.一般开发流程

1. 首先编写实体类，方便后面封装
2. 写实现类（mapper），在javaweb中该类要映射.xml文档来编写sql语句操作数据库，SpringBoot简化了这一过程，可以直接继承现有的类
3. 写服务端接口，也就是上图的UserService，里面定义了很多业务方法
4. 写impl接口实现类，实现定义的服务端接口，并实现其中的方法，javaweb中需要获得mapper来调用方法，SpringBoot中同样也需要
5. 表现层（前端）

11.MP快速开发

上文中提到的3,4步在MP中得到了简化开发

首先是服务端接口，现在不需要自己手动写一些基础操作的方法（增删改查）

直接继承官方提供的接口类，里面有很多基础的方法，传入泛型为实体类

其次是接口实现类

也是继承官方提供的ServiceImpl类，传入的两个泛型，一个是实现类Mapper，另一个是实体类，虽然简化开发了，但是仍然需要mapper（只是把我们一般开发的过程给封装成类，在后台执行，具体流程其实不变）

注意不要忘了继承接口

另外MP只是提供了某些基础方法，如果需要自定义或重写，还是得按老流程，现在接口中定义，然后在实现类中实现

12.完成Controller

在完成上面的一系列服务端代码并测试完之后，就可以写controller了

例如：

@RequestMapping()：这里定义的是访问路径，如果要访问你的springboot，则需要在浏览器中输入”http://localhost/ + 你在RequestMapping()写的路径”

下面的注解都是spring定义好的，例如GetMapping就是以get方式发送请求，PostMapping是Post请求

在这里引用一篇知乎文章，我认为讲得很全面，可以给之前没了解过的同学补补课：https://zhuanlan.zhihu.com/p/137507309

13.启动我们的Spring

springboot项目在创建时自带启动器，就是根目录下的XXXApplication，右键启动它

启动成功

14.利用API接口调试工具来检测我们的代码

很多老师推荐postman，但这玩意儿收费，我在网上找到了个叫Apifox的网站，可以实现在线调试，我用了一下，感jio还不错（建议使用edge浏览器，他自带插件）

调试窗口，还是比较方便的，具体操作可以到apifox主页，里面有教程。

15.前后端数据一致性处理（小优化）

我们在完成了上面的所有步骤，并能在调试工具中看到返回值时，就说明我们的开发已经完成一大部分了，但这里有一个小问题，我们后端的返回值类型不一致，例如getAll返回的是list列表，getById返回的是单个实体类，增删改查返回的是boolean，这些返回类型会对前端开发造成一定麻烦，所以我们需要统一返回类型

list：

boolean：

实体类：

返回类型很多

统一返回类型：

新建返回类型的封装类：

flag：后端代码是否正常执行（为了区分是找不到返回null还是出错返回null）

data：数据内容

把之前写好的controller中的方法，返回值都改成R

这样返回的就是统一的R类型了

！（补充）常用注解(一般我在学习过程中遇到不理解的都会在这里更新)：

@SpringBootApplication

这是一个组合注解

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

@SpringBootConfiguration,这个注解可以标注配置文件，在其中可以声明Bean对象

@EnableAutoConfiguration 自动配置

@ComponentScan 组件扫描，通过它能找到注解@Component

@Controller

注解控制类，可以在里面写业务方法

@Value(“${}”)

可以获取配置文件里的值

另外如果我们想将配置文件里的数据拿出来单独封装成一个类，我们需要用到

@ConfigurationProperties(prefix = "")

这个注解可以从配置文件里取值给类中的属性赋值，prefix这玩意儿后面可以给定一个名称前缀，比如我配置文件中有属性：user.username，user.password…,我想要取值，给我封装类里的属性username，password赋值，我就需要写prefix = “user”,这样就可以实现，注意属性名称要一致

@RequestBody

倘若前端传的数据为json格式，那就再参数前加这个注解

@PathVariable

一般路径中传键值对时，我们是不需要写这条注解的，但如果是路径中直接带值

@ResponseBody

一般写在服务方法上，将方法返回的东西转换为json字符串供前端接受

@Mapper

放在dao接口上面

/**
 * @Author 林峰
 * @Date
 * @Version 1.0
 * @Mapper: 告诉Mybatis这是dao接口，创建此接口的代理对象  位置：类的上面
 *
 */
@Mapper
public interface UserDao {

    List<User> getAll();
}

另外如果将来dao太多，一个一个加@Mapper太累，可以选择在Application上加@MapperScan

@MapperScan(basePackages = "com.lf.dao")
//这样就可以把dao包下的所有的dao扫描进去

Rest风格

@GetMapping()

获取前端参数，首先需要在GetMapping加占位符，比如@GetMapping(/user/{id})

然后就是获取路径中的数据

假如有如下方法

public String getById(@PathVariable("id")Interger id)

这样访问路径里的参数就赋值给了方法参数id

3.配置文件4级分类

我们开发过程中用的配置文件都是我们程序员方便开发测试的，等开发结束项目经理会有自己的配置，甲方也有别的要求，还有涉及到保密的行业（例如：银行），是不会告诉你配置的，所以boot就提供了配置覆盖的操作，一共有四个等级，高等级的配置可以覆盖低等级的

如图：

4.多环境开发

yaml版

也可以将多个环境写成文件

maven配置boot环境：

会自动读取maven配置

5.日志

1.日志对象创建

3.lombok简化日志开发

当我们导入了lombok包后，就不用麻烦在每一个类中都加一个log的声明了。只需要在类上加注释@Slf4j,然后就可以正常使用注释了

4.日志输出格式控制

一条日志：

解读

时间：这个不用多讲

级别：这个日志的级别，也没什么好说的

PID：进程ID，表示当前操作所处的进程，当多服务同时记录时，方便调试

所属类：发出日志的类名，长的类名boot会自动简化

日志信息：自定义

5.日志输出为文件（很常用）

6.第三方Bean属性绑定

1.注解

@ConfigurationProperties

@EnableConfigurationProperties

@EnableConfigurationProperties注解可以将使用@ConfigurationProperties注解的类加入Spring容器

@EnableConfigurationProperties(ServerConfig.class)

@ConfigurationProperties(prefix = "第三方bean名")

需要注意的是@EnableConfigurationProperties有两个功能，一是开启引用类的第三方bean数据绑定，二是将引用类加入Spring容器（和@Component作用相同），所以两者不能共存，切记！

题外话

yml文件里int的解析类型支持二进制，八进制，十六进制

现有一情景：一位同学在yml中配置数据库连接信息时，将password设置为：0127，然后连接数据库时一直报错密码错误（正确密码就是0127），原因是什么

因为yml中对int解析支持八进制，而八进制是以0开头，所以yml中将0127识别为八进制，最终读取的密码为87（0127八进制转十进制），故出错，解决方法其实只要将yml配置文件里的int属性变成字符串，即password: “0127”，即可解决。

7.测试类测试web（前端）

1.虚拟一个web环境

测试类注解@SpringBootTest()

如果直接启动测试类，这样只是启动了一个普通的java类，而不是web类，这样无法做到测试表现层（前端）

解决：@SpringBootTest(webEnviroment = SpringBootTest.webEnvironment.RANDOM_PORT)

2.开启虚拟MVC调用

@AutoconfigureMockMvc注解，用来开启虚拟MVC

然后我们需要一个虚拟Mvc对象：

@Autowired MockMvc mvc;

然后我们需要创建一个虚拟请求buider：

MockHttpServletRequestBuilder builder = MockRequestBuilders.get/put/post/delete等（”/访问路径”）

用mvc对象调用perform方法，放入我们的builder

mvc.perform(buider)即可

8.从容器中手动获取对象

假如现在我们有一个服务类：

@Service("userService")
public class UserServiceImpl implements UserService {
    @Override
    public void say(String name) {
        System.out.println(name + "hello world");
    }
}

我们怎样才能在类中通过手动方法获得该服务类的一个对象，从而调用我们的服务方法

即利用我们SpringBoot主方法里的run方法，它会返回一个容器对象，之后可以用getBean获得我们需要的对象了

Web：

1.拦截器

拦截器是SpringMvc中的一种对象，他可以拦截对后端的请求，可以自定义拦截器

1.自定义拦截器：

1.创建类实现SpringMVC框架的HandlerInterceptor接口

你可以在拦截器里写验证或者是对数据筛选过滤，此处只做测试，所以就输出了一句话

/**
 * @Author 林峰
 * @Date
 * @Version 1.0
 * 这里配置了一个自定义拦截器类
 */
public class LoginInter implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {

        /**
        * @Description:
        * @Params: [request, response, handler]
         * handler:被拦截的控制器对象
        * @Return boolean
         * true:放行
         * false：截断
        */
        System.out.println("执行了拦截器");
        return true;
    }
}

2.创建配置类，将我们自定义的拦截器注册到容器里

/**
 * @Author 林峰
 * @Date
 * @Version 1.0
 * 这里用来配置拦截器
 */
@Configuration
public class MyConfig implements WebMvcConfigurer {
    //添加拦截器对象，注入容器中
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        /**
        * @Description:
        * @Params: [registry]
         * InterceptorRegistry registry: 这玩意是个注册器，把你自定义的拦截器塞里面就
         * 可以注册了（相当于之前在xml注册，spring简化咯）
        * @Return void
        */
        //创建拦截器对象
        LoginInter loginInter = new LoginInter();

        //这种路径一般都指定一个字符串数组，比较方便
        //拦截
        String[] path = {"/user/**"};
        //不拦截
        String[] excludepath = {"/user/Login"};

        //addPathPatterns() 配置拦截路径
        //excludePathPatterns() 配置放行路径
        registry.addInterceptor(loginInter)
                .addPathPatterns(path)
                .excludePathPatterns(excludepath);
    }
}

看结果：

先访问了user/Login

因为没有拦截这个url，所以直接访问了我们的controller

然后访问/user/a

可以看到，先进入了我们的拦截器，触发了拦截器的输出，只不过拦截器放行了，所以依旧可以正常访问controller

2.使用Servlet

1.创建Servlet类。继承HttpServlet

//创建Servlet类
public class MyServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        PrintWriter out = resp.getWriter();

        out.println("Servlet执行");
    }
}

2.注册Servlet，放入SpringBoot框架里

@Configuration
public class Myconfig {

    //public ServletRegistrationBean(T servlet, String... urlMappings)
    //第一个参数是 Servlet对象 ，第二个是url地址

    //定义方法，注册Servlet
    @Bean
    public ServletRegistrationBean servletRegistrationBean(){
        ServletRegistrationBean bean
                = new ServletRegistrationBean(new MyServlet(),"/myservlet");
        //        也可以这样设置
//        bean.setServlet();
//        bean.setUrlMappings();
        return bean;
    }

}

注意一定要加@Bean

3.Filter过滤器

Filter是Servlet规范的过滤器，一般用来处理字符编码

1.创建自定义过滤器类

/**
 * @Author 林峰
 * @Date
 * @Version 1.0
 * 自定义过滤器
 */

public class Myfilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("执行过滤器");
        filterChain.doFilter(servletRequest,servletResponse);
    }
}

2.注册Filter对象

//注册Filter拦截器
@Bean
public FilterRegistrationBean filterRegistrationBean(){
    FilterRegistrationBean bean = new FilterRegistrationBean();

    bean.setFilter(new Myfilter());
    bean.addUrlPatterns("/user/*");

    return bean;

}

这里顺便提一个Filter的最常用应用方式：字符集过滤器（框架自带）

作用：解决post请求乱码问题

由于是框架自带的，所以只需要自己注册，将系统自带的过滤器放到注册Bean中

1.在容器中注册过滤器

@Bean
public FilterRegistrationBean filterRegistrationBean(){
    FilterRegistrationBean bean = new FilterRegistrationBean();

    //是用自带的过滤器对象
    CharacterEncodingFilter filter = new CharacterEncodingFilter();

    //指定使用的编码方式
    filter.setEncoding("utf-8");

    //指定req，resp都使用设定的编码
    filter.setForceEncoding(true);

    bean.setFilter(filter);
    bean.addUrlPatterns("/*");

    return bean;
}

2.设置过滤器使用编码等

因为这是专用的字符过滤器，所以可以直接设置

//指定使用的编码方式
filter.setEncoding("utf-8");

//指定req，resp都使用设定的编码
filter.setForceEncoding(true);

3.在配置文件中设置

server:
  port: 80
  servlet:
  #    将boot默认配置的过滤器关闭
    encoding:
      enabled: false

其实上面的方法略有脱裤放p之意😆

既然系统有自带的过滤器，我们可以直接修改默认过滤器的编码，以此来实现我们自己想要的效果

  servlet:
    encoding:
      charset: utf-8
#      把res，req都配置成我们的编码
      force: true
      enabled: true

9.ORM操作数据库（Mysql）

大体步骤：

1. mybatis起步依赖：完成mybatis对象自动配置
2. 创建实体类（对应数据库属性）
3. 创建Dao接口，在接口中写方法名
4. 写Dao接口对应的mapper文件，在mapper中写sql语句操作数据库
5. 配置pom文件，将mapper.xml包含到类路径中
6. 创建Service接口和实现类，调用dao方法
7. 创建Controller，访问service
8. 写配置类文件，在文件里配置数据库连接信息

具体实现：

1. 起步依赖：

   SpringBoot里整合了mybatis,只需要在创建项目时选择就可以

​

2.实体类

public class User {
    private String username;
    private String password;

    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 "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

3.dao接口

/**
 * @Author 林峰
 * @Date
 * @Version 1.0
 * @Mapper: 告诉Mybatis这是dao接口，创建此接口的代理对象  位置：类的上面
 *
 */
@Mapper
public interface UserDao {

    List<User> getAll();
}

记得加@Mapper，@Mapper在上面专门讲注解的章节里有

4.mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lf.dao.UserDao">

    <select id="getAll" resultType="com.lf.pojo.User">
        select * from users
    </select>
</mapper>

注意dao和mapper的分离，符合规范

这样需要配置两处地方：

一是：配置文件中

mybatis:
#Mapper文件位置
  mapper-locations: classpath:mapper/*.xml

二是：在pom文件中设置,把mapper放入资源中

<build>
<!--resource插件-->
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
            </resource>
        </resources>
</build>

6.Service接口和实现类

public interface UserService {

    List<User> getAll();
}

这个没什么好说的

@Service
public class UserServiceImpl implements UserService {

    @Resource
    private UserDao userDao;

    @Override
    public List<User> getAll() {
        return userDao.getAll();
    }
}

实现类，@Service用来标识服务类

7.Controller

@Controller
public class Mycontroller {
    @Resource
    private UserService userService;

    @RequestMapping("/")
    @ResponseBody
    public String AllUser(){
        List<User> users = userService.getAll();
        System.out.println(users);
        return users.toString();

    }
}

8.配置文件

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql:///db2?useSSL=false&useServerPrepStmts=true&useUnicode=true&characterEncoding=UTF-8
    username: root
    password: *****


server:
  port: 80
mybatis:
#Mapper文件位置
  mapper-locations: classpath:mapper/*.xml
#日志
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

如果想在控制台看到sql语句，就需要配置日志

10.事务开启

什么是事务：简单说事务就是把多条语句绑在一起，要执行成功就一起成功，如果其中有一条失败（出错）就会回滚

Springboot中使用事务：

1）在业务方法上面加@Transactional,加上后就有事务功能了

2）明确在主启动类上面加@EnableTransactionManager