SpringBoot

老庄发电机

已于 2023-04-05 11:03:13 修改

阅读量86

点赞数

于 2023-02-21 11:14:34 首次发布

本文链接：https://blog.csdn.net/m0_71222496/article/details/129138858

版权

这里写目录标题

1、认识springboot
2、新建springboot项目
- 创建放射式1：手动创建
3、springboot的启动方式
4、以向导方式创建springboot项目---了解
5、springboot整合mybatis
6、热启动
7、补充
总结
springboot自动装配

1、认识springboot

问题：spring springMVC的问题？

1、有大量的配置文件需要配置，比较繁琐

2、需要添加大量的jar的依赖

springboot不是一个新技术，只是对spring springmvc进行了内部的整合，让spring springMVC使用更就简单

springboot的优点：

1、自动装配，节省了大量的配置文件适用于敏捷式开发

2、使用starter,简化了大量jar的依赖

【starter】jar的集合

3、内置了组件，方便开发

例如：内置了tomcat组件，无需配置web服务器

4、springcloud基于springboot。

springboot=spring + springMVC

2、新建springboot项目

创建放射式1：手动创建

1、新建maven项目

在这里插入图片描述

2、添加依赖

【说明】必须先添加parent ,目的是对springboot的jar的版本进行统一控制

<!--用来统一限制springboot里的starter的版本号-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.4.RELEASE</version> <!--统一限定了springboot的jar的版本号-->
    <relativePath/> <!-- 从仓库的根目录开始寻找jar -->
</parent>
<!--springboot需要引入的starter-->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <!--在parent当中已经对spring-boot-starter开头的jar进行了统一的版本控制-->
    </dependency>
</dependencies>

3、新建启动程序

【说明】启动程序最好在父包中

package com.qf.springboot2204;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication  //进行自动装配
public class SpringBoot2204Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringBoot2204Application.class,args);
    }
}

4、测试

1、编写一个实体类

2、编写controller

package com.qf.springboot2204.controller;

import com.qf.springboot2204.pojo.Dept;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/dept")
public class DeptController {
    @GetMapping("/find")
    public Dept find(){
        Dept dept=new Dept();
        dept.setDeptNo(1001);
        dept.setDeptName("软件研发2204");
        return dept;
    }
}

5、启动程序

在这里插入图片描述
【强调】

1、默认的端口号8080

2、启动类的命名一定要注意 SpringBootAppliction 是关键字，是注解的名字

3、启动类要在父包中

自动装配时，springboot就从启动类所在的包作为父包开始扫描

springboot中约束大于配置：启动类在父包，默认就从父包开始扫描

如果启动类不在父包中，需要通过注解配置从哪里开始扫描

package com.qf.springboot2204.test;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication  //进行自动装配
@ComponentScan("com.qf.springboot2204")  //配置springboot开始扫描的父包
public class SpringBoot2204Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringBoot2204Application.class,args);
    }
}

6、springboot的配置文件

springboot默认读取的配置文件叫application 扩展名.properties 官方推荐

.yml 空格+缩进的格式

server.port=8082

server:
  port: 8083

3、springboot的启动方式

方式1：通过main方法来启动主要

方式2：通过maven命令来启动

在Terminal窗口中，输入命令 mvn spring-boot:run 来启动项目

方式3：以运行jar的方式来运行 java -jar 项目名了解

4、以向导方式创建springboot项目—了解

在这里插入图片描述

【说明】向导方式创建springboot项目，自动创建了启动类、配置文件

但是额外创建了很多文件夹，以及添加了不需要的一些jar依赖

5、springboot整合mybatis

spring：创建bean的问题

IoC
Aop
使现有框架更好用

springMVC: 收参问题，传值问题—转JSON

ORM:对象关系映射

操作DB
mybatis

使用springboot整合mybatis

springboot特点：重约束、轻配置

配置类：springboot使用配置类进行配置，来代替配置文件

整合方式一：使用配置类

1、准备数据库表

在这里插入图片描述
2、准备实体类

package com.qf.springboot2204.pojo;

import java.io.Serializable;

public class Dept implements Serializable {
    private int deptNo;
    private String deptName;
    private String loc;

    public int getDeptNo() {
        return deptNo;
    }

    public void setDeptNo(int deptNo) {
        this.deptNo = deptNo;
    }

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    public String getLoc() {
        return loc;
    }

    public void setLoc(String loc) {
        this.loc = loc;
    }
}

3、添加spring整合mybatis的starter

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.0.5</version>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.10</version>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.2</version>
</dependency>

4、在applicatio.yml配置文件中，编写数据库的连接信息

server:
  port: 8083  # 端口号
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource   # Druid连接池
    url: jdbc:mysql://localhost:3306/java2204 # 数据库连接地址
    username: root # mysql账号
    password: root # mysql 密码
    driver-class-name: com.mysql.jdbc.Driver #驱动
    druid:
      initial-size: 3 # 连接池中初始化连接的数量

5、创建mybatis使用的文件夹，在resources目录下

在这里插入图片描述
6、创建配置类，编写具体的配置信息

通常在dao中

【面试题】spring整合mybatis时，都整合了mybatis的哪些组件？

1、Druid连接池

2、SqlSessionFactoryBean

3、MapperScannerConfigurer

package com.qf.springboot2204.dao;

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;
import java.io.IOException;

//配置类，配置mybatis的信息
@Configuration  //标明此类是配置类，相当于spring配置文件里的beans标签，在springboot启动时，就
                //自动读取、加载该注解修饰的类
public class MybatisConfig {
    //创建SqlSessionFactoryBean
    @Bean //用于方法的上方，调用该方法，把该方法返回的bean存于bean容器中
    @ConditionalOnMissingBean //到bean容器中寻找该方法的参数类型需要的bean,然后赋值给参数
    public SqlSessionFactoryBean createSqlSessionFactoryBean(DataSource dataSource){
        //1、创建SqlSessionFactoryBean对象
        SqlSessionFactoryBean sqlSessionFactoryBean=new SqlSessionFactoryBean();
        //2、设置数据源
        sqlSessionFactoryBean.setDataSource(dataSource);
        //3、如果mybatis有单独的配置文件，设置配置文件的路径,如果没有则忽略
        sqlSessionFactoryBean.setConfigLocation(new ClassPathResource("mybatis/mybatis-config.xml"));

        //4、需要读取mybatis的映射文件
        //声明数组，用于存放读取到的映射文件
        Resource[] aryMapper=null;
        //创建解析器 来读取应映射文件
        PathMatchingResourcePatternResolver resolver=new PathMatchingResourcePatternResolver();

        try {
            aryMapper=resolver.getResources("classpath:mybatis/mapper/*.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        //设置读取到的映射文件
        sqlSessionFactoryBean.setMapperLocations(aryMapper);

        //设置实体类所在的包
        sqlSessionFactoryBean.setTypeAliasesPackage("com.qf.springboot2204.pojo");
        return sqlSessionFactoryBean;
    }
    //创建MapperScannerConfigurer对象
    @Bean
    @ConditionalOnBean(SqlSessionFactoryBean.class) //把方法中需要的bean进行注入到方法中
    public MapperScannerConfigurer createMapperScannerConfigurer(){
        MapperScannerConfigurer mapperScannerConfigurer=new MapperScannerConfigurer();
        //设置dao的包
        mapperScannerConfigurer.setBasePackage("com.qf.springboot2204.dao");
        return mapperScannerConfigurer;
    }

}

其余 dao service controller的编写不变

6、热启动

springboot项目，在改动代码后，需要重启才会生效，Tomcat才会感知到。

热启动：当代码变动后，Tomcat能够自动感知到，加载变动的内容。

1、添加devtools的jar

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

2、勾选自动构建

在这里插入图片描述
3、重新构建项目

在这里插入图片描述
如果代码改动后，重新构建(步骤3)即可。

7、补充

springboot默认不支持JSP

1、项目的类型改为war

2、添加 servlet jsp的jar依赖

<!-- 添加servlet依赖模块 -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
</dependency>
<!-- 添加jstl标签库依赖模块 -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>
<!--添加tomcat依赖模块.-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>
<!-- 使用jsp引擎，springboot内置tomcat没有此依赖 -->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

3、在main目录下创建名为webapp的目录，作为web的根目录即可

总结

1、传统项目：特定人员使用的项目，俗称各类管理系统

2、互联网项目：全民使用的项目

一、springboot是重中之重

1、无需配置大量的配置文件

2、starter,是jar的整合，无需添加大量的jar依赖

3、内置了插件，方便开发，Tomcat

4、约定大于配置

5、springcloud必须基于springboot

二、配置文件

1、springboot默认无法识别、不能读取xml配置文件

使用IO流读取。

2、默认支持的配置文件有两个

bootstrap、application

支持的格式，官方推荐properties，常用yml

区别：读取的先后顺序不同，先读取bootstrap 然后读取application

目前：配置端口号

配置数据源、连接池信息

三、整合

3、1：常用注解 @SpringBootApplication ……

3、2：配置类

3、3：具体整合参见代码

四、启动方式（3种）

springboot自动装配

装配：在spring springmvc中需要在配合文件中手动配置扫描的额基本包，设置后，当启动时，根据扫描的情况进行容器的创建、扫描到注解，执行注解的命令，进入注入等操作。

springboot无需配置扫描的基本包，能够自动装配

从@SpringBootApplication注解开始，它是一个复合注解，其中核心注解有3个，

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

@SpringBootConfiguration：里的@Configuration注解标明当前启动类是一个配置类，在启动时读取、加载类的内容，同时里的@Component注解会创建启动类的对象，创建bean容器，存于bean容器中

@ComponentScan：作用是找到当前启动类所在的包，然后赋值给basePackages，设置当前启动类所在的包为扫描的起始包

@EnableAutoConfiguration：作用：1、按父包开始扫描父包及子包，创建bean,注入值

2、加载pom.xml文件中配置的starter及对应的jar

由@AutoConfigurationPackage注解，又由@Import({Registrar.class})组成，到入自己写的

@Import({AutoConfigurationImportSelector.class})注解组成，导入的是pom文件里引入的，里面有一个Selector选择器，只导入starter配置文件里配置的内容。

核心都是导入类。

老庄发电机

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot

笔记
复制链接

扫一扫