SpringBoot框架

Naaaaa.a

已于 2022-07-25 09:30:15 修改

阅读量391

点赞数

分类专栏： java 文章标签： spring boot java

于 2022-07-23 10:03:36 首次发布

本文链接：https://blog.csdn.net/qq_44189274/article/details/125921090

版权

java 专栏收录该内容

49 篇文章 1 订阅

订阅专栏

1.什么是SpringBoot框架?

springboot可以帮你简化spring的搭建，并且快速创建一个spring的应用程序。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置

2.Springboot特点有哪些?

（1）可以创建独立的Spring应用程序，并且基于其Maven或Gradle插件，可以创建可执行的JARs和WARs；
（2）内嵌Tomcat或Jetty等Servlet容器；
（3）提供自动配置的“starter”项目对象模型（POMS）以简化Maven配置；
（4）尽可能自动配置Spring容器；
（5）提供准备好的特性，如指标、健康检查和外部化配置；
（6）绝对没有代码生成，不需要XML配置。

3.创建springboot工程

1.JDK必须为1.8以上

2.spring的jar必须5.0以上

3.maven必须3.3以上

创建一个controller类

运行

3.1springboot中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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--parent: 继承
           如果你的maven项目想成为springboot工程必须继承SpringBoot父依赖
    -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.12.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ykq</groupId>
    <artifactId>qy151-springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>qy151-springboot</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--web的启动依赖 把spring中常见的jar都集成到该依赖中,集成了springmvc的启动配置类 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

默认springboot扫描的包为主启动类所在的包以及子包。

3.2.springboot的配置文件

有两种格式的配置文件:

第一种： properties属性文件

# 修改springboot中tomcat端口号.
server.port=8888

第二种: yml文件

server:
  port: 6666

4.无论是哪种，他们的名字必须以application开始。

如果两个配置文件同时存在，而且有些内容一样。按照properties的优先级高。如果有些不一样，两个配置文件不一样的会合并在一起。

4.读取springboot配置文件中的内容

OSS文件上传

密钥和bucket名称等---密钥和bucket都写死在java代码中。如果后期修改密钥和bucket的值，你必须修改源码代码。我们要写在配置文件。然后通过代码在读取配置文件中的密钥和bucket.

如何读取springboot配置文件的内容呢?

通过@PropertiesConfiguration或者@Value注解。

@PropertiesConfiguration该注解使用在类上。

student.name=张三
student.age=18
student.hobby[0]=唱歌
sutdent.hobby[1]=游泳

@Data
@Component //该类对象的创建和销毁都有spring容器来管理
@ConfigurationProperties(prefix = "student") //读取springboot中的配置内容
public class Student {
    private String name;
    private Integer age;
    private String[] hobby;
    private Map<String,Object> map;
}

    @Autowired
    private Student student;

    @RequestMapping("/index")
    public Student index(){
        return student;
    }

@Value 只能放在我们的类属性上。而且它只能读取基本类型和字符串类型。

5.profiles文件的介绍

思考: 我们在实际开发中，环境有哪些?

开发环境---->测试环境---->线上环境由于环境的不同，那么就会有不同的配置内容。

难道我们不断的修改配置内容。----不会

实际工作中，针对不同的环境配置不同的配置文件，然后再总的配置文件中激活相应的配置文件。

6.Springboot注册web三大组件

什么是web的三个组件?

Servlet和Filter以及Linstener监听器（不常用）。

为什么要注册这三个组件呢?

因为后面springboot有可能要集成第三方框架，而第三方框架的底层可能就依赖于过滤器或者servlet.

如何注册呢?

思考: 早期:

<1>Servlet类

<2>注册到Tomcat容器web.xml

<servlet>
    <servlet-name></servlet-name>
    <servlet-class>Servlet类</servlet-class>
</servlet>
<servlet-mapping>
     <servlet-name></servlet-name>
     </url-parterrn>/</url-parterrn>
</servlet-mapping>

创建一个配置类:

@Configuration//该类为配置类 xml文件
public class MyConfig {

    @Bean//理解为配置文件中<bean >
    public ServletRegistrationBean<Servlet> serviceServletRegistrationBean(){
        //创建一个servlet注册器
        ServletRegistrationBean<Servlet> servletServletRegistrationBean = new ServletRegistrationBean<>();
        servletServletRegistrationBean.setName("my");
        servletServletRegistrationBean.setServlet(new MyService());
        servletServletRegistrationBean.addUrlMappings("/my");
        return servletServletRegistrationBean;
    }
}

以前如何注册过滤器:

 <filter>

 <filter-name></filter-name>

 <filter-class></filter-class>

 </filter>

 <filter-mapping>

 <filter-name></filter-name>

 <url-partter></url-partter>

 </filter-mapping>

    @Bean
    public FilterRegistrationBean<Filter> filterFilterRegistrationBean(){
        //创建一个filter注册器
        FilterRegistrationBean<Filter> filterFilterRegistrationBean = new FilterRegistrationBean<>();
        filterFilterRegistrationBean.setName("myFilter");
        filterFilterRegistrationBean.setFilter(new MyFilter());
        filterFilterRegistrationBean.addUrlPatterns("/*");
        return filterFilterRegistrationBean;
    }

7.springboot自动装配原理

什么是自动装配?

无需手动加载某些配置，而由Springboot自动加载进来。

譬如: 自己加载DispatcherServlet.

如何完成自动装配?

为什么总的自动装配类由127个。因为这些自动装配类都在某个文件中写死了。

看DispatcherServlet如何完成自动装配。

8.springboot整合数据源

数据源: 指的是数据源。即是: springboot框架连接数据库。

（1）引入依赖

        <!--加入数据源的启动依赖: springboot启动时会加载对应的自动装配类。-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

（2）配置数据源信息---application.properties

# 配置数据源
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root

(3)测试

@SpringBootTest
class SpringbootApplicationTests {

    @Autowired
    private DataSource dataSource;

    @Test
    public void test01() throws Exception {
        System.out.println(dataSource);
        System.out.println(dataSource.getConnection());
    }
}

上面默认这个数据源使用的连接池Hikari。如果不想使用默认的连接池，我们可以引入第三方的连接池。

8.1.集成druid数据源

（1）依赖

        <!--引入数据库连接池druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.8</version>
        </dependency>

（2）配置文件

spring.datasource.druid.url=jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai
spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.druid.username=root
spring.datasource.druid.password=1234
#初始化的个数
spring.datasource.druid.initial-size=5
# 最大活跃数
spring.datasource.druid.max-active=10
# 最大等待时间
spring.datasource.druid.max-wait=3000
# 最小的闲置个数
spring.datasource.druid.min-idle=5

(3)测试

    @Autowired
    private DataSource dataSource;

    @Test
    public void test01() throws SQLException {
        //验证了springboot可以帮你完成数据源的自动装配功能
        System.out.println(dataSource);
        System.out.println(dataSource.getConnection());
    }

9.springboot整合mybatis

(1)引入mybatis启动依赖类

        <!--引入mybatis的启动依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>

(2) 修改配置文件

#指定映射文件的路径
mybatis.mapper-locations=classpath:mapper/*.xml

（3）在主启动类加上注解

@SpringBootApplication
@MapperScan(basePackages = "com.zsy.dao") //为指定的包下的接口生成代理实现类
public class SpringbootApplication {

    public static void main(String[] args) {
        //加载那含有@SpringBootApplication注解的类,它的特殊之处就是该类使用了@SpringBootApplication ，它是一个复合组件。
        //@EnableAutoConfiguration
        SpringApplication.run(SpringbootApplication.class, args);
    }

}

(4)测试

    @Test
    public void test02(){
        System.out.println(userMapper.findById(2));
    }

10.springboot整合PageHelper分页插件

（1）引入依赖

        <!--pageHelper的启动依赖 自动装配拦截器-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.4.2</version>
        </dependency>

（2）测试:

    @Autowired
    private UserMapper userMapper;
    @Test
    public void test03(){
        PageHelper.startPage(1,3);
        List<User> list = userMapper.findAll();
        PageInfo<User> pageInfo = new PageInfo<>(list);
        System.out.println("当前页码:"+pageInfo.getPageNum());
        System.out.println("总页码:"+pageInfo.getPages());
        System.out.println("总条数:"+pageInfo.getTotal());
        System.out.println("当前页码的记录:"+pageInfo.getList());
    }

11.springboot整合swagger2.

什么是swagger2.

它是一个接口文档----用来前后端分离的一款文档。

（1）引入swagger依赖

        <dependency>
            <groupId>com.spring4all</groupId>
            <artifactId>swagger-spring-boot-starter</artifactId>
            <version>1.9.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>swagger-bootstrap-ui</artifactId>
            <version>1.7.8</version>
        </dependency>

（2）创建swagger配置类

@Configuration
public class SwaggerConfig {
    /**
     * swagger中所有的功能都封装再Docket类中
     */
    @Bean
    public Docket docket(){
        Docket docket = new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())//设置api文档信息
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.zsy.controller"))//指定为哪些包下的类生成接口文档
                .build()
                ;
        return docket;
    }

    /**
     * 定义自己接口文档信息
     */
    private ApiInfo apiInfo(){
        Contact DEFAULT_CONTACT = new Contact("张三", "http://www.baidu.com", "110@qq.com");
        ApiInfo apiInfo = new ApiInfo("springboot文档","这是一个文档","v1.0",
                "http://www.jd.com",DEFAULT_CONTACT,"北京",
                "http://www.taobao.com",new ArrayList<VendorExtension>());
        return apiInfo;
    }

}

（3）开启swagger注解

（4）使用swagger注解

swagger通过注解表明该接口会生成文档，包括接口名、请求方法、参数、返回信息的等等。

@Api：修饰整个类，描述Controller的作用接口类的注解---接口类上 tag属性
@ApiOperation：描述一个类的一个方法，或者说一个接口接口方法的注解---接口方法上 value:
@ApiParam：单个参数描述
@ApiModel：用对象来接收参数---- 实体类接口注解
@ApiModelProperty：用对象接收参数时，描述对象的一个字段---->实体类属性的说明
@ApiImplicitParam：一个请求参数
@ApiImplicitParams：多个请求参数

@ApiImplicitParams( 接口参数的说明
{
ApiImplicitParam() //单个参数的说明
}
)

实现CRUD

@RestController
@Api(tags = "user的接口类")
public class UserController {
    @Autowired
    private UserService userService;

    //查询所有
    @PostMapping("select")
    @ApiOperation(value = "查询接口")
    public CommonResult select(){
        return userService.findAll();
    }

    //添加
    @PostMapping("insert")
    @ApiOperation(value = "添加接口")
    @ApiImplicitParams(
            {
                    @ApiImplicitParam(value = "编号",name = "id",dataType = "int"),
                    @ApiImplicitParam(value = "账号",name = "username",required = true),
                    @ApiImplicitParam(value = "密码",name = "password",required = true)
            }
    )
    public CommonResult insert(User user){
        return userService.add(user);
    }

    //修改
    @PostMapping("update")
    @ApiOperation(value = "修改接口")
    @ApiImplicitParams(
            {
                    @ApiImplicitParam(value = "编号",name = "id",required = true,dataType = "int"),
                    @ApiImplicitParam(value = "账号",name = "username",required = true),
                    @ApiImplicitParam(value = "密码",name = "password",required = true)
            }
    )
    public CommonResult update(User user){
        return userService.upd(user);
    }

    //删除
    @PostMapping("delete")
    @ApiOperation(value = "删除接口")
    @ApiImplicitParams(
            {
                    @ApiImplicitParam(value = "编号",name = "id",required = true,dataType = "int")
            }
    )
    public CommonResult delete(Integer id){
        return userService.del(id);
    }

}

（5）访问

第一种: http://localhost:8081/swagger-ui.html

第二种: http://localhost:8081/doc.html

Naaaaa.a

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringBoot框架

springboot可以帮你简化spring的搭建，并且快速创建一个spring的应用程序。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置思考我们在实际开发中，环境有哪些?开发环境---->测试环境---->线上环境由于环境的不同，那么就会有不同的配置内容。难道我们不断的修改配置内容。----不会实际工作中，针对不同的环境配置不同的配置文件，然后再总的配置文件中激活相应的配置文件。......
复制链接

扫一扫