SpringBoot2.x学习笔记基础篇

零、前期准备

1. 要想创建springboot项目，首先得要有MAVEN(项目管理jar包依赖工具) 如果没有，可以参考一下这篇博客:(1条消息) 菜鸟教你如何安装MAVEN(还是不会，我把电脑吃咯)_Brilliant.Louis的博客-CSDN博客_maven安装不上

2. 然后打开idea，将安装maven的本地路径设置为默认，这样以后每次创建新项目就不用每次都要重新设置maven的路径了。

   • File->New Projects Setup->Setting for New Projects

   

   • Build->Build Tools->Maven

     ps:要点击Override按钮，这样才能选中自己安装的maven文件的路径了。这作用相当于将maven的安装路径设置为全局控制了！

一、创建springboot项目步骤:

• 基于IDEA

  1. new project(创建一个新工程)->选中Spring Initializr

     • 项目文件名(可自定义)
     • Location 项目文件位置(可自定义)
     • 默认语言java
     • jdk版本(建议1.8)
     • java(建议java8)

     

  2. 设置springboot的版本2.x

  

  3. springboot的web开发——添加springWeb依赖

     点击上图Web->Spring Web ->create 成功如下图:
     

  4. 运行application文件(启动类文件)

     位置:src->main->java->com.example.xxx->xxxApplication

     如下图:即为运行成功
     

• 基于国外官网

https://start.spring.io（步骤如上一致，只是界面不一样而已）

• 基于国内官网，但依旧是在IDEA中操作
  

默认地址Default为spring官网

自定义custom国内官网:https://start.aliyun.com（更快）

博客详述:(2条消息) springboot系列(一):如何创建springboot项目及启动?| 超级详细，建议收藏_springboot 项目启动_bug菌¹的博客-CSDN博客

• 基于手工(了解即可)

  • 步骤

    1）创建普通的Maven工程

    2）继承spring-boot-starter-parent

    <parent>
        <groupId>模块名</groupId>
        <artufactUd>spring-boot-starter-parent</artufactUd>
        <version>自己选用的springboot的版本号</version>
    </parent>
    <!--我自己用的springboot版本是2.7.7-->
    

    3）添加spring-boot-starter-web依赖(pom.xml)

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

    4）制作引导类Application(模仿上面的springboot项目模板内容…)

  注意:以上四个方案都要联网联网联网！！！

二、遇到的问题：

1. 创建后，pom.xml文件没有蓝色标识，页面没有maven面板

   解决的博客:(2条消息) Maven面板不见了怎么办（pom.xml被忽略，pom.xml文件变成灰色，并且有一个删除线怎么办）_�欢快↑㎡的博客-CSDN博客_idea的pom文件不见了

2. Plugin ‘org.springframework.boot:spring-boot-maven-plugin:‘ not found

   解决的博客:(2条消息) Cannot resolve plugin org.springframework.boot:spring-boot-maven-plugin: 解决办法_大王我亲自来巡山的博客-CSDN博客

   <!--Pom.xml(配置文件)-->
   <build>
   	  <plugins>
               <plugin>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-maven-plugin</artifactId>
                   <version>2.7.7</version><!--添加spring_boot的版本号2.7.7-->
               </plugin>
         </plugins>
   </build>
   

3. Cannot resolve org.apache.tomcat.embed:tomcat-embed-core:9.0.60标红解决办法

   解决的博客:(2条消息) Cannot resolve org.apache.tomcat.embed:tomcat-embed-core:9.0.60标红解决办法_爱吃面包的小胖墩的博客-CSDN博客

   <!--在Pom.xml文件中在properties中添加tomcat的版本号-->
   <properties>
           <java.version>1.8</java.version>
           <tomcat.version>9.0.60</tomcat.version>
    </properties>
   
   

三、初始化Pom.xml文件

1. parent标签

• 应用场景

  当创建多个Module(模块)时，会有多个模块(多个Pom.xml)，而这多个模块需要同一个jar包，万一出现该jar包内容改变了，就必须每个安装此jar的项目都要进行更改，这样不灵活，“不解耦”。

• 方法

  1. 单独创建一个父类Pom.xml 该父类项目没有任何代码，在该项目的Pom.xml导入子模块共用的jar包依赖

  <dependencies>
          <dependency>
              <!--坐标groupId artifactId-->
              <groupId>项目名</groupId>
              <artifactId>包名</artifactId><!--相当于com.example.xxx-->
              <version>${某jar包.version}</version>
          </dependency>
  </dependencies>
  

  2. 子类模块项目的Pom.xml文件使用parent标签，在标签中写上parent项目的pom坐标就可以引用到子类公共的jar啦

   <parent>
          <artifactId>父类项目名</artifactId>
          <groupId>包名</groupId>
          <version>版本号</version>
   </parent>
  

ps:对坐标的具体介绍:(1条消息) Maven项目中依赖的groupId和artifactId标签的含义？_groupid标签_贝贝才不是小淘气的博客-CSDN博客

2. dependencyManagement 依赖管理标签

• 应用场景

  其实是对parent标签补充使用标签。在父类项目中有多个子模块，其中的子模块并不是所有的模块都需要共用多个相同的jar包，这样只在子项目中使用parent标签显然不能对付此问题。

• 方法

  1. 在父类Pom.xml文件中使用dependencyManagement标签

     引入两个依赖并使用dependencyManagement标签

  <dependencyManagement>
          <dependencies>
          
              <dependency>
                  <groupId>xxx</groupId>
                  <artifactId>xxx</artifactId>
                  <version>${xxxx.version}</version>
              </dependency>
              
              <dependency>
                  <groupId>xxx</groupId>
                  <artifactId>xxx</artifactId>
                  <version>${xxx.version}</version>
              </dependency>
              
          </dependencies>
  </dependencyManagement>
  

  2. 子类项目模块Pom.xml文件使用parent标签

 <parent>
        <artifactId>父类项目名</artifactId>
        <groupId>包名</groupId><!--相当于默认生成包结构的com.example-->
        <version>xxx</version>
        <relativePath>../父类项目名/pom.xml</relativePath> <!-- 父工程 pom.xml 的相对路径-->
 </parent>
<dependencies>
        <dependency>
            <groupId>xxx</groupId><!--灵活选用父类Pom.xml的依赖jar包-->
            <artifactId>xxx</artifactId>
            <!--无需确定该jar包的版本 父类已经将其管理统一好了 子类直接继承该版本号-->
        </dependency>
 </dependencies>

• 作用

  1. 使用dependencyManagement可以统一管理项目的版本号，确保应用的各个子项目的依赖和版本一致，达到了统一管理版本号的目的，当需要变更版本号的时候只需要在父类容器里更新，不需要任何一个子项目的修改。

  2. 如果某个子项目需要另外一个特殊的版本号时，只需要在自己的模块dependencies中声明一个版本号即可。子类就会使用子类声明的版本号，不继承于父类版本号。如果不声明版本号的话，默认会使用父类的版本号。

3. starter

(1条消息) 自定义Starter详细教程_风清扬鍀师傅的博客-CSDN博客

详细介绍了starter(自身现在能力不够，只能引用他人博客进行记录学习了)

4. 引导类(后缀Application)

• 定义

  是boot工程的执行入口，运行main方法就可以启动项目

• 功能

  springboot工程运行创建并初始化spring容器，扫描引导类所在的包加载bean对象

5. 内嵌的tomcat

• 原理

  将Tomcat服务器当做对象运行，并将对象交给Spring容器管理

<!--pom.xml文件中starter类-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- GAV-->   <!-- 是spring内嵌的tomcat服务器 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <version>2.7.7</version>
    <scope>compile</scope>
</dependency>
<!--排除依赖的代码语句-->
<!--如果排除tomcat依赖-->
<!--在pom.xml文件里编写排除依赖语句-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions><!--排除依赖标签-->
            <exclusion>
                 <artifactId>spring-boot-starter-tomcat</artifactId>
    			<version>2.7.7</version>
            </exclusion>
    </exclusions>
</dependency>
<!--可以更换其他的服务器 使用jetty服务器-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

• 内置服务器(目前了解)

  1. tomcat(默认)

     应用面广，负载了若干较重的组件

  2. jetty

     更轻量级，负载性能远不及tomcat

  3. undertow

     负载性能勉强跑赢tomcat

四、REST风格

1. 定义

   • REST为表现行驶状态转换

   //传统风格资源描述形式
   http://localhost/user/getById?id=1
   http://localhost/user/saveUser
   //REST风格描述形式
   http://localhost/user/1
   http://localhost/user
   

2. 优点

   • 隐藏资源的访问行为，无法通过地址得知对资源是何种操作

     问题:那如何判断访问形式呢？（重点）

     • http://localhost/users 查询全部用户信息 GET(查询)
     • http://localhost/users/1 查询指定用户信息 GET（查询）
     • http://localhost/users 添加用户信息 POST（新增/保存）
     • http://localhost/users 修改用户信息 PUT（修改/更新）
     • http://localhost/users/1 删除用户信息 DELETE（删除）

   • 书写简洁

3. 注意

   • 上述行为是约定方式，约定不是规范，可以打破，所以是风格，而不是规范
   • 描述模块的名称通常使用复数，也就是加s的格式描述，表示此类资源，而非单个资源 如users books…

4. REST风格代码展示

//@Controller
//把@ResponseBody提前 相当于全局变量 requestMapping映射的第一地址提前 也是当做成全局变量来使用
    @RestController
    @ResponseBody
    @RequestMapping("/users")//映射的一级标题
public class UserController {
//   @RequestMapping(value="/users",method=RequestMethod.POST)//映射的一级标题
    @PostMapping
   //@ResponseBody//反应主体 返回值response
    public String save (){//请求参数
       return "{'module:'user save'}";
   }

//    @RequestMapping(value = "/users/{id}",method=RequestMethod.DELETE)//映射的一级标题
    @DeleteMapping("/{id}")
    //@ResponseBody//反应主体 返回值response
    public String delete (@PathVariable Integer id){//请求参数
        return "{'module:'user delete'}"+id;
    }

//    @RequestMapping(value="/users",method=RequestMethod.PUT)//映射的一级标题
    @PutMapping
    //@ResponseBody//反应主体 返回值response
    public String update (@RequestBody User user){//请求参数
        return "{'module:'user update'}";
    }

//    @RequestMapping(value="/users{id}",method=RequestMethod.GET)//映射的一级标题
    //@ResponseBody//反应主体 返回值response
    @GetMapping("/{id}")
    public String getById (@PathVariable Integer id){//请求参数
        return "{'module:'user getById'}";
    }

//    @RequestMapping(value="/users",method=RequestMethod.GET)//映射的一级标题
    //@ResponseBody//反应主体 返回值response
    @GetMapping()
    public String getAll (){//请求参数
        return "{'module:'user getAll'}";
    }

}

五、基础配置

1. 复制模块

2. 属性配置

   • 修改服务器端口

     #application.properties文件中
     #在properties写键值对 key and value
     server.port=xxxx
     

   • 修改banner(springboot)

   spring.main.banner-mode=off
   

   • 修改日志

   logging.level.root=info
   

   除了这些，还有很多基础配置 都可以在官方文档查到 并在properties文件中设置

3. 配置文件

   • properties文件(传统文件/默认格式)

     server.port=80
     

   • yaml文件

     server:
     	port: 81
     

   • yml文件（主流）

     # 键值对为主导
     server:
     	port: 82
     

     注意:当三个文件共存叠加时，主导权properties>yml>yaml（有内容相同时，就有先后的加载情况，如果内容不相同，都会保留下来）

     • 语法

       1. 大小写敏感
       2. 属性层级关系使用多行描述，每行结尾使用冒号结束
       3. 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格(一个空格)
       4. #表示注释

       核心规则:数据前面要加空格

       user:
        - 
          name: zhangsan
          age: 18
        - 
          name: lisi
          age: 17
          #用-表示对象的更换 可以与-换行 使得更简洁明了
          
       

     • java程序读取yml文件的单一数据

       1. 使用@Value配合SpEL读取单一数据
       2. 如果数组存在多层级，依次书写层级名称即可

       //读取yml文件的单一数据
           @Value("${country}")
           private String country1;
           //读取对象属性
           @Value("${user.name}")
           private String name;
           //读取对象数组
           @Value("${user1[1].age}")
           private int age;
           
       

     • Java程序读取yml文件的全部数据

       1. 减少对变量的定义 直接统一封装到一个对象中（Environment）
       2. 使用自动装配@Autowired

        //自动装配将所有的数据封装到Environment
           @Autowired
           private Environment env;
       	@GetMapping//请求模式 get提交 无二级路径
           public String getById(){
               System.out.println(env.getProperty("user.name"));
               System.out.println(env.getProperty("user1[1].age"));
               return "spring_boot is running...";
           }
       

     • Java程序读取局部数据

       1. 自定义对像封装指定数据

          • 自定义对象(yml文件)

          • 定义一个类(java程序)

            1. 使用**@ConfigerationProperties**注解绑定到配置信息到封装类Enterprise
            2. 封装类Enterprise需要定义为Sping管理的bean对象，否则无法进行属性注入@Component

       @Component
       @ConfigurationProperties(prefix = "enterprise")//通过前缀enterprise在yml文件中找到指定的类
       public class Enterprise {
           private String name;
           private int age;
           private String []subject;
       }
       
       

       # yml中的对象
       enterprise:
         name: louis
         age: 20
         tel: 14754856065
         subject:
           - java
           - 前端
           - 大数据
       

     • 重复代码复用

       使用SpEL书写规范

       # 使用${属性名}引用数据
       baseDir: c:\win10
       tempDir: ${baseDir}\temp
       # 用引号（双引号）包裹的字符串 其中的转义字符可以生效\t
       tempDir2: "${baseDir}\temp \t1 \t2 t3"
       

六、整合第三方技术

6.1整合Junit

• 名称：@SpringBootTest

• 类型：测试类注解

• 位置：测试类定义上方

• 作用：设置JUnit加载SpringBoot启动类

• 范例

  //此代码在ApplicationTests类中
  @SpringBootTest(classes=引导类名.class)
  //如果测试类所在包的位置不同于引导类所在的包的话 需要指明引导类名.class 如果相同 则不用写~ 因为找的话是从测试类所在的包下以及引导类所在的包下是否有@SpringBootConfiguration
  //@Configuration(classes=引导类.class)也可以写上
  class ApplicationTests{}
  //我自个代码样例
  @SpringBootTest
  class ApplicationTests {
      @Autowired
      private BookDao bookDao;
      @Test
      void contextLoads() {
          for (int i = 0; i < 100; i++) {
              System.out.println(bookDao.getById(i));
          }
      }
  }
  @Mapper
  public interface BookDao {
      @Select("select * from t_order_item where id =#{id}")//sql语句查询
      public Book getById(int id);
  }
  

• 相关属性

  classes：设置SpringBoot启动类

6.2整合Mybatis

• 整合内容

  1. 核心配置:数据库连接相关信息

  2. 映射配置:SQL映射(xml/注解)

     #核心配置
     spring:
       datasource:
         driver-class-name: com.mysql.cj.jdbc.Driver
         url: jdbc:mysql://localhost:3306/book
         username: root
         password: xxx
     

//映射配置@Mapper用于被容器识别
@Mapper
public interface BookDao {
    @Select("select * from t_order_item where id =#{id}")//sql语句查询
    public Book getById(int id);
}

• 依赖内容
  1. Mybatis Framework
  2. Mysql Driver

<!--pom.xml-->
<dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
</dependency>
<!--第三方技术mybatis导入对应的starter类-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>3.0.0</version>
</dependency>

6.3整合Mybatis-Plus

• 整合内容

  1. 核心配置:数据库连接相关信息
  2. 映射配置:继承BaseMapper

  @Mapper//作用mapper映射到spring容器中 让其管理
  public interface BookDao extends BaseMapper<Book> {
  }
  //有很多的增删改查的方法可以直接调用
  

• 依赖（坐标）内容

  1. Mybatis-plus(得自己配)

     官网:Maven Repository: com.baomidou » mybatis-plus-boot-starter » 3.4.3 (mvnrepository.com)

  2. Mysql Driver

  <dependency>
              <groupId>com.baomidou</groupId>
              <artifactId>mybatis-plus-boot-starter</artifactId>
              <version>3.4.3</version>
  </dependency>
  <dependency>
              <groupId>com.mysql</groupId>
              <artifactId>mysql-connector-j</artifactId>
              <scope>runtime</scope>
  </dependency>
  

  spring:
    datasource:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://127.0.0.1:3306/book
      username: root
      password: xxx
  #在mybatis的基础上再配置对表名的指定
  mybatis-plus:
    global-config:
      db-config:
        table-prefix: t_order_item #要查寻数据对应的表名
  

6.4整合Druid

• 依赖内容

  1. Mybatis Framework

  2. Mysql Driver

  3. Druid

     Maven Repository: com.alibaba » druid » 1.2.15 (mvnrepository.com)

<!--三个坐标-->
<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.3.0</version>
</dependency>
<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.15</version>
</dependency>
<dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
</dependency>

• 整合内容
  1. 核心配置:数据库连接相关信息

#两种配置都行 建议使用第二种(结果第一种可以运行...)
#spring:
#  datasource:
#    driver-class-name: com.mysql.cj.jdbc.Driver
#    url: jdbc:mysql://127.0.0.1:3306/book
#    username: root
#    password: xxx
#    type: com.alibaba.druid.pool.DruidDataSource

spring:
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://127.0.0.1:3306/book
      username: root
      password: xxx

6.5 整合JPA

这里就先不介绍讲解SpringData JPA的用法了，只介绍如何在springboot项目中整合。

1.添加依赖

• SpringData JPA依赖

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

• Mysql驱动依赖

  <dependency>
              <groupId>com.mysql</groupId>
              <artifactId>mysql-connector-j</artifactId>
              <scope>runtime</scope>
  </dependency>
  

2.配置文件properties

#自动生成数据库表（关键）
spring.jpa.hibernate.ddl-auto=update
#mysql数据库连接配置（非常重要）默认端口3306
spring.datasource.url = jdbc:mysql://localhost:3306/springbootjpa?serverTimezone=Asia/Shanghai
#数据库用户名 默认为root
spring.datasource.username = root
#数据库密码(只有有你知道)
spring.datasource.password = xxx
#mysql数据库驱动程序（重要）
spring.datasource.driver-class-name = com.mysql.cj.jdbc.Driver
#jpa配置：在控制台显示Hibernate的sql(可选) false也行
spring.jpa.show-sql = true
#其他配置：关闭Thymeleaf 的缓存
spring.thymeleaf.cache = false

欲知如何使用整合的jpa 且听我下篇博客吧~

附:开发一点点心得

后端开发流程

1. 实体类开发

   • 导入lombok坐标依赖(创建springboot工程模块时，可以勾选依赖)

     注意:实体类对应一个表 要加上标签@TableName 指定要查询的表

   • domain层 使用lombok简化实体类创建

     @Data//提供了构造器和getter和setter方法 toString方法 equals hashCode
     //使用lombok.Data 简化(PoJo)实体类开发
     @TableName("t_order_item")//查询的表名
     public class Book {
         private Integer id;
         private String name;
         private int count;
         private double price;
         private double total_price;
         private String order_id;
     }
     

2. 数据层开发

   • 技术实现法案

     • MybatisPlus

     • Druid(数据源)

       注意:Druid配置 id应该遵守auto

       mybatis-plus:
         global-config:
           db-config:
             table-prefix: t_order_item #查询的表名
             id-type: auto
         configuration:
            log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #mybatisplus 日志 设置为标准输出
       

   • 开发Dao接口(继承BaseMapper)

   • 制作测试类(增删查改)

     • 分页功能

     1. 制作分页拦截器Interceptor

        @Configuration
        public class MPConfig {
            //分页拦截器
            @Bean
            public MybatisPlusInterceptor mybatisPlusInterceptor(){
                MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
                interceptor.addInnerInterceptor(new PaginationInnerInterceptor());//具体的分页拦截器
                return interceptor;
            }
        }
        

3. 表现层(控制层)

   • Rest风格

     1. 新增:POST
     2. 删除：DELETE
     3. 修改：PUT
     4. 查询：GET

   • 接收参数

     1. 实体参数：@RequestBody
     2. 路径变量：@PathVariable

   • 前后端数据格式统一

     1. 过渡的数据返回模型R
        • data
        • flag 用于判断数值为空 是数据不存在 还是运行异常没查到

@RestController
@RequestMapping("/books")
public class BookController {
    @Autowired
    private BookService bookService;
    @GetMapping
    public List<Book> getAllBooks(){
        return bookService.getAll();
    }
    @PostMapping
    public void saveBook(@RequestBody Book book){
        bookService.add(book);
    }
    @DeleteMapping("/{id}")
    public void deleteBook(@PathVariable Integer id){
        bookService.delete(id);
    }
    @PutMapping
    public void updateBook(@RequestBody Book book){
        bookService.update(book);
    }
    @GetMapping("/{name}")
    public void getByBookName(@RequestBody String name){
        bookService.getByName(name);
    }
}

​ 前端数据获取三步走

• 页面样式对应的代码在哪里(找出来
• 如何获取用户在表单填写的信息
• 获取的信息如何传到后台

图中遇到的问题:

1. to {GET [/books]}: There is already ‘bookController’ bean method

​ 路径重名 Mapping映射到spring容器的地址重名了 需要将其改掉即可

​ (3条消息) There is already ‘xxxController‘ bean method_Hubz131的博客-CSDN博客