Spring Boot 开发流程

code_YuJun
14 阅读5分钟

开发流程

  1. 创建 Maven 工程
  2. 转换为 boot 工程：在 pom.xml 中配置 <parent>父工程
<!-- 继承父工程 -->
<parent>
    <!-- 代表这是 spring-boot 工程-->
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.0.5</version>
</parent>
  1. 导入 web 的启动器，这个不需要写版本，因为父工程帮忙写版本了（导入之后，自动有：springmvc、jackson、servlet 等web开发时依赖）
<dependencies>
    <!-- web 相关的启动器，里面已经包括 springmvc json解析-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
  1. 创建启动类
// Main.java
// 配置类 && 自动加载其他配置类 && 自动扫描当前类所在的包和子包
@SpringBootApplication  //启动类
public class Main {
    public static void main(String[] args) {
        // 自动创建ioc容器 && 启动tomcat服务器软件
        SpringApplication.run(Main.class,args);
    }
}
  1. 在启动类 相同的包下 创建 Controller
// 标记类为控制器,自动返回 JSON/XML 所有方法的返回值直接作为响应体返回,替代了传统的 @Controller+@ResponseBody组合注解
@RestController
// @RequestMapping("hello") 类上：统一前缀
@RequestMapping("hello")
public class HelloController {
    @GetMapping("boot")
    public String hello(){
        return "hellp springboot3!!";
    }
}
  1. 启动项目即可

Spring Boot 配置文件

  • application.yaml
# 项目启动的端口号 & 项目启动的根目录
server:
  port: 8088
  servlet:
    context-path: /book

# 自定义配置（yaml格式）
xiaoming:
  user:
    gfs:
      - a
      - b
      - c
    username: root
    password: 123456

# 外部配置配置 application-druid.yaml && 激活
spring:
  profiles:
    active: druid
  # 禁用数据库初始化脚本，避免自动配置H2驱动
  sql:
    init:
      mode: never
  • application-druid.yaml
...此处省略1w字
  • 在程序中读取配置变量
// pojo/User.java
@Data
@Component
@ConfigurationProperties(prefix = "xiaoming.user")
public class User {
    private String username; //等于key
    private String password;
    private List<String> gfs;
}

// UserController
@RestController
@RequestMapping("user")
public class UserController {
    @Autowired
    private User user;
    @GetMapping("show")
    public User show(){
        return user;
    }
}

静态资源配置

  1. 创建静态资源
  2. 配置访问路径
spring:
  profiles:
    active: druid
  web:
    resources:
      # 配置静态资源地址,如果设置,会覆盖默认值
      static-locations: classpath:/webapp

拦截器配置

  • 拦截器
// 拦截器 接收到请求的时候，能获取
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("request = " + request + ", response = " + response + ", handler = " + handler);
        return true;
    }
}
  • 在配置类中声明拦截器
//  配置类
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor());
    }
}

druid 连接池配置

直接连 MySQL

  • 建立连接非常慢 MySQL 连接是重量级操作：三次握手、认证、权限检查……一次连接可能几十毫秒～几百毫秒。你频繁创建销毁，接口会巨慢。
  • 高并发下直接崩库 MySQL 能同时接受的连接数有限（默认 151 左右）。你一上来并发几百个请求，直接：too many connections数据库直接拒绝服务。
  • 频繁创建销毁连接，服务器资源爆炸，操作系统要维护大量 socket，CPU、内存都扛不住。
  • 没有任何监控和防护：慢 SQL、连接泄漏、长时间不释放连接……

连接池（Druid）

  • 启动时就创建 5、10 个连接放着
  • 你要用就从池子里 “借” 一个
  • 用完不是关闭，而是 “还回去”
  • 控制最大连接数，不会打崩 MySQL
  • 自动检查无效连接、超时连接
  • 自带监控：慢 SQL、并发数、执行时间

JdbcTemplate

Spring 对原生 JDBC 的简化封装，让你少写一堆重复代码，更安全、更方便地执行 SQL、操作数据库。

  • 原生 JDBC（又长又乱） 加载驱动、获取连接、创建 Statement、执行 SQL、处理 ResultSet 遍历封装成对象、一堆 try-catch-finally、手动关闭连接、结果集、statement
Connection conn = null;
PreparedStatement pst = null;
ResultSet rs = null;
try {
    conn = dataSource.getConnection();
    pst = conn.prepareStatement("select name from user where id =?");
    pst.setInt(1, 1);
    rs = pst.executeQuery();
    if (rs.next()) {
        String name = rs.getString("name");
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    // 手动关 rs、pst、conn
}
  • JdbcTemplate（清爽） 写 SQL、传参数、拿结果
String name = jdbcTemplate.queryForObject(
    "select name from user where id =?",
    String.class,
    1
);

Druid 和 JdbcTemplate 的关系

  • Druid：负责提供数据库连接（连接池）
  • JdbcTemplate：负责执行 SQL、处理数据
你的代码
   ↓
JdbcTemplate（执行SQL）
   ↓
DruidDataSource（拿连接）
   ↓
MySQL

1.下载依赖

<dependencies>
    <!-- web 相关的启动器，集成：Spring MVC、Tomcat 内置服务器、JSON 解析、请求、响应、参数解析-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 数据库相关配置启动器，集成：JdbcTemplate、事务管理、数据源（DataSource）自动配置-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <!-- druid启动器的依赖  -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-3-starter</artifactId>
        <version>1.2.18</version>
    </dependency>
    <!-- 驱动类：没有驱动 → Java 根本连不上 MySQL-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.28</version>
    </dependency>
</dependencies>
  • 原因：
前端请求
   ↓
spring-boot-starter-web （接收请求）
   ↓
你的代码（Controller → Service）
   ↓
JdbcTemplate（spring-boot-starter-jdbc）执行SQL
   ↓
Druid连接池 （提供连接）
   ↓
mysql-connector-java （驱动，真正和MySQL通信）
   ↓
MySQL数据库

2.Druid 的基础配置

...省略

3.定义 pojo、controller

  • Stu.java
import lombok.Data;
@Data
public class Stu {
    // 主键ID
    private Integer id;
    // 姓名
    private String name;
    // 性别
    private String gender;
    // 年龄
    private Integer age;
    // 班级
    private String className;
}
  • StudentController.java
@RestController
@RequestMapping("stud")
public class StudentController {
    // 只要导入了 JDBC 的启动器，就自动完成配置类的加载，这里就可以注入使用了
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @GetMapping("list")
    public List<Stu> list(){
        //数据库
        String sql ="select * from students;";
        List<Stu> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Stu.class));
        return list;
    }
}

整合 mybatis

  1. 导入依赖
<!-- mybatis 启动器-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>3.0.1</version>
</dependency>
  1. 数据库链接配置 & mybatis 功能配置
  • application-druid.yaml
...
spring:
  profiles:
    active: druid,mybatis
...
  • application-mybatis.yaml
mybatis:
  mapper-locations: classpath:/mappers/*.xml # 指定 Mapper 映射 XML 文件的路径
  type-aliases-package: com.study.java.pojo # 配置实体类别名包
  configuration:
    # 开启下划线转驼峰命名映射（例如数据库 user_name 对应实体类 userName）
    map-underscore-to-camel-case: true
    # 设置自动映射级别为 full（全映射），支持级联映射
    auto-mapping-behavior: full
    # 指定 MyBatis 日志实现为 SLF4J，方便在控制台打印 SQL 语句
    log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl
  1. 创建与数据库表对应的实体类
@Data
public class Stu {
    // 主键ID
    private Integer id;
    // 姓名
    private String name;
    // 性别
    private String gender;
    // 年龄
    private Integer age;
    // 班级
    private String className;
}
  1. 创建 Mapper 接口
// com.study.java.mapper
public interface StuMapper {
    List<Stu> queryAll();
}
  1. 创建 Mapper 接口 sql 实现
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace = 接口的全限定符 -->
<mapper namespace="com.study.java.mapper.StuMapper">
    <select id="queryAll" resultType="stu">
        select * from students;
    </select>
</mapper>
  1. 创建程序启动类，需要指定 mapper 接口了
    告诉 MyBatis 去哪里扫描 Mapper 接口，让 Spring 把这些接口生成代理对象，放进 IOC 容器里，你才能用 @Autowired 注入使用。
// 指定 mapper 接口所在的位置
@MapperScan("com.study.java.mapper")
@SpringBootApplication  //启动类
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class,args); //自动创建ioc容器,启动tomcat服务器软件
    }
}

@MapperScan 就是做这件事的：

  1. 扫描 com.study.java.mapper 包下 所有接口
  2. 识别它们是 MyBatis 的 Mapper
  3. 为每个接口生成 代理实现类
  4. 把这些实现类 放进 Spring 容器
  5. 你才能在 Controller / Service 里：
@Autowired
private UserMapper userMapper;
  1. 注解扫描
  2. 使用 Mapper 接口
@RestController
@RequestMapping("stu")
public class MybatisStuController {
    @Autowired
    private StuMapper stuMapper;
    @GetMapping
    public List<Stu> query(){
        return stuMapper.queryAll();
    }
}
avatar
文章
阅读
粉丝