SpringBoot(One·上)

一、简介

概述

Spring Boot是spring家族中的一个全新的框架，它用来简化Spring应用程序的创建和开发过程，也可以说Spring Boot可以简化我们SSM框架进行开发的过程

Spring Boot特性

• 能够快速创建基于Spring的应用程序
• 能够直接使用java main方法启动内嵌的Tomcat服务器运行SpringBoot程序，不需要部署war包文件
• 提供约定的starter POM来简化Maven配置，让Maven的配置更加简单
• 自动化配置，根据项目的Maven依赖配置，SpringBoot自动配置Spring、SpringMVC等
• 提供了程序的健康检查功能
• 基本可以完全不使用XML配置文件，采用注解配置

SpringBoot四大核心

• 自动配置
• 起步依赖
• Actuator（检测程序运行状态）
• 命令行界面

二、SpringBoot项目分析

1、创建第一个案例

1、我这里使用的是阿里云的镜像

2、勾选需要的起步依赖

结构目录和pom文件

大体目录：

resource下的目录结构

pom中的部分依赖

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintagegroupId>
                    <artifactId>junit-vintage-engineartifactId>
                exclusion>
            exclusions>
        dependency>
 
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <version>2.3.7.RELEASEversion>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Springboot的第一个java文件

//SpringBoot项目启动入口类
@SpringBootApplication//springboot核心注解，主要用于开启spring自动配置
public class Springboot001Application {

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

}
1
2
3
4
5
6
7
8
9

2、Springboot集成mvc

编写Controller类
必须放在Springboot启动类所在的同级目录或者下级目录

@Controller
public class IndexController {
    @RequestMapping(value = "/springboot/say")
    @ResponseBody
    public String say(){
        return "nihao";
    }

}
1
2
3
4
5
6
7
8
9

启动并访问

输出结果：

Springboot核心配置文件application.properties

设置端口号和上下文根

# 应用名称
spring.application.name=springboot_003
# 应用服务 WEB 访问端口/设置内嵌Tomcat端口号
server.port=8080

#设置上下文根
server.servlet.context-path=/springboot

1
2
3
4
5
6
7
8

测试：

Springboot核心配置文件application.yml或者application.yaml

application.yml

添加配置，注意格式

正确配置：

server:
  port: 8081
  servlet:
    context-path: /
1
2
3
4

测试：

---

application.yaml

添加配置

server:
  port: 8080
  servlet:
    context-path: /666
1
2
3
4

测试

两种配置文件同时存在

如果两个文件同时存在，优先取的是properties文件内的

设置Maven私服仓库

如果项目出现问题，可以把maven镜像修改成我的（本地）
maven寻找依赖的时候，首先会去本地找，然后再到镜像仓库

	<mirror> 
      <id>nexus-aliyunid>
      <mirrorOf>*mirrorOf>
      <name>Nexus aliyunname>
      <url>http://maven.aliyun.com/nexus/content/groups/publicurl>
    mirror>
  mirrors>
1
2
3
4
5
6
7
8

三、多环境开发核心配置文件

多环境配置文件切换（properties）

一般情况我们的环境有：1开发环境 、2 测试环境、3 准生产环境 4 生产环境
有时候我们会在不同的环境对项目进行操作。但每个环境的配置不一样，比如IP端口、数据库等等。如果我们通过单一的配置文件进行反复的修改，会显得很麻烦。因此我们需要使用使用多环境开发模式对配置文件进行切换。

---

步骤：
1️⃣ 首先创建所需要的开发环境配置文件

我这里有dev:开发、product：生产、ready：准生产环境。你也可以根据自己的需求进行添加

下面是各个配置文件的详细内容
Dev：

#开发环境
# 应用名称
spring.application.name=springboot-properties-yal-yaml
# 应用服务 WEB 访问端口
server.port=8080
server.servlet.context-path=/dev
1
2
3
4
5
6

product：

#生产环境
server.port=9090
server.servlet.context-path=/product
1
2
3

ready：

#准生产环境
server.port=8082
server.servlet.context-path=/ready
1
2
3

test：

#测试环境
server.port=8081
server.servlet.context-path=/test
1
2
3

2️⃣我们还需要一个核心配置文件——application.properties
我们需要在这个文件里面激活需要的具体的环境配置文件

里面具体的操作：
使用spring.profiles.active激活我们想要使用的配置文件，“=”号后面只需要填写application-后面且,properties前面的内容。注意格式标准

#springboot主核心配置文件
#激活使用的配置文件
spring.profiles.active=dev
1
2
3

这是我们使用的是dev开发环境，开发环境的端口号是8080，此时我们启动程序查看日志
此时我们可以看到已经成功的切换到了开发环境，端口是8080

我们在换一个环境试试：换一个测试环境test，同样我们需要在核心配置文件里去激活

#springboot主核心配置文件
#激活使用的配置文件
spring.profiles.active=test
1
2
3

启动程序并查看日志

我们可以看到成功切换了

---

多环境配置文件切换（yaml/yml）

基本步骤和properties的配置相差不大

1️⃣
首先创建所需要的配置文件，这里我就只举一个例子了

dev

配置内容：

#开发环境
server:
  port: 8080
  servlet:
    context-path: /dev
1
2
3
4
5

2️⃣创建一个核心配置文件，这里的核心配置文件不是以.properties结尾的，而是以.yaml结尾的

激活配置文件

spring:
  profiles:
    active: dev
1
2
3

启动程序查看结果

OK

---

获取自定义配置(单个值)

比如我们在配置文件中定义了数据
然后我们需要在外部获取

1️⃣我们首先在外部定义好数据

school.name=Sichuan Dachuan Middle School
websit=http://www.scdczx.en
1
2
3

2️⃣然后我们通过@Value注解来获取数据

@Controller
public class IndexController {
    @Value("${school.name}")
    private String schoolName;

    @Value("${websit}")
    private String websit;

    @RequestMapping(value = "/say")
    @ResponseBody
    public String say(){
        return "msg:"+schoolName+":"+websit;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果：

---

获取自定义配置(映射成对象)

1️⃣首先我们也设置好数据源

school.name=四川省达川中学
school.master=ObjectMan
school.websit=http://www.scdczx.en
1
2
3

2️⃣使用@ConfigurationProperties(prefix = “”) 进行数据注入prefix的值为前数据源名称的前缀

@Component//将此类交给Spring容器管理
@ConfigurationProperties(prefix = "school")
public class School {
    private String name;

    private String master;

    private String websit;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getMaster() {
        return master;
    }

    public void setMaster(String master) {
        this.master = master;
    }

    public String getWebsit() {
        return websit;
    }

    public void setWebsit(String websit) {
        this.websit = websit;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

获取对象

@Controller
public class IndexController {
    @Autowired
    private School school;
    
    @RequestMapping(value = "/say")
    @ResponseBody
    public String say(){
        return "学校："+school.getName()+" "+"校长："+school.getMaster()+" "+"学校官网："+school.getWebsit();
    }
1
2
3
4
5
6
7
8
9
10

四、SprigBoot集成Mybatis

步骤

1、添加mybatis依赖
2、添加Oracle驱动
3、使用Mybatis提供的逆向工程生成实体bean，映射文件，dao接口

        <!--MySQL数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--MyBatis整合SpringBoot框架起步依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>
1
2
3
4
5
6
7
8
9
10
11
12

mybatis逆向工程1

我们可以通过配置文件和插件来自动生成我们需要的模块

插件

            <!--mybatis 代码自动生成插件-->
            
                org.mybatis.generator
                mybatis-generator-maven-plugin
                1.3.6
                
                    
                    GeneratorMapper.xml
                    true
                    true
                
            
1
2
3
4
5
6
7
8
9
10
11
12

配置文件（在项目根目录创建）

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
>
    <!-- 指定连接数据库的 JDBC 驱动包所在位置，指定到你本机的完整路径 -->
    
    
    
        
        
            
        
        
        
        
        
        
            
            
        
        
        
            
        
        
        
            
        

        <!-- 数据库表名及对应的 Java 模型类名 -->
        >>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
运行：
 
我们可以看到已经生成了
 
关于生成的Mapper映射文件

DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dunv.study.mapper.StudentMapper">
  <resultMap id="BaseResultMap" type="com.dunv.study.model.Student">
    
    
    

    
    

    
    <id column="id" jdbcType="INTEGER" property="id" />
    <result column="name" jdbcType="VARCHAR" property="name" />
    <result column="age" jdbcType="INTEGER" property="age" />
  resultMap>

  
  <sql id="Base_Column_List">
    id, name, age
  sql>

  
  <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
    select 
    <include refid="Base_Column_List" />
    from t_student
    where id = #{id,jdbcType=INTEGER}
  select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
    delete from t_student
    where id = #{id,jdbcType=INTEGER}
  delete>

  <insert id="insert" parameterType="com.dunv.study.model.Student">
    insert into t_student (id, name, age
      )
    values (#{id,jdbcType=INTEGER}, #{name,jdbcType=VARCHAR}, #{age,jdbcType=INTEGER}
      )
  insert>

  
  <insert id="insertSelective" parameterType="com.dunv.study.model.Student">
    insert into t_student
    <trim prefix="(" suffix=")" suffixOverrides=",">
      <if test="id != null">
        id,
      if>
      <if test="name != null">
        name,
      if>
      <if test="age != null">
        age,
      if>
    trim>
    <trim prefix="values (" suffix=")" suffixOverrides=",">
      <if test="id != null">
        #{id,jdbcType=INTEGER},
      if>
      <if test="name != null">
        #{name,jdbcType=VARCHAR},
      if>
      <if test="age != null">
        #{age,jdbcType=INTEGER},
      if>
    trim>
  insert>

  <update id="updateByPrimaryKeySelective" parameterType="com.dunv.study.model.Student">
    update t_student
    <set>
      <if test="name != null">
        name = #{name,jdbcType=VARCHAR},
      if>
      <if test="age != null">
        age = #{age,jdbcType=INTEGER},
      if>
    set>
    where id = #{id,jdbcType=INTEGER}
  update>

  <update id="updateByPrimaryKey" parameterType="com.dunv.study.model.Student">
    update t_student
    set name = #{name,jdbcType=VARCHAR},
      age = #{age,jdbcType=INTEGER}
    where id = #{id,jdbcType=INTEGER}
  update>
mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
案例——springboot集成Mybatis
1、准备好实体类、mapper接口、mapper映射文件(由GeneratorMapper.xml使用mybatis逆向工程生成)
2、创建service层以及其实现层
 
service
package com.dunv.study.service;

import com.dunv.study.model.Student;

/**
 * @author ZS
 * @Description
 * @date 2022/11/29 13:48
 */
public interface StudentService {
    /**
     * 根据学生ID查询详情
     * @param id
     * @return
     */
    Student queryStudentById(Integer id);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
serviceImpl
为StudentServiceImpl 添加@Service注解
package com.dunv.study.service.impl;

import com.dunv.study.mapper.StudentMapper;
import com.dunv.study.model.Student;
import com.dunv.study.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author ZS
 * @Description
 * @date 2022/11/29 13:49
 */
@Service //为StudentServiceImpl 添加@Service注解
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentMapper studentMapper;

    @Override
    public Student queryStudentById(Integer id) {
        Student student = studentMapper.selectByPrimaryKey(id);
        return student;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
2、创建控制层的StudentController
package com.dunv.study.controller;

import com.dunv.study.model.Student;
import com.dunv.study.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author ZS
 * @Description
 * @date 2022/11/29 13:45
 */

@Controller
public class StudentController {
    @Autowired
    private StudentService studentService;


    @RequestMapping(value = "/student")
    @ResponseBody
    public Object student(Integer id){
        Student student = studentService.queryStudentById(id);
        return student;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
3、为mapper接口添加mapper扫描
package com.dunv.study;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author 28259
 */
@SpringBootApplication
@MapperScan("com.dunv.study.mapper")//开启扫描mapper接口的包以及子目录
class Application {

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

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
4、在pom.xml的build中指定文件夹为resource
        
        <resources>
            <resource>
                <directory>src/main/javadirectory>
                <includes>
                    <include>**/*.xmlinclude>
                includes>
            resource>
        resources>
1
2
3
4
5
6
7
8
9
5、运行并访问
数据库信息
 
查询结果
Mapper映射文件存放位置（不在pom文件中指定资源目录）
1、把mapper.xml映射文件放到resource/mapper目录下
 
2、在核心配置文件application.properties中指定
#设置数据库连接
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/dunv?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&nullCatalogMeansCurrent=true
spring.datasource.username=root
spring.datasource.password=654321

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

1
2
3
4
5
6
7
8
9
3、运行并访问
 
springboot集成mybatis总结
1️⃣Springboot集成Mybatis
添加mybatis依赖，Mysql/Oracle驱动
使用Mybatis提供的逆向工程生成实体bean，映射文件，DAO接口
2️⃣Springboot集成mybatis，最主要的两个注解是@Mapper和@MapperScan
@Maper 需要在每一个Mapper接口类上添加，作用扫描dao/mapper接口
@MapperScan是在SpringBoot启动入口类添加的，它是扫描所有得1包
3️⃣关于映射文件存放的位置
 1、将Mapper接口和Mapper映射文件存放到src.mian/java同一目录下，
 还需要在pom文件中手动指定资源文件夹的路径resource
2、将Mapper接口和Mapper映射文件分开存放，需要在核心配置文件中指定mapper映射文件存放的位置
五、 SpringBoot支持事物
前言
事物是一个完整的功能，也叫一个完整的业务
 事物只跟什么SQL语句有关系？（DML【数据操纵语言】：增、删、改）
上面说了，事物是一个完整的业务，里面包含了多个执行单元。由于事物的一致性原则——这些执行单元要么全部执行，要么全不执行
我们以数据修改为例
    public int updateStudentById(Student student) {

        //修改成功
        int i = studentMapper.updateByPrimaryKey(student);

        //失败
        int a = 10/0;
        return i;
    }
1
2
3
4
5
6
7
8
9
在上面的方法中，就可以把这个方法看成是一个事务，里面包含了两个执行单位
int i = studentMapper.updateByPrimaryKey(student);
int a = 10/0;
第二个 int a = 10/0 肯定会报错
现在我们要把数据库里面的哈哈修改成啦啦，如果不添加事务，我们可以看看结果是什么样的。
 
我们可以看到页面上报错了
 
后端控制台也报错了，正是第二个错误
此时我们再看数据库
 
 数据被修改了！，也就是说int i = studentMapper.updateByPrimaryKey(student);执行成功了，但是int a = 10/0执行失败了。这违反了事务的一致性原则
此时我们应该添加事务
添加事务
在对应的业务上添加 @Transactional（Springboot2.0以上）注解即可，这样就不会保持事务的一致性原则
    @Transactional
    @Override
    public int updateStudentById(Student student) {

        //修改成功
        int i = studentMapper.updateByPrimaryKey(student);

        //失败
        int a = 10/0;
        return i;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12


                    相关阅读:

                    
理解系统内核linux phy驱动                            

golang常用库之-HTTP客户端请求库 grequests                            

单点登录以及实现（前后端分离和前后端不分离方式）                            

vue 引入zTree                            

国产短视频：成都柏煜文化传媒有限公司                            

代码随想录7——哈希表：454四数相加II、383赎金信、15三数之和、18四数之和                            

【学习笔记之数据结构】时间复杂度与空间复杂度                            

LeetCode 2530. 执行 K 次操作后的最大分数：优先队列（贪心）                            

如何提升设备投资回报率：预测性维护在制造业的应用                            

开源 2 年、打磨 13 年、300 万行代码的开源项目                            

                    
                

                    原文地址：https://blog.csdn.net/qq_49385719/article/details/126927812
                

            

                

                    最新文章
                
                

                    
攻防演习之三天拿下官网站群                            

数据安全治理学习——前期安全规划和安全管理体系建设                            

企业安全 | 企业内一次钓鱼演练准备过程                            

内网渗透测试 | Kerberos协议及其部分攻击手法                            

0day的产生 | 不懂代码的"代码审计"                            

安装scrcpy-client模块av模块异常，环境问题解决方案                            

leetcode hot100【LeetCode 279. 完全平方数】java实现                            

OpenWrt下安装Mosquitto                            

AnatoMask论文汇总                            

【AI日记】24.11.01 LangChain、openai api和github copilot                            

                    
                
            

            

                

                    热门文章
                
                

                    
十款代码表白小特效 一个比一个浪漫 赶紧收藏起来吧！！！                            

奉劝各位学弟学妹们，该打造你的技术影响力了！                            

五年了，我在 CSDN 的两个一百万。                            

Java俄罗斯方块，老程序员花了一个周末，连接中学年代！                            

面试官都震惊，你这网络基础可以啊！                            

你真的会用百度吗？我不信 — 那些不为人知的搜索引擎语法                            

心情不好的时候，用 Python 画棵樱花树送给自己吧                            

通宵一晚做出来的一款类似CS的第一人称射击游戏Demo！原来做游戏也不是很难，连憨憨学妹都学会了！                            

13 万字 C 语言从入门到精通保姆级教程2021 年版                            

10行代码集2000张美女图，Python爬虫120例，再上征途